继承和多态
一、继承
1.为什么需要继承
Java中使用类对现实世界中实体来进行描述，类经过实例化之后产生产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序时就需要考虑。
使用Java语言来描述猫和狗：
public class Dog {
String name;
int age;
float weight;
public void eat(){
System.out.println(name +"正在吃饭");
}
public void sleep(){
System.out.println(name+"正在睡觉");
}
void Bark(){
System.out.println(name+"汪汪汪~~~");
}
}
/
public class Cat {
String name;
int age;
float weight;
public void eat(){
System.out.println(name+"正在吃饭");
}
public void sleep(){
System.out.println(name+"正在睡觉");
}
void mew(){
System.out.println(name+"喵喵喵~~~");
}
}
通过观察上述代码，我们可以发现在猫和狗的类中存在许多重复的代码。我们能否将这些共性抽取出来呢？
面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码的复用。
2.继承概念
继承机制：面向对象程序设计使代码可以重复使用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称为派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
例如：猫和狗都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。
在上图中，Dog和Cat都继承了Animal类。其中：Animal类被称为父类/基类或超类，Dog和Cat可以称为Animal的子类或者派生类，继承之后，子类可以复用父类中的成员，子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态(后续介绍)。
3.继承的语法
在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：
class 子类 extends 父类{
//...
}
对上面的猫和狗类使用继承方式重新设计：
public class Animal {
String name;
int age;
public void eat(){
System.out.println(name+"正在吃饭");
}
public void sleep(){
System.out.println(name+"正在睡觉");
}
}
public class Dog extends Animal{
void Bark(){
System.out.println(name+"汪汪汪~~~");
}
}
public class Cat extends Animal {
void mew(){
System.out.println(name+"喵喵喵~~~");
}
}
public class TestExtend {
public static void main(String[] args) {
Dog dog=new Dog();
//dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
System.out.println(dog.name);
System.out.println(dog.age);
//dog访问的eat()和sleep()方法也是从Animal中继承下来的
dog.eat();
dog.sleep();
dog.Bark();
}
}
注意：
- 子类确实将父类中的成员变量或者属性继承到子类中了。
- 子类继承父类之后，必须要新添加自己特有的成员体现出与基类的不同，否则就没有必要继承了。
4.父类成员访问
在继承体系中，子类将父类中的方法和属性继承到子类中了，那在子类中能否直接访问父类中继承下来的成员呢？
4.1 子类中访问父类的成员变量
- 子类和父类不存在同名成员变量
public class Base{
int a;
int b;
}
public class Derived extends Base{
int c;
public void method(){
a=10;//访问从父类中继承下来的a
b=20;//访问从父类中继承下来的b
c=30;//访问子类自己的c
}
}
- 子类和父类成员变量同名
public class Base{
int a;
int b;
int c;
}
///
public class Derived extends Base{
int a;//与父类中成员a同名，且类型相同
char b;//与父类中成员b同名，但类型不同
public void method(){
a=100;//访问从父类继承的a，还是子类自己新增的a？
b=101;//访问从父类继承的b，还是子类自己新增的b？
c=102;//子类没有c，访问的肯定是从父类继承下来的c
//d=103,;//编译失败，因为父类和子类都没有定义成员变量d
}
}
在子类方法中或者通过子类对象访问成员时：
- 如果访问的成员变量子类中有，优先访问自己的成员变量。
- 如果访问的成员变量子类中没有，则访问从父类继承下来的，如果父类也没有定义，则编译报错。
- 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。即：子类将父类同名成员隐藏了。
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。
4.2 子类中访问父类的成员方法
1.成员方法名字不同
public class Base {
public void methodA(){
System.out.println("Base中的methodA()");
}
}
public class Derived extends Base{
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
methodB();//访问子类自己的methodB()
methodA();//访问从父类继承的methodA()
//methodD();//编译失败，在整个继承体系中没有发现方法methodD()
}
}
总结： 成员方法没有同名时，通过子类方法中或者通过子类对象访问方法则优先访问自己的，自己没有再到父类中找，如果父类中也没有则报错。
2.成员方法名字相同
public class Base {
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
public void methodA(int a){
System.out.println("Derived中的methodA(int)方法");
}
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
methodA();//没有传参，访问从父类继承的methodA()
methodA(20);//传递int参数，访问子类中的methodA(int)
methodB();//直接访问，则访问子类自己的methodB()，基类的无法访问到
//methodD();//编译失败，在整个继承体系中没有发现方法methodD()
}
}
说明：
- 通过子类对象访问父类与子类中不同名方法时，优选在子类中找，找到则访问；找不到则去父类中找，在父类中找到则访问，否则编译报错。
- 通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法的原型一致(重写–后面介绍)，则只能访问到子类的，父类的无法通过子类对象直接访问到。
5.super关键字
由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。
public class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
int a;//与父类中成员变量同名且类型相同
char b;//与父类中成员变量同名但类型不同
public void methodA(int a){
System.out.println("Derived中的methodA(int)方法");
}
//与父类中methodB()构成重写(即原型一致，重写后续详细介绍)
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
//对于同名的成员变量，直接访问时，访问的都是子类的
a=100;//等价于：this.a=100;
b=101;//等价于：this.b=101;
//注意：this是当前对象的引用
//访问父类的成员变量时，需要借助super关键字
//super是获取到子类对象中从基类继承下来的部分
super.a=200;
super.b=201;
//父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
methodA();//没有传参，访问从父类继承的methodA()
methodA(20);//传递int参数，访问子类中的methodA(int)
//如果在子类中要访问重写的父类方法，则需要借助super关键字
methodB();//直接访问，则访问子类自己的methodB()，父类的无法访问到
super.methodB();//访问父类的methodB()
}
}
在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。
注意事项：
- 只能在非静态方法中使用
- 在子类方法中，访问父类的成员变量和方法。
6. 子类构造方法
子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法。
public class Base {
public Base(){
System.out.println("Base()");
}
}
public class Derived extends Base{
public Derived(){
//super();//注意子类构造方法中默认会调用父类的无参构造方法：super(),
//用户没有写时，编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
//并且只能出现一次
System.out.println("Derived()");
}
}
public class Test {
public static void main(String[] args) {
Derived d=new Derived();
}
}
//输出结果：
Base()
Derived()
在子类构造方法中，并没有写任何关于父类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法。因为：子类对象是一个父类对象，在构造子类对象时，先将从父类继承下来的成员初始化完整，然后再初始化子类自己新增加的成员。
注意：
- 如果父类的构造方法无参的或者默认的构造方法，此时，子类的构造方法可以不用定义，如果需要再定义。在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。
- 如果父类构造方法是带有参数的，此时编译器不会再给子类生成默认的构造方法，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
- 在子类构造方法中，super()调用父类构造时，必须是子类构造函数中第一条语句。
- super()只能在子类构造方法中出现一次，并且不能和this同时出现。
- 构造哪个类的对象就调用哪个类的构造方法。
子类对象在构造时，先调用父类的构造方法，再调用子类的构造方法。这种说法是错误的。
解释：
当在构造子类对象时，调用子类的构造方法完成该对象的初始化。
子类的构造方法()
{
1.先将父类的成员构造完成------->super():如果父类的构造方法是无参的或者默认的-----编译器会自动添加。如果用户显式提供了，则编译器不再增加。
2.再将子类新增的成员构造完成------执行子类构造方法程序。
}
7. super和this
super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那它们之间有什么区别呢？
相同点：
- 都是Java中的关键字。
- 只能应用在类的非静态方法中，用来访问非静态成员方法和属性。
- super和this作为构造方法调用时，都必须是构造方法中的第一条语句，并且不能同时存在。
不同点：
-
this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是父类对象的引用。注意：this和super都没有包含在对象中。
-
在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性。
-
this是非静态成员方法的一个隐藏参数，super不是隐藏的参数。
-
成员方法中直接访问本类成员时，编译之后会将this还原，即本类非静态成员都是通过this来访问的；在子类中如果通过super访问父类成员，编译之后在字节码层面super实际是不存在的。(
super只在代码中可以体现出来，告诉编译器访问父类的成员)
-
在构造方法中：this()用于调用父类构造方法，两种调用不能同时在构造方法中出现。
-
构造方法中一定会存在super()的调用，用户没有写编译器也会增加，但是this()用户不写则没有。
8.再谈初始化
我们简单回顾一下几个重要的代码块：实例代码块和静态代码块。在没有继承关系时的执行顺序。
public class Person {
public String name;
public int age;
public Person(String name,int age){
this.name=name;
this.age=age;
System.out.println("构造方法执行");
}
{
System.out.println("实例代码块执行");
}
static{
System.out.println("静态代码块执行");
}
}
public class TestDemo {
public static void main(String[] args) {
Person p1=new Person("Jam",10);
System.out.println("=========================");
Person p2=new Person("Mike",14);
}
}
执行结果：
静态代码块执行
实例代码块执行
构造方法执行
=========================
实例代码块执行
构造方法执行
1.静态代码块只执行一次
2.静态代码块先执行，实例代码块接着执行，最后构造方法执行。
继承关系下的执行顺序：
public class Person {
public String name;
public int age;
public Person(String name,int age){
this.name=name;
this.age=age;
System.out.println("父类构造方法执行");
}
{
System.out.println("父类实例代码块执行");
}
static{
System.out.println("父类静态代码块执行");
}
}
public class Student extends Person{
public Student(String name,int age){
super(name, age);
System.out.println("子类构造方法执行");
}
{
System.out.println("子类实例代码块执行");
}
static {
System.out.println("子类静态代码块执行");
}
}
public class TestDemo2 {
public static void main(String[] args) {
Student s1=new Student("lucy",14);
System.out.println("=====================");
Student s2=new Student("Jone",15);
}
}
执行结果：
父类静态代码块执行
子类静态代码块执行
父类实例代码块执行
父类构造方法执行
子类实例代码块执行
子类构造方法执行
=====================
父类实例代码块执行
父类构造方法执行
子类实例代码块执行
子类构造方法执行
通过分析该执行结果，得出以下结论：
- 父类静态代码块优先于子类静态代码块执行，且是最早执行的。
- 父类实例代码块和父类构造方法紧接着执行。
- 子类的实例代码块和子类构造方法紧接着再执行。
- 第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。
9.protected关键字
在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。
那在父类中不同访问权限的成员，在子类中的可见性又是怎样的呢？
public class B {
private int a;
protected int b;
public int c;
int d;
}
//同一个包中的子类
public class D extends B{
public void method(){
//super.a=10; //编译报错，父类private成员在相同包子类中不可见
super.b=20; //父类中protected 成员在相同包子类中可以直接访问
super.c=30; //父类中public成员在相同包子类中可以直接访问
super.d=40; //父类中默认访问权限修饰的成员在相同包子类中可以直接访问
}
}
import day0923.test4.B;
public class C extends B {
public void method(){
//super.a=10; //编译报错，父类private成员在不同包子类中不可见
super.b=20; //父类中protected 成员在不同包子类中可以直接访问
super.c=30; //父类中public成员在不同包子类中可以直接访问
//super.d=40; //编译报错 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
}
}
public class TestC {
public static void main(String[] args) {
C c=new C();
c.method();
//System.out.println(c.a);//编译报错，父类中private成员在不同包其他类中不可见
//System.out.println(c.b);//父类中protected成员在不同包非子类中不能直接访问
System.out.println(c.c);//父类中public成员在不同包其他类中可以直接访问
//System.out.println(c.d);//父类中默认访问权限修饰的成员在不同包其他类中不能直接访问
}
}
注意： 父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了。
访问权限比较多，一般这样设计：
成员方法：一般都给public
成员变量：一般设置为private或者protected
private：修饰的成员既不能在类外被访问，也不能被子类访问。
protected：修饰的成员不能在类外访问，可以被子类访问。
10.继承方式
在Java中有以下几种继承方式：
继承关系一般不超过三层。
11.final关键字
final关键字可以用来修饰变量、成员方法以及类。
- 修饰变量或字段，表示常量(即不能修改)。
final int a=10;
a=20;//编译出错
- 修饰类：表示此类不能被继承
final public class Animal{
...
}
public class Bird extends Animal{
...
}
//编译出错
//java: 无法从最终day0923.test1.Fu进行继承
final关键字的功能是限制类被继承
- 修饰方法：表示该方法不能被重写。
12.继承与组合
和继承类似，组合也是一种表达类之间关系的方式，也是能够达到代码重复使用的效果。组合并没有涉及到特殊的语法(像extends这样的关键字)，仅仅是将一个类的实例作为另一个类的字段。
继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物。
组合表示对象之间是has-a的关系，比如：汽车。
汽车和它的轮胎、发动机、方向盘、车载系统等的关系就是组合，因为汽车是由这些部件组成的。
//轮胎类
class Tire{
.......
}
//发动机类
class Engine{
........
}
//车载系统类
class VehicleSystem{
.....
}
class Car{
private Tire tire;//复用轮胎中的属性和方法
private Engine engine;//可以复用发动机中的属性和方法
private VehicleSystem vs;//可以复用车载系统中的属性和方法
....
}
组合和继承都可以实现代码复用，选择使用继承还是组合，需要根据应用场景来选择。建议：能用组合尽量用组合。
二、多态
1.多态的概念
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
分类：
- 静态多态(早绑定)：在程序编译阶段，已经确定了方法的具体行为，即已经确定了具体要调用哪个方法。典例------->方法重载
- 动态多态(晚绑定)
2.多态实现条件
- 必须在继承体系下。
- 子类必须要对父类中方法进行重写。
- 只能通过父类的引用调用重写的方法。在程序执行时，根据父类引用不同类的对象，就会调用对应类中被重写的方法。
多态的体现： 在运行代码传递不同类对象时，会调用对应类中的方法。
public class Animal {
String name;
int age;
public Animal(String name,int age){
this.name=name;
this.age=age;
}
public void eat(){
System.out.println(name+"吃饭");
}
}
public class Cat extends Animal{
public Cat(String name,int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃鱼~~~");
}
}
public class Dog extends Animal{
public Dog(String name,int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃骨头~~~");
}
}
//编译器在编译代码时，并不知道要调用Dog还是Cat中的eat方法
//等程序运行起来后，形参a引用的具体对象确定后，才知道调用哪个方法
//注意：此处的形参类型必须是父类类型才可以
public static void eat(Animal a){
a.eat();
}
public static void main(String[] args) {
Cat cat=new Cat("元宝",2);
Dog dog=new Dog("小七",3);
eat(cat);
eat(dog);
}
}
运行结果：
元宝吃鱼~~~
小七吃骨头~~~
当类的调用者在写eat这个方法的时候，参数类型为Animal(父类)，此时在该方法内部并不知道，也不关注当前的a引用指向的是哪个类型(哪个子类)的实例。此时，a这个引用调用eat方法可能会有多种不同的表现(和a引用的实例相关)，这种行为就称为多态。
3.重写
重写：也称为覆盖。重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写。重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
方法重写的规则:
- 子类在重写父类方法时，一般必须与父类方法原型一致：修饰符、返回值类型、方法名、参数列表要完全一致。
- JDK7以后，被重写方法的返回值类型可以不相同，但是必须是具有父子关系。
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
- 父类被static、private修饰的方法、构造方法都不能被重写。
- 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
- 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
- 重写的方法，可以使用@Override注解来显示指定。有了这个注解能帮我们进行一些合法性校验。例如不小心将方法名字拼写错了，那么此时编译就会报错，提示无法构成重写。
重写和重载的区别：
| 区别点 | 重载 | 重写 |
|---|---|---|
| 方法名 | 必须相同 | 必须相同 |
| 参数列表 | 必须修改 | 不能修改 |
| 返回类型 | 可以修改 | 不能修改 |
| 访问限定符 | 可以修改 | 可以降低限制 |
| 方法定义范围 | 没有限制 | 一个方法必须在基类、另一个方法必须在子类中 |
| 异常 | 可以修改 | 可以减少或删除，一定不能抛出新的或者更广的异常 |
即：方法重载是一个类的多态性表现，而方法重写是子类和父类的一种多态性表现。
重写的设计原则：
对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个类，来重复利用其中共性的内容，并且添加或者改动新的内容。
例如：以前的手机，只能打电话、发短信，来电显示只能显示号码，而今天的手机不仅可以显示号码，还可以显示头像，地区等等。在这个过程中，我们不应该在原来的类上进行修改，因为原来的类，可能还有用户在使用，我们正确的做法是：新建一个手机的类，对来电显示这个方法重写就可以了，这样就可以达到现在的需求。
4.向上转型和向下转型
4.1 向上转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名=new 子类类型()
Animal animal =new Cat("元宝",2);
Animal是父类类型，但可以引用一个子类对象。因为：子类对象是一个父类对象，即可以将一个子类对象当成一个父类对象来应用。因此向上转型是安全的，因为是从小范围向大范围转换的。
使用场景：
1.直接赋值
2.方法传参
3.方法返回
public class TestAnimal {
//2.方法传参：形参为父类型引用，可以接收任意子类的对象
public static void eatFood(Animal a){
a.eat();
}
//3.作返回值：返回任意子类对象
public static Animal buyAnimal(String var){
if("狗"==var){
return new Dog("狗狗",1);
}else if("猫==var"){
return new Cat("猫猫",1);
}else {
return null;
}
public static void main (String[]args){
Animal cat=new Cat("元宝",2);//1.直接赋值：子类对象赋值给父类对象
Dog dog=new Dog("小七",1);
eatFood(cat);
eatFood(dog);
Animal animal=buyAnimal("狗");
animal.eat();
animal=buyAnimal("猫");
animal.eat();
}
}
}
向上转型的优点：让代码实现更简单灵活。
向上转型的缺点：不能调用到子类特有的方法。
4.2 向下转型
将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法。此时：将父类引用再还原为子类对象即可，即向下转型。
public class TestAnimal {
public static void main(String[] args) {
Cat cat=new Cat("元宝",2);
Dog dog=new Dog("小七",1);
//向上转型
Animal animal=cat;
Animal.eat();
animal=dog;
animal.eat();
//编译失败，编译器将animal当成Animal对象处理
//Animal类中没有bark方法,因此编译失败
//animal.bark();
//向上转型
//程序可以通过编译，但运行时抛出异常-----因为animal实际指向的是狗
//现在要强制还原为猫，无法正常还原
cat=(Cat) animal;
cat.mew();
//animal本来指向的就是狗，因此将animal还原为狗也是安全的
dog=(Dog)animal;
dog.bark();
}
}
向下转型用的比较少，而且不安全，一旦转换失败，运行就会抛异常。Java中为了提高向下转型的安全性，引入了instanceof，如果该表达式为true，则可以安全转换。
public class TestAnimal {
public static void main(String[] args) {
Cat cat=new Cat("元宝",2);
Dog dog=new Dog("小七",1);
//向上转型
Animal animal=cat;
Animal.eat();
animal=dog;
animal.eat();
if(animal instanceof Cat){
cat=(Cat)animal;
cat.mew();
}
if(animal instanceof Dog){
dog=(Dog)animal;
dog.bark();
}
}
}
5.多态的优缺点
使用多态的好处是什么？
1.类调用者对类的使用成本进一步降低
- 封装是让类的调用者不需要知道类的实现细节。
- 多态能让类的调用者连这个类的类型是什么都不必知道，只需知道这个对象具有某个方法即可。
因此，多态可以理解成是封装的更进一步，让类的使用者对类的使用成本进一步降低。
2.能够降低代码的"圈复杂度"，避免使用大量的if-else
例如我们现在需要打印的不是一个形状了，而是多个形状。如果不基于多态，实现代码如下：
public static void drawShapes() {
Rect rect = new Rect();
Cycle cycle = new Cycle();
Flower flower = new Flower();
String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
for (String shape : shapes) {
if (shape.equals("cycle")) {
cycle.draw();
} else if (shape.equals("rect")) {
rect.draw();
} else if (shape.equals("flower")) {
flower.draw();
}
}
}
如果使用多态，则不需要写这么多的if-else语句，代码更简单。
public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
new Rect(), new Flower()};
for (Shape shape : shapes) {
shape.draw();
}
}
什么叫圈复杂度？
圈复杂度是一种描述一段代码复杂程度的方式。我们可以简单粗暴地计算一段代码中的条件语句和循环语句出现的个数，这个个数就称为"圈复杂度"。
如果一个方法的圈复杂度太高，就需要考虑重构。
3.可扩展能力更强
如果想要增加一种新的形状，使用多态的方式代码改动成本也比较低。
class Triangle extends Shape{
@Override
public void draw (){
System.out.println("三角形")
}
}
对于类的调用者来说(drawShapes方法)，只要创建一个新类的实例就可以了，改动成本很低。
而对于不同多态的情况，就要把drawShape中的if-else进行一定的修改，改动成本更高。
多态缺陷：代码的运行效率低。
可以从两个方面验证：
1.测试代码运行时间。
2.了解多态的底层实现原理。
6.避免在构造方法中调用重写的方法
下面是一段有坑的代码。
public class B {
public B(){
func();
}
public void func(){
System.out.println("B.func()");
}
}
public 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。
总结： 用尽量简单的方式使对象进入可工作状态，尽量不要在构造器中调用方法(如果这个方法被子类重写，就会触发动态绑定，但是此时子类对象还没有构造完成)，可能会出现一些隐藏的但是又极难发现的问题。
7706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
