常用类 第1天（内部类的分类，内部类的概念，成员内部类，静态内部类，局部内部类，匿名内部类）

1. 内部类的分类

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

2. 内部类的概念

• 概念：在一个类的内部再定义一个完整的类（内部类也会生成class文件）

  class Outer{
      class Inner{
          
      }
  }
  

• 特点：

  • 编译之后可生成独立的字节码文件

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

    public class Outer {
        private String name;
    
        class Inner {
            public void show() {
                System.out.println(name);
            }
        }
    }
    

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

3. 成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

• 当外部类、内部类存在重名属性时，会优先访问内部类属性

• 成员内部类不能定义静态成员，但是可以定义静态常量

public class Test {
    public static void main(String[] args) {
        // 创建外部类对象
        Outer outer1 = new Outer();

        // 创建内部类对象
        Outer.Inner inner1 = outer1.new Inner();

        inner1.show();

        System.out.println("***************");

        // 简化
        Outer.Inner inner2 = new Outer().new Inner();

        inner2.show();
    }
}

// 外部类
public class Outer {
    // 实例变量
    private String name = "ABC";
    private int age = 10;

    // 内部类
    class Inner {
        private String address = "qwe";
        private String phone = "123";
        private int age = 20;

        // 方法
        public void show() {
            // 打印外部类的属性
            System.out.println(Outer.this.name);
            System.out.println(Outer.this.age);

            // 打印内部类的属性
            System.out.println(this.address);
            System.out.println(this.phone);

            // 属性与外部类的属性同名，需要用 外部类名.this 调用
            System.out.println(this.age);
        }
    }
}

4. 静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
• 只有内部类才能用static修饰

public class Test {
    public static void main(String[] args) {
        // 直接创建静态内部对象
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

// 外部类
public class Outer {
    // 实例变量
    private String name = "ABC";
    private int age = 10;

    // 静态内部类（级别和外部类相同）
    static class Inner {
        private String address = "qwe";
        private String phone = "123";

        // 静态成员
        private static int num = 20;

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

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

5. 局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法

• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final

• 限制类的使用范围，只能在当前方法中使用

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();

        outer.show1();
    }
}

// 外部类
public class Outer {
    private String name = "ABC";
    private int age = 10;

    public void show1() {
        // 定义局部变量
        String address = "qwe";

        // 局部内部类（不能加任何访问修饰符）
        class Inner {
            // 局部内部类的属性（不能有静态变量，但可以有静态常量）
            private String phone = "123";
            private final static int num = 20;

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

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

                // 访问局部变量（jdk1.7要求：变量必须是常量，jdk1.8之后自动添加final）
                System.out.println(address);
            }
        }

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

6. 匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）

• 必须继承一个父类或者实现一个接口

• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象

• 优点：减少代码量

• 缺点：可读性较差

public class Test {
    public static void main(String[] args) {
        // 创建接口类型的对象
        USB usb1 = new Mouse();
        usb1.service();

        // 局部内部类
        class Keyboard implements USB {

            @Override
            public void service() {
                System.out.println("Keyboard connect successfully");
            }
        }

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

        // 匿名内部类进行优化（相当于创建了一个局部内部类）
        USB usb3 = new USB() {
            @Override
            public void service() {
                System.out.println("Connect successfully");
            }
        };
        usb3.service();
    }
}

public class Mouse implements USB {
    @Override
    public void service() {
        System.out.println("Mouse connect successfully");
    }
}

// 接口
public interface USB {
    // 方法
    void service();
}