继承与多态核心知识点总结
1. 继承 (Inheritance)
概念：
- 允许一个类(子类)继承另一个类(父类)的特征和行为
- 子类可以获得父类的属性和方法，并可以添加新的属性和方法
语法：
java
1
2
3
| class 子类 extends 父类 {
// 子类特有的属性和方法
}
|
特点：
- Java是单继承，一个类只能直接继承一个父类
- 子类继承父类非private的成员(属性和方法)
- 子类可以重写(override)父类的方法
- 构造方法不能被继承
关键字：
extends：表示继承关系super：引用父类的成员
super()：调用父类构造方法super.方法名()：调用父类方法
示例：
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| class Animal {
String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
System.out.println(name + "正在吃东西");
}
}
class Dog extends Animal {
String breed;
public Dog(String name, String breed) {
super(name); // 调用父类构造方法
this.breed = breed;
}
@Override
public void eat() {
super.eat(); // 调用父类方法
System.out.println(name + "正在吃狗粮");
}
public void bark() {
System.out.println(name + "汪汪叫");
}
}
|
2. 多态 (Polymorphism)
概念：
- 同一操作作用于不同对象，可以有不同的解释，产生不同的执行结果
- 主要包括编译时多态(方法重载)和运行时多态(方法重写)
实现条件：
- 继承关系
- 方法重写
- 父类引用指向子类对象
表现形式：
- 方法重载(Overload) - 编译时多态
- 方法重写(Override) - 运行时多态
示例：
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| // 方法重载示例
class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
// 方法重写(多态)示例
class Animal {
public void makeSound() {
System.out.println("动物发出声音");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("喵喵叫");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("汪汪叫");
}
}
public class Test {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Animal对象
Animal myCat = new Cat(); // Cat对象
Animal myDog = new Dog(); // Dog对象
myAnimal.makeSound(); // 输出: 动物发出声音
myCat.makeSound(); // 输出: 喵喵叫
myDog.makeSound(); // 输出: 汪汪叫
}
}
|
3. 继承与多态的重要特性
3.1 方法重写(Override)规则
- 方法名和参数列表必须完全相同
- 返回类型可以是父类方法返回类型的子类(协变返回类型)
- 访问权限不能比父类方法更严格
- 不能重写private、final和static方法
- 重写方法可以抛出与父类方法相同的异常或不抛出异常或抛出父类异常的子类异常
3.2 向上转型(Upcasting)和向下转型(Downcasting)
instanceof运算符：
用于检查对象是否是特定类的实例，常用于向下转型前的安全检查
java
1
2
3
4
| if (animal instanceof Dog) {
Dog dog = (Dog)animal;
dog.bark();
}
|
3.3 抽象类与多态
- 抽象类不能实例化，只能被继承
- 抽象方法没有方法体，必须在子类中实现
- 抽象类可以包含普通方法和抽象方法
示例：
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| abstract class Shape {
abstract double area(); // 抽象方法
void display() { // 普通方法
System.out.println("这是一个形状");
}
}
class Circle extends Shape {
double radius;
Circle(double r) {
radius = r;
}
@Override
double area() {
return Math.PI * radius * radius;
}
}
class Rectangle extends Shape {
double length, width;
Rectangle(double l, double w) {
length = l;
width = w;
}
@Override
double area() {
return length * width;
}
}
|
3.4 接口与多态
- 接口是完全抽象的类，所有方法默认是public abstract
- 类可以实现多个接口
- 接口可以多继承其他接口
- Java 8后接口可以有默认方法和静态方法
示例：
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| interface Flyable {
void fly(); // 抽象方法
default void land() { // 默认方法
System.out.println("正在着陆");
}
static int getMaxAltitude() { // 静态方法
return 10000;
}
}
interface Swimmable {
void swim();
}
class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("鸭子飞起来了");
}
@Override
public void swim() {
System.out.println("鸭子在游泳");
}
}
|
4. 继承与多态的应用场景
- 代码复用：通过继承复用父类代码
- 扩展功能：子类可以在继承的基础上添加新功能
- 统一接口：多态允许不同类型的对象响应相同的消息
- 框架设计：通过抽象类和接口定义框架，具体实现由子类完成
- 插件架构：通过接口定义标准，具体实现可以动态加载
5.tips
import lombok.AllArgsConstructor:
import lombok.Data;
import lombok.NoArgsConstructor;
// lombok技术可以实现为类自动添加getter setter方法无参数构造器，toString方法等
@Data // @Data注解可以自动生成getter setter方法无参构造器 toString方法等
@NoArgsConstructor
@AllArgsConstructor
