Java内部类

package com.oop.demo11;

/**
 * @ClassName: Outer
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/30-1:16
 * @Description: 外部类、成员内部类
 */
//外部类
public class Outer {
    //实例变量
    private String name = "张三";
    private int age = 20;

    //内部类
    class Inner{
        private String address = "北京";
        private String phone = "110";
        //属性和外部类的属性名相同
        private String name = "李四";

        //成员内部类不能定义静态成员(static),但是可以定义静态常量(static final)
        //private static String country = "中国";//报错
        private static final String country = "中国";


        //方法
        public void show(){
            //打印外部类的属性（如果内部类属性和外部类的属性名相同 Outer.this.属性）
            System.out.println(Outer.this.name);
            System.out.println(age);//调用外部类Outer的属性时，前面都可以加 Outer.this.
            //打印内部类的属性（属性前面可以加 this.）
            System.out.println(this.address);
            System.out.println(phone);//属性前面加 this. 之后，调用的属性更加明确
            System.out.println(name);//当外部类、内部类存在重名属性时，会优先访问内部类属性。
        }

    }

}

package com.oop.demo11;

/**
 * @ClassName: TestOuter
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/30-1:30
 * @Description: 测试成员内部类
 */
public class TestOuter {
    public static void main(String[] args) {
        //1创建外部类对象
//      Outer outer = new Outer();
        //2创建内部类对象
//      Outer.Inner inner = outer.new Inner();

        //一步到位
        Outer.Inner inner = new Outer().new Inner();

        inner.show();
    }
}

package com.oop.demo12;

/**
 * @ClassName: Outer
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/30-2:49
 * @Description: 外部类、静态内部类
 */
//外部类
public class Outer {
    private String name = "xxx";
    private int age = 18;

    //静态内部类：级别和外部类相同
    static class Inner{     //只有内部类才能用static修饰
        private String address = "上海";
        private String phone = "111";
        //静态成员
        private static int count = 1000;

        public void show(){
            //调用外部类的属性
            //1先创建外部类对象
            Outer outer = new Outer();
            //2再来调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);

            //调用静态内部类的属性和方法
            System.out.println(this.address);//属性前面可以加 this.（也可以不加）
            System.out.println(phone);

            //调用静态内部类的静态属性
            System.out.println(Inner.count);//静态成员是通过类名来访问的
        }

    }
}

package com.oop.demo12;

/**
 * @ClassName: TestOuter
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/30-3:12
 * @Description: 测试静态内部类
 */
public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();//这里new的是Outer下面的Inner，不是Outer（Outer后面没有写()，这里只是表示包含关系）
        //调用方法
        inner.show();
    }
}

package com.oop.demo13;

/**
 * @ClassName: Outer
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/30-23:05
 * @Description: 外部类、局部内部类
 */
//外部类
public class Outer {
    private String name = "刘德华";
    private  int age = 35;

    public void show(){
        //定义局部变量
        String address = "深圳";//（jdk1.8）前面默认加了一个 final（常量），即 final String address = "深圳";
        //final String address = "深圳"; //因为局部变量在方法运行结束后就消失了，所以要加一个final，使其变为常量，这样局部内部类才能够访问到

        //局部内部类：注意前面不能加任何访问修饰符（public、private、protected……）
        class Inner{    //局部内部类在外部类的方法中
            //局部内部类的属性
            private String phone = "15588888888";
            private String email = "liudehua@qq.com";
            private final static int count = 2000;//在局部内部类中不能包含静态成员（static），但可以有静态常量（final static）

            public void show2(){
                //访问外部类的属性
                System.out.println(Outer.this.name);
                System.out.println(age);//Outer.this. 可以省略
                //访问内部类的属性
                System.out.println(this.phone);
                System.out.println(email);//this. 可以省略

                //访问局部变量,jdk1.7要求：变量必须是常量 final；jdk1.8自动添加 final
                System.out.println(address);//address为常量，后面不能进行修改   这里的address已经是常量"深圳"了，即 System.out.println("深圳");
                System.out.println("深圳");
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }

}

package com.oop.demo13;

/**
 * @ClassName: TestOuter
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/30-23:33
 * @Description: 测试局部内部类
 */
public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

package com.oop.demo14;

/**
 * @ClassName: USB
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/31-18:07
 * @Description: 接口
 */
//接口
public interface Usb {
    //服务方法
    void service();
}

package com.oop.demo14;

/**
 * @ClassName: Mouse
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/31-18:12
 * @Description: 接口实现类  鼠标
 */
public class Mouse implements Usb{

    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始工作了...");
    }
}

package com.oop.demo14;

/**
 * @ClassName: TestUsb
 * @Author: 南冥有猫不须铭
 * @Date: 2021/5/31-18:11
 * @Description: 测试类
 */
public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
        /*Usb usb = new Mouse();//多态：接口创建一个变量，来研究具体的实现类
        usb.service();*/

        //局部内部类(实现接口)
//        class Fan implements Usb{
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，风扇开始工作了...");
//            }
//        }
        //使用局部内部类创建对象
//        Usb usb = new Fan();
//        usb.service();


        //使用匿名内部类优化（相当于创建了一个局部内部类）
        Usb usb = new Usb() { // 即 new Usb() { （可省略前面的）    // 这里的 Usb() 可以是接口、抽象类、父类，在{}里重写其中的方法
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了...");
            }
        };
        usb.service();

    }
}