JavaSE10

内部类

分类

• 成员内部类
• 静态内部类
• 局部内部类（定义在方法内部）
• 匿名内部类

特点

//外部类
public class Outer {
    private String name="Outer";
    private int age=20;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //内部类
     class Inner{
        private int age=15;//内部类属性和外部类属性重名时优先访问内部类
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public void showOuterName(){
            System.out.println(name);
        }
        public void showInnerAge(){
            System.out.println(age);
        }
        public void showOuterAge(){System.out.println(Outer.this.age);}//获取重名外部类的属性
    }
}

• 编译后可生成独立的字节码文件
• 可以访问外部类的私有成员而不破坏封装
• 可以为外部类提供必要的内部功能组件

成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类
• 创建内部类对象时，必须依赖外部类对象

         //先创建外部类对象
       // Outer outer = new Outer();
        //创建内部类对象
        //Outer.Inner inner = outer.new Inner();
         //一步到位
        Outer.Inner inner = new Outer().new Inner();
        inner.showOuterName();//Outer
        inner.showInnerAge();//15

• 当外部类属性和内部类属性重名时优先访问内部类
• 当外部类属性和内部类属性重名时需要访问外部类的属性需加外部类名.this.属性名（Outer.this.age）
• 成员内部类不能定义静态成员，但可以包含常量

静态内部类

• 在类的内部定义，与外部类同一级别
• 不依赖外部对象，只有直接创建或通过类名访问，可以声明静态成员 （相当一个外部类）

//外部类
public class Outer2 {
    private static String name="Outer";
    private int age=18;
    //静态内部类，级别相当于外部类
    static class Inner{
        private int age=20;
        private static int id=15;
        public void sayOuterName(){
            //访问外部类属性或者将该属性设为static或者通过实例化外部类
            System.out.println(name);
        }
        public void sayInnerAge(){
            System.out.println(age);
        }
        public void sayOuterAge(){
            //过实例化外部类
            System.out.println(new Outer2().age);
        }
    }
}
//测试
        new Outer2.Inner().sayInnerAge();
        new Outer2.Inner().sayOuterName();
        new Outer2.Inner().sayOuterAge();

局部内部类

• 定义在方法中，作用范围和创建对象范围仅限于当前方法
• 局部内部类访问外部类当前方法中的局部变量，因为无法保证变量的生命周期与自身相同，变量必须用final修饰为常量
• 使用访问：当前方法

//外部类
public class Outer3 {
    private String name="Outer";
    private int age=20;
    public void sayName(){
         int id=150;//局部变量 默认使用final修饰的常量，jdk1.8后不用加了
        //局部内部类前面不能加任何访问修饰符
        class Inner{
            private int age=18;
            public void sayOuterName(){
                System.out.println(name);
            }
            public void sayInnerAge(){
                System.out.println(age);
            }
            public void sayOuterAge(){
                System.out.println(new Outer3().age);
            }
            public void sayId(){
                System.out.println(id);
            }
        }
        //在方法内创建局部内部类的对象
        new Inner().sayInnerAge();
        new Inner().sayOuterAge();
        new Inner().sayOuterName();
        new Inner().sayId();//访问局部变量
    }
}

//测试
    Outer3 outer3 = new Outer3();
    outer3.sayName();//在调用外部类的方法时执行内部类对象的方法

匿名内部类

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

//Usb接口
public interface Usb {
    void service();
}
//测试
 public static void main(String[] args) {
  //使用匿名内部类（相当于创建了一个局部内部类）
 Usb kerBorad = new Usb(){
            @Override
            public void service() {
                System.out.println("连接电脑成功，键盘可以工作了。。。");
            }
        };
        kerBorad.service();
    }