内部类介绍

局部内部类:

public class test {
    public static void main(String[] args) {
        outerClass outerClass = new outerClass();
        outerClass.m2();
    }
}

public class outerClass {
    private int n1=100;
    private void m1(){
        System.out.println("m1被调用");
    }
    public void m2(){
        //局部内部类定义在外部类的局部位置,通常在方法中(也可以在代码块中)
        class inner{
            int n1=800;
            public void show(){
                System.out.println("n1="+n1+"外部类的n1="+outerClass.this.n1);
                //当内部类中的成员名与外部类中成员相同,采用就近原则
                //如果想使用外部类中的成员,可以用外部类名.this.成员名来调用
                //哪个对象调用了show()方法,哪个对象就是outerClass.this
                m1();//局部内部类可以直接访问外部类的所有成员
            }
        }//内部类不能添加访问修饰符,因为它本身是该方法里的局部变量,可以用final

        inner inner = new inner();
        inner.show();//外部类在调用内部类成员时,先在方法里new内部类对象,再调用
    }
}

匿名内部类:

public class Anonymous {
    public static void main(String[] args) {
        outer outer = new outer();
        outer.m();
    }
}

class outer{
    int n1;
    public void m(){
        //基于接口A的匿名内部类
        A a = new A(){
            @Override
            public void cry() {
                System.out.println("狮子怒吼");
            }
        };
        //jdk底层创建匿名内部类outer$1后,立即创建outer$1实例,并把地址返回给a
        //a的编译类型A,运行类型为匿名内部类outer$1,该类实现了A接口
        //匿名内部类outer$1使用一次后就不能再用,对象a还可以使用
        System.out.println(a.getClass());
        a.cry();

        //基于类B的匿名内部类
        B b = new B("cathrine"){
            @Override
            public void thanks() {
                System.out.println("谢谢"+name);
            }
        };
        System.out.println(b.getClass());
        b.thanks();
    }
}

interface A{
    public void cry();
}

class B{
    String name;
    public void thanks(){}
    public B(String name) {
        this.name = name;
    }
}

成员内部类:

public class member {
    public static void main(String[] args) {
        //外部其他类使用成员内部类的两种方法
        //1.new
        outer o = new outer();
        outer.inner inner1 = o.new inner();
        inner1.say();
        //2.用外部类中的方法,返回一个
        outer.inner inner2 = o.getinner();
        inner2.say();
    }
}

class outer{
    private int num1=1;
    public String name="Leo";

    class inner{//成员内部类就是外部类的一个成员
        private int num2;
        void say(){
            System.out.println("num1="+num1);
            //可以直接访问外部类成员,包含私有的
        }
    }

    public inner getinner(){
        return new inner();
    }

    public void t(){
        inner inner = new inner();//创建成员内部类对象就可以使用它的成员
        inner.say();
    }
}

静态内部类:

public class jingtai {
    public static void main(String[] args) {
        A a = new A();
        a.m();
        //外部其他类使用静态内部类的两种方法
        //1.
        A.B b = new A.B();//这里是通过类名创建,而成员内部类是根据外部类对象再创建内部类对象
        System.out.println(b);
        //2.通过外部类中的方法,返回一个
        A.B bb= a.getB();
        bb.say();

    }
}

class A{
    static int num1=1;
    int num2=2;
    static class B{
        public void say(){
            System.out.println("num1="+num1);
            //System.out.println("num2="+num2);静态内部类中只能使用静态成员
        }
    }
    public void m(){
        B b = new B();
        b.say();
        System.out.println(b);
    }

    public B getB(){
        return new B();
    }
}