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();
    }
}