多态
# 多态
注意
多态跟属性无关,多态指的是方法的多态,而不是属性的多态
案例:
Cat.java
package com.duotai;
public class Cat extends Animal {
// 方法: 猫叫
public void shout() {
System.out.println("喵喵喵");
}
public void scratch() {
System.out.println("挠人");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
Dog.java
package com.duotai;
public class Dog extends Animal {
public void shout() {
System.out.println("汪汪汪");
}
public void guard() {
System.out.println("可以看家护院,保护主人");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
Animal.java
package com.duotai;
public class Animal {
public void shout() {
System.out.println("我是动物,我可以叫");
}
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
Girl.java
package com.duotai;
public class Girl {
// 跟猫玩耍的方法
// public void play(Cat cat) {
// cat.shout();
// }
//
// // 重载
// public void play(Dog dog) {
// dog.shout();
// }
// 跟小动物玩
public void play(Animal animal) {
animal.shout();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Test.java
package com.duotai;
public class Test {
public static void main(String[] args) {
// 具体的猫 -> 猫的对象
Cat c = new Cat();
// 具体的小女孩 -> 女孩的对象
Girl g = new Girl();
// 创建一个狗的对象
Dog d = new Dog();
// 小女孩和猫玩耍
g.play(c);
// 小女孩跟狗玩
g.play(d);
Animal animal = new Animal();
g.play(animal);
// 泛化
Animal dog = new Dog();
g.play(dog);
}
}
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
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
喵喵喵
汪汪汪
我是动物,我可以叫
汪汪汪
1
2
3
4
2
3
4
后面后续,再有更多的动物,这里就无需修改,只需添加一个动物的类即可
# 简单工厂模式
在上面多态的基础上,新增了一个PetStore
类,可以认为这是一个工厂类,工厂负责创建对象
package com.duotai;
public class PetStore {
// 提供动物
// 多态的应用场景:父类当成返回值
public static Animal getAnimal(String petName) {
Animal an = null;
if ("猫".equals(petName)) { // petName.equals("猫") 为了防止petName空指针异常
an = new Cat();
} else if ("狗".equals(petName)) {
an = new Dog();
}
// 具体返回的是子类
return an;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.duotai;
public class Test {
public static void main(String[] args) {
Animal an = PetStore.getAnimal("猫");
an.shout();
}
}
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
# 总结
先有父类,再有子类
->
继承先有子类,再抽取父类
->
泛化多态:多种状态,同一个行为,不同的子类表现出来的不同的形态,指的就是同一个方法的调用,由于对象不同会产生不同的行为
好处:为了提高代码的扩展性,符合面向对象设计的原则:开闭原则
开闭原则:*指的就是扩展是开放的,修改是关闭的
多态的要素:
继承:
<Cat extends Animal>、<Dog extends Animal>、
重写,子类对父类的方法进行重写
父类引用指向子类对象
Animal dog = new Dog();
1=左侧
:编译期类型=右侧
:运行期类型g.play();
1public void play(Animal animal) { // Animal dog = new Dog(); animal.shout(); }
1
2
3
- 上面的代码,也是多态的一种常见的应用场景:父类当方法的形参,然后传入的是子类的对象,然后调用同一个方法,根据传入的子类的不同展现出的效果也不同,构成了多态
提示
多态可以提高扩展性,但是扩展性没有达到最好,后面有反射
比较好
编辑 (opens new window)
上次更新: 2021/11/10, 23:27:25