Java内部类总结

小伙伴们，好久没有写文了，一直在学习 Java，写了一篇Java面向对象内部类的文章，如果觉得有用的话点赞收藏+关注哦！！！，开始吧 ✔️

---

如果痛苦的话，不努力也没关系

---

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类成为内部类 (inner class)

在学习内部类之前，先来了解一下类的五大成员

类的五大成员

1. 属性
2. 方法
3. 构造器
4. 代码块
5. 内部类

---

内部类

定义类在局部位置(方法中/代码块) :

• 局部内部类
• 匿名内部类

定义在成员位置

• 成员内部类
• 静态内部类

---

局部内部类

局部内部类是定义在外部类的局部位置，通常方法中，并且有类名

• 可以直接访问外部类的所有成员，包含私有的
• 不能添加访问修饰符，但是可以使用final 修饰
• 作用域：仅仅在定义它的方法或代码块中
• 局部内部类可以直接访问外部类的所有成员
• 外部类在方法中可以创建内部类实例，然后调用方法即可
• 外部其他类不能访问局部内部类
• 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果
• 想访问外部类的成员，可以使用：外部类名.this.成员

public class inner05 {
    public static void main(String[] args) {
        new Outer01().m();
    }
}

class Outer01 { //外部类
    private int n = 50;

    private void f() {
        System.out.println("我是外部类的f私有方法，我被调用了");
    }

    public void m() {
        int n = 100; //重名了，访问遵循就近原则
        //局部内部类
        class Inner01 {
            public void f1() {
                //可以直接访问外部类的所有成员，包含私有的
                System.out.println("n=" + n);
                //访问外部类的属性通过 外部类名.this.成员
                System.out.println("n=" + Outer01.this.n);
                f();
            }
        }
        //在方法中new内部类并调用方法
        new Inner01().f1();
    }
}

输出：
n=100
n=50
我是外部类的f私有方法，我被调用了

---

✔️匿名内部类

传统方法，写一个类，实现该接口，并创建对象
新需求，只使用一次，后面不在使用，使用匿名内部类简化开发

cat 的编译类型 AA ，cat 的运行类型是匿名内部类 inner03$1

JDK在底层，创建了匿名内部类inner03$1，new立即就创建了一个inner03$1实例，并且把地址返回给 cat,匿名内部类，使用一次就不能再使用了，但是生成的对象 cat 可以一直使用。

基于接口的匿名内部类

public class inner03 {
    public static void main(String[] args) {
        AA cat = new AA(){
            @Override
            public void shot() {
                System.out.println("喵喵叫");
            }
        };
        cat.shot();
        System.out.println(cat.getClass());
    }
}

interface AA { //接口
    public void shot();
}

输出：
喵喵叫
class innerclass.inner03$1

基于类的匿名内部类

public class inner04 {
    public static void main(String[] args) {
        //基于类的匿名内部类
        Fa f = new Fa("森") {
        };
        f.say();
        System.out.println();
    }
}

class Fa {
    private String name;

    public Fa(String name) {
        this.name = name;
    }

    public void say() {
        System.out.println(this.name + "说话了");
    }
}

输出：
森说话了

---

成员内部类

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/09/06/10:26
 */
public class demo08 {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.t1();

        //外部其他类访问成员内部类
        //1
        Outer03.Inner03 inner03 = outer03.new Inner03();
        inner03.say();

        //2，再外部类中编写一个方法
        Outer03.Inner03 getinnero3 = outer03.getInnero3();
        getinnero3.say();

    }
}

class Outer03 {//外部类
    private int n1 = 10;
    public String name = "小刘";
    private void say(){
        System.out.println("say");
    }

    //成员内部类（没有写在方法中或代码块中，就好比是Outer03的一个成员，因此叫成员内部类）
    //可以添加四种修饰符，因为它的低位就是类成员
    //作用域就是整个外部类，其实成员内部类就相当于类成员，那自然作用域就是这个类
    //成员内部类可以直接访问外部类成员(属性和方法)，私有也可以
    //外部类访问成员内部类，创建对象，再访问
    //外部其他类访问成员内部类
    public class Inner03 {
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            System.out.println("n1:" + n1 + "  name：" + name);
            //如果外部类和内部类有重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，可以使用
            //外部类名.this.类名    去访问，如下
            Outer03.this.say();
        }
    }

    public void t1(){
        //使用了成员内部类
        Inner03 inner03 = new Inner03();
        inner03.say();
    }

    //方法，返回一个Inner03的实例
    public Inner03 getInnero3(){
        return new Inner03();
    }
}

---

静态内部类

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/09/06/21:41
 */
public class demo09 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.na();

        //外部其他类  访问静态内部类
        //1,静态内部类可以通过类名直接访问，前提是要满足访问权限
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //2.写一个方法，返回静态内部类的对象实例
        Outer10.Inner10 inner101 = outer10.getInner10();
        inner101.say();
    }
}

class Outer10 {//外部类
    private int n1 = 10;
    private static String name = "小刘";

    private static void cry(){}
    static class Inner10 {//静态内部类
        //在外部类的成员位置，使用 static 修饰
        //可以直接访问外部类的所有静态成员，包含私有的，但是不能访问非静态的方法
        //可以添加任意地访问修饰符，因为它的低位就是一个成员
        //作用域：同其他成员，为整个类体
        private static String name = "小张";

        public void say(){
//            System.out.println(n1);//报错，不允许
            //外部类和静态内部类重名，静态内部类访问时默认遵循就近原则
            System.out.println(name);//OK
            //如果想访问外部的成员，可以用(外部类名.成员)
            System.out.println(Outer10.name);
            //静态内部类访问外部类，直接访问所有静态成员

            cry();
        }
    }
    public void na(){
        //外部类访问静态内部类，先创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10(){
        return new Inner10();
    }
}