Java内部类

在本文,我们将讨论Java的内部类。

嵌套类

在Java中,就像方法一样,一个类的变量也可以将另一个类作为其成员。Java允许在另一个内部编写一个类。用内部编写的类称为嵌套类,而保存内部类的类称为外部类

句法

以下是编写嵌套类的语法。在此,Outer_Demo类是外部类,而Inner_Demo类是嵌套类。

class Outer_Demo {

   class Inner_Demo {

   }

}

嵌套类分为两种类型-

  • 非静态嵌套类-这些是的非静态成员。
  • 静态嵌套类-这些是的静态成员。

Java内部类

内部类(非静态嵌套类)

内部类是Java中的一种安全机制。我们知道一个类不能与访问修饰符private关联,但是如果我们将该类作为其他类的成员,则可以将内部类设为私有。这也用于访问类的私有成员。

内部类分为三种类型,具体取决于您定义它们的方式和位置。他们是-

  • 内部阶层
  • 方法本地内部类
  • 匿名内部阶层

内部阶层

创建内部类非常简单。您只需要在一个类中编写一个类。与类不同,内部类可以是私有的,并且一旦将内部类声明为私有,就不能从该类外部的对象访问它。

以下是创建内部类并对其进行访问的程序。在给定的示例中,我们将内部类设为私有,并通过一种方法访问该类。

现场演示

class Outer_Demo {

   int num;

  

   // inner class

   private class Inner_Demo {

      public void print() {

         System.out.println("This is an inner class");

      }

   }

  

   // Accessing he inner class from the method within

   void display_Inner() {

      Inner_Demo inner = new Inner_Demo();

      inner.print();

   }

}

  

public class My_class {

 

   public static void main(String args[]) {

      // Instantiating the outer class

      Outer_Demo outer = new Outer_Demo();

     

      // Accessing the display_Inner() method.

      outer.display_Inner();

   }

}

在这里,您可以观察到Outer_Demo是外部类,Inner_Demo是内部类,display_Inner()是在其中实例化内部类的方法,并且该方法是从main方法调用的。

如果编译并执行上述程序,将得到以下结果-

输出量

This is an inner class.

访问私人会员

如前所述,内部类也用于访问类的私有成员。假设某个班级有私有成员可以访问它们。在其中编写一个内部类,从内部类中的方法例如getValue())返回私有成员,最后从另一个类(要从中访问私有成员的类)返回内部成员的getValue()方法类。

要实例化内部类,首先必须实例化外部类。之后,使用外部类的对象,下面是实例化内部类的方法。

Outer_Demo outer = new Outer_Demo();

Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

以下程序显示如何使用内部类访问类的私有成员。

现场演示

class Outer_Demo {

   // private variable of the outer class

   private int num = 175; 

  

   // inner class

   public class Inner_Demo {

      public int getNum() {

         System.out.println("This is the getnum method of the inner class");

         return num;

      }

   }

}

 

public class My_class2 {

 

   public static void main(String args[]) {

      // Instantiating the outer class

      Outer_Demo outer = new Outer_Demo();

     

      // Instantiating the inner class

      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

      System.out.println(inner.getNum());

   }

}

如果编译并执行上述程序,将得到以下结果-

输出量

This is the getnum method of the inner class: 175

方法本地内部类

在Java中,我们可以在方法中编写类,而这将是局部类型。与局部变量一样,内部类的范围也受方法限制。

只能在定义内部类的方法内实例化方法本地内部类。以下程序显示了如何使用方法本地的内部类。

现场演示

public class Outerclass {

   // instance method of the outer class

   void my_Method() {

      int num = 23;

 

      // method-local inner class

      class MethodInner_Demo {

         public void print() {

            System.out.println("This is method inner class "+num);       

         }  

      } // end of inner class

         

      // Accessing the inner class

      MethodInner_Demo inner = new MethodInner_Demo();

      inner.print();

   }

  

   public static void main(String args[]) {

      Outerclass outer = new Outerclass();

      outer.my_Method();              

   }

}

如果编译并执行上述程序,将得到以下结果-

输出量

This is method inner class 23

匿名内部阶层

没有类名声明的内部类称为匿名内部类。在匿名内部类的情况下,我们同时声明和实例化它们。通常,它们在需要覆盖类或接口的方法时使用。匿名内部类的语法如下:

句法

AnonymousInner an_inner = new AnonymousInner() {

   public void my_method() {

      ........

      ........

   }  

};

下面的程序显示了如何使用匿名内部类重写类的方法。

现场演示

abstract class AnonymousInner {

   public abstract void mymethod();

}

 

public class Outer_class {

 

   public static void main(String args[]) {

      AnonymousInner inner = new AnonymousInner() {

         public void mymethod() {

            System.out.println("This is an example of anonymous inner class");

         }

      };

      inner.mymethod();    

   }

}

如果编译并执行上述程序,将得到以下结果-

输出量

This is an example of anonymous inner class

以相同的方式,您可以使用匿名内部类覆盖具体类的方法以及接口。

匿名内部类作为参数

通常,如果方法接受接口,抽象类或具体类的对象,则我们可以实现接口,扩展抽象类并将对象传递给方法。如果它是一个类,那么我们可以直接将其传递给方法。

但是在这三种情况下,都可以将匿名内部类传递给该方法。这是将匿名内部类作为方法参数传递的语法-

obj.my_Method(new My_Class() {

   public void Do() {

      .....

      .....

   }

});

以下程序显示了如何将匿名内部类作为方法参数传递。

现场演示

// interface

interface Message {

   String greet();

}

 

public class My_class {

   // method which accepts the object of interface Message

   public void displayMessage(Message m) {

      System.out.println(m.greet() +

         ", This is an example of anonymous inner class as an argument"); 

   }

 

   public static void main(String args[]) {

      // Instantiating the class

      My_class obj = new My_class();

 

      // Passing an anonymous inner class as an argument

      obj.displayMessage(new Message() {

         public String greet() {

            return "Hello";

         }

      });

   }

}

如果编译并执行上述程序,它将为您提供以下结果-

输出量

Hello, This is an example of anonymous inner class as an argument

静态嵌套类

静态内部类是嵌套类,它是外部类的静态成员。使用其他静态成员可以访问它而无需实例化外部类。就像静态成员一样,静态嵌套类无法访问外部类的实例变量和方法。静态嵌套类的语法如下-

句法

class MyOuter {

   static class Nested_Demo {

   }

}

实例化静态嵌套类与实例化内部类有点不同。以下程序显示了如何使用静态嵌套类。

现场演示

public class Outer {

   static class Nested_Demo {

      public void my_method() {

         System.out.println("This is my nested class");

      }

   }

  

   public static void main(String args[]) {

      Outer.Nested_Demo nested = new Outer.Nested_Demo();    

      nested.my_method();

   }

}

如果编译并执行上述程序,将得到以下结果-

输出量

This is my nested class

 

上一篇:Java学习


下一篇:java爬虫问题二: 使用jsoup爬取数据class选择器中空格多选择怎么解决