了解多态的及使用

认识多态

多态是Java面向对象中的一个重要特性。
在程序中，它意味着一个特定类型的变量可以引用不用类型的对象，并且能自主地调用对象的方法，
也就是根据作用到不同类型对象类型，响应不同的操作。
方法从写是实现多态的基础。
多态： 父类的引用可以传入子类的对象

多态的最基本使用方法：

1.父类的引用作为方法的形参：

public void toHospital(Pet pet) {
System.out.println("给宠物挂号");
System.out.println("给宠物吃药....");
pet.setHealth(pet.getHealth() + 5);
}

• 1
• 2
• 3
• 4
• 5

2.父类的引用可以作为方法的返回值类型

// 2.父类的引用作为方法的返回值类型
public Pet runPet(int choice) {
if(choice == 1) {
Dog dog = new Dog("小黄", 20, 60, "阿拉加斯");
System.out.println("开心的咬了陈旭！");
return dog;
}else if(choice == 2) {
Cat cat = new Cat();
cat.setName("小绿");
cat.setHealth(40);
cat.setLove(60);
cat.setGender('母');
System.out.println("开心的跳起来了");
return cat;
}return null;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

举例说明
有一个宠物类Pet；它有几个子类，如Bird ，Dog
宠物类定义了看病的方法toHospital（）；子类分别重写了看病的方法。
例1：

//Pet 父类
class Pet{
public void toHospital（）{
System.out.println("宠物看病");
}}

//Dog 子类继承父类
class Dog extends Pet{
public void toHospital（）{
System.out.println(“狗狗看病”);
}
}

//Birad 子类继承Pet父类
class Birad extendsPet{
public void toHospital(){
System.out.println(“小鸟看病”)；
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

//以上为Pet和其子类代码，以下是调用代码

public class Test {
public static void main(String[] args){
Dog dog = new Dog();
dog.toHospital();//狗狗看病
Bird bird = new Bird ();
bird.toHospital();//鸟看病

}

}
输出结果：
狗狗看病
鸟看病

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

下面用多态的形式进行修改：

public class Test{
public static void main(String[] args){
Pet pet;
pet  = new Dog();
pet.toHospital();//狗狗看病
pet = new Bird();
pet.toHospial();//鸟看病

}

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

多态意味着在一次方法调用中根据包好的对象的实际类型（）
即实际的子类对象来决定应该调用那个方法，而不是由用来存储对象引用的变量的类型决定的。

向上转型
子类象父类的的转换方法称为向上转型。
语法格式：

<父类型> <引用变量名> = new <子类型>();

• 1

例如之前的例子中
//Pet为父类 Dog为子类
Pet pet = new Dog()；//子类到父类的转换
这就是向上转型。
向下转型：
将一个指向子类对象的父类引用赋给一个子类的引用，即将父类类型转换为子类类型，称为向下转型。类似于 int num = （int）10.1；
语法格式：

<子类型> <引用变量名> = (<子类型>) <父类型的引用变量名>;

Cat cat = (Cat)pet;
cat.setGender();

• 1
• 2
• 3
• 4
• 5

在类型转换时，很可能出现问题，父类的引用指向的对象和你要转换的为的类型不匹配，所以为了避免这种问题，一般都要添加instanceof判断。
例：

if(pet instanceof Cat){
Cat cat = (Cat)pet;
cat.setGender();
}

• 1
• 2
• 3
• 4

String的equals方法：
// Object类的此方法 是给所有的类使用的 希望所有的类在比较相等时都采用此方法 // 所以使用了多态：父类的引用(Object anObject)作为方法的形参 将此方法可扩展性大大的提升了 // 继承自Object类 并且进行了重写 方便我们进行[字符串的相等比较]
/*
String str1 = “hello World”;
String str2 = “hello WoRld”;
str1.equals(str2)
*/
public boolean equals(Object anObject) {
// str1：this anObject：str2
// 判断地址值是否相同 == 比较引用数据类型 比较地址值
if (this == anObject) {
return true;
}
// 判断要比较的对象 是否是String类型 原因是Object类型多态可以传入任何类型的子类对象 猫、狗
if (anObject instanceof String) {
// 向下类型转型 因为Object是父类 父类的引用无法直接使用子类的特有信息
String anotherString = (String)anObject;

        // 获取this的字符数组长度  (String底层是char数组)
int n = value.length;
// 获取anObject的字符数组长度  判断是否和this的字符数组长度相同
if (n == anotherString.value.length) {
// 获取this的字符数组
char v1[] = value;
// 获取anObject的字符数组
char v2[] = anotherString.value;
// 循环比较两个字符数组的每一个元素是否相同
int i = 0;
while (n-- != 0) {
// 只要有不同的内容  直接返回false
if (v1[i] != v2[i])
return false;
i++;
}return true;
}}return false;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

}

</div>
<link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-258a4616f7.css" rel="stylesheet">
</div>