多态的概念——精选推荐

多态的概念1 多态
1.1 开发⼯具
eclipse:
1.1.1 快捷键
快捷键描述
ctrl+m最⼤化/恢复编辑区
ctrl + +/-放⼤/缩⼩字体
shift+alt+s呼出source菜单
ctrl+alt+向上/向下快速复制代码
ctrl+2,L快速⽣成本地变量
alt+向上/向下快速移动代码
ctrl+1快速修复/建议代码
1.1 多态
软件设计原则—开闭原则
对拓展开放，对修改关闭。

为什么要使⽤多态？
对系统进⾏业务拓展，增加系统的可维护性。

1.1.1 多态的概念
可以理解为多种状态/多种形态
同⼀事物，由于条件不同，产⽣的结果不同
程序中的多态
同⼀引⽤类型，使⽤不同的实例⽽执⾏结果不同的。

同:同⼀个类型，⼀般指⽗类。

不同:不同的⼦类实例
不同:针对同⼀⽅法执⾏的结果不同
package cn.sxt05;
public class Test01 {
public static void main(String[] args) {
// 多态
// ⽗类引⽤引⽤⼦类对象
pet = new Dog("⼆狗",100,0,"⼟狗");
// 呈现多态
pet.eat();
pet = new Penguin("⼤脚", 90, 50, Penguin.SEX_FEMALE);
// 呈现多态
pet.eat();
}
}
实现多态的步骤
[1] 编写⽗类
[2] 编写⼦类，⼦类⼀定要重写/实现⽗类的⽅法
[3] 运⾏时，⽗类类型引⽤⼦类对象 (Pet pet = new Dog()
1.1.1 多态的实现形式
[1] ⽗类类型引⽤⼦类对象(本质)
// 多态
// 同⼀引⽤类型
Pet pet = null;
// ⽗类引⽤引⽤⼦类对象
pet = new Dog("⼆狗",100,0,"⼟狗");
// 呈现多态
pet.eat();
pet = new Dog() ⽗类类型引⽤⼦类对象，当调⽤eat⽅法时，执⾏的是被⼦类对象重写/实现的eat⽅法。

[2] ⽗类作为⽅法形参实现多态
public void feed(Pet pet) {
System.out.println(this.getName() + "正在喂" + pet.getName());
pet.eat();
}
[3] ⽗类作为⽅法的返回值实现多态
public Pet adoptPet(int type) {
Pet pet = null;
if(1 == type) {
pet = new Dog();
}else if(2 == type) {
pet = new Penguin();
}
return pet;
}
1.1 类型转换
在多态中存在两种类型转换，⼀种是⾃动类型转换，⼀种是强制类型转换。

在引⽤数据类型转换过程中，
⾃动类型转换也称向上类型转换。

⼦类可以⾃动转换成⽗类。

Pet pet = null;
pet = new Dog();
强制类型转换也称向下类型转换。

⽗类可以强制转换成⼦类。

⼦类类型引⽤ = (⼦类)⽗类对象
obj instanceOf 类/接⼝判断obj是否是类/接⼝的实例
public class TestInstanceOf {
public static void main(String[] args) {
Dog dog = new Dog();
System.out.println(dog instanceof Dog); //true
System.out.println(dog instanceof Pet); //true
System.out.println(dog instanceof Object); //true
}
}
如果要调⽤⼦类特有的⽅法时，⼀定要强制类型转换，通过instanceof鉴别具体类型public void play(Pet pet) {
if(pet instanceof Dog) {
Dog dog = (Dog) pet;
dog.catchFlyDisc();
}else if(pet instanceof Penguin) {
Penguin penguin = (Penguin) pet;
penguin.swimming();
}
}
1.1 调试技巧
step over: 单步调试，⼀次只执⾏⼀⾏代码。

step into: 进⼊⽅法调试
step return: 返回/结束⽅法
:停⽌调试
2 何时使⽤继承
[1] 符合 is – a 关系
学⽣ is a ⼈;
⽼师 is a ⼈;
[2] 继承实现代码重⽤
当多个⼦类拥有共同的属性和⾏为时，⼈为把共同的属性和⽅法提取到⽗类中，⼦类继承⽗类实现代码重⽤
1.1 抽象类
1.1.1 抽象类概念
C extends B，B extends A，在继承过程中，形成⼀个继承⾦字塔，位于⾦字塔底部的类越来越具体(强⼤)，位于塔顶的越来越抽象(简单)。

例如：⼈继承于动物，鱼继承于动物。

⼈有睡觉(闭眼睡)的⽅法，鱼有睡觉的⽅法，动物也有睡觉的⽅法，
当⼀个类中的⽅法过于抽象时，实现不确定如何实现，此时可以把该⽅法定义成抽象⽅法。

抽象⽅法所在的类过于抽象，称为抽象类(abstract class)
public abstract class 类名 {}
1.1.1 抽象类的特性
[1] 抽象类过于抽象，实例化后⽆语义 => 不能实例化
public abstract class Animal{
private String name;
public void setName(String name){
= name;
}
public String getName(){
return ;
}
public Animal(){
}
public Animal(String name){
= name;
}
public void sleep(){
}
[2] 如果⼀个⽅法过于抽象⽆法实现，需要把该⽅法声明为抽象⽅法。

形式
public abstract void sleep();
抽象⽅法⼀定位于抽象类中。

抽象⽅法没有⽅法体。

抽象类中的⽅法不⼀定都是抽象⽅法。

⼦类继承抽象类，⼀定要根据⾃⾝情况重写抽象类的抽象⽅法，除⾮⼦类也是抽象类。

1.1.1 重写和实现
重写(override):⼦类继承⽗类的⽅法时不能满⾜⾃⾝需要时，⼦类重写⽗类的同名⽅法。

实现(implement):⼦类继承抽象⽗类时，⼀定要重写⽗类的抽象⽅法，此时⽗类的抽象⽅法没有⽅法体，也即没有实现；⼦类⼀定重写⽗类的抽象⽅法也即实现了⽗类的抽象⽅法。

实现是⼀种特殊的重写。

实现建⽴在重写的继承上。

1.1 Final 关键字
final 是⼀个java的关键字，⽤于修饰局部变量、属性、⽅法、类，表⽰最终的意思。

[1] final修饰类表⽰最终类，⽆法被继承。

[2] final修饰符⽅法，⽅法就不能被重写。

[3] final 修饰属性，经常和static搭配使⽤，形成静态常量。

public static final String SEX_MALE = “Q仔”;
public static final String SEX_FEMALE = “Q妹”;
[4] final修饰变量
final 修饰基本数据类型，表⽰a中的内容(值)不能被改变
final int a = 10;
final 修饰引⽤数据类型，表⽰person中的内容(地址)不能被概念
public class Test01{
public static void main(String[] args){
final Person person = new Person();
person.sleep();
person = new Person();
person.sleep();
}
}。