抽象类、final关键字、多态

1.1 抽象类

1.1.1 抽象类概念

C extends B，B extends A，在继承过程中，形成一个继承金字塔，位于金字塔底部的类越来越具体(强大)，位于塔顶的越来越抽象(简单)。

例如：人继承于动物，鱼继承于动物。人有睡觉(闭眼睡)的方法，鱼有睡觉的方法，动物也有睡觉的方法，

当一个类中的方法过于抽象时，实现不确定如何实现，此时可以把该方法定义成抽象方法。

抽象方法所在的类过于抽象，称为抽象类(abstract class)

public abstract class 类名 { }

扫描二维码关注公众号，回复： 5990408 查看本文章

1.1.2 抽象类的特性

[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();

抽象方法一定位于抽象类中。

抽象方法没有方法体。

抽象类中的方法不一定都是抽象方法。

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 abstract void sleep(); }

子类继承抽象类，一定要根据自身情况重写抽象类的抽象方法，除非子类也是抽象类。

public class Person extends Animal{ /* public void sleep(){ System.out.println("闭眼躺着睡觉..."); } */ }

1.1.2 重写和实现

重写(override):子类继承父类的方法时不能满足自身需要时，子类重写父类的同名方法。

实现(implement):子类继承抽象父类时，一定要重写父类的抽象方法，此时父类的抽象方法没有方法体，也即没有实现；子类一定重写父类的抽象方法也即实现了父类的抽象方法。

实现是一种特殊的重写。实现建立在重写的继承上。

1.2 Final 关键字

final 是一个java的关键字，用于修饰局部变量、属性、方法、类，表示最终的意思。

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

public final class Animal{ }

public class Person extends Animal{ public void sleep(){ System.out.println("闭眼躺着睡觉..."); } }

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

public final void sleep(){ System.out.println("animal:sleep"); }

[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(); } }

思考:

[1] 静态方法能被继承吗？

[2] 静态方法可以被重写吗？

java中静态属性和静态方法可以被继承，但是没有被重写(overwrite)而是被隐藏。

1）

静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成对，不需要继承机制及可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静态方法和属性，但是跟实例方法和属性不太一样，存在"隐藏"的这种情况。
2）

多态之所以能够实现依赖于继承、接口和重写、重载（继承和重写最为关键）。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是："重写"后子类的优先级要高于父类的优先级，但是“隐藏”是没有这个优先级之分的。

3）

静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写，因此可以实现多态。

1.3 多态

软件设计原则—开闭原则

对拓展开放，对修改关闭。

为什么要使用多态？

对系统进行业务拓展，增加系统的可维护性。

1.3.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.3.2 多态的实现形式

[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.4 类型转换

在多态中存在两种类型转换，一种是自动类型转换，一种是强制类型转换。

在引用数据类型转换过程中，

自动类型转换也称向上类型转换。子类可以自动转换成父类。

Pet pet = null; pet = new Dog();

强制类型转换也称向下类型转换。父类可以强制转换成子类。

子类类型 引用 = (子类)父类对象

一般而言，需要判断父类对象的真实类型，用instanceof关键字

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.5 调试技巧

step over:  单步调试，一次只执行一行代码。

step into: 进入方法调试

step return: 返回/结束方法

:停止调试