java内部类

内部类

在类外面的类(两个平等的类)

跟建立两个类一样，但是只能有一个public类

成员内部类（相当于外部类的一个属性）

1. 创建内部类必须依赖外部类对象
2. 内部类可以访问外部类的私有属性

public class Outer {
    private int id=100;
    public void out(){
        System.out.println("这是一个外部类");
    }
    class Inner{//内部类
        public void in(){
            System.out.println("这是一个内部类");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }

    }

 //内部类可以直接访问外部类的方法和属性，不需要创建外部类对象
//当内部类为static，它是在程序最开始运行，就不能访问非static属性，但是可以访问static属性
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner=outer.new Inner();
        outer.out();//这是一个外部类
        inner.in();//这是一个内部类
        inner.getID();//这是一个内部类

    }
}

3. 当外部类与内部类重名时，优先访问内部类属性

public class Outer {
    private String name="Liuxinyu";
    private int id=100;
        private int age=15;

    public void out(){
        System.out.println("这是一个外部类");
    }
    class Inner{
        private String name="刘心雨";
        private int id=20;

        public void in(){
            System.out.println("这是一个内部类");
        }
        //获得外部类的私有属性
        public void show(){
            System.out.println(age);//15(外部类独有)
            System.out.println(name);//刘心雨(内部类数据)
            System.out.println(id);//20（内部类数据）
            System.out.println(Outer.this.name);//Liuxinyu(外部类数据)
            System.out.println(Outer.this.id);//100(外部类数据)
        }

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner=outer.new Inner();
        outer.out();//这是一个外部类
        inner.in();//这是一个内部类
        inner.show();

    }
}

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

静态内部类（相当于一个平等外部类）

1. 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
2. 直接访问外部类的静态成员，不需要实例化外部类

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

    //静态内部类：和外部类相同
    static class Tnter{
        private String address="宿州";
        private String phone="123456789";
        //静态成员
        private static int count=1000;
        public void show(){
            //调用静态内部类的外部类属性
            Outer outer = new Outer();//和外部类一样，先创建一个外部类对象，然后访问属性
            System.out.println(outer.name);//外部
            System.out.println(outer.age);//10
            //调用静态内部类的内部类属性
            System.out.println(address);//宿州
            System.out.println(phone);//123456789
            //调用静态内部类的静态属性
            System.out.println(Tnter.count);//1000

        }
    }
}

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

局部内部类

1. 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
2. 访问局部内部类需要在方法中创建一个内部类对象在访问方法直接可以用
3. 访问外部类属性：不重名可以直接访问,重名看程序
4. 访问局部变量:(自动添加finall)是一个常量，不能修改

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

    public void show(){
        String address="宿州";//不能带修饰符

        class Inter{//局部内部类：不能加任何修饰符
            private String phone="123456789";
            private String name="内部";

            public void show_2(){
                //访问外部类属性：不重名可以直接访问,
                System.out.println(name);//内部(重名，访问内部数据)
                System.out.println(Outer.this.name);//外部(外部数据)推荐使用这个
                System.out.println(age);//10(不重名，外部数据)
                System.out.println(Outer.this.age);//10(外部数据)推荐使用这个
                //访问内部类属性
                System.out.println(phone);//123456789(内部数据)
                System.out.println(name);//内部(内部数据)
                System.out.println(this.name);//内部(内部数据)
                //访问局部变量:(自动添加finall)是一个常量，不能修改
                System.out.println(address);//宿州
            }
        }
        //访问局部内部类需要在方法中创建一个内部类对象在访问方法直接可以用
        Inter in=new Inter();
        in.show_2();
    }
}

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

    }
}

匿名内部类

1. 没有类名的局部内部类（一切特征都与局部内部类相同）
2. 必须继承一个父类或者接口
3. 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
4. 优点：减少代码

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

public class USBTest {//局部内部类
    public static void main(String[] args) {
        

        局部内部类：在静态main方法中
        class Fan implements USB{
            @Override
            public void service() {
                System.out.println("风扇");
            }
        }
        //使用局部内部类创建对象
        USB usb=new Fan();
        usb.service();
        }}

public class USBTest {//匿名内部类
    public static void main(String[] args) {

        //因为这个类只使用一次，所以采用匿名内部类
        USB usb=new USB() {
            @Override
            public void service() {
                System.out.println("风扇");
            }
        };
        usb.service();

     }

    }