Java 内部类

内部类：成员内部类 、静态内部类、局部内部类、匿名内部类

内部类：

1.定义：在一个类的内部再定义一个完整的类

2.特点：编译之后可生成独立的字节码文件

内部类可以直接访问外部类的私有成员，而不破坏封装性

可为外部类提供必要的内部功能组件

成员内部类：

• 在类的内部定义，与实例变量、实例方法同级别的类。
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
• 当外部类、内部类存在重名属性时，会优先访问内部类属性。
• 若要输出外部类属性，则需要使用 外部类名.this.属性名
• 成员内部类不能定义static（静态类），但可以定义static final（静态常量）

eg: private static final String name = "王五";

public class demo01 {  //外部类
    private String name;  //在外部类里定义一个私有变量name
    public void out() {   //在外部类里定义的一个方法
        System.out.println("这是外部类的方法");
    }
    
    class Inner {   //内部类
        public void in() {  //在内部类里定义的一个方法
            System.out.println("这是内部类的方法");
            System.out.println(name);   //访问外部类的私有变量name
            
        }
    }
    
    public static void main(String[] args) {
        demo01 a = new demo01();
        a.out();

        demo01.Inner b = a.new Inner(); //通过这个外部类来实例化内部类
        b.in();
    }
}

//外部类
public class demo02 {
    //实例变量
    private String name = "张三";
    private int age = 20;

    //内部类
    class Inner {
        private String address = "北京";
        private String phone = "110";
        private String name="李四";

        //内部类定义一个方法
        public void show() {
            //打印外部类的属性
            System.out.println(demo02.this.name);
            System.out.println(age);
            System.out.println("=================");

            //打印内部类中的属性
            System.out.println(name);
            System.out.println(address);
            System.out.println(phone);
            System.out.println("=================");

            //属性和外部类数属性名字相同，优先输出内部类，若要输出外部类属性，则需要使用 外部类名.this.属性名
            System.out.println(demo02.this.name);
            System.out.println(name);
        }

    }

    public static void main(String[] args) {
        //1，创建一个外部类对象
        demo02 a1 = new demo02();

        //2.创建内部对象
        demo02.Inner a2 = a1.new Inner();

        //1.2可以合在一起一步到位
        demo02.Inner a3 = new demo02().new Inner();

        a2.show();
    }
}

静态内部类：

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 静态内部类和外部类的级别相同
• 调用外部类的属性：1.先创建外部类对象

                                       2.调用外部类对象的属性

• 调用静态内部类的属性和方法：用类名来调用

                                格式： 静态内部类类名 . 属性

public class demo03 {
    private String name="xxx";
    private int age = 18;

    //静态内部类:级别和外部类相同
    static class Inner{
        private String address="上海";
        private String phone ="111";

        //静态成员
        private static int count =10000;

        public void show(){
            //调用外部类的属性
            //1.先创建外部类对象
            //2.调用外部类对象的属性
            demo03 a1 = new demo03();
            System.out.println(a1.name);  // 分步写
            System.out.println(new demo03().age); //一步写
            System.out.println("===========");

            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            System.out.println("===========");

            //调用静态内部类的静态属性(用类名来调用）
            System.out.println(Inner.count);
        }
    }

    public static void main(String[] args) {
        //静态内部可以直接被创建，不必依赖外部类，级别和外部类一样
        demo03.Inner aaa = new demo03.Inner();
        //调用方法
        aaa.show();

    }

}

局部内部类 ：

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期和自己相同，变量必须修饰为final
• 只有局部内部类调用了这个局部变量，这个变量才会会变成常量
• 局部内部类，不可以加任何的访问修饰符
• 限制类的使用

public class demo04 {
    public static void main(String[] args) {
        demo04 a1 = new demo04();
        a1.show();

    }

    private String name = "张三";
    private int age=35;

    public void show(){
        //定义局部变量
         String address = "深圳";


        //局部内部类:注意不能加任何访问修饰符
        class Inner{
            private  String phone ="111";
            private  String email = "453456789876@qq.com";

            //静态成员
            private final static  int count =123;

            public void show2(){
                //访问外部类的属性
                System.out.println(demo04.this.name);
                System.out.println(demo04.this.age);
                System.out.println("==============");

                //访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.email);
                System.out.println("==============");

                //访问局部变量：jdk1.7要求，变量必须是常量final ，jdk1.8会自动添加final
                //只有局部内部类调用了这个局部变量，这个变量才会会变成常量
                System.out.println(address);

            }

        }

        //创建局部内部类对象
        Inner a2 = new Inner();
        a2.show2();

    }
}

匿名内部类：

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类或实现一个接口
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

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


/*
        //局部内部类
        class fan implements USB{
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了...");
            }
        }

        //使用局部内部类创建对象
        USB a2 = new fan();
        a2.service();

 */

        //使用匿名内部类优化（相当于创建于一个局部内部类）
        USB a2 = new USB() {
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了...");
            }
        };
        a2.service();
    }
}

package Oop.ChangYong.demo05;
//实现接口，要写下接口的所有方法
public class Mouse implements USB {
    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始工作了...");

    }
}

//接口
public interface USB {
    //服务
    void service();
}