20220812-Java内部类

跟老韩学完了java面向对象的高级篇，老师提到了卖油翁和老黄牛的故事，在学习Java的路上，借以自勉，“我亦无他，唯手熟尔”，天道酬勤，长路漫漫，少年加油，未来可期～
今晚对学习到的内部类进行知识总结。
！！匿名内部类比较关键，注意使用方法

目录

• 一、内部类概念
• 二、内部类分类
  • 1. 局部内部类
    • 1.1 代码示例
    • 1.2 使用细节
  • 2. 匿名内部类!!!重要
    • 2.1 代码示例
    • 2.2 使用细节
  • 3. 成员内部类
    • 3.1 代码示例
    • 3.2 使用细节
  • 4. 静态内部类
    • 4.1 代码示例
    • 4.2 使用细节

一、内部类概念

内部类：在一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套其他类的类称为外部类。

至此，类的五大成员全部接触过了：

• 属性Field
• 方法Method
• 构造器Constructor
• 代码块Code Block
• 内部类Inner Class

---

二、内部类分类

1. 局部内部类

1.1 代码示例

public class ParameterInnerClass {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.f();
    }
}
class Outer01 {
    private int age = 10;
    //1. 成员方法内部的局部内部类
    public void f() {
        class Inner01 {
            int age = 20;
            public void m() {
           //内部类中可以直接调用父类中的成员
           //当内部类与外部类存在相同名称的变量时，遵循就近原则
           //调用父类成员时需要使用：外部类.this.变量名；
                System.out.println(age);
                System.out.println(Outer01.this.age);
            }
        }
        Inner01 inner01 = new Inner01();
        inner01.m();
    }
    //2. 代码块内部的局部内部类
    {
        class Inner02 {
            int age = 20;
            public void m() {
                System.out.println(age);
                System.out.println(Outer01.this.age);
            }
        }
        Inner02 inner02 = new Inner02();
        inner02.m();
    }
}

1.2 使用细节

• 局部内部类中可以直接访问外部类的所有成员，包含私有成员；
• 局部内部类不能添加访问修饰符，因为它的地位就是一个局部变量，但是可以使用final修饰；
• 作用域：在定义它的方法或者代码块中；
• 局部内部类—访问—外部类的成员（访问方式：直接访问）；
• 外部类—访问—局部内部类的成员（访问方式：创建内部类对象，通过对象访问）；
• 外部其他类无法访问局部内部类；
• 外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，使用（外部类名.this.成员）去访问。

---

2. 匿名内部类!!!重要

2.1 代码示例

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.f();
    }
}
class Outer02 {
    private int age = 10;
    //1. 成员方法中的匿名内部类
    public void f() {
        IF01 a = new IF01() {
            @Override
            public void m() {
                System.out.println("方法中匿名内部类f()...age=" + age + " " + this.getClass());
            }
        };
        a.m();
        A b = new A() {
            @Override
            public void n() {
                System.out.println("方法中匿名内部类n()...age=" + age + " " + this.getClass());
            }
        };
        b.n();
    }
    //2. 代码块中的匿名内部类
    {
        new IF01() {
            @Override
            public void m() {
                System.out.println("代码块中匿名内部类f()...age=" + age);
            }
        };
        new A() {
            @Override
            public void n() {
                System.out.println("代码块中匿名内部类n()...age=" + age);
            }
        };
    }
}
interface IF01 {
    public void m();
}
class A {
    public void n() {
        System.out.println("A n()...");
    }
}

2.2 使用细节

• 本质是类；内部类；该类没有名字；同时是一个对象;
• 匿名内部类即使一个类的定义，本是也是一个对象，它既有定义类的特征，也有创建对象的特征;
• 可以访问外部类的所有成员，包含私有的;
• 不能添加访问修饰符，因为他的地位就是一个局部变量;
• 作用域：方法体中或者代码块中;
• 匿名内部类—访问—外部类成员（访问方式：直接访问）;

---

3. 成员内部类

3.1 代码示例

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer03 o1 = new Outer03();
        o1.m();
        //外部其他类访问成员内部类的方式
        //1. 方式1
        Outer03.Inner03 i1 = o1.new Inner03();
        //2. 方式2
        Outer03.Inner03 i2 = new Outer03().new Inner03();
        //3. 方式3
        Outer03.Inner03 i3 = o1.getInnerInstance();
    }
}
class Outer03 {
    private int age = 10;
    //成员内部类
    class Inner03 {
        public void f() {
            //成员内部类中可以直接访问外部类成员，包括私有成员
            System.out.println("age=" + age);
        }
    }
    // 方法：创建内部类对象，并访问内部类成员
    public void m() {
        //外部类通过创建内部类对象访问内部类成员
        Inner03 inner03 = new Inner03();
        inner03.f();
    }
    // 方法：返回内部类对象
    public Inner03 getInnerInstance() {
        return new Inner03();
    }
}

3.2 使用细节

• 成员内部类可以定义在外部类的成员位置，并且没有static修饰
• 可以直接访问外部类的所有成员，包含私有的
• 可以添加任意访问修饰符，因为它的地位是成员
• 作用域：与外部类其他成员一样，为整个类体
• 成员内部类—访问-外部类成员（访问方式：直接访问）
• 外部类成员—访问—内部类（访问方式：创建成员内部类的对象，再访问）
• 外部其他类—访问—内部类（访问方式：创建外部类对象，通过外部类对象来创建内部类对象）

---

4. 静态内部类

4.1 代码示例

public class StaticInnerClass {
    public static void main(String[] args) {
        //外部其他类访问静态内部类
        //方式1
        Outer04.Inner04 inner04 = new Outer04.Inner04();
        //方式2
        Outer04.Inner04 innerInstance = Outer04.getInnerInstance();
    }
}
class Outer04 {
    private int age = 10;
    public static String name = "A";
    //静态内部类
    static class Inner04 {
        public void f() {
            //静态内部类中不能访问外部类非静态属性
            //System.out.println("age = "+age);
            System.out.println("name = " + name);
        }
    }
    //方法：创建静态内部类对象，并访问其成员
    public void m() {
        Inner04 inner04 = new Inner04();
        inner04.f();
    }
    public static Inner04 getInnerInstance() {
        return new Inner04();
    }
}

4.2 使用细节

• 静态内部类定义在外部类的成员位置，并且有static修饰
• 可以直接访问外部类的所有静态成员，包含私有的，但不可以访问非静态成员
• 可以添加任意访问修饰符
• 作用域：整个类体

---