Java 四大内部类 总结

(成员)内部类-常用

特点：可以把内部类当作是外部类的一个【成员】

同外部类的成员一样，内部类可被private、protected等权限修饰符修饰
同外部类的成员一样，private修饰的内部类仅对外部类是可见的【public Inner in=new Inner();】，对外部类以外的地方不可见
同外部类的成员一样，内部类中也可以访问外部类的private成员（当然包括static成员）
同外部类的成员不一样的是，成员内部类中不能定义静态变量(否则就要定义为静态内部类)，但是可以定义 static final 变量(即常量)
同外部类的成员不一样的是，编译完成后，内部类会被编译成一个独立的类【Outer$Inner.class】，而不是Outer类的一个域



特殊使用场合：

通过使用内部类可以间接实现多继承，可以解决实现的多个接口之间，或继承的类与接口之间方法同名的冲突

例如 class Robot extends People implement Machine { }

而若 class People 和 interface Machine 都有一个同名的方法 run() 

此时若按以上结构是无法区分 Robot 中的 run() 到底是继承的还是实现的

此时的解决方式为：让 Robot 仅继承或仅实现，再在 Robot 中定义一个内部类仅实现或仅继承即可


外部类访问内部类的方式：

1.1、在外部类及其[非静态]方法中可以直接访问内部类【 new Inner().内部类的成员】
1.2、在外部类的[静态]方法中需要先创建外部类对象，才访问内部类【new Outer(). new Inner().内部类的成员】
1.3、其他地方访问内部类也是【new Outer(). new Inner().内部类的成员】


内部类访问外部类的方式：

2.1、外部类的成员变量如果和内部类的变量不同名，则内部类可直接用【变量名】访问外部类的成员变量
2.2、若同名，则内部类可用【Outer.this.变量名】来访问外部类的实例变量(注意不是Outer.Inner.变量名)
2.3、在内部类中直接用【变量名】或【this.变量名】访问的都是内部类自己的实例变量



// 外部类之外的其他类

class InnerClassDemo {

    public static void main(String[] args) {

        new Outer().new Inner().innerSpeak(); //1.3、其他地方访问内部类

    }

}


//外部类

class Outer {

    private static int age = 1;

    private String name = "外部类";

    private Inner ooo = new Inner(); //1.1、在外部类中可以直接访问内部类

    public void method() {

        new Inner().innerSpeak(); //1.1、在外部类的非静态方法中可以直接访问内部类

    }

    public static void method2() {

        new Outer().new Inner().innerSpeak();//1.2、在外部类的静态方法中访问内部类

    }


    //内部类

    class Inner {

        private String name = "普通内部类";

        void innerSpeak() {

            System.out.println(age++ + "..." + name); //2.1、不同名，可直接用变量名访问外部类的成员变量

        }

        void hello() {

            String name = "局部变量";

            System.out.println(Outer.this.name + "..." + this.name + "..." + name); //2.2、同名，可用Outer.this.变量名 访问    

        }

    }

}

静态内部类-较麻烦

特点：可以把静态内部类当作外部类的一个【静态成员】

和静态成员一样，静态内部类用 static 定义，可以用 public,protected,private修饰
和静态成员一样，静态内部类随着外部类的加载而产生，可以用外部类类名+静态成员名直接获得
和静态方法不一样的是，静态内部类中可以定义静态的也可以定义非静态的成员



外部类访问内部类方式：

1.1、外部类可以直接访问静态内部类【 new Inner().静态内部类的成员】
1.2、外部类的[静态和非静态]成员都可以用【Outer.Inner.成员】访问内部类的[静态]成员
1.3、外部类的[静态和非静态]成员都可以用【new Outer.Inner().成员】访问内部类的[非静态]成员
1.4、其他地方访问内部类可用【new Outer.Inner().成员】，其中访问静态成员还可以用【Outer.Inner.成员】


内部类访问外部类方式：

