Java常用类：内部类

内部类

• 在类的内部再定义一个完整的类

• 特点：

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

成员内部类

• 在类的内部定义，与实例变量、实例方法同级
• 外部类的实例部分，创建内部对象时必须依赖外部类对象
  • Out out = new Outer();
  • Inner in = out.new Inner();
• 当外部类和内部类存在重名属性时，优先访问内部类属性
  • 要访问需要使用 外部类名称.this.属性名
• 成员内部类不能声明静态成员，可以包含静态常量 ，如： private static final Int AGE = 12;

静态内部类

在成员内部类的基础上添加 static修饰符

• 不依赖外部类对象，可以直接创建或通过类名访问，可以声明静态成员
• 调用外部类的属性和方法，需要在内部类中将外部类实例化，通过对象调用属性
• 调用内部的属性和方法可以直接调用
• 调用内部的静态属性：静态内部类名.属性

public class Outer {
    private String name = "chachan53";
    private int age = 13;

    //静态内部类：和外部类相同
    static class Inner{
        private String address="city";
        private String phone = "number";
    //静态成员
    private static int count = 1233;

        public void show(){
            //调用外部成员属性
            //1. 创建外部类对象
            Outer outer = new Outer();
            //2. 调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类的属性和方法：直接使用
            System.out.println(address);
            //调用静态内部类的静态属性：类名.属性
            System.out.println(Inner.count);
        }
    }
}

使用：

public static void main(String[] args) {
    //创建静态内部类对象
    Outer.Inner inner = new Outer.Inner();
    //调用方法
    inner.show();
}

局部内部类

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

public class Outer2 {
    private String name= "chachan53";
    private int age=22;

    //静态方法不能访问非静态属性
    public void show(){
        //定义局部变量(自动添加final)
        //show方法执行后，局部变量会消失，若不将其定义为常量，类中的方法无法使用消失的变量
        String address="city";

        //局部内部类:前面不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "2343423";
            private String email = "123@qq.com";
            //静态常量
            private final static int count = 120032;

            public void show2(){
                //访问外部类的属性
                System.out.println(name);
                //内部类属性和外部类属性重名时可以使用
                System.out.println(Outer2.this.name);
                System.out.println(age);
                //访问内部类的属性
                System.out.println(this.phone);//or phone
                System.out.println(this.email);
                //访问局部变量，在JDK1.7中要求变量必须是常量（final），在JDK1.8中会自动添加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象，外部对象才能调用局部内部类中的属性
        //执行后inner变量会消失，对象(new Inner())不会消失，类(Inner)不会消失
        Inner inner = new Inner();
        inner.show2();
    }
}

使用：

public static void main(String[] args) {
    Outer2 outer2 = new Outer2();
    outer2.show();//无法调用show2，需要在方法中创建局部内部类对象后才能调用
}

匿名内部类

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

接口的使用：

方法1：创建实现类，在 mian方法中通过创建对象调用

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

//使用
    public static void main(String[] args) {  
        //创建接口类型的变量，多态
        USB usb = new Mouse();
        usb.service();
    }

方法2：在 main方法中创建实现接口的局部内部类

//mian函数中的局部内部类
//实现接口的局部内部类
class Fan implements USB{
    @Override
    public void service() {
        System.out.println("风扇");
    }
}

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

方法3：使用匿名内部类优化

使用时，在语句中创建一个一次性的实现类

//只使用一次，使用匿名内部类优化(相当于创建了一个局部内部类)
USB usb = new USB() {
    @Override
    public void service() {
        System.out.println("风扇");
    }
};//注意此处的封号，是语句的结尾
usb.service();