Java内部类

一、概念

当一个事物的内部，还有一个完整的结构进行描述，而这个内部类的完整结构体又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。内部类也是一种封装的体现。

二、分类：

实例内部类

静态内部类

匿名内部类

局部内部类（一般不会涉及)

1、实例内部类

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

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

在实例内部类方法中访问同名的成员时，优先访问自己的，如果访问外部类同名成员，必须：外部类名.this.同名成员来访问

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

实力内部类的非静态方法中包含了一个指向外部类对象的引用（this）

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

class OuterClass{

    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    public void testA(){
        System.out.println("OuterClass::testA()");
    }

    //实例内部类
    //定义在类的内部，方法的外部
    class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        public void test(){
            System.out.println("InnerClass::test()");
            //可访问内部类成员
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("========");
            //可访问外部类成员
            System.out.println(data1);
            System.out.println(OuterClass.this.data1);//如果变量名相同，可以拿外部类的变量
            System.out.println(data2);
            System.out.println(data3);
          /* OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.data1);*///也可以拿到外部类的变量
        }

    }
    
}
public class innerClass {

    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //通过对象的引用来new内部类对象
        OuterClass.InnerClass innerClass = out.new InnerClass();
        innerClass.test();
    }
    
}

2、静态内部类

实际开发经常使用，因为和实例内部类相比，少一个外部类的实例化对象

在静态内部类中，不能访问外部类的非静态成员，需要new外部类的对象后再进行访问

创建静态内部类对象时，不需要先创建外部类对象

class OuterClass2{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
  
    public void testA(){
        System.out.println("OuterClass::testA()");
    }
    //静态内部类
    static class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;
        
        public void test(){
            System.out.println("InnerClass::test()");
            //System.out.println(data1);不能直接访问调用非静态类的成员变量，需要对外部类引用
            OuterClass2 outerClass2 = new OuterClass2();
            System.out.println(outerClass2.data1);
            System.out.println(outerClass2.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    
}
public class Test {
    public static void main(String[] args) {
        //静态内部类,实际开发经常使用，因为和实例内部类相比，少一个外部类的实例化对象
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
        innerClass.test();
    }
}

3、匿名内部类 

相当于一个类实现了这个接口同时重写了test方法

interface ITestable{
    void test();
}

public class Test2 {
 
    public static void main(String[] args) {
        //匿名内部类
        ITestable iTestable = new ITestable() {
            @Override
            public void test() {
                System.out.println("test()");
            }
        };
        //相当于一个类实现了这个接口同时重写了test方法！！
        iTestable.test();
    }
}

下面这样就是有名字

interface ITestable{
    void test();
}
class ITE implements ITestable{
    @Override
    public void test() {
        System.out.println("test()");
    }
}
public class Test2 {
    public static void main(String[] args) {
        ITestable it = new ITE();
        it.test();
    }
  
}