Java内部类

2021-07-16 19:05

阅读：464

　　Java编译器在内部类的情况下创建两个类文件。内部类的类文件名是“outer$inner”。如果要实例化内部类，则必须创建外部类的实例。在这种情况下，内部类的实例是在外部类的实例中创建的。

　　编译器生成的内部代码：

　　java编译器创建一个名为"outer$inner"的类文件。成员内部类具有外部类的引用，这就是为什么成员内部类可以访问外部类的所有数据成员的原因

import java.io.PrintStream;  
class Outer$Inner  
{  
    final Outer this$0;  
    Outer$Inner()  
    {   super();  
        this$0 = Outer.this;  
    }  
    void msg()  
    {  
        System.out.println((new StringBuilder()).append("data is ")  
                    .append(Outer.access$000(Outer.this)).toString());  
    }  
}

2.匿名内部类

　　一个没有名字的类在Java中被称为匿名内部类。如果您必须重写类或接口的方法，则应该使用它。可以通过两种方式创建Java匿名内部类

类（可以是抽象类或具体类）
接口

　　java匿名内部类举例

 1 abstract class Person{  
 2   abstract void eat();  
 3 }  
 4 class TestAnonymousInner{  
 5  public static void main(String args[]){  
 6   Person p=new Person(){  
 7   void eat(){System.out.println("nice fruits");}  
 8   };  
 9   p.eat();  
10  }  
11 }

　　匿名内部类的工作原理

类被创建，但是它的名称由编译器决定，编译器实现Person类，并实现eat方法
创建匿名类的对象，该对象由Person类型的p引用变量引用。

　　编译器生成的代码

import java.io.PrintStream;  
static class TestAnonymousInner$1 extends Person  
{  
   TestAnonymousInner$1(){}  
   void eat()  
    {  
        System.out.println("nice fruits");  
    }  
}

3. 局部内部类

　　在方法中创建的类称为Java中的本地内部类。如果要调用本地内部类的方法，必须在该方法中实例化该类。

　　局部内部类举例

 1 public class localInner1{  
 2  private int data=30;//instance variable  
 3  void display(){  
 4   class Local{  
 5    void msg(){System.out.println(data);}  
 6   }  
 7   Local l=new Local();  
 8   l.msg();  
 9  }  
10  public static void main(String args[]){  
11   localInner1 obj=new localInner1();  
12   obj.display();  
13  }  
14 }

　　编译器生成的内部类：

 1 import java.io.PrintStream;  
 2 class localInner1$Local  
 3 {  
 4     final localInner1 this$0;  
 5     localInner1$Local()  
 6     {     
 7         super();  
 8         this$0 = Simple.this;  
 9     }  
10     void msg()  
11     {  
12         System.out.println(localInner1.access$000(localInner1.this));  
13     }  
14 }

　　规则：

局部内部类不能声明为public、protected、private，只能是默认访问权限
局部内部类不能被外部方法调用
局部内部类不能访问非final局部变量在JDK1.7之前，但是可以访问final变量；在JDK1.8以后，局部内部类也可以访问非final局部变量

4.静态嵌套类

　　在类中创建的静态类在Java中称为静态嵌套类。它不能访问非静态数据成员和方法。它可以由外部类名访问。

它可以访问包括私有的外部类的静态数据成员。
静态嵌套类不能访问非静态（实例）数据成员或方法

　　静态嵌套类举例

class TestOuter1{  
  static int data=30;  
  static class Inner{  
   void msg(){System.out.println("data is "+data);}  
  }  
  public static void main(String args[]){  
  TestOuter1.Inner obj=new TestOuter1.Inner();  
  obj.msg();  
  }  
}

　　在这个例子中，你需要创建静态嵌套类的实例，因为他含有实例方法msg()。但是你不需要创建外部类的实例，因为嵌套类是静态的并且静态的属性、方法、类在没有对象情况下可以被访问

　　编译器生成的代码：

1 import java.io.PrintStream;  
2 static class TestOuter1$Inner  
3 {  
4 TestOuter1$Inner(){}  
5 void msg(){  
6 System.out.println((new StringBuilder()).append("data is ")  
7 .append(TestOuter1.data).toString());  
8 }    
9 }

5. 嵌套接口

　　在另一个接口或类中声明的接口称为嵌套接口。嵌套接口用于对相关接口进行分组，以便它们易于维护。嵌套接口必须由外部接口或类引用。它不能直接访问。

　　嵌套接口要记住的要点

嵌套接口在接口内声明时必须是公共的，但是如果在类内声明，则它可以具有任何访问修饰符。
嵌套接口隐式地声明为静态的

　　嵌套接口在接口内声明举例

interface Showable{  
  void show();  
  interface Message{  
   void msg();  
  }  
}  
class TestNestedInterface1 implements Showable.Message{  
 public void msg(){System.out.println("Hello nested interface");}  
  
 public static void main(String args[]){  
  Showable.Message message=new TestNestedInterface1();//upcasting here  
  message.msg();  
 }  
}

　　正如您在上面的示例中看到的，我们通过其外部接口Showable访问Message接口，因为它不能直接访问。就像房间里的衣橱一样，我们不能直接进入衣橱，因为我们必须先进入房间。在集合的框架中， sun microsystem提供了嵌套接口Entry，Entry是Map的子接口，可以通过Map.Entry访问

　　java编辑器为嵌套接口生成的代码

public static interface Showable$Message  
{  
  public abstract void msg();  
}

　　我们能在接口中定义一个类吗？

　　是的，我们可以在接口中定义一个类，java编译器将会创建一个静态嵌套类

原文地址：https://www.javatpoint.com/java-inner-class

上一篇：Python 类的初见

下一篇：基础算法-->堆排序

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Java内部类
文章链接：http://soscw.com/essay/106084.html

亲，登录后才可以留言！