[Java]内部类

内部类

当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么这个内部的完整结构最好使用内部类,后者称为外部类.

• 内部类和外部类共用同一个java源文件,但是经过编译之后,内部类会形成单独的字节码文件

 class OuterClass{
     public int data1=1;
     private int data2=2;
     public static int data3=3;
     static class InnerClass{
         public int data4=4;
         private int data5=5;
         public static int data6=6;
         public void func(){
             System.out.println(asdasd);
         }
     }
 }

分类

1.成员内部类 (1)实例内部类:未被static修饰的成员内部类 (2)静态内部类:被static修饰的成员内部类

2.局部内部类(不谈修饰符)/匿名内部类

实例内部类

 public class OutClass {
     private int a;
     static int b;
     int c;
     public void methodA(){
         a=10;
         System.out.println(a);
     }
     public static void methodB(){
         System.out.println(b);
     }
     class InnerClass{
         int c;
         public void methodInner(){
             //在实例内部类中可以直接访问外部类中任意访问限定符修饰的成员
             a=100;
             b=200;
             methodA();
             methodB();
             c=300;//如果外部类和实例内部类中具有相同名称成员时,优先访问的时内部类自己的
             System.out.println(c);
             OutClass.this.c=400;//如果要访问外部类同名成员的时候,必须用:外部类.this.同名成员名字
             System.out.println(OutClass.this.c);
         }
     }
 ​
     public static void main(String[] args) {
         OutClass outClass=new OutClass();
         System.out.println(outClass.a);//0
         System.out.println(outClass.b);//0
         System.out.println(outClass.c);//0
         outClass.methodA();//10
         outClass.methodB();//0
     }
 }

• 在实例内部类当中不能定义静态的成员变量 可以加final定义

• 外部类中的任何成员都可以在实例内部类方法中直接访问

实例化实例内部类

• 要访问实例内部类中成员,必须要创建实力内部类的对象,而实例内部类定义与外部类成员定义位置相同,因此创建实例内部类对象时必须借助外部类

实例化静态内部类

 OutClass.InnerClass innerClass=new OutClass.InnerClass();

 OutClass outClass=new OutClass();
 OutClass.InnerClass innerClass2=outClass.new InnerClass();

• 外部类中的任何成员都可以在实例内部类方法中直接访问

• 实例内部类所处位置与外部类成员位置相同,因此也受public,private等访问限定符的约束

• 实例内部类对象必须在先有外部类对象的前提下才能创建

• 实例内部类的非静态方法中包含了一个指向外部类对象的引用

• 外部类中,不能直接访问实例内部类的成员,如果要访问必须要创建内部类的对象

静态内部类

被static修饰的内部类成员被称为静态内部类

 public class OutClass {
     private int a;
     static int b;
     public void methodA(){
         a=10;
         System.out.println(a);
     }
     public static void methodB(){
         System.out.println(b);
     }
     static class InnerClass{  //静态内部类:被static修饰的成员内部类
         public void methodInner(){
             //在静态内部类中只能访问外部类的静态成员
             a=100; //编译失败,因为a不是静态成员
             b=200;
             methodA();//编译失败 因为methodA不是静态方法
             methodB();
         }
     }
 }

可以在内部类里建造外部类的对象来调用外部类的成员 改进

 public class OutClass {
     private int a;
     static int b;
     public void methodA(){
         a=10;
         System.out.println(a);
     }
     public static void methodB(){
         System.out.println(b);
     }
     static class InnerClass{  //静态内部类:被static修饰的成员内部类
         public void methodInner(){
             OutClass outClass=new OutClass();
             outClass.a=100;
             outClass.b=200;
             outClass.methodA();
             methodB();
         }
     }
 }

外部类访问静态内部类当中的成员:

 class OuterClass{
     public int data1=1;
     private int data2=2;
     public static int data3=3;
     public class InnerClass{
         public int data4=4;
         private int data5=5;
         public static int data6=6;
         public void func(){
             OuterClass outerClass=new OuterClass();
             System.out.println(outerClass.data1);
             System.out.println(data3);
         }
     }
     public void Test(){
         InnerClass innerClass=new InnerClass();
         System.out.println(data1);
         System.out.println(data2);
         System.out.println(data3);
         System.out.println(innerClass.data4);
         System.out.println(innerClass.data5);//外部类可以访问静态内部类当中的所有成员
         System.out.println(innerClass.data6);
     }
 }

静态内部类的实例化

 public static void main(String[] args) {
     OutClass.InnerClass innerClass=new OutClass.InnerClass();
     innerClass.methodInner();//10 200
 }

• 有内部类相当与有两个this,一个this,一个 外部类名.this.xxxx

 class OuterClass{
     public int data1=1;
     private int data2=2;
     public static int data3=3;
     class InnerClass {
         public int data1=11111;
         public int data4 = 4;
         private int data5 = 5;
         public static final int data6 = 6;
 ​
         public void func() {
             System.out.println(data1);//11111
             System.out.println(OuterClass.this.data1);//1
             System.out.println(data2);
             System.out.println(data3);
             System.out.println(data4);
             System.out.println(data5);
             System.out.println(data6);
         }
     }
 }

局部内部类

 public class OutClass {
     int a=10;
     public void method(){ //局部内部类:定义在方法体内部  不能被public static修饰
         int b=10;
         class InnerClass{
             public void methodInnerClass(){
                 System.out.println(a);
                 System.out.println(b);
             }
         }
         InnerClass innerClass=new InnerClass();//实例化只能在该方法体中使用,其他位置都不能用
         innerClass.methodInnerClass();
     }
     public static void main(String[] args) {
         OutClass outClass=new OutClass();
         outClass.method();//10 10
     }
 }

匿名内部类

 interface IA{
     public void func();
 }
 class AA implements IA{
     public void func(){
         System.out.println("hello");
     }
 }
 public class JavaSE15 {
     public static void main(String[] args) {
         new IA() {  //匿名内部类
             public void func() {
                 System.out.println("asasd");
             }
         }.func(); //asasd   "."之前是对IA接口的实现,整个相当于一个类,在调用func
     }
 }