学习JavaEE的日子 day16 抽象类，接口，多态，对象转型，内部类

发布时间：2024年01月21日

Day16

1.抽象类及抽象方法的使用

*我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类*

*抽象方法* ：使用abstract关键字修饰，抽象方法只包含一个方法名，而没有方法体。

*抽象类*：如果一个类包含抽象方法，那么该类必须是抽象类。*注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。*

需求：编写人类为父类，编写两个子类（中国人、日本人）

抽象方法：没有代码块，使用abstract修饰的方法，交给非抽象的子类去实现

注意：

? 抽象方法必须在抽象类中

? 继承抽象类的子类****必须重写父类所有的抽象方法****。否则，该子类也必须声明为抽象类。

//抽象类：使用abstract修饰       
public abstract class Person {//父类

	private String name;
	private char sex;
	private int age;
	
	//无参构造，有参构造，get、set方法，省略
	
	//抽象方法：没有代码块，使用abstract修饰的方法，交给非抽象的子类去实现
	//注意：抽象方法必须在抽象类中
	public abstract void eat();
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}

public abstract class Chinese extends Person{

	private String id;
	
	public Chinese() {
	}

	public Chinese(String name, char sex, int age, String id) {
		super(name, sex, age);
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	 
	public abstract void hobbies();
	
}

public class SiChuan extends Chinese{
	
	public SiChuan() {
	}
	
	public SiChuan(String name,char sex,int age,String id){
		super(name, sex, age, id);
	}

	@Override
	public void hobbies() {
		System.out.println(super.getName() + "喜欢打麻将、炸金花");
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃火锅、串串香");
	}

}

public class Japanese extends Person{

	private String yearNum;
	
	public Japanese() {
	}
	
	public Japanese(String name, char sex, int age, String yearNum) {
		super(name, sex, age);
		this.yearNum = yearNum;
	}

	public String getYearNum() {
		return yearNum;
	}

	public void setYearNum(String yearNum) {
		this.yearNum = yearNum;
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃马赛克");
	}

}

//测试类
public class Test01 {
	public static void main(String[] args) {
		
		Japanese j = new Japanese("波多野结衣", '女', 18, "令和");
		j.eat();
		j.sleep();
		
		System.out.println("-----------------------");
		
		SiChuan sc = new SiChuan("小彭", '男', 21, "1234567890");
		sc.eat();
		sc.hobbies();
		sc.sleep();
		
		System.out.println("-----------------------");
		
		GuangDong gd = new GuangDong("李嘉诚", '男', 97, "0987654321");
		gd.eat();
		gd.hobbies();
		gd.sleep();
	}
}

1.1抽象类的特征

抽象类的特征总结起来可以说是有得有失

? 1.*有得：抽象类得到了拥有抽象方法的能力。*

? 2.*有失：抽象类失去了创建对象的能力。*****

其他成员（构造方法，实例方法，静态方法等）抽象类都是具备的。

1.2抽象类的细节

1.抽象类****不能创建对象****，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

? 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

? 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

? 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4.抽象类的子类，必须重写抽象父类中****所有的****抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

? 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

5.抽象类存在的意义是为了被子类继承。

? 理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

6.抽象方法只有实现

? 理解：方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做****实现方法****。

2.抽象类及抽象方法的深入

面试题

1.抽象类不能有构造方法？

? 抽象类可以有构造方法

2.抽象类中只能有抽象方法？
抽象类中可以有属性、构造方法、成员方法、静态方法、抽象方法

3.抽象类中不可以没有抽象方法？
可以，但是这样毫无意义
（因为某些原因将方法设计成抽象的，抽象方法必须在抽象类中，这是你才会使用到抽象类）

4.什么原因将方法设计成抽象的？
这个方法应该在该类中，但是该方法不太好实现，就将方法设计成抽象的，交给非抽象的子类去实现

5.如果父类是抽象类，则子类必须实现父类的抽象方法？
不一定，如果子类是抽象类，可以不实现父类的抽象方法

6.可以使用new关键字来创建抽象类对象？
不可以,创建的是匿名子类的对象

public class Test02 {
	public static void main(String[] args) {
		
		Person p = new Person("弗罗兹·甘地",'男',23) {//底层是创建匿名类内类，不是抽象类
			
			@Override
			public void eat() {
				System.out.println(super.getName() + "吃咖喱");
			}
		};
		p.eat();
		
	}
}

匿名类内类内存理解图1：

在这里插入图片描述

匿名类内类创建过程：

1.创建一个没有名字的匿名类(子类)，继承Person类(父类)，重写eat方法

2.创建匿名子类的对象

3.将匿名子类对象的内存地址赋值给父类的引用(多态)

3.接口的使用

理解：
1.接口是一个特殊的抽象类
2.JDK1.8之前，接口中只能有抽象方法及静态常量
3.JDK1.8开始，接口中允许使用抽象方法、静态常量、静态方法、默认方法

注意：
1.接口中的抽象方法默认添加public abstract（经验：一般把abstract去掉）
2.接口中的属性默认添加public static final (j静态常量)
3.接口中的默认方法默认添加public

应用场景：接口相当于是制定规则(标准)，再让实现类去实现

需求：设计学生管理系统项目的接口（列大纲）

分析：
学生管理系统管理一个一个的学生对象
管理 - 数据的操作：增、删、改、查

//实体类
public class Student {
	
	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;

