Java内部类

内部类

内部类是定义在另一个类内部的类。内部类可以访问外部类的成员，包括私有成员，并且可以提供更好的封装和组织代码的能力。

Java中的内部类分为四种类型：定义在外部类局部位置上（如方法内）的局部内部类和匿名内部类，定义在外部类的成员位置上的成员内部类和静态内部类。

class Outer{ // 外部类
	class Inner{ //内部类
		...
	}
}

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

局部内部类

局部内部类是定义在方法内部的类，它只能在方法内部被访问。

public class OuterClass {
    public void createLocalInnerClass() {
        int x = 10;
        class LocalInnerClass {
            public void display() {
                System.out.println("x = " + x);
            }
        }

        LocalInnerClass inner = new LocalInnerClass();
        inner.display();
    }
}

局部内部类的细节

1）局部内部类可以访问外部类的所有成员，包含私有的属性。

2）局部内部类不能添加修饰符，但可以用final修饰。

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

4）在外部类中可以创建该对象，并调用方法。

5）如果外部类和局部内部类的成员重名是，默认遵循就近原则，如果想访问外部类的成员，使用“外部类.this.成员“去访问。

public class OuterClass {
    int x = 10;
    public void createLocalInnerClass() {
        int x = 5;
        class LocalInnerClass {
            public void display() {
                System.out.println("x = " + x); // 5
                System.out.println("外部类的x = " + OuterClass.this.x); // 10
            }
        }

        LocalInnerClass inner = new LocalInnerClass();
        inner.display();
    }
}

匿名内部类

匿名内部类是没有名字的内部类，它通常用于创建只需要使用一次的类的实例。它可以继承一个类或实现一个接口。

匿名内部类的语法格式如下：

new 父类构造器/接口() {
    // 类的实现
}

假设有一个接口Animal，定义了一个抽象方法eat()：

public interface Animal {
    void eat();
}

我们可以使用匿名内部类来创建一个实现Animal接口的类的实例，同时定义eat()方法的实现：

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void eat() {
                System.out.println("The animal is eating");
            }
        };

        animal.eat();
    }
}

匿名内部类的细节

1）没有类名：匿名内部类没有类名，它是直接通过new关键字创建的。

2）只能使用一次：匿名内部类通常用于创建只需要使用一次的类的实例，因此它只能使用一次。

3）可以访问外部类的成员：匿名内部类可以访问外部类的成员，包括私有成员。

4）可以实现接口或继承类：匿名内部类可以实现一个接口或继承一个类，但不能同时实现接口和继承类。

成员内部类

成员内部类是定义在另一个类的内部的普通类。它可以访问外部类的成员，包括私有成员，并且可以通过外部类的实例来创建和访问。

public class OuterClass {
    private int x;

    public class InnerClass {
        public void display() {
            System.out.println("x = " + x);
        }
    }

    public void createInnerClass() {
        InnerClass inner = new InnerClass();
        inner.display();
    }
}

成员内部类的细节

1）可以访问外部类的所有成员，包括私有的。

2）可以添加任意访问修饰符，与成员属性，成员方法一致。

3）作用域为整个类体。

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

静态内部类

静态内部类是定义在另一个类内部的静态类。它可以直接通过外部类的类名来访问，无需创建外部类的实例。

public class OuterClass {
    private static int x;

    public static class StaticInnerClass {
        public void display() {
            System.out.println("x = " + x);
        }
    }

    public static void createStaticInnerClass() {
        StaticInnerClass inner = new StaticInnerClass();
        inner.display();
    }
}

静态类的细节

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

2）可以添加任意访问修饰符。

3）作用域为整个类体。

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