Java基础十九（内部类和匿名类）

1. 内部类

内部类是指将一个类定义在另外一个类的内部，称为内部类。
内部类分为 static 内部类 和 普通内部类 。

public class A {
    // 定义内部类
    static class B {
        void show(){
            System.out.println("我是内部类");
        }
    }
    void call(B b) {
        b.show();
    }

    public static void main(String[] args) {
        A a = new A();
        a.call(new B());  // 我是内部类
    }
}

这个文件编译过后会产生两个 .class 文件，分别是 A.class 、A$B.class。

一个类可以有多个内部类，内部类可以实现接口和继承类。内部类可以解决 java 单继承问题，因为内部类和外部类可以相互访问。

1.1 数据访问

外部类和内部类可以互相访问类中的成员，包括私有域的。

public class A {
    public String name;
    private int age;
    // 定义内部类
    public class B {
        public String bName;
        private int bAge;
        private void setbAge() {
            name = "";
            // 内部类访问外部类数据
            this.bAge = age;
        }

        void show(){
            System.out.println("我是内部类" + bName);
        }
    }

    public class C {
        public String cName;
        private int cAge;
    }
	// 外部类访问内部类的数据
    public void compareAge() {
        B b = new B();
        this.age = b.bAge;
        b.setbAge();
        C c = new C();
        c.cAge = 20;
    }

}

内部类的实例化，内部类依托与外部类，所以内部类的实例化要先实例化外部类，然后再实例化内部类。

import kfm.bases.AbstractInterface.A.B;  // 导包
public class TestA {
    public static void main(String[] args) {
        A a = new A();
        // 此处如果不导包可以写成 A.B b = a.new B();
        B b = a.new B();
        b.bName = "小羊呆呆";
        b.show();  // 我是内部类小羊呆呆
    }
}

1.2 静态内部类

静态内部类不能直接访问外部类的成员，可以直接访问外部内的静态成员。

public class AA {
	static class BB{ //`static`内部类
		
	}
}

import com.itlaobing.demo.AA.BB;//导包
public class AATest {
	public static void main(String[] args) {
		AA a = new AA();
		BB b = new BB();//实例化内部类
	}
}

所有的访问修饰符都可以修饰内部类

1.3 外部类和内部类的区别

• 访问修饰符：
  • 外部类只有两种访问修饰符：public 和 package-access 。
  • 内部类有四种访问修饰符：pulic \ protected \ package-access \ private 。
• static 修饰：
  • 外部类不可以使用 static 修饰，内部类可以 。
• 使用：
  • 外部类可以直接被使用，内部类的使用则依赖于外部类 。

2. 匿名类

在 Java 中，你可以使用匿名类（anonymous class）来创建一个没有显式定义的类，它是一个临时的、只在特定位置使用的类。

匿名类通常用于实现接口或扩展抽象类。它的语法形式如下：

接口名/父类名 变量名 = new 接口名/父类名() {
    // 匿名类的具体实现
};

示例

public interface A1 {
    void show();
}

class Test02 {
    public static void main(String[] args) {
        A1 a1 = new A1() {
            @Override
            public void show() {
                System.out.println("我是匿名类的show()方法");
            }
        };
        a1.show();
    }
}

• 匿名类不能使用修饰符，如 public、private、protected。
• 匿名类不能定义静态成员（包括静态块、静态方法、静态变量）。
• 匿名类没有类名，因此无法定义构造方法。
• 匿名类可以访问外部类中的成员，包括字段和方法。但如果要在匿名类中访问方法中的局部变量，则该变量必须声明为 final 或事实上的 final（即不会再改变）。
• 匿名类通常用于实现接口或继承抽象类，相当于创建了一个实现了该接口或继承了该抽象类的临时子类。

由于匿名类没有类名，因此它的作用域被限制在创建它的方法或区域内部。这使得匿名类对外部代码隐藏起来，只能通过接口或抽象类进行访问和使用。匿名类是临时的，无法被重复使用。它只能在创建时被实例化并使用一次。匿名类通常适用于某个特定方法内部或作为方法的参数传递。