快速学习成员内部类与局部内部类

成员内部类

首先我们要对成员内部类的基本要点做一个学习
1.类的组成：属性、方法、构造器、代码块（普通块、静态块、构造块、同步块）、内部类
2. 一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest 外部类：TestOuter
3. 内部类：成员内部类 (静态的，非静态的) 和 局部内部类（位置：方法内，块内，构造器内）
4. 成员内部类:
含有：属性、方法、构造器等；
修饰符：private、default、protect、public、final、abstract

public class TestOuter {
    
    
    //非静态的成员内部类
    public class D{
    
    
        int age = 20;
        String name;
        public void method(){
    
    
            //5.内部类可以访问外部类的内容
            /*System.out.println(age);
            a();*/
            int age = 30;

            //8.内部类和外部类属性重名时如何调用
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age);//10
        }
    }

    //静态的成员内部来
    static class C{
    
    
        public void method(){
    
    
            //6.静态内部类中只能访问外部类中被static修饰的内容
            /*System.out.println(age);
            a();*/
        }
    }

    //属性
    int age = 10;
    //方法
    public void a(){
    
    
        System.out.println("这是a方法");
        {
    
    
            System.out.println("这是普通块");
            class B{
    
    

            }
        }
        class A{
    
    

        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象而后进行调用
        D d = new D();
        System.out.println(d.name);
        d.method();
    }

    static{
    
    
        System.out.println("这是静态块");
    }
    {
    
    
        System.out.println("这是构造块");//构造块先于内部类中的普通块运行
    }
    //构造器：
    public TestOuter(){
    
    
        class C{
    
    
        }
    }
    public TestOuter(int age) {
    
    
        this.age = age;
    }
}

class Demo{
    
    
    public static void main(String[] args) {
    
    
        //创建外部类对象
        TestOuter to = new TestOuter();
        to.a();

        //9.创建内部类对象
        //静态成员内部类创建对象
        TestOuter.C c = new TestOuter.C();
        //非静态成员内部类创建对象
        //错误：TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();//二次创建外部类，将会再次加载构造块
        TestOuter.D d = t.new D();
    }
}
运行结果：
这是静态块
这是构造块
这是a方法
这是普通块
null
30
20
10
这是构造块

成员内部类

先上代码

public class TestOuter {
    
    
    //1.在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
    
    
        final int num = 10;
        class A{
    
    
            public void a(){
    
    
                //num = 20;  报错
                System.out.println(num);
            }
        }
    }
    //2.如果类B在项目中只使用一次，那么就没必要单独创建一个B类，使用内部类就可以了
    public Comparable method2(){
    
    //用接口当做方法的返回值，返回一个具体实现类对象，一个多态的应用
        class B implements Comparable{
    
    //随意实现一个接口，不用纠结实现什么接口，先将该重写的重写了
            @Override
            public int compareTo(Object o) {
    
    
                return 100;
            }
        }
        return new B();
    }
}
	 public Comparable method3(){
    
    
	        //匿名内部类
	        return new Comparable() {
    
    
	            @Override
	            public int compareTo(Object o) {
    
    
	                return 200;
	            }
	        };
	    }
	
	    public void test(){
    
    
	        Comparable com = new Comparable() {
    
    
	            @Override
	            public int compareTo(Object o) {
    
    
	                return 300;
	            }
	        };
	        System.out.println(com.compareTo("abc"));
	    }

可以看到特别是后面是两个个匿名内部类的写法，就是这个类没有名字，我们直接用这个接口来创建该对象；接收时直接用接口做对象，相当于接口等于创建的该对象。。。这块的写法很多源码都可以看到，初学者可以稍微跟着敲一敲，就知道是什么意思了