基本介绍

一个类的内部又完整的嵌套了另外一个类结构，被嵌套的类称为内部类 嵌套其他类的类外部类 ，是我们类的第五大成员（属性 方法 构造器 代码块 内部类），内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

基本语法

class Outter{//外部类
    class Lnner{//内部类

    }
}
class Other{}//外部其他类

内部类的分类

定义在外部类局部位置上的（比如方法内）

1.局部内部类（有类名）

2.匿名内部类（没有类名， 重点）

定义在外部类的成员位置上

1.成员内部类（没用static修饰）

2.静态内部类（使用static修饰）

局部内部类的使用

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

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

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

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

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

5.外部类---访问--->局部内部类的成员【访问方式：创建对象 再访问（注意：必须在作用域中）】

class Out{//外部类
    int w=10;
    public void ww() {
        class Lnner {//局部内部类
            public void dw(){}
        }
        Lnner lnner = new Lnner();
        lnner.dw();
    }
}

• 局部内部类定义在方法中/代码块
• 作用域在方法或者代码块中
• 本质仍然是一个类

6.外部其他类---不能访问--->局部内部类【因为 局部内部类地位是一个局部变量】

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

如：System.out.println("外部类的n2"+外部类名.this.n2)

匿名内部类的使用（重要）

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

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

new 类或者接口(){
    类体
        };

2.匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因为从语法上看，它即有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因为可以调用匿名内部类方法

class Other{
    public void ww(){
        new Other(){

        };
        ii i=new ii(){
            @Override
            public void uu() {
                System.out.println("重写接口");
            }
        };
    }
}
interface ii{
    public void uu();
}

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

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

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

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

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

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

成员内部类的使用

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

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

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

3.作用域

和外部类的其他成员一样，为整个类体

4.成员内部类---访问--->外部类（比如属性）【访问方式：直接访问】

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

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

public class Nbn {
    public static void main(String[] args) {
        Ue ue = new Ue();
        //Ue.Dd dd =ue.new Dd()第一种
        //Ue.Dd dd = ue.dd();第二种  创建方法返回实例
    }
}
class Ue{
    class Dd{

    }
    public Dd dd(){
        return new Dd();
    }


}

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

静态内部类的使用

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

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

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

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

4.静态内部类---访问--->外部类(比如：静态属性)【访问方式：直接访问所有静态成员】

5.外部类---访问--->静态内部类【访问方式：创建对象，在访问】

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

public class Nbn {
    public static void main(String[] args) {
        Ue ue = new Ue();
        //Ue.Dd dd =new Ue.Dd();第一种
        //Ue.Dd dd =ue.dd();第二种(1)  创建方法返回实例
        //Ue.Dd dd =Ue.dd1();第二种(2) 创建方法返回实例
    }
}
class Ue{
    static class Dd{

    }
    public Dd dd(){
        return new Dd();
    }
    public static Dd dd1(){
            return new Dd();
    }

}

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

小结

1.内部类有四种 局部内部类 匿名内部类 成员内部类 静态内部类

2.重点是 匿名内部类的使用

如：new 类/接口 （参数列表）{}

3.成员内部类 静态内部类 是放在外部类的成员位置，本质就是一个成员