内部类总结

就是在一个类的内部再定义一个类

内部类与它的名字一致，在A类的内部定义一个B类，那么B类就是A类的一个内部类；同样地，A类就是B类的外部类。

内部类的特点：

• 编译之后可以生成独立的字节码文件
• 内部类可以直接访问外部类的私有成员，而不破坏封装

内部类分为：成员内部类、静态内部类、局部内部类、匿名内部类

一、成员内部类

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

举例说明：

//外部类
public class OuterClass {
    
    private int id = 1;
    public void out(){
        System.out.println("外部类方法！");
    }

    //内部类
    class InClass{
        public void in(){
            System.out.println("内部类方法！");
        }

        //获取外部类的私有属性
        public void getId(){
            System.out.println(id);
        }

    }

}

成员内部类的使用方式：（外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象）

public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        //通过这个外部类来实例化内部类
        OuterClass.InClass in = outer.new InClass();
    	//也可以将两行代码合并 - 一步到位
    	//InClass in = new OuterClass(),new InClass();
        in.getId();
}

实例化内部类后，如果外部类、内部类存在重名属性，调用会优先访问内部类属性，比如：

public class Outer {

    private String name = "张三";

    class Inner{
        private String name = "李四";

        public void Print(){
            //属性重名后内部类会直接访问内部类中的属性
            System.out.println(name);//习惯写为this.name
            //想要访问外部类的同名属性，就用外部类名.this的方式来访问
            System.out.println(Outer.this.name);
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.Print();
    }
}

结果为：

李四

张三

成员内部类不能定义静态成员

二、静态内部类

成员内部类的基础之上，添加static关键字，不依赖外部类对象，可以直接创建或通过类名访问，可声明静态成员

举例说明：

public class Outer {

    private String name = "张三";

    //静态内部类：级别和外部类相同
    static class Inner{
        private String address = "山西";
        //静态内部类可以声明静态成员（成员内部类不可以）
        private static int count = 1;

        public void Print(){
            //调用外部类的属性 - 用法与假设Inner类拿到Outer类的外边的用法一致（常规用法）
            //1.创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            //调用静态内部类的属性和方法可以直接调用
            System.out.println(address);
            //调用静态内部类的静态属性 - 直接用类名.属性
            System.out.println(Inner.count);
        }
    }

    public static void main(String[] args) {
        //静态内部类和外部类同级别 - 可以直接创建内部类对象（Outer.Inner可以清晰知道两者的包含关系）
        Outer.Inner inner = new Outer.Inner();
        inner.Print();
    }
}

三、局部内部类

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

举例说明：

//外部类
public class Outer {
    private String name = "张三";
    //外部类方法
    public void Print(){
        //局部变量
        String address = "山西";
        //局部内部类 - 在方法中(注意不能加任何访问修饰符)
        class Inner{
            //局部内部类属性
            private int count = 1;
            //局部内部类方法
            public void PrintTwo(){
                //访问外部类的属性
                System.out.println(LocalClass.this.name);
                //访问内部类的属性
                System.out.println(this.count);
                //访问外部类方法中的局部变量
                System.out.println(address);
                //访问外部类方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
                //jdk1.7要求必须是常量（final）；jdk1.8会自动添加final
            }
        }
        //要想使用内部类，就在包含有局部内部类的方法中创建一个内部类对象进行调用
        Inner inner = new Inner();
        inner.PrintTwo();
    }

    public static void main(String[] args) {
        //局部内部类的使用方法
        //1.先创建外部类对象
        Outer outer = new Outer();
        Outer.Print();
    }
}

四、匿名内部类

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

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

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

优点：减少代码量

缺点：可读性下降

举例说明：

public class AnonymousInnerClass {
    //匿名内部类配合接口使用
    public interface Test{
        void Print();
    }
    public static void main(String[] args) {
        //通过匿名内部类简化代码，实现定义类、实现类、创建对象的语法合并
        //该类只能创建一个当前这一个对象
        Test test = new Test() {    //{}括号之间的代码就属于匿名内部类
            @Override
            public void Print() {
                System.out.println("匿名内部类！");
            }
        };
        //用该对象调用对应方法
        test.Print();
    }
}

知识点整理自b站（Java学习营）视频链接