Java常用类（内部类）

内部类

• 概念：在一个类的内部再定义一个完整的类
• 内部类也回生成class文件
• 内部类可以直接访问外部类的私有成员，而不破坏封装
• 可为外部类提供必要的内部功能组件

public class Body {
    private String name="su";
    public static void main(String[] args) {
        Body body = new Body();
        body.new Header().show();
    }
    class Header{
        public void show(){
            System.out.println(name);
        }

一、成员内部类

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

Outer out = new Outer();
Inner in = out.new Inner();

• 当外部类、内部类存在重名属性时，会优先访问内部类属性
  此时访问外部类要加Outer.this.属性名
• 成员内部类中不能有静态属性，但是可以有静态常量

二、静态内部类

• 不依赖外部类对象，可以直接创建或通过类名访问
• 可声明静态成员
• 只能直接访问外部类的静态成员，实例成员需实例化外部类对象

public class Outer {
    private String name = "su";
    private static int age=18;
    //静态内部类，级别和外部类相同
    static class Inner{
        private String ad="jiangsu";
        private static int count=1000;
        public void show(){
            Outer outer = new Outer();
            System.out.println(outer.name);
            System.out.println(age);
            System.out.println(ad);
            System.out.println(count);
        }
    }

public class A {
    public static void main(String[] args) {
        new Outer.Inner().show();
    }
}

三、局部内部类

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

public class A {
    private String name="su";
    private int age=23;
    public void show(){
        //定义局部变量
        final String address = "js";
        //局部内部类,不能加任何访问修饰符
        class Inner{
            private String phone ="115";
            private char sex='女';
            public void show2(){
                System.out.println(A.this.name);
                System.out.println(age);
                System.out.println(this.phone);
                System.out.println(sex);
                //访问局部变量，自动添加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        new Inner().show2();
    }

public class Outer {
    public static void main(String[] args) {
        A a = new A();
        a.show();
    }
}

四、匿名内部类

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

public interface Usb {
    void service();
}

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

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("sucessfully,working...");
//            }
//        }
//        Usb usb = new Fan();
//        usb.service();

        //匿名内部类(相当于创建了一个局部内部类)
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("sucessfully,is working...");
            }
        };
        usb.service();
    }
}