	//无参构造，有参构造，get、set方法，省略

	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id + "]";
	}
}

//学生管理系统的接口  (大纲)
public interface IStudentManagerSystem {
	
	//静态常量
	//默认使用public static final修饰
	int NAME = 1;
	int SEX = 2;
	int AGE = 3;
	int CLASS_ID = 4;
	int ID = 5;

	//抽象方法  (大纲)
	//默认使用public abstract修饰
	public void add(Student stu);//添加
	
	public void delete(String classId,String id);//删除
	
	public void update(String classId,String id,int type,Object val);//更新
	
	public Student getStu(String classId,String id);//查询
	
	//静态方法
	public static void method01(){
		System.out.println("IStudentManagerSystem接口中的静态方法");
	}
	
	//默认方法
	//默认使用public修饰
	default void method02(){
		System.out.println("IStudentManagerSystem接口中的默认方法");
	}
}

//学生管理系统的实现类
public class StudentManagerSystemImpl implements IStudentManagerSystem{

	@Override
	public void add(Student stu) {
	}

	@Override
	public void delete(String classId, String id) {
	}

	@Override
	public void update(String classId, String id, int type, Object val) {
	}

	@Override
	public Student getStu(String classId, String id) {
		return null;
	}

}

//测试类
public class Test01 {
	public static void main(String[] args) {
		
		StudentManagerSystemImpl sms = new StudentManagerSystemImpl();
		
		//调用实现类实现的方法
		sms.add(new Student());
		//调用默认方法
		sms.method02();
		//调用静态方法
		IStudentManagerSystem.method01();
	}
}

3.1定义格式

接口的声明：interface

接口名称：首字母大写，满足“驼峰模式”

interface 接口名称{

  // 抽象方法

}

注意：接口可以多继承，类只能单继承。

3.2接口的实现

类与接口的关系为实现关系，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

实现接口的格式

//接口的实现：
class 类名 implements 接口1,接口2,接口3...{

}

3.2.1 类实现接口的要求和意义

1.必须重写实现的全部接口中所有抽象方法。

2.如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。

3.*意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范。*

4.接口的深入

面试题

1.一个类可以实现多个接口？

? 可以

2.一个接口可以实现多个接口？

? 不可以

? 但是一个接口可以继承多个接口

3.接口里面的方法不一定都是抽象的？

? JDK1.8之前，接口中只能有抽象方法和静态常量

? JDK1.8开始，接口中除了有抽象方法和静态常量以外，还可以有静态方法和默认方法

4.接口解决了类的单继承问题？

? 是的，因为一个类可以实现多个接口

5.一个类是否可以继承一个类并同时实现多个接口？

? 可以

6.接口可以new对象？

? 不可以，创建的是匿名实现类的对象

类 - 接口的关系：

类 - 类：单继承（一个类只能继承另一个类，不能继承多个类）

类 - 接口：多实现（一个类可以实现多个接口）

接口 - 接口：多继承（一个接口可以继承多个接口）

public interface I1 {

	public void i1Method();
}

public interface I2 {

	public void i2Method();
}

public interface I3 extends I4,I5{

	public void i3Method();
}

public interface I4 {

	public void i4Method();
}

public interface I5 {

	public void i5Method();
}

public class B {

}

public class A extends B implements I1,I2,I3{//A 继承 B 实现I1，I2，I3接口

	@Override
	public void i2Method() {
	}

	@Override
	public void i1Method() {
	}

	@Override
	public void i4Method() {
	}

	@Override
	public void i5Method() {
	}

	@Override
	public void i3Method() {
	}

}

5.多态

5.1类的多态

理解：子类对象指向父类引用；父类引用中存储的是子类对象在堆中开辟的内存地址

