何为多态?
多态,通俗一点说就是在完成某一个行为的时候,不同的对象会产生不同的形态。
比如说:打印机在完成打印行为的时候,可以根据不同的对象打印不同的类型,有黑白,有彩色等等,打印的结果是不一样的。
总的来说:同一件事情,发生在不同对象身上,就会产生不同的结果。
如何实现多态?
在java中要实现多态,必须要满足如下几个条件,缺一不可:
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
多态体现:在代码运行时,当传递不同类对象时,会调用对应类中的方法。
本类用作多态的入门案例
public class TestDemo {
public static void main(String[] args) {
Animal a = new Animal();
Cat c = new Cat();
Dog d = new Dog();
a.eat();//调用父类自己的功能
c.eat();//调用子类重写后的功能
d.eat();//调用子类重写后的功能
//父类对象不可以使用子类的特有功能
//a.jump();//报错,Animal类里并没有这个方法
//a.run();//报错,Animal类里并没有这个方法
c.jump();//子类调用自己的功能
d.run();//子类调用自己的功能
//创建多态对象进行测试
//口诀1:父类引用指向子类对象
//解释:创建出来的子类对象的地址值,交给父类类型的引用类型变量来保存
Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
//测试多态对象
//口诀2:编译看左边,运行看右边
//解释:
//必须要在父类定义这个方法,才能通过编译,把多态对象看作是父类类型
//必须要在子类重写这个方法,才能满足多态,实际干活的是子类
a2.eat();//多态对象使用的是父类的定义,子类的方法体
}
}
//多态的前提:继承+重写
//1.创建父类
class Animal{
//创建父类的普通方法
public void eat(){
System.out.println("Animal吃");
}
}
//创建子类Cat
class Cat extends Animal{
//重写父类方法
@Override
public void eat(){
System.out.println("小猫吃");
}
//子类的特有方法
public void jump(){
System.out.println("小猫跳");
}
}
//创建子类Dog
class Dog extends Animal{
//重写父类方法
@Override
public void eat(){
System.out.println("小狗吃");
}
//添加子类的特有方法
public void run(){
System.out.println("小狗跑");
}
}
这里以一个支付的结果来作为测试:
//提供一个抽象类或者接口
//这里提供一个抽象类
public abstract class Pay {
abstract String PayMethod();
}
public class PayPal extends Pay {
@Override
public String PayMethod() {
System.out.println("支付宝Pay........");
return "success";
}
}
public class UnionPay extends Pay {
@Override
public String PayMethod() {
System.out.println("银联Pay........");
return "success";
}
}
public class WeChatPay extends Pay {
@Override
public String PayMethod() {
System.out.println("微信Pay........");
return "success";
}
}
public class Main {
public static void main(String[] args) {
//支付宝
Pay pay1=new PayPal();
pay1.PayMethod();
//银联
Pay pay2=new UnionPay();
pay2.PayMethod();
//微信
Pay pay3=new WeChatPay();
pay3.PayMethod();
}
}
//结果:
//支付宝Pay........
//银联Pay........
//微信Pay........
//都调用了PayMethod(),不同对象调用同一方法产生了不同结果
多态的使用案例:
public class TestDemo {
public static void main(String[] args) {
Dog d = new Dog();
System.out.println(d.sum);//子类自己的属性
d.eat();//子类自己的方法
//创建多态对象
//口诀1:父类引用指向子类对象
//口诀2:编译(保存)看左边,运行(效果)看右边
Animal a = new Dog();
//多态中,成员变量使用的是父类的
System.out.println(a.sum); //10
//多态中,方法的声明使用的是父类的,方法体使用的是子类的
a.eat();//小狗吃
/*多态中,调用的静态方法是父类的,因为多态对象把自己看作是父类类型
* 直接使用父类中的静态资源*/
a.play();//没有提示,玩啥都行~
Animal.play();
}
}
//创建父类
class Animal{
int sum = 10; //创建父类的成员变量
public void eat(){ //创建父类的普通方法
System.out.println("吃啥都行~");
}
public static void play(){//定义父类的静态方法play
System.out.println("玩啥都行~");
}
}
//创建子类
class Dog extends Animal{
int sum = 20; //定义子类的成员变量
@Override //重写父类的方法
public void eat(){
System.out.println("小狗吃");
}
//创建子类的静态方法play
//@Override
/*这不是一个重写的方法,只是恰巧在两个类中出现了一模一样的两个静态方法
* 静态方法属于类资源,只有一份,不存在重写的现象
* 在哪个类里定义,就作为哪个类的资源使用*/
public static void play(){
System.out.println("小狗玩");
}
}
汽车设计案例
public class DesignCar {
public static void main(String[] args) {
Car c = new Car();
System.out.println(c.getColor());//color:null
c.start();//我的小车车启动啦~
c.stop();//唉呀妈呀熄火了~
//c.swim();//报错,父类对象不可以调用子类的特有方法
BMW b = new BMW();
System.out.println(b.color); //五彩斑斓的黑
System.out.println(b.getColor());//父类中的color为null
b.start();//都让开,我的车要起飞啦~//用自己的方法
b.stop();//唉呀妈呀熄火了~,自己没有用父类的方法
//创建多态对象进行测试
Car c2 = new TSL();
//System.out.println(c2.color);//报错,父类的color不能直接访问
System.out.println(c2.getColor());//父类的color可以通过封装的getcolor()接口间接访问
c2.stop();//自己的方法
c2.start();//父类的方法
// c2.swim();//报错,Car类型的c2里,没有swim()方法
}
}
class Car{
//2.定义并封装汽车类的属性--成员变量
private String brand;//品牌
private String color;//颜色
private int id;//编号
private double price;//价格
//3.定义功能
public void start(){
System.out.println("我的小车车启动啦~");
}
public void stop(){
System.out.println("唉呀妈呀熄火了~");
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
class BMW extends Car{
String color = "五彩斑斓的黑";
@Override //重写父类的方法
public void start(){
System.out.println("都让开,我的车要起飞啦~");
}
}
class TSL extends Car{
@Override//重写父类的方法
public void stop(){
System.out.println("唉呀妈,怎么停不下来呢");
}
//添加子类的特有方法
public void swim(){
System.out.println("没想到吧,我还是个潜水艇");
}
}
水果案例:
public class TestFruit {
public static void main(String[] args) {
Fruit f = new Fruit();
Apple a = new Apple();
Orange o = new Orange();
get(f);
get(a);
get(o);
}
//只需要创建一个方法,就可以执行截然不同的效果
//忽略子类对象的差异统一看作父类类型
public static void get(Fruit f){
f.clean();
}
}
class Fruit{
public void clean(){
System.out.println("水果要洗洗再吃");
}
}
class Apple extends Fruit{
@Override
public void clean(){
System.out.println("苹果需要削皮");
}
}
class Orange extends Fruit{
@Override
public void clean(){
System.out.println("橙子需要剥皮");
}
}
//水果要洗洗再吃
//苹果需要削皮
//橙子需要剥皮
这就体现了多态。其中也包含了向上转型的方法。
什么是向上转型?
向上转型:实际就是创建一个子类对象,将其当成父类对象来使用。
语法格式:父类类型 对象名 = new 子类类型()
就比如上面的:
//支付宝
Pay pay1=new PayPal();
pay1.PayMethod();
父类引用子类,因为是小范围到大范围,所以可以实现向上转型
向上转型的优点:让代码实现更简单灵活。
向上转型的缺陷:不能调用到子类特有的方法。
有向上转型肯定会有向下转型啦!
什么是向下转型?
向上转型会导致无法调用子类特有的方法,但是有时候可能需要调用子类特有的方法,此时:将父类引用再还原为子类对象即可,即向下转换。
public abstract class Pay {
abstract String PayMethod();
}
public class PayPal extends Pay {
@Override
public String PayMethod() {
System.out.println("支付宝Pay........");
return "success";
}
public void prompt(){
System.out.println("余额不足,请选择其他方式进行支付");
}
}
public class Main {
public static void main(String[] args) {
//支付宝
Pay pay1=new PayPal();
pay1.PayMethod();
//方法一:直接强转
pay1=(PayPal)pay1;
((PayPal) pay1).prompt();
//方法二:利用instanceof
if(pay1 instanceof PayPal){
pay1=(PayPal)pay1;
((PayPal) pay1).prompt();
}
}
}
//结果:
//支付宝Pay........
//余额不足,请选择其他方式进行支付
//余额不足,请选择其他方式进行支付
注意:使用强转符 ()可能存在ClassCastException错误。
向下转型用的比较少,而且不安全,万一转换失败,运行时就会抛异常。Java中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为true,则可以安全转换。
多态的优点:
可替换性(substitutability):多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
灵活性(flexibility)。它在应用中体现了灵活多样的操作,提高了使用效率。
简化性(simplicity)。多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。
需要注意的是要避免在构造方法中调用重写的方法。
尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。
什么是静态绑定与动态绑定?
静态绑定:也称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。典型代表方法重载。
动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。