学习笔记：内部类总结

成员内部类

写在类内部（和成员一个级别）
可以被public protected default private修饰。

静态内部类

写在类内部的静态类（和静态成员的使用方法一致）。
静态内部类对象的创建不需要依赖外部类对象，所以静态内部类中不能访问外部类的非静态变量，因为当静态内部类对象存在时，外部类对象不一定存在，而其变量是随对象的存在而存在的。

静态内部类中有静态和非静态方法，静态方法只能使用静态成员，非静态方法可以使用静态和非静态成员。
静态内部类的静态方法不需要依赖外部类对象和内部类对象。

public class Outer {
    int a = 10;
    static int b = 20;
    //成员内部类
    public class Inner{
        int a = 20;
        public void method(){
            int a = 30;
            System.out.println(a);              //30
            System.out.println(this.a);         //20 当前Inner对象
            System.out.println(Outer.this.a);   //5 当前Outer对象的a
            System.out.println(new Outer().a);  //10 新建了一个Outer对象，初始化10
        }
    }
    
    //静态内部类
    public static class Inner2{
		int c = 30;
		static int d = 40;
    	public void show(){
//静态内部类对象不需要依赖外部类对象来创建，所以当内部类对象存在时，外部类非静态变量不一定还存在
            //System.out.println(Outer.this.a);报错↑
            System.out.println(Outer.b);//20
            System.out.println(b);//20可以直接访问外部类的静态变量
            System.out.println(c);//30
            System.out.println(d);//40
        }
        //静态内部类的静态方法
        static void show00(){
            System.out.println(b);//20
            //System.out.println(c);  c非静态不能在静态方法中使用
            System.out.println(d);//40
        }
    }
}

public class Test {
    //测试内部类的用法
    public static void main(String[] args) {
        //成员内部类
        //Inner对象创建方式一
        //Outer.Inner oi = new Outer().new Inner();
        //Inner创建方式二
        Outer o = new Outer();
        o.a = 5;       //此时对a进行重新赋值，还是使用本Outer对象o
        Outer.Inner i = o.new Inner();
        i.method();

        //静态内部类创建对象方式
        //因为此时是静态的，就像调用静态方法一样，直接使用类名.类（方法）即可,无需先new一个Outer对象
        Outer.Inner2 oi2 = new Outer.Inner2();
        oi2.show();
        Outer.Inner2.show00();
}

局部内部类（写在方法内的）

写在方法内部或者代码块内部的类，只能用final修饰。
局部内类如果想要访问使用局部变量，则局部变量需要添加final修饰，为的是延长局部变量的生命周期，防止它在方法调用结束出栈后消失。

interface Demo1{
    void run1();
}
public class Outer {
  public Demo1 run(){
  	final int a = 10;     //局部变量，需要加final修饰后才可以被局部类访问
        //局部内部类
        class Inner1 implements Demo1{
            @Override
            public void run1() {   //重写接口内方法
                System.out.println("局部内部类");
                System.out.println(a);  //访问局部变量
            }
        }
        return new Inner1();      //返回一个Inner1对象
    }
}

public class Test {
	//局部内部类
	public static void main(String[] args) {
    Outer o2 = new Outer();  
    Demo1 demo1 = o2.run(); //用于接收Inner1对象，使用demo1接收，使用多态
    demo1.run1();           //父类引用调用子类重写方法
    }
}

私有内部类

private修饰的内部类，主要是为了封装核心成员使用过程中不对外展示。

	interface Demo{
    	void run();
	}
    public class Outer {
	 //私有内部类
    private class Inner3 implements Demo{
        public void run(){    //重写
            System.out.println("私有内部类，不对外展示");
        }
    }
    
	//创建私有内部类对象的方法,返回一个私有内部类对象
    	public Demo useInner3(){
        	Inner3 i3 = new Inner3();
       	 	return i3;
    	}
}

public class Test {
    public static void main(String[] args) {
		//私有内部类
        Outer o3 = new Outer();
        //o1.Inner3 = o3.new Inner3();报错
        Demo demo = o3.useInner3(); //外界无法知道使用的哪个类
        //此过程中私有内部类的创建对象不可见，即new Inner3不可见
        demo.run();
    }

私有静态内部类

主要作用在于封装保护，以及不依赖于外部类对象而创建私有静态内部类对象，直接用外部类名即可。
匿名内部类