需求：使用代码描述出老师骑着自行车上班

分析：老师类、自行车类

需求升级：自行车 -> 小汽车

步骤：

? 1.创建Car类，编写open、close

? 2.改动原来的Teacher，编写start、stop

设计原则：前人给我们总结的经验，告诉我们不能做什么，如果做了会出现严重后果

设计模式：前人给我们总结的经验，告诉我们怎么做，我们就跟着他一步一步做就能实现功能

开闭原则 - OCP

O - Open - 在需求升级时，对于创建类是欢迎的（因为创建类对于原来代码的影响几乎为0）

C - Close - 在需求升级时，对于改动原有类是拒绝的（因为原有类之间的关系是趋于稳定状态，如果改动原有类，很有可能打破这种平衡，导致bug的出现）

P - Principle - 原则

需求升级：自行车 -> 小汽车 -> 飞机

步骤：创建Plane类，继承Vehicles，重写open、close

//交通工具
public abstract class Vehicles {

	private int count;//座位数
	private String color;//颜色
	
	public Vehicles() {
	}
	
	public Vehicles(int count, String color) {
		this.count = count;
		this.color = color;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public abstract void open();
	
	public abstract void close();
}

public class Bick extends Vehicles{
	
	public Bick() {
	}
	
	public Bick(int count,String color){
		super(count, color);
	}
	
	public void open(){
		System.out.println("自行车：握好扶手，踩下脚踏板");
	}
	
	public void close(){
		System.out.println("自行车：捏手刹");
	}
}

public class Car extends Vehicles{
	
	public Car() {
	}
	
	public Car(int count,String color){
		super(count, color);
	}

	public void open(){
		System.out.println("小汽车：一键启动，挂D档，踩下油门");
	}
	
	public void close(){
		System.out.println("小汽车：踩刹车，挂P档，熄火");
	}
}

public class Plane extends Vehicles{

	@Override
	public void open() {
		System.out.println("飞机：踩油门");
	}

	@Override
	public void close() {
		System.out.println("飞机：达到P城，跳伞");
	}

}

public class Teacher {

	public void start(Vehicles v){
		v.open();
	}
	
	public void stop(Vehicles v){
		v.close();
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		Teacher t = new Teacher();
		
		//类的多态：子类对象指向父类引用
		//理解：父类引用中存储的是子类对象在堆中开辟的内存地址
		Vehicles v = new Plane();
		
		t.start(v);
		System.out.println("欣赏沿途的风景");
		t.stop(v);
		 
	}
}

5.2接口的多态

理解：实现类对象指向接口的引用；接口的引用存储的是实现类对象在堆中开辟的地址

需求：使用代码描述出电脑连接外部设备

public interface IUSB {

	public void use();
}

public class Mouse implements IUSB{

	@Override
	public void use() {
		System.out.println("鼠标：左点点、右点点");
	}
}

public class KeyBoard implements IUSB{

	@Override
	public void use() {
		System.out.println("键盘：输入数据");
	}

}

//电脑类
public class Computer {

	//连接
	public void connection(IUSB usb){
		usb.use();
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		Computer computer = new Computer();
		
		//接口的多态：实现类对象指向接口的引用
		//理解：接口的引用存储的是实现类对象在堆中开辟的地址
		IUSB usb = new KeyBoard();
		
		computer.connection(usb);
	}
}

5.3多态的形式

*多态是出现在继承或者实现关系中的*。

多态体现的格式：

父类类型变量名 = new 子类/实现类构造器;

变量名.方法名();

*多态的前提*：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

5.4多态的前提

*多态*：是指同一行为，具有多个不同表现形式。

*前提【重点】*

1.有继承或者实现关系

2.方法的重写【意义体现：不重写，无意义】

3.父类引用指向子类对象【格式体现】

? 父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

*多态的前提*：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

6.对象转型

6.1向上转型

自动转型 - 向上转型：子类类型转父类类型 (转 --> =)

? 父类类型变量名 = new 子类类型();

注意：

1.向上转型就是多态！！！

2.向上转型后，可以调用父类属性

3.向上转型后，可以调用父类方法

4.向上转型后，不可以调用子类独有的属性,方法

5.向上转型后，可以调用子类重写父类的方法

public class Father {

	String fatherAttr = "父类属性";
	
	public void fatherMethod(){
		System.out.println("父类方法");
	}
	
	public void fun(){
		System.out.println("父类方法");
	}
}

public class Son extends Father{

	String sonAttr = "子类属性";
	
	public void sonMethod(){
		System.out.println("子类方法");
	}
	
