内部类和匿名类

内部类和匿名类

内部类

内部类是指将一个类定义在另一类里面，这个类就是内部类。

内部类分为 static 内部类和普通内部类

public class A {
class B{//内部类
}
}

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

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

数据访问

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

public class A {
public String name;
private int age;
public class B{//内部类
public String bName;
private int bAge;
private void setAge() {
name = "";
this.bAge = age;
}
}
public class C{
public String cName;
    private int cAge;
}
public void compareAge() {
B b = new B();
this.age = b.bAge;
b.setAge();
C c = new C();
c.cAge = 10;
}
public static void main(String[] args) {
}
}

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

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

静态内部类

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();//实例化内部类
}
}

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

内部类和外部类区别?

访问修饰符： 外部类只能有两种访问权限： public 以及 package-access

内部类可以有四种访问权限： public / protected / package-access / private

static 修饰： 外部类不可以使用 static 修饰类，内部类可以

使用：外部类可以直接被使用，内部类的使用则依赖于外部类

匿名类

匿名类是没有明确的名称的类。

public static void main(String[] args) {
Pet pet = new Dog();
pet.cry();
//匿名类
Pet p = new Pet() {
@Override
public void cry() {
System.out.println("喵 喵 喵");
}
};
p.cry();
}

匿名类不能使用修饰符，在方法的内部，对外隐藏。不能是 static ，隐式 final 类。匿

名类没有类名，没有构造方法。

匿名类不能定义接口，不能定义静态块，静态方法，静态变量

匿名类可以访问类中的成员，不能访问方法中的变量，除非是 final 的。

匿名类一般是实现接口、继承抽象类。相当于实现、继承了这个接口/类。

public abstract class Pet {
public abstract void cry();
}
//匿名类
Pet p = new Pet() {
@Override
public void cry() {
System.out.println("喵 喵 喵");
}
};
//等同于
public class 类名 extends Pet{
@Override
public void cry() {
System.out.println("喵 喵 喵");
}
}