Java – 内部类

简介

在一个类的里面，再定义一个类

内部类

就是在类的内部再创建一个类

// 创建一个外部类
public class Car {
    private String carName;
    private int carAge;
    
    // 创建一个内部类
    class Engine{
        public String engineName;
        public int engineAge;
        
        public void show(){
            // 在内部类中可以访问自己的内部类成员属性
            System.out.println(engineName);
            // 在内部类中，可以访问外部类的私有成员属性
            System.out.println(carName);
        }
    }
    // 在外部类不能访问内部类的成员属性
    System.out.println(carName);  // => 报错
}

要访问内部类的成员，需要实例化内部类，再访问。

内部类的分类

匿名内部类

匿名内部类本质上就是隐藏了名字的内部类。

格式：

new 抽象父类/接口 {
    重写方法
    @override
    public void method(){}
};

匿名内部类的变化过程（*）

变换说明：

1.因为叫匿名内部类，所以定义类的名称就被删掉了，只剩下继承的 接口 或 抽象类。

去掉类名声明后只剩下类的函数体
{
    @Override
    public void show() {

    }
}

2.因为要突出这个匿名类是继承那个抽象类或接口，所以要定义继承类

// 抽象类或接口 ( 构造参数列表 )
Inter ( 构造参数列表 ){
    @Override
    public void show() {

    }
}

3.因为匿名类是没有名字的，所以就要先 new 出来，所以要在前面加上 new,和正常的 new Class(); 一样，后面都有一个 ";" 号，所以，我们 new 这个匿名内部类时都要在后面加上 ";"

// 抽象类或接口 ( 构造参数列表 )
new Inter ( 构造参数列表 ){
    @Override
    public void show() {

    }
};

4.其它重写要求就和一般子类一样定义了，注意，抽象类和接口都一样定义。

P.S:虽然说匿名内部类，但实际上Java会在编译的时候自动帮我们加上这个类的类名，如Class$1.class

 使用场景：

当方法的参数是接口或者类时，

以接口为例，可以传递这个接口的实现类对象

如果实现类只要使用一次，就可以用匿名内部类简化代码

成员内部类

1.写在成员位置的，属于外部类的成员。

public class Car {
  class Engine{}
}

2. 成员内部类可以被一些修饰符所修饰，如 public , 不写（默认），protected , private , static 等，这些修饰符在内部类中和类成员一样作用。

3.在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

获取成员内部类对象

方法一：在外部类中编写方法，对外提供内部类的对象

方法二：直接创建格式 外部类类名.内部类类名 内部类实例 = new 外部类类名().new 内部类类名()

示例：Outer.Inner oi = new Outer().new Inner();

访问处部类成员

外部类成员变量和内部类成员变量重名时，在内部类如何访问？

public class Outer {
    String name = "10";
    class Inner {
        String name = "20";

        public void show(){
            String name = "30";
            // 我们需要如何才能获得这三个成员变量？
            System.out.println(??);  // => 10
            System.out.println(??);  // => 20
            System.out.println(??);  // => 30
        }
    }
}

1.通过就近原则，我们可以使用直接访问的方式取得离自己最近的成员变量值。

2.通过 this 方式获取本类的成员变量值。

3.通过 Outer.this  方式获取外部类的成员变量值

System.out.println(Outer.this.name);  // => 10
System.out.println(this.name);  // => 20
System.out.println(name);  // => 30

静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。

public class Outer {
    static class Inner {
        public void show(){
        }
    }
}

创建静态内部类对象

外部类类名.内部类类名 内部类实例 = new 外部类类名.内部类类名()

public class Outer {
    static class Inner {
        public void show(){ }
        public static void staticShow(){}
    }
}

Outer.Inner oi = new Outer.Inner();

调用非静态方法的格式

先创建对象，用对象调用

public class Outer {
    static class Inner {
        public void show(){ }
        public static void staticShow(){}
    }
}

Outer.Inner oi = new Outer.Inner();
oi.show()

调用静态方法的格式

外部类名.内部类名.方法名();

public class Outer {
    static class Inner {
        public void show(){ }
        public static void staticShow(){}
    }
}

Outer.Inner.staticShow()

局部内部类

1.将内部类定义在方法里就叫做局部内部类，类似于方法里面的局部变量

2.外界是无法直接使用，需要在方法内部创建对象并使用。

3.该类可以直接访问处部类的成员，也可以访问方法内的局部变量。

public class Outer {
    // 成员内部类
    static class Inner {
        public void show(){ 
            // 成员方法中的局部内部类
            class innerClass{
                
            }
        }
        public static void staticShow(){
            // 静态方法中的内部类
            class innerStaticClass{
                
            }
        }
    }
}