目录

概念：

基本语法：

局部内部类

匿名内部类：

 匿名内部类的最佳使用场景：

成员内部类

6.外部其他类 访问 成员内部类

 第一种：直接new一个外部类，在利用该对象new一个内部类

第二种：在外部类中提供一个方法，返回一个内部类实例

静态内部类

分组：

---

概念：

一个类的内部又完成的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套其他类的类成为外部类。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之前的包含关系。

基本语法：

局部内部类

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名、

1.可以直接访问外部类的所有成员，包含私有的

2.不能添加访问修饰符，以为它的地位就是一个局部变量，局部变量不可以添加访问修饰符。但是可以使用final修饰，因为局部变量也可以使用final

3.作用域：仅仅在定义它的方法或代码块中

4.局部内部类 访问 外部类的成员【直接访问】

5.外部类 访问 局部内部类的成员

访问方式：创建对象，再访问(注意：必须在作用域内)

 6.外部其他类 不能访问 局部内部类(因为局部内部类地位是一个局部变量)

7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问（第一点的那个图的右边红框就是演示示例）

匿名内部类：

非常重要！！！！！！

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

本质是类，是一个内部类，没有名字(在系统内部)，同时还是一个对象

1.匿名内部类的基本语法

new 类或接口(形参列表) {

        类体

}

 调用一个实现IA接口的类，并只使用一次

接口的匿名内部类

class Outer04 {//外部类
    private int n1 = 10;//属性
    public void method() {//方法
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };//这本身是条语句，分号不能少
        tiger.cry();
    }
}
 
interface IA {//接口
    public void cry();
}

下面的匿名内部类名字了解即可

其实该内部类可以认为是

class xxxx implements IA {
 
    @Override
    public void cry() {
        System.out.println("老虎叫唤...");
    }
}

其中xxxx是【外部类名+$+数字】

发现创建两个不同的匿名内部类时，匿名内部类的类名中的数字时从小到大依次递增的

匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它即有定义类的特征，又有创建对象的特征。

public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}
 
class Outer05 {
    private int n1 = 99;
    public void f1() {
        //创建一个基于类的匿名内部类
        Person person = new Person("tom") {
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi方法 n1=" + n1 +
                        " 外部内的n1=" + Outer05.this.n1);
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };
        person.hi();//动态绑定
    }
}
 
class Person {//类
    private String name;
 
    public Person(String name) {
        this.name = name;
    }
 
    public void hi() {
        System.out.println("Person hi()");
    }
 
    public void ok() {
        System.out.println(name);
    }
    public void say(String str) {
        System.out.println(str);
    }
}

 3.可以直接访问外部类的所有成员，包含私有的

4.不能添加访问修饰符，以为它的地位就是一个局部变量

5.作用域：仅仅在定义它的方法或代码块中

6.匿名内部类 访问 外部类成员【访问方式：直接访问】

7.外部其他类 不能访问 匿名内部类（因为匿名内部类地位是一个局部变量）

8.如果外部类和匿名内布列的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

 匿名内部类的最佳使用场景：

作为实参传入方法

经典案例：

 

成员内部类

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰

1.可以持节访问外部类的所有成员，包含私有的

2.可以添加任意访问修饰符，以为它的地位就是一个成员

 

3.作用域，和外部类的其他成员一样，为整体类体，在外部类的成员方法

4.成员内部类 访问 外部类【访问方式：直接访问】

5.外部类 访问 内部类【访问方式：创建对象，再访问】

6.外部其他类 访问 成员内部类

 第一种：直接new一个外部类，在利用该对象new一个内部类

第二种：在外部类中提供一个方法，返回一个内部类实例

 

7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

静态内部类

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

1.可以直接访问外部类的所有静态成员，但是不能直接访问非静态成员(可以创建一个对象访问)

2.可以添加任意访问修饰符，因为它的位置就是一个成员

3.作用域：同其他的成员，为整体类体

4.静态内部类 访问 外部类【访问方式：直接访问所有静态成员】

5.外部类 访问 静态内布列【访问方式：创建对象，再访问】

外部类方法中

 6.外部其他类 访问 静态内部类

第一种方式

 

第二种方式

也可以使用非静态方法，就是让static去掉，这里不演示了

 

7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

分组：

局部内部类、匿名内部类

成员内部类、静态内部类