Java 成员内部类 静态内部类 局部内部类 匿名内部类

一.成员内部类：与外部类的成员变量、成员方法同级别。

public class Outer {

    private int age = 11;

    public void out(){
        System.out.println("外部类");
    }

    //内部类
    public class Inner{

        public void in(){
            System.out.println("内部类");
        }

		/**
		*内部类可以直接访问外部类的私有成员，而且不会破坏封装。
		*/
        public void getOut(){
            System.out.println(age); //获得外部类的私有属性
            out();//获得外部类的方法
        }
    }


}

main方法：

public class Test {

    public static void main(String[] args) {

        Outer outer = new Outer();//实例化外部类

        Outer.Inner inner = outer.new Inner();//通过外部类实例化内部类
		
		//也可以一行代码实例化两个类
		//Outer.Inner inner = new Outer().new Inner();
		
        //执行内部类的方法
        inner.in();
        inner.getOut();

    }

}

结果：

注意：当外部类和内部类存在重名属性时，会优先访问内部类属性。
实例：

public class Outer {

    public int age = 11;

    public class Inner{

        /**
         * 注意：成员内部类不能定义静态成员，但可以定义静态常量成员。
         */
        public static final int age = 22;//正确
        //public static int age = 22;//错误

        public void out(){

            System.out.println(age);//默认访问内部类的属性

            System.out.println(Outer.this.age);//访问外部类的属性

        }

    }
}

main方法：

public class TestOuter {

    public static void main(String[] args) {

        Outer outer = new Outer();

        Outer.Inner inner = outer.new Inner();

        inner.out();//调用内部类的方法

    }
}

结果：

二.静态内部类：与外部类同级别。不依赖外部类对象，可直接创建或通过类名访问，可定义静态成员。

实例：

public class Outer {

    public int age = 11;

    public static class Inner{

        public static int age = 22;

        public void out(){

            System.out.println(Inner.age);//静态内部类可以通过类名访问内部类属性
            System.out.println(age);//内部类属性

            //因为静态内部类与外部类同级别，所以访问外部类时就当一个普通类来访问。
            Outer outer = new Outer();
            System.out.println(outer.age);//外部类属性

        }

    }
}

main方法：

public class TestOuter {

    public static void main(String[] args) {

        //不用创建外部类对象，因为静态内部类和外部类同级别。
        Outer.Inner inner = new Outer.Inner();
        inner.out();
    }
}

结果：

注意：只用内部类才能使用static关键字修饰，普通类不能。

三.局部内部类：定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。

实例：

public class Outer {

    private int age1 = 11;

    public void show1(){

        int age2 = 22;

        //局部内部类前面不能加任何访问修饰符：如public/private等
        class Inner{

            private int age3 = 33;

            public void show2(){
                System.out.println(age1);//11
                System.out.println(age2);//22
                System.out.println(age3);//33

            }
        }

        //使用show1方法中的局部内部类
        Inner inner = new Inner();
        inner.show2();
    }
}

main方法：

public class TestOuter {

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show1();
    }
}

结果：

四：匿名内部类：没有类名的局部内部类（一切特征都与局部内部类相同）。必须继承一个父类或者实现一个接口。

实例：使用普通方法和局部内部类的方法完成。

定义一个接口：

public interface Usb {
    void service();
}

实现接口：

public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("Connected to computer successfully");
    }
}

main方法：

public class TestUsb {

    public static void main(String[] args) {

        /**
         * 第一种方法：创建接口类型的变量
         */
        /*Usb usb = new Mouse();
        usb.service();*/


        /**
         * 第二种方法：使用局部内部类
         */
        class Test implements Usb{

            @Override
            public void service() {
                System.out.println("Connected to computer successfully");
            }
        }
        Usb usb = new Test();
        usb.service();
    }

}

以上两种方法的测试结果相同，如下：

接下来使用匿名内部类进行优化：

实例：

public class TestUsb {

    public static void main(String[] args) {

        /**
         * 第三种方法：使用匿名内部类（相当于创建了一个局部内部类）
         */
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("Connected to computer successfully");
            }
        };
        usb.service();
    }

}

使用匿名内部类的优缺点：
优点：减少代码量。
缺点：可读性较差。