【软考】继承、多态、动态绑定、静态绑定

# 继承
父类和子类之间共享数据（属性）和方法的机制
在定义和实现一个子类的时候，可以在一个已经存在的父类的基础上进行，把这个已经存在的父类所定义的内容作为自己（子类）的内容，并加入若干新的内容
父类 A 和 子类 B 的继承关系：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/gshtp9.webp)
java：extends

一个父类可以有多个子类，父类有的属性和方法子类都可以继承，在子类中不必定义，子类可以定义新的

```java
public class Person{
	private String name;
	private int age;
	
	public void setName(String name){
		this.name = name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public String getName(){
		return name;
	}
	
	public int getAge(){
		return age;
	}
	
	private void eat(){
		System.out.println(name + " " + age + "吃饭");
	}
	
	public void run(){
		System.out.println(name + " " + age + "跑步");
	}
	
	public void sleep(){
		System.out.println(name + " " + age + "睡觉");
	}

}
```

现在有一个新的类 student 要继承 上面的 person
完全集成父类的属性和方法：
```java
public class Student extends Person{

}

public class Main{
	public static void main(String[] args){
		// 之前父类的属性和方法不需要重新定义
		Person zst = new Person();
		
		Studnt lisi = new Student();
		// 如果新的学生类下的对象 lisi. 可以调用的一些属性或方法，详见下图，会发现有：setName、setAge、getName、getAge、sleep、run，没有 eat()，因为上面对于 person 的定义中，eat 是 private 的，私有的是不可继承的。上面对于 Person 的属性，也是不可继承的，因为属性定义的时候也是私有的
		// 但可以通过类设置的接口来继承
		lisi.setName("李四");
		System.out.println(lisi.getName());
	}
}
```

![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/h83krc.webp)
在继承中什么都没有写，但是依然有继承成功，
上面的运行结果：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/hcp8zx.webp)

也可以在继承中加入自己的属性和行为：
```java
public class Student extends Person{
	private int id;
	
	public void setId(int id){
		this.id = id;
	}
	
	public int getId(){
		return id;
	}
	
	public void work(){
		System.out.println(id + " " + getName() + "做作业"); // 在继承中不能直接获取 name 属性的内容，因为 name 在父类中是 private 定义的私有的，但是可以通过 getName 这个对外 public 的接口间接地获取
	}
}

public class Main{
	public static void main(Sting[] args){
		Person zst = new Person();
		
		Student lisi = new Student();
		lisi.setName("李四");
		lisi.setId(2022);
		System.out.println(lisi.getName());
		lisi.work();
	}
}
```

这次的运行结果：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/hgyvw0.webp)

覆盖父类中的一些方法：
```java
public class Student extends Person{
	private int id;
	
	public void setId(int id){
		this.id = id;
	}
	
	public int getId(){
		return id;
	}
	
	public void work(){
		System.out.println(id + " " + getName() + "做作业"); 
	}
	
	public void sleep(){
		System.out.println(id + " " + getName() + "在熬夜");
	}
	// 把父类中的行为覆盖掉
}

public class Main{
	public static void main(Sting[] args){
		Person zst = new Person();
		
		Student lisi = new Student();
		lisi.setName("李四");
		lisi.setAge(18);
		lisi.setId(2022);
		
		lisi.sleep();
	}
}
```

运行结果：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/i7qupw.webp)

子 继承 父
子 有独有的属性和行为
子 重写 / 覆盖 父

---
子类只从一个父类得到继承：单重继承
子类有两个 或 更多个父类：多重继承

---
# 多态
在收到消息时，对象要予以响应，不同的对象收到同一消息可以产生完全不同的结果：多态

使用多态时，用户可以发送一个通用的消息，
实现的细节 由 接收对象自行决定

![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/icb21z.webp)

学生 Student 和 员工 Employee 都继承 Person
一般写法：
类名 对象名 = new 类名；

多态里面的写法：
父类名 对象名 = new 子类名;

```java
Person zst = new Student(); 
// zst 是人 这个类型的，但是右边实例化出的是学生对象
// 把学生对象当成一个人来看也没问题
// 就会出现不同的形态
// 左边 Person 形态是：人，右边 形态是：学生
// 在编译的时候，看左边 zst 当做是人的形态来看
// 在运行的时候，把 zst 当成学生来看

zst.work();
// 假设 人就是 work，学生的 work 是学习，员工的 work 是上班
// 运行的时候会跑去执行 学生的 work，就是学习

```

```java
public class Person(){
	public void work(){
		System.out.println("工作");
	}
}

public class Student extends Person{
	public void work(){
		System.out.println("学习");
	}
	
	public void run(){
		System.out.println("跑步");
	}
}

public class Employee extends Person(){
	public void word(){
		System.out.println("上班");
	}
	
	public void sleep(){
		System.out.println("睡觉");
	}
}

public class Main{
	Person zst = new Student();
	// 编译看左边
	zst.work();//编译时，zst 调用 人 的 work，如果人的里面有 work 就可以编译通过
	// 运行看右边
	
	Person lisi = new Employee();
	lisi.work();
}
```

运行结果：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/r1la6g.webp)

多态形式：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/13/r2v586.webp)
参数多态：最纯的多态
包含多态：子类型化，一个类型是另一个类型的子类型
过载多态：同一个名字在不同的上下文中所代表的含义不同

---
# 动态绑定、静态绑定

编译：静态绑定
运行：动态绑定

动态绑定是和类的继承以及多态相联系的。在继承关系中，子类是父类的一个特例，所以父类对象可以出现的地方，子类对象也可以出现
在运行过程中，当一个对象发送消息请求服务时，要根据接收对象的具体情况将请求的操作与实现的方法进行联系：动态绑定

---