1 多态
1.1 开发工具
eclipse:www.eclipse.org
下载地址: https://www.eclipse.org/downloads/packages/
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 pet = null;
// 父类引用 引用 子类对象
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();
}else if(3 == type){
pet = new Cat();
}
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){
this.name = name;
}
public String getName(){
return this.name;
}
public Animal(){
}
public Animal(String name){
this.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();
}
}