多态
所谓的多态，字面意义来看就是多种形态。它是面向对象程序设置的最核心的特征。从某种意义上来讲，封装和继承都是为了多态而准备的。
多态的概念
在现实生活中，动物都有吃东西，跑和跳等通用的行为能力，但是不同的动物针对行为的表现形式是不同的。比如猫，狗，兔子喜欢吃的东西各有不同，而叫声也是不一样的。
再比如键盘上的f1键，在eclipse的界面会唤出eclipse的帮助文档，在word的界面会唤出word的帮助文档，在Windows系统下回唤出Windows的帮助文档。可以看到同样的行为在不同的对象上会产生不同的形式结果，这就是生活中的多态。
在程序中：
多态意味着允许不同类的对象对同一消息作出不同的响应。
在Java中，多态在广义上来说可以分为编译时多态（方法的多态性）和运行时多态（对象的多态性）。
1. 编译时多态
2. 运行时多态
（程序运行时动态决定调用哪个方法）
在Java中指的多态，大多指的是运行时多态（狭义上的多态）。
**
多态实现的具体条件在于：
- 满足继承关系
- 父类引用指向子类对象
多态的实现
场景描述及实体类编写
package com.dodoke.proJ.animal;public class Animal {//属性：昵称、年龄private String name;private int month;//方法：吃东西public void eat() {System.out.println("动物都有吃东西的能力");}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getMonth() {return month;}public void setMonth(int month) {this.month = month;}public Animal(String name, int month) {super();this.name = name;this.month = month;}public Animal() {super();}}
package com.dodoke.proJ.animal;public class Cat extends Animal {//属性：体重private double weight;//方法：跑动public void run() {System.out.println("小猫快乐的奔跑");}//方法：吃东西@Overridepublic void eat() {System.out.println("猫吃鱼~");}public double getWeight() {return weight;}public void setWeight(double weight) {this.weight = weight;}public Cat() {super();}public Cat(String name, int month, double weight) {super(name, month);this.weight = weight;}}
package com.dodoke.proJ.animal;
public class Dog extends Animal{
//属性：性别
private String sex;
//方法：睡觉
public void sleep() {
System.out.println("小狗有午睡的习惯");
}
//方法：吃东西
@Override
public void eat() {
System.out.println("狗吃肉~");
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Dog() {
super();
}
public Dog(String name, int month, String sex) {
this.setMonth(month);
this.setMonth(month);
this.sex = sex;
}
}
多态是指编译时类型和运行时类型不一致
Java引用类型变量有两种类型：一种是编译时类型，一种是运行时类型
**
- 编译的类型是由声明变量的时候确定的
- 运行时的类型是由实际上赋给该变量的对象决定的
//比如声明变量类型为Animal，实际赋给该变量的对象类型为Dog Animal animal = new Dog();
向上转型
向上转型是指父类引用指向子类的实例
通常也称向上转型为隐式转型和自动转型。通俗来说，是子类转型为父类，小类转型为大类。
public class Test {
public static void main(String[] args) {
//animal的引用 = 具体的animal实例
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
one.getMonth();
two.getName();
//three.sleep();
}
}
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，但是无法调用子类独有方法！
父类中的静态方法无法被重写，所以向上转型后，只能调用到父类原有的静态方法
向下转型
向下转型指的是子类引用指向父类对象
向下转型又称之为强制类型转换，通俗来讲就是父类转型为子类，大类转为小类。对比之前的基本数据类型转换，数据范围大的类型转为数据范围小的类型就需要进行强制类型转换，引用数据类型也是如此。
public class Test {
public static void main(String[] args) {
//animal的引用 = 具体的animal实例
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
one.getMonth();
two.getName();
//three.sleep();
System.out.println("=======================================");
Cat temp = (Cat)two;
temp.eat();
temp.run();
temp.getMonth();
/**
* 此处的代码不能进行强制类型转换
* 原因：two这个对象定义的时候，实际上指向的是Cat这个类型的空间
* Cat temp = (Cat)two; 相当于把two对象还原成原来的实例空间。
* 但是狗和猫并没有兼容的关系，只是拥有同一个父类而已，是兄弟关系
*/
Dog temp1 = (Dog)two;//必须满足转型条件才能转换
temp1.eat();
temp1.sleep();
temp1.getMonth();
System.out.println("程序继续执行");
}
}
向上转型和向下转型比较
| 向上转型 | 向下转型 |
|---|---|
| 又称隐式转型、自动转型 | 又称强制类型转换 |
| 父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法 | 子类引用指向父类对象，此处必须进行强制转换，可以调用子类特有的方法 |
| 小类转为大类 | 必须满足转型条件才能进行转换 |
instanceof关键字
在之前的章节中，我们提到向下转型需要满足转型条件，那么我们该如何才能知道是否满足转型条件呢
这时候，instanceof关键字就派上用处了！
instanceof关键字用于判断左边的对象是否满足右边的实例。如果满足返回ture，否则返回false。
public class Test {
public static void main(String[] args) {
//animal的引用 = 具体的animal实例
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
one.getMonth();
two.getName();
//three.sleep();
System.out.println("=======================================");
if(two instanceof Cat) {
Cat temp = (Cat)two;
temp.eat();
temp.run();
temp.getMonth();
System.out.println("two可以转换为Cat类型");
}
if(two instanceof Dog) {
Dog temp1 = (Dog)two;
temp1.eat();
temp1.sleep();
temp1.getMonth();
System.out.println("two可以转换为Dog类型");
}
if(two instanceof Animal) {
System.out.println("Animal");
}
if(two instanceof Object) {
System.out.println("Object");
}
//所以two对象具有Animal类型和Object类型的特征
System.out.println("程序继续执行");
}
}
类型转换案例
案例
在原有的项目中，增加一个主人类。在猫类中添加玩线球方法
public class Master {
/**
* 喂宠物：
* 喂猫咪：吃完东西后，主人会带着去玩线球
* 喂狗狗：吃完东西后，主人会带着去睡觉
* 养兔子、样鹦鹉、养乌龟
*/
//方案一：编写方法，传入不同类型的动物，调用各自的方法
public void feed(Cat cat) {
cat.eat();
cat.palyBall();
}
public void feed(Dog dog) {
dog.eat();
dog.sleep();
}
//方案二：编写方法传入动物的父类，方法中通过类型转换，调用指定的子类的方法
public void feed(Animal ani) {
if(ani instanceof Cat) {
Cat cat = (Cat)ani;
cat.eat();
cat.palyBall();
} else if(ani instanceof Dog) {
Dog dog = (Dog)ani;
dog.eat();
dog.sleep();
}
}
}
多个对象要实现一个方法吃的时候，一般的解决方法是写重载函数。
而新的解决方法是用一个方法传参的时候先向上转化成父类， 然后再根据实际情况进行判断后，转化成原来的类型 ，在调用自己本身的方法 （向下转型）
新增需求
针对主人空闲时间的判断，如果时间多则养狗，如果时间少则养猫。
package com.dodoke.proJ.animal;
public class Master {
//方案一
public Dog hasManyTime() {
System.out.println("主人空闲时间充足，适合养狗狗");
return new Dog();
}
public Cat hasLittleTime() {
System.out.println("主人空闲时间比较少，适合养猫咪");
return new Cat();
}
//方案二
public Animal raise(boolean isManyTime) {
if(isManyTime) {
System.out.println("主人空闲时间充足，适合养狗狗");
return new Dog();
} else {
System.out.println("主人空闲时间比较少，适合养猫咪");
return new Cat();
}
}
}
在方法内部实现多态。返回值为子类对象，由父类引用接收。相当于Animal animal=new Cat();向上转型。
当我们在实际开发当中需要同一个操作行为，针对不同的参数， 返回不同的实例对象，完成不同的操作结果的时候，就比较适用于这种多态的操作。类型转换的优势就会充分体现出来了。
抽象类
在之前的代码中，我们创建了一个动物类。接下来，我们来看看这段代码
Animal pet = new Animal("花花",2);
pet.eat();
针对于这样的代码，编译运行都没有什么问题，但是它在实际的开发中并没有有效的意义。每个动物都应该有具体的吃东西的行为，实例化pet对象没有意义。实际的开发中会指代具体的猫还是狗来完成指代。如上的代码并不符合程序的逻辑。
那么，该如何限制程序员写这些没有意义的代码呢？
我们可以使用abstract关键字来限制类的实例化。
abstract 是不能修饰成员变量的；
**
public abstract class Animal {}
abstract public class Animal {}
抽象数据类型： 在类的定义前加上 abstract 关键字，使得该类成为一个抽象类
抽象类不允许被实例化，但是可以通过向上转型，指向子类实例，调用子类重写父类的方法以及父类派生的方法
public 与 abstract可以互换，但是却不能 与class关键字相互换位。
抽象类利用子类与父类的继承关系，既限制了子类的设计随意性，又避免了父类无意义的实例化。
应用场景：
某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法
抽象方法
public abstract class Animal {
//属性：昵称、年龄
private String name;
private int month;
/**
* 抽象方法：没有方法体，在子类中必须重写抽象方法，如果子类不重写，则子类只能设置为抽象类
*/
public abstract void eat();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public Animal(String name, int month) {
super();
this.name = name;
this.month = month;
}
public Animal() {
super();
}
}
含有抽象方法的类，只能被定义为抽象类。抽象类中不一定含有抽象方法。
在抽象类中的成员方法可以包括一般方法和抽象方法。
抽象类不能实例化，即使抽象类中不包含抽象方法，这个抽象类也不能创建实例。
一个类继承抽象类后，必须实现其所有的抽象方法，否则也是抽象类，不同的子类对父类的抽象方法可以有不同的实现。
如果方法定义为 static，就不能使用 abstract 修饰符；
如果方法定义为 private ，也不能使用 abstract 修饰符；
**
抽象类体现的是一种模板模式的设计思想，抽象类作为多个子类的通用模板，子类在抽象的基础上进行扩充，但是子类整体上会保留抽象类的行为方法（必须要实现抽象类的抽象方法）。
抽象类一般只是定义需要使用的方法，把不能实现的部分抽象成抽象方法，留给子类去实现。
父类中可以有实现的方法，但是子类也是可以对已经实现的方法进行改造的（override），但是如果在子类中还需要调用父类的实现方法，可以使用 super 关键字。
若有收获，就点个赞吧
0 人点赞
