Java面向对象：多态

1.多态的概念2.向上转型和向下转型（1）向上转型（2）向下转型 3.方法重写4.动态绑定与静态绑定5.多态的优缺点

========================================================================================

1.多态的概念

多态：是面向对象程序设计重要特性之一；多态：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。多态的实现：必须在继承体系之下；子类对父类的方法进行重写；通过父类的引用调用子类重写的方法；在代码运行时，当传递不同类对象时，会调用对应类中的方法。

2.向上转型和向下转型

（1）向上转型

子类对象是一个父类对象，即可以将一个子类对象当成父类对象来应用。因此：向上转型是安全的，因为是从小范围向大范围的转换。

例：

—父类 People

package polymorphic;public class People {//父类成员变量public String name;public int age;//构造方法public People(String name, int age) {this.name = name;this.age = age;}//父类成员方法public void introduce(){System.out.println(name+"今年"+age+"岁了！");}}

—子类Teacher

package polymorphic;public class Teacher extends People{//子类新增成员属性public String teach;//子类构造方法，必须第一行使用关键字super显示调用父类构造方法public Teacher(String name,int age,String teach) {super(name,age);this.teach = teach;}//方法重写@Overridepublic void introduce(){System.out.println(name+"是一个"+teach+"老师，今年"+age+"岁！");}}

—第一种 向上转型方式：通过直接赋值父类 实例名=（父类）子类对象；

package polymorphic;public class Main {public static void main(String[] args) {Teacher teacher=new Teacher("于帆",48,"计算机网络");//显示转换 子类实例 向上转型为 父类实例People people=(People) teacher;people.introduce();}}

—第二种 向上转型方式：通过方法传参，将实参（子类的对象）传给方法的形参（父类的一个引用）

package polymorphic;public class Main {public static void main(String[] args) {Teacher teacher=new Teacher("于帆",48,"计算机网络");introduce((teacher));}public static void introduce(People people){people.introduce();}}

—第三种 向上转型方式：通过方法返回 进行子类向父类的向上的转化

package polymorphic;/*** @Author: 19261* @Date: /9/12 12:21*/public class Main {public static void main(String[] args) {Teacher teacher=new Teacher("于帆",48,"计算机网络");People people=transform(teacher);people.introduce();}public static People transform(Teacher teacher){return teacher;}}

向上转型的优点：让代码实现更简单灵活。向上转型的缺陷：不能调用到子类特有的方法。

（2）向下转型

向下转型：在实现多态时，有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象，即为向下转换。

例：

package polymorphic;public class Student extends People{//子类新增成员变量public String grade;public int classNum;public int score;public Student(String name, int age, String grade, int classNum, int score) {super(name, age);this.grade = grade;this.classNum = classNum;this.score = score;}@Overridepublic void introduce(){System.out.println(name+",今年"+grade+age+"岁,目前在"+classNum+"班!");}//子类Student新增方法public void showScore(){System.out.println(name+"总分为："+score);}}

—向下转型：为了更安全=> 在实现多态时，将向上转型的父类 再转化为 子类，以便调用子类特有方法；

package polymorphic;public class Main {public static void main(String[] args) {Student student=new Student("张三",16,"高一",1,490);//向上转型People people=(People) student;people.introduce();//向下转型student=(Student) people;student.showScore();}}

3.方法重写

方法重写：子类继承父类之后，对于父类发方法进行重写，是一种避免修改的覆盖；重写的要求： 参数列表与被重写方法的参数列表必须完全相同。访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。父类的成员方法只能被它的子类重写。声明为 final 的方法不能被重写。声明为 static 的方法不能被重写，但是能够被再次声明。构造方法不能被重写。子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。如果不能继承一个类，则不能重写该类的方法。重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 就会编译报错, 提示无法构成重写.

4.动态绑定与静态绑定

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。// 对于动态绑定：就是在实现多态时，不断有向上转化或向下转化，并且父类与子类的方法可能存在重写；所以运行时，在具体调用方法时才能通过动态绑定父类或者子类实例/对象进行选择调用，明确调用的是父类方法还是子类重写的方法；避免在构造方法中调用重写的方法；“用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

例：

package polymorphic;// 父类public class People {public String name;public int age;public People(String name, int age) {this.name = name;this.age = age;}public void introduce(){System.out.println(name+"今年"+age+"岁了！");}}// 子类public class Student extends People{public String grade;public int classNum;public int score;public Student(String name, int age, String grade, int classNum, int score) {super(name, age);this.grade = grade;this.classNum = classNum;this.score = score;}@Overridepublic void introduce(){System.out.println(name+",今年"+grade+age+"岁,目前在"+classNum+"班!");}public void showScore(){System.out.println(name+"总分为："+score);}}public class Main {public static void main(String[] args) {Teacher teacher=new Teacher("赵六",45,"数值分析",7000);People people=(People) teacher;teacher=(Teacher) people;people=(People) teacher;teacher=(Teacher) people;teacher.showWages();people=(People) teacher;teacher=(Teacher) people;people=(People) teacher;people.introduce();}

5.多态的优缺点

缺点：代码运行效率随着多态的实现降低；

优点：

类调用者对类的使用成本进一步降低；封装是让类的调用者不需要知道类的实现细节.多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可. **能够降低代码的 “圈复杂度”, 避免使用大量的 if - else；**可通过创建一个相关继承关系类的数组；进行选择或者循环调用类方法或实现特定操作；可扩展能力更强；只需要创建一个新类的实例，调用重写的方法即可实现更多功能的修改；