day16

抽象类及抽象方法

//抽象类
public abstract class 类名{
    //抽象方法
    public abstract void method();
}

abstract

关键字，用来修饰类和方法

不能与final，static，private一起修饰，不能被重写

抽象类

1.概念：

被abstract修饰的类，包含抽象方法的类就是抽象类

2.抽象类的特征：
  1. 抽象类不能实例化，即不能用new来实例化抽象类
  2. 抽象类中包含有构造方法，但构造方法不能用来new实例，只能用来被子类调用
  3. 抽象类中可以包含成员变量，成员方法，静态方法，构造方法，final 修饰的方法，抽象方法
  4. 抽象类只能用来被继承
3.应用场景：

当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现

抽象方法

1.概念

使用abstract修饰的方法，没有方法体，只有声明，交给非抽象的子类去实现（重写）

理解：

将共性的行为(方法)抽取到父类之后。由于每一个子类执行的内容是不一样的,在父类中不能确定具体的方法体。 即正向实现反向抽取。

2.抽象方法的特征：
  1. 抽象类中可以包含 0 个或多个抽象方法
  2. 抽象方法必须被子类实现
  3. 抽象类中可以有属性、构造方法、成员方法、静态方法、抽象方法
  4. 有抽象方法的类只能定义成抽象类(含有抽象方法的类必须是抽象类)
  5. 只有当子类实现了抽象超类中的所有抽象方法，子类才不是抽象类，才能产生实例
  6. 如果子类中仍有抽象方法未实现，则子类也只能是抽象类

抽象类及抽象方法的使用

需求：

编写人类为父类，编写两个子类(ps:中国人、日本人)，中国人的子类(ps:四川人、广东人)

封装Person类并为抽象类，写一个抽象方法eat()

	public abstract void eat();

Japanese类继承Person类，重写eat()

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() + "吃生鱼片");
}

}

Chinese类继承Person类，但是并没有实现eat()，所以Chinese类为抽象类，交给他的子类去实现。这里扩展添加了一个抽象方法hobbies()

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();

}

SiChuan类继承Chinese类，去实现了eat()，他可以实例化

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() + "吃火锅、串串香");
}

}

抽象类及抽象方法的深入

面试题：

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

抽象类可以有构造方法

2.抽象类中只能有抽象方法？

抽象类中有非抽象方法（成员方法和静态方法）

3.抽象类中不可以没有抽象方法？

抽象类中可以没有抽象方法，但是毫无意义

4.如果父类是抽象类，则子类必须实现父类的抽象方法？

不一定，子类如果是抽象类，可以不实现父类的抽象方法

5.可以使用new关键字来创建抽象类对象？

不可以，创建的是匿名内部类的对象

抽象类及抽象方法的使用的扩展

匿名内部类

  I1 i1 = new Person() {
  	          @Override
  	          public void i1Method() {
  		            System.out.println("用良心做教育");
  	           }
  };

在需要创建一个临时对象来实现特定抽象类的情况下，可以直接通过匿名内部类来完成。这样不必单独编写一个新的类文件，节省了开发工作量。

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.概念：

Java中一种引用类型，是方法的集合

特殊的抽象类

关键字interface

理解：

  1. 特殊的抽象类
  2. JDK1.7时，接口中只能有静态常量和抽象方法
  3. JDK1.8开始，接口中添加了静态方法和默认方法

注意：

​ 1.接口中的抽象方法默认添加public abstract（经验：一般把abstract去掉）

​ 2.接口中的属性默认添加public static final

​ 3.接口中的默认方法默认添加public

2.应用场景：

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

抽象类 vs 接口

抽象类：成员变量、静态变量、静态常量、成员方法、静态方法

接口：静态常量、静态方法(JDK1.8)、默认方法(JDK1.8)

3.类 - 接口的关系：

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

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

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

做代码实验验证

4.实现

关键字implements，子类实现接口

需求：设计学生管理系统项目的接口
分析：
学生管理系统管理一个一个的学生对象
管理 - 数据的操作：增、删、改、查

(1)封装一个学生类，里面重写toString()

(2)写一个学生管理系统的接口

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接口中的默认方法");
}
}

(3)写学生管理系统的实现类实现接口生管理系统，当写完类名时就会报红提示实现接口里的抽象方法，点击就会自动需要实现的方法，之后去完善就可以了

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;
}

}

(4)测试类调用方法

		StudentManagerSystemImpl sms = new StudentManagerSystemImpl();
		
		//调用实现类实现的方法
		sms.add(new Student());
		//调用默认方法
		sms.method02();
		//调用静态方法，类名调用
		IStudentManagerSystem.method01();
	}
5.面试题：

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

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