2.1、若内部类的[静态和非静态]成员和外部类的[静态]成员不同名，可以直接用【成员名】访问
2.2、同名时，内部类的[静态和非静态]成员可以用【Outer.成员】访问外部类的[静态]成员
2.3、内部类的[静态和非静态]成员可以用【new Outer().成员】访问外部类的[非静态]成员



// 外部类之外的其他类

class InnerClassDemo {

    public static void main(String[] args) {

        new Outer.Inner2().innerSpeak(); //1.4

        new Outer.Inner2().innerSpeak2(); //1.4        Outer.Inner2.innerSpeak(); //1.4

    }

}


//外部类

class Outer {

    private static int age = 1;

    private String name = "外部类";

   private Inner2 ooo = new Inner2(); //1.1

    public void method() {

      new Inner2().innerSpeak();//1.1

      new Outer.Inner2().innerSpeak(); //1.1

      Outer.Inner2.innerSpeak();//1.2      

      new Outer.Inner2().innerSpeak2(); //1.3

    }


    //静态内部类

    static class Inner2 {

        private static String name = "静态内部类";

        static void innerSpeak() {

           System.out.println(age + "..." + Outer.age + "..." + name + "..." + new Outer().name);//2.1、2.2、2.3

        }

        void innerSpeak2() {

            System.out.println("静态内部类的非静态方法");

        }

    }

}

匿名内部类-最简单

典型使用场景：

若一个类继承于某个类(不般是一个抽象类)，或是实现了某个接口，那么此类一般是需要重写或实现某些抽象方法的
除此之外，若此类并不需要增加额外的成员，且我们不需要知道此类的实际类型(只是为了获得一个对象，且用完之后没有任何一个地方会再用到)，则适合使用匿名内部类


 注意：

匿名内部类是唯一一种【无构造方法类】，匿名内部类中不能定义构造方法
匿名内部类在编译的时候由系统自动起名Out$1.class




常用格式一（单一引用）：

        new Fu() {    //或接口

            void show(){} //子类【重写或隐藏】的父类的方法

        }.show();


常用格式二（多引用）：

        Fu f = new Fu() {

            void show1(){}

            void show2(){}

        };

        f.show1();

        f.show2();


常用格式三（参数传递）：

   obj.show(new InterfaceDemo(){ //函数参数是接口类型

        public void show1(){}   //接口中的方法通常不超过2个

        public void show2(){}

    });

局部内部类-不常用

特点：可以把局部内部类当作外部类方法中的一个局部变量

与局部变量一样，局部内部类是在方法(当然可以是静态方法)中定义的
与局部变量一样，局部内部类只能在其所在方法中使用，且不能被public、static等修饰
与局部变量一样，只有定义局部内部类之后的代码，才可访问局部内部类(即先定义后使用)
与局部变量一样，局部内部类可以访问外部类的任何成员
与局部变量不一样的是，局部内部类中不可定义静态变量(不管外部方法是不是静态的)
与局部变量不一样的是，局部内部类只能访问 final 修饰的局部变量(也即只能访问常量)


外部类不能访问局部内部类

内部类访问外部类的方式：

1.1、局部内部类的变量若和外部类的成员变量不同名，则可直接用【变量名】访问外部类的成员
1.2、若同名，则局部内部类可用【Outer.this.变量名】来访问外部类的成员
1.3、在局部内部类中可以直接用【变量名】或【this.变量名】来访问内部类自己的成员



// 外部类之外的其他类

class InnerClassDemo {

    public static void main(String[] args) {

        new Outer().method(3);

    }

}


// 外部类

class Outer {

    private int s = 1;

    private static int o = 2;

    private static int oo = 3;

    public void method(final int k) {

        final int s = 100;

        final int oo = 200;

        int i = 300;

        //局部内部类

        class Inner {

            Inner(int k) {

                method();//我是外部类的方法

                System.out.println(o);//2

                System.out.println(oo);//200

                System.out.println(s);//100

                System.out.println(Outer.this.s);//1

                //System.out.println(i);//错误

            }

        }

        new Inner(k);

    }

    private void method() {

        System.out.println("我是外部类的方法");

    }

}

来自为知笔记(Wiz)