	@Override
	public void fun() {
		System.out.println("子类重写父类的方法");
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		//向上转型
		Father father = new Son();
		
		System.out.println(father.fatherAttr);
		father.fatherMethod();
		
		father.fun();
	}
}

6.2向下转型

强制转型 - 向下转型：父类类型转子类类型

? 子类类型变量名 = (子类类型) 父类变量名;

注意：

? 1.向下转型是不安全的 – ClassCastException类型转换异常，出现ClassCastException，一定要看错误信息

? 2.父类对象不能赋值给子类引用 – Dog dog = (Dog) new Animal();

? 3.向下转型之前必须先向上转型

? 4.向下转型之前，使用instanceof判断类型

public class Test01 {
	public static void main(String[] args) {
		
		//向上转型
		Animal an = new Cat();
		
		//向下转型
		if(an instanceof Dog){//判断引用an中指向的对象是否是Dog类型
			Dog dog = (Dog) an;
			dog.shout();
		}else if(an instanceof Cat){//判断引用an中指向的对象是否是Cat类型
			Cat cat = (Cat) an;
			cat.eat();
		}
		
	}
}

6.3对象转型的应用场景

public class MyString {

	private char[] value;
	
	public MyString(String original) {
		//"abc"
		//['a','b','c']
		value = original.toCharArray();//将字符串转换为字符数组
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		if(obj instanceof MyString){
			MyString my = (MyString) obj;
			
			char[] v1 = this.value;
			char[] v2 = my.value;
			
			//比较字符长度
			if(v1.length != v2.length){
				return false;
			}
			
			for (int i = 0; i < v1.length; i++) {
				//比较字符的Unicode码是否相同
				if(v1[i] != v2[i]){
					return false;
				}
			}
			return true;
		}
		return false;
	}
	
	@Override
	public String toString() {
		return String.valueOf(value);//将字符数组转为字符串
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		String str1 = new String("abc");
		
		System.out.println(str1.equals(new Student()));//false
		
		
		System.out.println("-------------------------------");
		
		MyString m1 = new MyString("abc");
		
		System.out.println(m1.equals(new Student()));//false
		
	}
}

7.内部类

理解：一个类中再声明另外一个类

? 将一个类A定义在另一个类B里面，里面的那个类A就称为****内部类*，B则称为*外部类****。

分类：

成员内部类：类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)

静态内部类：类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
接口内部类
局部内部类：类定义在方法内
匿名内部类：没有名字的内部类，可以在方法中，也可以在类中方法外

应用场景：

B类的对象只在A类中使用，并且B类对象使用到了A类所有的属性，就可以将B类作为A类的成员内部类
B类的对象只在A类中使用，并且B类对象使用到了A类静态的属性，就可以将B类作为A类的静态内部类
抽象类的子类只创建一次对象，就没必要创建子类，直接使用匿名内部类（new 抽象类）
接口的实现类只创建一次对象，就没必要创建实现类，直接使用匿名内部类（new 接口）

public interface I1 {

	//接口内部类
	class Inner{
	}
}

//外部类
public class Outter {

	//成员内部类
	class Inner01{
	}
	
	//静态内部类
	static class Inner02{
	}
	
	public void method(){
		
		//局部内部类
		class Inner03{
		}
		
	}	
	
}

7.1成员内部类

需求：创建成员内部类的对象，操作对象的方法

成员内部类对象的创建格式：

? 内部类变量 = new 外部类（）.new 内部类（）;

小结：

? 1.创建成员内部类对象之前，必须创建外部类对象

? 2.成员内部类可以调用外部类所有的属性

? 3.在成员内部类中调用指定的外部类属性：外部类.this.属性

//外部类
public class Outter {
	
	private 		String str1 = "外部类属性1";
					String str2 = "外部类属性2";
	protected 		String str3 = "外部类属性3";
	public 			String str4 = "外部类属性4";
	final 			String str5 = "外部类属性5";
	static 			String str6 = "外部类属性6";
	static final 	String str7 = "外部类属性7";

	//成员内部类
	class Inner{
		
		String str1 = "内部类属性";
		
