Java Basics Part 20/20 - Inner Classes

Java Basics Part 20/20 - Inner Classes

目录

---

嵌套类

在 Java 中，在类中可以编写另外一个类。类中的类就叫做嵌套类(nested class)，包含内部类的类就叫做外部类(outer class)。

语法

编写内部类的语法如下：

class Outer_Demo{   class Nested_Demo{      }   }

嵌套类分成两种形式：

• 非静态内部类：这些是类的非静态成员
• 静态内部类：这些是类的静态成员。

---

非静态内部类

内部类是 Java 安全机制的一种。Java 的类不可以有 private 这种访问级别，但是如果一个类中存在内部类，那么内部类就可以使 private 的了。

根据内部类定义的位置，可以分为三类：

• 内部类
• 方法内部类
• 匿名内部类

内部类

创建一个内部类是很easy的，只需要在类中编写另外一个类即可，但是与普通的类不同，内部类可以是 private 的，一旦将内部类声明为 private，那么在外部类类外部就无法访问这个内部类了。

例如下面这个程序，将内部类定义成 private 的，通过方法访问这个 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();   }}// output 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());   }}// outputThe value of num in the class Test is: 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();              }}// outputThis 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();    }}// outputThis is an example of anonymous inner class

同样，可以使用匿名内部类来重写一个接口实现类的方法。

使用匿名内部类作为参数

一般情况下，如果一个方法接收一个接口/抽象类/具体类的对象作为参数，那么我们就可以实现接口，继承抽象类，然后把对象传递给方法。但是如果它是一个类，那么我们可以直接传递给方法。

针对以上三种情况，均可以传递匿名内部类给方法。下面是语法：

obj.my_Method(new My_Class(){   public void Do(){   .....   .....   }});

使用如下：

//interfaceinterface 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";                     }      });   }}// outputHello 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();   }   }// outputThis is my nested class