什么是内部类
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。
成员内部类
- 成员内部类 :定义在类中方法外的类。
定义格式:
class 外部类 {
class 内部类{
}
}
在描述事物时,若一个事物内部还包含其他事物,就可以使用内部类这种结构。比如,汽车类Car
中包含发动机类Engine
,这时,Engine
就可以使用内部类来描述,定义在成员位置。
代码举例:
class Car { //外部类
class Engine { //内部类
}
}
访问特点
- 内部类可以直接访问外部类的成员,包括私有成员。
- 外部类要访问内部类的成员,必须要建立内部类的对象。
创建内部类对象格式:
外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
访问演示,代码如下:
public class Body {// 外部类
// 成员变量
private int numW = 10;
int num = 100;
// 成员方法
public void methodW1(){
System.out.println("外部类中的methodW1方法...");
}
public void methodW2(){
System.out.println("外部类中的methodW2方法...");
// 创建内部类对象
Body.Heart bh = new Body().new Heart();
// 访问内部类成员变量
System.out.println("内部类成员变量numN:"+bh.numN);
// 访问内部类成员方法
bh.methodN2();
}
public class Heart{// 成员内部类
// 成员变量
int numN = 20;
int num = 200;
// 成员方法
public void methodN(){
System.out.println("内部类中的methodN方法...");
// 访问外部类成员变量
System.out.println("外部类成员变量:"+numW);
// 访问外部类成员方法
methodW1();
}
public void methodN2(){
System.out.println("内部类中的methodN2方法...");
}
public void methodN3(){
int num = 300;
System.out.println("局部变量num:"+num);// 300
System.out.println("内部类成员变量num:"+this.num);// 200
System.out.println("外部类成员变量num:"+Body.this.num);// 100
}
}
}
public class Demo {
public static void main(String[] args) {
// 测试
// 创建外部类对象,调用外部类的方法methodW2
Body body = new Body();
body.methodW2();
System.out.println("=======================");
// 创建内部类对象,调用内部类的methodN方法
Body.Heart heart = new Body().new Heart();
heart.methodN();
System.out.println("=======================");
heart.methodN3();// 300 200 100
}
}
小结:
内部类:将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。
成员内部类的格式:
public class 外部类名{
public class 内部类名{
}
}
成员内部类的访问特点:
- 内部类可以直接访问外部类的成员,包括私有成员。
- 外部类要访问内部类的成员,必须要建立内部类的对象。
成员内部类的创建方式:
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
匿名内部类
概述
- 匿名内部类 :是内部类的简化写法。它的本质是一个
带具体实现的
父类或者父接口的
匿名的
子类对象。
代码一
public abstract class Animal {
public abstract void eat();
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头...");
}
}
public class Test {
public static void main(String[] args) {
/*
- 匿名内部类的概述:本质就是继承了父类或者实现了接口的匿名子类的对象
- 匿名内部类的格式:
new 类名\接口名(){
方法重写
};
- 匿名内部类的作用: 为了简化代码,并没有什么特殊的功能
需求: 调用Aniaml类的eat()方法
1.创建一个子类继承Animal类
2.在子类中重写eat方法
3.创建子类对象
4.使用子类对象调用eat方法
想要调用抽象类中的方法,必须具备以上4步,那能不能减后呢? 可以 使用匿名内部类
*/
Animal anl1 = new Dog();
anl1.eat();
Animal anl2 = new Animal() {
@Override
public void eat() {
System.out.println("Animal子类的eat方法...");
}
};
anl2.eat();
}
}
代码二
public interface AInterface {
void method();
}
public class AImp implements AInterface {
@Override
public void method() {
System.out.println("AImp 实现类重写method方法....");
}
}
public class Demo {
public static void main(String[] args) {
/*
匿名内部类:
本质是一个继承了父类的匿名子类的对象
本质是一个实现了接口的匿名实现类的对象
案例: A接口中有一个抽象方法method(),现在需要调用A接口中的method方法
思路:
1.创建一个实现类实现A接口
2.重写A接口中的抽象方法method()
3.创建实现类对象
4.使用实现类对象调用method方法
想要调用A接口中的method方法,按照传统方式,必须有以上4步,一步都不可少
前面三步就是为了得到A接口的实现类对象
现在: 匿名内部类可以表示一个接口的匿名实现类对象,所以,可以直接创建接口的匿名内部类来调用method方法即可
*/
AInterface a = new AInterface(){
@Override
public void method() {
System.out.println("匿名内部类方式重写method方法....");
}
};
a.method();
System.out.println("==================");
AInterface a2 = new AImp();
a2.method();
System.out.println("======================");
AInterface a3 = new AInterface() {
@Override
public void method() {
// 实现
}
};
}
}
小结
概述: 本质就是一个接口\父类的匿名子类对象
格式:
new 接口名\父类名(){ 重写抽象方法 };
使用场景:
如果需要得到一个抽象类的子类对象,那么就直接给该抽象类的匿名内部类即可
如果需要得到一个接口的实现类对象,那么就直接给该接口的匿名内部类即可