不可以，接口与接口的关系是多继承
3.接口里面的方法不一定都是抽象的？

是的，因为JDK1.7时接口里只能有抽象方法，JDK1.8时接口可以有抽象方法和默认方法
4.接口解决了类的单继承问题？

是的，因为类与类是单继承，类与接口是多实现
5.一个类是否可以继承一个类并同时实现多个接口？

可以
6.接口可以new对象？

不可以，因为接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象

6.接口的使用扩展

(匿名内部类)匿名实现类

  I1 i1 = new I1() {
  	          @Override
  	          public void i1Method() {
  		           System.out.println("用良心做教育");
  	          }
  };

二、多态*

概念

多态性是指同一操作或方法可以在不同的对象上具有不同的行为。它允许我们通过使用基类或接口类型的引用变量来调用子类或实现类的方法。

理解：多种形态

分类：

​ 类的多态：子类对象指向父类引用（父类引用中存储的是子类对象在堆中开辟的地址）

​ 接口的多态：实现类对象指向接口的引用（接口的引用中存储的是实现类对象在堆中开辟的地址）

设计

设计原则：前人总结的经验，告诉我们什么不该做

设计模式：前人总结的经验，告诉我们一步一步的怎么做

ps：OCP原则：

​ O - Open - 在需求升级时，对于创建类是欢迎的

​ (因为创建类对于原来代码的影响几乎为0)

​ C - Close - 在需求升级时，对于改动原有类是拒绝的

​ (因为原有类之间的关系是趋于稳定状态，如果改动原有类，

​ 很有可能打破这种平衡，导致bug的出现)

​ P - Principle - 原则

优缺点：

​ 优点：提高程序的维护性，在需求升级/迭代时，不违反OCP原则

​ 缺点：不能调用子类独有的属性和方法

类的多态：

1.概念：

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

2.需求

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

步骤：

​ 1.创建Bick类，编写open、close

​ 2.创建Teacher，编写start、stop

Teacher类start、stop方法里面调用Bick类的start、stop方法，操作具体的车

需求升级：自行车 -> 小汽车
步骤：
1.创建Car类，编写open、close
2.改动原来的Teacher，编写start、stop

同理Teacher类重载start、stop方法

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

步骤：

​ 1.创建Vehicles类，编写抽象方法open、close

​ 2.创建Plane类，改动Bick、Car类继承Vehicles，重写open、close

​ 3.改动原来的Teacher，改动start、stop操作交通工具

测试类：

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

接口的多态

1.概念

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

2.需求：

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

分析：电脑类、USB接口、鼠标类、硬盘类、键盘类

步骤：

​ 1.创建IUSB接口，抽象方法use

​ 2.创建鼠标类Mouse、硬盘类Disk、键盘类KeyBoard、都实现接口，并且都重写抽象方法use；

​ 3.电脑类Computer写一个连接方法connection操作接口

测试类：

		Computer computer = new Computer();
		
		//接口的多态：实现类对象指向接口的引用
		//理解：接口的引用存储的是实现类对象在堆中开辟的地址
		IUSB usb = new KeyBoard();
		
		computer.connection(usb);
	}

三、对象转型

前提：有继承关系

自动转型 - 向上转型：

子类类型 转 父类类型

注意：

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

       2. 向上转型后，可以调用父类属性、方法 
   3. 向上转型后，不可以调用子类独有的属性、方法 
   4. 向上转型后，可以调用子类重写父类的方法

需求：父类，子类

写一个Father类、一个Son类继承Father

测试类进行验证

	//向上转型
	Father father = new Son();
	
	System.out.println(father.fatherAttr);
	father.fatherMethod();

强制转型 - 向下转型：

父类类型 转 子类类型

注意：

  1. 向下转型是不安全的 – ClassCastException类型转换异常
  2. 出现ClassCastException，一定要看错误信息
  3. 父类对象不能赋值给子类引用 – Dog dog = (Dog) new Animal();
  4. 向下转型之前必须先向上转型
  5. 向下转型之前，使用instanceof判断类型

ps：MyString

	if(obj instanceof MyString){
		MyString my = (MyString) obj;
	}

需求:动物类，猫类，狗类

创建动物类Animal；创建猫类Cat、狗Dog继承Animal

测试类验证：

  //前提：向上转型
  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();
  }

应用场景