		public void innerMethod(){
			System.out.println("成员内部类的方法");
			System.out.println(str1);//this.str1
			System.out.println(Outter.this.str1);
			System.out.println(str2);//Outter.this.str2
			System.out.println(str3);//Outter.this.str3
			System.out.println(str4);//Outter.this.str4
			System.out.println(str5);//Outter.this.str5
			System.out.println(str6);//Outter.str6
			System.out.println(str7);//Outter.str7
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建成员内部类的对象
		Inner inner = new Outter().new Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

7.3静态内部类

需求：创建静态内部类的对象，操作对象的方法

静态内部类对象的创建格式：

? 外部类.内部类变量 = new 外部类.内部类构造器;

小结：

? 1.创建静态内部类对象，不用创建外部类对象

? 2.静态内部类只能调用外部类静态的属性

//外部类
public class Outter {
	
	static 			String str1 = "外部类属性1";
	static final 	String str2 = "外部类属性2";

	//静态内部类
	static class Inner{
		
		
		public void innerMethod(){
			System.out.println("静态内部类的方法");
			System.out.println(str1);//Outter.str1
			System.out.println(str2);//Outter.str2
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建静态内部类的对象
		 Inner inner = new Outter.Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

7.4接口内部类

需求：创建静态内部类的对象，操作对象的方法

小结：

? 接口内部类的使用方式和静态内部类一致

//外部接口
public interface Outter {
	
	//接口内部类
	//默认使用public static修饰
	class Inner{
		
		public void innerMethod(){
			System.out.println("接口内部类的方法");
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建静态内部类的对象
		 Inner inner = new Outter.Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

7.5局部内部类

需求：调用局部内部类的方法

小结：

? 1.局部内部类不能使用访问修饰符

? 2.局部内部类的作用域就在外部类方法中

//外部类
public class Outter {
	
	public void method(){
		
		//局部内部类
		class Inner{
			public void innerMethod(){
				System.out.println("局部内部类的方法");
			}
		}
		
		//创建局部内部类对象
		Inner inner = new Inner();
		//调用方法
		inner.innerMethod();
		
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		Outter outter = new Outter();
		outter.method();
	}
}

7.5.1局部内部类的面试题

面试题：局部内部类使用到外部类的局部变量时，为什么局部变量会变为常量

答：局部变量变成常量，是让该变量的生命周期变长，是的方法以外还能找的到该数据，

? 如果该变量时局部变量，方法执行完毕就直接被回收，在方法就不能使用该数据

//外部类
public class Outter {
	
	public Object method(){
		
		int num = 100;
		
		//局部内部类
		class Inner{
			@Override
			public String toString(){
				return "局部内部类的方法 -- " + num;
			}
		}
		
		Object obj = new Inner();
		
		return obj;
	}
	
}

public class Test01 {

	public static void main(String[] args) {
		
		Outter out = new Outter();
		
		Object obj = out.method();
		System.out.println(obj.toString());//调用子类重写的toString
	}
}

局部内部类理解图：

在这里插入图片描述

常量和局部变量的生命周期？

? 常量：存放在常量池中，项目销毁时，常量才会被回收

? 局部变量：调用方法，方法在栈中开辟空间，用于存放局部变量，方法执行完毕，该空间会立刻回收

? 意味着方法结束，局部变量也结束了

7.6匿名内部类

匿名内部类前提：

匿名内部类必须****继承一个父类*或者*实现一个父接口****

匿名内部类格式

new 父类名或者接口名(){

      // 方法重写

      @Override 

      public void method() {

      // 执行语句

    }

};

创建匿名内部类的对象
1.底层创建一个匿名类(Test01$1.class)，继承A类，重写method方法
2.创建匿名子类的对象
3.赋值给父类的引用（类的多态）

public abstract class A {

	public abstract void method();
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建匿名内部类的对象
		//1.底层创建一个匿名类(Test01$1.class)，继承A类，重写method方法
		//2.创建匿名子类的对象
		//3.赋值给父类的引用（类的多态）
		A a = new A() {
			@Override
			public void method() {
			}
		};
		
		a.method();
		
	}
}

7.6.1匿名内部类(接口)

创建匿名内部类的对象
1.底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法
2.创建匿名实现类的对象
3.赋值给接口的引用（接口的多态）

public interface I1 {

	public void method();
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建匿名内部类的对象
		//1.底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法
		//2.创建匿名实现类的对象
		//3.赋值给接口的引用（接口的多态）
		I1 i1 = new I1() {
			@Override
			public void method() {
				
			}
		};
		
		i1.method();
	}
}

总结

1.抽象类及抽象方法

2.接口

3.思考题：抽象类与接口的区别

4.多态 – 重要！！！

5.对象转型（向上转型、向下转型）

6.内部类（成员内部类，静态内部类，接口内部类，局部内部类，匿名内部类）
1.注重使用
2.注重局部内部类的面试题
3.注重匿名内部类的内存图

文章来源:https://blog.csdn.net/weixin_69595694/article/details/135728247
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！