- 本文已参加「新人创作礼活动」，一起开启掘金之路。
文章目录
内部类的分类
概念
-
在一个类的内部再定义一个完整的类。
-
特点
- 编译之后，可生成独立的字节码文件。
- 内部类可直接访问外部类的私有成员，而不破坏封装。
成员内部类
- 在类的内部，定义与实例变量、实例方法同级别的类。
- 外部类的一个实例部分，创建内部类对象时，必须依赖外部对象。
//创建外部类对象
Outer outer=new Outer();
//创建内部类对象
Inner inner=outer.new Inner();
- 当外部类、内部类存在重名属性时，会优先访问内部类属性。
- 成员内部类不能定义静态成员。但可以定义静态常量【+final】
栗子
package 内部类.成员内部类;
/**
* @author 缘友一世
* date 2022/10/8-18:16
*/
//外部类
public class Outer {
//实例变量
private String name="酸梅汤小王子";
private int age=12;
//内部类
class Inner {
private String name="内卷小王子";
//无法定义静态变量，但可以定义静态常量
private static final String college="河大";
private String address="开封";
private String phone="华为";
//方法
public void show() {
//使用外部类的类名和this关键字进行区分属性
//打印外部类中的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//打印内部类中的属性
System.out.println(this.address);
System.out.println(this.phone);
//调用内部类的静态属性
System.out.println(this.college);
System.out.println(Inner.college);
}
}
}
package 内部类.成员内部类;
import 内部类.成员内部类.Outer.Inner;
/**
* @author 缘友一世
* date 2022/10/8-18:23
*/
//注意要添加内部类的导入；否则会遇到'内部类.成员内部类.Outer' 不是封闭类
public class TestOuter {
public static void main(String[] args) {
//创建外部类对象
Outer outer=new Outer();
//创建内部类对象
Inner inner=outer.new Inner();
inner.show();
System.out.println("===========");
//一步到位
Inner inner1 = new Outer().new Inner();
inner1.show();
}
}
- 结果如下
静态内部类
- 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
- 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
Outer.Inner inner=new Outer.Inner();
Outer.Inner.show()；
栗子
- 请认真琢磨例子，必要可以自己动手敲敲看。
package 内部类.静态内部类;
/**
* @author 缘友一世
* date 2022/10/8-18:57
*/
public class Outer {
//实例变量
private String name="酸梅汤小王子";
private int age=12;
//静态内部类：和外部类相同
static class Inner {
private String name="内卷小王子";
private static int count=666;
private String address="开封";
private String phone="华为";
//方法
public void show() {
//先创建外部类的对象,在调用外部类的属性
Outer outer=new Outer();
//打印外部类中的属性
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类中的属性
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性 类名.静态属性
System.out.println(Inner.count);
}
}
}
package 内部类.静态内部类;
/**
* @author 缘友一世
* date 2022/10/8-19:06
*/
public class TestStaticOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
//调用方法
inner.show();
}
}
- 结果如下
局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
栗子
package 内部类.局部内部类;
/**
* @author 缘友一世
* date 2022/10/8-19:08
*/
public class LocalOuter {
private String name="华兴";
private int age=22;
public void show() {
//定义局部变量
String address="开封";
//局部内部类：注意不能加任何访问修饰符
class Inner {
//局部内部类的属性
private String phone="5201314";
//非静态类不能定义静态变量，但是可以定义静态常量
private final static String college="河大";
public void show2() {
//访问外部类的属性
System.out.println(LocalOuter.this.name);
System.out.println(LocalOuter.this.age);
//访问内部类的属性
System.out.println(this.phone);
System.out.println(this.college);
//访问局部变量
// jdk1.7要求：变量必须是常量final
//jdk1.8会自动添加final
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
package 内部类.局部内部类;
/**
* @author 缘友一世
* date 2022/10/8-19:14
*/
public class LocalOuterTest {
public static void main(String[] args) {
LocalOuter localOuter = new LocalOuter();
localOuter.show();
}
}
- 结果如下
匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）。
- 必须继承一个父类或者实现一个接口。
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点：可读性较差
栗子
- 接口
/**
* @author 缘友一世
* date 2022/10/8-19:24
*/
public interface Usb {
void service();
}
- Mouse实现接口
public class Mouse implements Usb{
@Override
public void service() {
System.out.println("连接电脑成功！");
}
}
- 测试文件
package 内部类.匿名内部类;
/**
* @author 缘友一世
* date 2022/10/8-19:26
*/
public class TestNameless {
public static void main(String[] args) {
Mouse mouse = new Mouse();
mouse.service();
//局部内部类
class Fan implements Usb {
@Override
public void service() {
System.out.println("风扇连接电脑成功！");
}
}
//使用局部内部类创建对象
Fan fan = new Fan();
fan.service();
//使用匿名内部类优化（相当于创建了一个局部内部类）
Usb usb=new Usb() {
@Override
public void service() {
System.out.println("键盘连接电脑成功！");
}
};
usb.service();
}
}
- 结果如下
匿名内部类的实质：是局部内部类
通过编译文件看一看
