4.2 向下转型
将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
public class Test1 { public static void main(String[] args) { Cat cat = new Cat("小花",2); Dog dog = new Dog("Peter", 1); // 向上转型 Animal animal = cat; animal.eat(); animal = dog; animal.eat(); animal.bark();// 编译失败，编译时编译器将animal当成Animal对象处理，而Animal类中没有bark方法，因此编译失败 // 向上转型 cat = (Cat)animal; cat.miaomiao();// 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗，现在要强制还原为猫，无法正常还原 dog = (Dog)animal;// animal本来指向的就是狗，因此将animal还原为狗也是安全的 dog.bark(); } }
向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换：
public class Test1 { public static void main(String[] args) { Cat cat = new Cat("小花",2); Dog dog = new Dog("Peter", 1); // 向上转型 Animal animal = cat; animal.eat(); animal = dog; animal.eat(); //类型比较运算符:instanceof if(animal instanceof Cat){ cat = (Cat)animal; cat.miaomiao(); } if(animal instanceof Dog){ dog = (Dog)animal; dog.bark(); } } }
🍤 运行结果：
5. 多态的优点
1.能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
圈复杂度是一种描述一段代码复杂程度的方式。
一段代码如果平铺直叙，那么就比较简单容易理解，而如果有很多的条件分支或者循环语句，就认为理解起来更复杂。
因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数，这个个数就称为 “圈复杂度”。
如果一个方法的圈复杂度太高, 就需要考虑重构。
实例：打印多个形状
public class drawShape { public static void main(String[] args) { //实例化 Rect rect = new Rect(); Cycle cycle = new Cycle(); Flower flower = new Flower(); String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"}; //遍历shapes数组 for (String shape : shapes) { if (shape.equals("cycle")) { cycle.draw();//画● } else if (shape.equals("rect")) { rect.draw();//画♦ } else if (shape.equals("flower")) { flower.draw();//画❀ } } } } class Shape { //属性.... public void draw() { System.out.println("画图形！"); } } class Rect extends Shape{ @Override public void draw() { System.out.println("♦"); } } class Cycle extends Shape{ @Override public void draw() { System.out.println("●"); } } class Flower extends Shape { @Override public void draw() { System.out.println("❀"); } }
🍤 运行结果：
上面的代码使用 if-else 分支语句太过复杂，我们可以使用多态来简化代码：
public class drawShape { public static void main(String[] args) { // 创建了一个 Shape 对象的数组 Shape[] shapes = {new Cycle(), new Rect(), new Cycle(), new Rect(), new Flower()}; for (Shape shape : shapes) { shape.draw();//根据shapes所指的对象，引用不同类中的draw } } }
2.可扩展能力更强
如果要新增一种新的形状，使用多态的方式代码改动成本也比较低。
//新增一个形状 class Triangle extends Shape { @Override public void draw() { System.out.println("△"); } }
对于类的调用者来说，只要创建一个新类的实例就可以了，改动成本很低。
而对于不用多态的情况，就要把 main 中的 if - else 进行一定的修改，改动成本更高。
多态缺陷：代码的运行效率降低。
- 属性没有多态性
- 当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
- 构造方法没有多态性
6. 避免在构造方法中调用重写的方法
下面是一段有坑的代码：
创建两个类，B 是父类，D 是子类。D 中重写 func 方法，并且在 B 的构造方法中调用 func
class B { public B() { func(); } public void func() { System.out.println("B.func()"); } } class D extends B { private int num = 1; @Override public void func() { System.out.println("D.func() " + num); } } public class Test { public static void main(String[] args) { D d = new D(); } }
🍤 运行结果：
在构造 D 对象的同时，会调用 B 的构造方法，而B 的构造方法中调用了 func 方法，此时会触发动态绑定，会调用到 D 中的 func。此时 D 对象自身还没有构造， num 处在未初始化的状态值为 0。 如果具备多态性，num的值应该是1。
所以在构造函数内，尽量避免使用实例方法，除了 final 和 private 方法。
结论：
用尽量简单的方式使对象进入可工作状态，尽量不要在构造器中调用方法(如果这个方法被子类重写，就会触发动态绑定，但是此时子类对象还没构造完成)，可能会出现一些隐藏的但是又极难发现的问题。
