Java--常用类之内部类

内部类

定义：在一个类的内部在定义一个类。
特点：
      1.编译之后可以生成一个独立的字节码文件
      2.内部类可以直接访问外部类的私有成员，但是不破坏其封装性。
      3.可以为外部类提供必要的内部功能组件 

成员内部类

1.在类的内部定义，与实例变量、实例方法同级的类
2.外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
3.当外部类、内部类存在重名属性时，会优先访问内部类成员
4.成员内部类不能定义静态内部类。

public class StuffInnerClassDemo {
    private String name = "张三";
    private int age = 18;
    class Inner{
        private String id = "adas2d1";
        private String country = "中国";
        private String name = "李四";
        void show(){
            //重名属性，优先调用内部类成员属性
            System.out.println(name);
            //重名属性  加 类名.this.属性名   调用外部成员属性
            System.out.println(StuffInnerClassDemo.this.name);
            System.out.println(age);
            System.out.println(id);
            System.out.println(country);
        }
    }

    public static void main(String[] args) {
//        1.
//        StuffInnerClassDemo stuffInnerClassDemo = new StuffInnerClassDemo();
//        Inner inner = stuffInnerClassDemo.new Inner();

//        2.
        Inner inner = new StuffInnerClassDemo().new Inner();
        inner.show();
    }
}

静态内部类

1.不依赖外部类对象，可以直接创建或通过类名访问，可声明静态成员
2.只能直接访问外部类的静态成员（实例对象需要实例化外部类对象）

public class QuietInnerClassDemo {
    private String name = "赞啥";
    private static String address = "上海";

    static class Inner{
        private int age = 15;
        private static int id = 25935;

        public void show(){
            //可直接调用外部类静态成员
            System.out.println(address);
            //调用外部类的非静态成员时，需实例化外部类对象
            QuietInnerClassDemo quietInnerClassDemo = new QuietInnerClassDemo();
            System.out.println(quietInnerClassDemo.name);
            System.out.println(age);
            System.out.println(id);
        }
    }

    public static void main(String[] args) {
        Inner inner = new Inner();
        inner.show();
    }
}

局部内部类

1.定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法；
2.局部内部类访问外部类当前方法中的局部变量时，因无法保证变量的生命周期与自身相同，变量必须修饰为final。
3.限制类的适用范围

public class PartInnerClassDemo {
    private String name = "张三";
    private int age = 16;
    public void show01(){
        String address = "上海";
        class Inner{
            private String email = "65654351354dfs";
            private String country = "中国";
            public void show2(){
                System.out.println(name);  //  =  System.out.println(PartInnerClassDemo.this.name);
                System.out.println(age);
                //直接调用方法中的属性时，address相当于常量，即final String address = "上海"；
                System.out.println(address);
                System.out.println(email);
                System.out.println(country);
            }
        }
        //方法体内需要实例化局部类,才可以调用局部类中的方法
        Inner inner = new Inner();
        inner.show2();
    }

    public static void main(String[] args) {
        PartInnerClassDemo partInnerClassDemo = new PartInnerClassDemo();
        partInnerClassDemo.show01();
    }
}

匿名内部类

1.没有类名的局部内部类，（一切特征和局部内部类相同）
2.必须继承一个父类或实现一个接口
3.定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
4.优点：减少代码使用量；缺点：可读性较差。

public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
        Usb usb = new Mouse();
        usb.service();

        //局部内部类
        class Fun implements Usb{

            @Override
            public void service() {
                System.out.println("连接成功，风扇启动了。。。");
            }
        }
        //使用局部内部类创建对象
        Usb usb1 = new Fun();
        usb1.service();

        //匿名内部类
        Usb usb2 = new Usb() {
            @Override
            public void service() {
                System.out.println("链接成功。");
            }
        };
        usb2.service();

    }
}