对象转型的应用包括但不限于以下几个方面:
1.多态性的实现:Java中的多态性是通过对象转型来实现的。通过向上转型，将子类对象赋值给父类类型的变量，可以实现对多个子类对象的统一处理，从而实现多态性。
2.接口的实现:接口是Java中重要的面向对象编程概念，对象转型可以用于实现接口。将一个实现了某个接口的类类型对象转换为该接口类型，就可以通过接口类型调用实现类中实现的方法。
3.继承关系的处理:Java中的继承关系是通过对象转型来实现的。将一个子类类型的对象转换为一个父类类型的对象，就可以实现父类和子类之间的继承关系。
总之，Java中的对象转型是java面向对象编程的重要特性之一，可以帮助程序员更好地实现面向对象编程的思想，提高代码的可复用性和可维护性。

案例：MyString(参考day15)

更新MyString(代码，向下转型之前，使用instanceof判断类型

	if(obj instanceof MyString){
		MyString my = (MyString) obj;

测试类：测试MyString达到要求

	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

四、内部类

理解：

一个类中再声明另外一个类

应用场景：

成员内部类：B类的对象只在A类中使用，并且B类使用了A类所有的属性，就可以将B类设计成A类的成员内部类
静态内部类：B类的对象只在A类中使用，并且B类使用了A类静态的属性，就可以将B类设计成A类的静态内部类
接口内部类：B类的对象只在I1接口中使用，就可以将B类设计成I1接口的接口内部类
局部内部类：B类的对象只在A类的method方法中使用，就可以将B类设计成A类的局部内部类
匿名内部类：抽象类的子类 或 接口的实现类 只创建了一个对象时，就没有必要去创建子类或者实现类，直接使用匿名内部类创建即可

分类：

  1. 成员内部类
  2. 静态内部类
  3. 接口内部类
  4. 局部内部类
  5. 匿名内部类
//外部类
public class Outter {
	//成员内部类
	class Inner01{
	}
	
	//静态内部类
	static class Inner02{
	}
	
	public void method(){
		//局部内部类
		class Inner03{
		}	
	}
}
//接口
public interface I1 {
	//接口内部类
	class Inner{
	}
}

成员内部类

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

注意：

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

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

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

ps：测试类

	//创建成员内部类的对象
	Inner inner = new Outter().new Inner();
	//调用方法
	inner.innerMethod();

//外部类
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
	}
}
}

静态内部类

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

注意：

  1. 创建静态内部类对象，不用创建外部类对象
  2. 静态内部类只能调用外部类静态的属性

测试类

//创建静态内部类的对象
	 Inner inner = new Outter.Inner();
	//调用方法
	inner.innerMethod();

//外部类
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
	}
}
}

接口内部类

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

注意：

  1. 接口内部类默认使用public static修饰
  2. 接口内部类的使用方式和静态内部类一致

测试类

  //创建静态内部类的对象
   Inner inner = new Outter.Inner();
  
  //调用方法
  inner.innerMethod();

//外部接口
public interface Outter {

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

}

局部内部类

1.使用

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

注意：

  1. 局部内部类不能使用访问修饰符
  2. 局部内部类的作用域就在外部类方法中
  3. 常量：存放在常量池中，项目销毁时，常量才会被回收；局部变量：调用方法，方法在栈中开辟空间，用于存放局部变量，方法执行完毕，该空间会立刻回收

测试类：

  Outter outter = new Outter();
  outter.method();

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

局部内部类理解图

3.面试题：

局部内部类使用到外部类的局部变量时，为什么局部变量会变为常量？

答：局部变量变成常量，是让该变量的生命周期变长，是让方法以外还能找的到该数据，如果该变量是局部变量，方法执行完毕就直接被回收，在方法就不能使用该数据

匿名内部类

匿名内部类理解图

匿名内部类理解图(类)匿名内部类理解图01
匿名实现类理解图（接口）匿名内部类理解图02

应用场景：

作为接口或者抽象类的实现类：在需要创建一个临时对象来实现特定接口或者抽象类的情况下，可以直接通过匿名内部类来完成。这样不必单独编写一个新的类文件，节省了开发工作量。

创建匿名内部类的对象

（匿名子类，父类）

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

【Test01$1.class是系统默认命名，通过查看class文件就可以看到；eclipse里查看：的工具栏---->window—>showview---->Navigator—显示bin目录的class文件】

（匿名子类实现类，父类接口）

  1. 底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法
  2. 创建匿名实现类的对象
  3. 赋值给接口的引用（接口的多态）
# 学习 # java-ee # java
Logo
科技创新，汇聚千年文化底蕴，共筑璀璨首都未来之梦！

欢迎加入北京社区

更多推荐

cover

️‍♂️ Heisenbug: 难以重现的Bug排查技巧

avatar 北京城市开发者社区
cover

Unhandled Exception: 处理未捕获异常的最佳实践 ️

avatar 北京城市开发者社区
cover

Memory Corruption: 代码中的内存损坏问题

avatar 北京城市开发者社区