多态基本介绍
多态是面向对象程序设计(OOP)的一个重要特征,指同一个实体同时具有多种形式,即同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态。
方法或对象具有多种形态,是面向对象的第三大特征,多态是建立在封装和继承基础之上的。
多态的前提是:1.继承。2.重写。
多态的具体体现为:1.方法的多态(重写和重载就体现多态)。2.对象的多态。
(1)本质:父类的引用指向了子类的对象。
(2)语法:父类类型 引用名 = new 子类类型();
(3)特点:编译类型看左边,运行类型看右边,可以调用父类类型中的所有成员(需要遵守访问权限),不能调用子类中的特有成员,最终运行效果看子类的具体实现。
多态的优点
1.能够降低代码的“圈复杂度”,避免使用大量的if-else。
2.可扩展能力更强。
多态实现的条件
- 必须在继承体系下
- 子类必须要对父类中的方法进行重写
- 通过父类的引用调用重写的方法
方法的多态:
(1)重写和重载。
对象的多态:
(1)一个对象的编译类型和运行类型可以不一致。
(2)编译类型在定义对象时,就确定了,不能改变。
(3)运行类型是可以变化的。
(4)编译类型看定义时 “=”的左边,运行类型看“=”的右边。
Animal animal = new Dog();
animal = new Cat();
以上代码中animal的编译类型是Animal,运行类型是Dog。
后将运行类型变为Cat,编译类型仍是Animal。
重写和重载的区别
区别点 | 重载(overloading) | 重写(override) |
---|---|---|
参数列表 | 必须修改 | 一定不能修改 |
返回类型 | 可以修改 | 一定不能修改 |
访问限定符 | 可以修改 | 不能做出更严格的限制(子类权限大于父类) |
方法重载式一个类的多态性的表现,而方法重写式子类与父类的一种多态性表现。
重写的规则
(1)子类在重写父类的方法时,一般必须与父类方法原型一致:修饰符 返回值类型 方法名(参数列表)要完全一致
(2)被重写的方法返回值类型可以不同,但是必须是具有父子关系的
(3)访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类方法被public修饰,则子类中重写该方法就不能声明为protected
(4)父类被static、private修饰的方法都不能被重写
(5)子类和父类在同一个包中,那么子类可以重写父类中的所有方法,除了声明为private和final的方法
(6)子类和父类不在同一个包中,那么子类只能够重写父类的 声明为public 和protected的非final方法
(7)重写的方法,可以使用 @Override 注解来显式指定。有了这个注解能够帮我们检查这个方法有没有被正确重写。例如不小心讲方法名拼写错了,此时编译器就会发现父类中并没有这个方法,就会编译报错,构不成重写。
多态的简单案例
用多态机制实现主人喂食问题:
package poly;
public class poly01 {
public static void main(String[] args) {
Master tom = new Master("汤姆");
Dog dog = new Dog("大黄");
Bone bone = new Bone("大棒骨");
tom.feed(dog,bone);
Cat cat = new Cat("大白");
Fish fish = new Fish("小黄鱼");
tom.feed(cat,fish);
}
}
package poly;
public class Master {
private String name;
public Master(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void feed(Animal animal,Food food){
System.out.println("主人" + name + "给" + animal.getName() + "吃" + food.getName());
}
// public void feed(Dog dog,Bone bone){
// System.out.println("主人" + name + "给" + dog.getName() + "吃" + bone.getName());
// }
// public void feed(Cat cat,Fish fish){
// System.out.println("主人" + name + "给" + cat.getName() + "吃" + fish.getName());
// }
}
package poly;
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package poly;
public class Dog extends Animal{
public Dog(String name) {
super(name);
}
}
package poly;
public class Cat extends Animal{
public Cat(String name) {
super(name);
}
}
package poly;
public class Food {
private String name;
public Food(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package poly;
public class Bone extends Food{
public Bone(String name) {
super(name);
}
}
package poly;
public class Fish extends Food{
public Fish(String name) {
super(name);
}
}
向上转型和向下转型
在JAVA中,继承是一个重要的特征,通过extends关键字,子类可以复用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法来加以扩展。
那么在这个过程中就存在着多态的应用。存在着两种转型方式,分别是:向上转型和向下转型。
向上转型:可以把不同的子类对象都当作父类来看,进而屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,统一调用标准。
向上转型时,子类对象当成父类对象,只能调用父类的功能,如果子类重写了父类中声明过的方法,方法体执行的就是子类重过后的功能。但是此时对象是把自己看做是父类类型的,所以其他资源使用的还是父类型的。
向下转型:子类的引用的指向子类对象,过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能,所以需要重新恢复成子类对象。
Parent p = new Child();//向上转型,此时,p是Parent类型
Child c = (Child)p;//此时,把Parent类型的p转成小类型Child