文章目录
一、多态是什么？二、多态的必要条件2.1 初始多态2.2 多态的优缺点2.3 重写 三、转型3.1 向上转型3.2 向下转型3.3 避免在构造方法中调用重写方法.
一、多态是什么？
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：
二、多态的必要条件
2.1 初始多态
要实现多态，以下三大条件缺一不可:
必须在继承体系下子类必须要对父类中方法进行重写通过父类的引用调用重写的方法
class Shape { void draw() { }}class Square extends Shape { @Override void draw() { System.out.println("画Square!"); }}class Circle extends Shape { @Override void draw() { System.out.println("画Circle!"); }}class Triangle extends Shape { @Override void draw() { System.out.println("画Triangle!"); }}public class Test { public static void draw(Shape shape) { shape.draw(); } public static void main(String[] args) { Circle circle = new Circle(); Square square = new Square(); draw(circle); draw(square); }}
在这里实现了同一个方法同一引用，因为传入对象的不同，产生了不同的效果，这种不同的体现就是多态的体现.
2.2 多态的优缺点
优点:
消除类型之间的耦合关系可替换性可扩充性接口性灵活性简化性缺点:
1.属性没有多态性
当父类和子类属性同名时，只能访问父类的
2.构造方法没有多态性.
2.3 重写
重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
在重写的时候可以加上@Override关键字，系统会默认帮我们检查重写的方法是否正确，如果父类没有此类方法，就会编译报错.
| 区别 | 重写 | 重载 |
|---|---|---|
| 方法名 | 不能修改 | 不能修改 |
| 参数列表 | 一定不能修改 | 必须修改 |
| 返回类型 | 不能修改或者构成父子关系 | 可以修改 |
| 访问限定符 | 不能增强限制 | 可以修改 |
对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，
并且添加或者改动新的内容。
静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。
三、转型
3.1 向上转型
Shape shape = new Circle();向上转型就是new 一个子类对象，让父类对象来使用
class Animal { String neme; int age; public Animal(String neme, int age) { this.neme = neme; this.age = age; } public void eat(){ }}class Cat extends Animal { public Cat(String neme, int age) { super(neme, age); } public void eat() { System.out.println("吃鱼"); } public void work() { System.out.println("抓老鼠"); }}class Dog extends Animal { public Dog(String neme, int age) { super(neme, age); } public void eat() { System.out.println("吃骨头"); } public void work() { System.out.println("看家"); }}1.直接赋值:
public static void main(String[] args) { Animal cat = new Cat("咪咪",18);//直接将子类对象赋值给父类对象 }2.方法传参:
public static void eat(Animal animal) { //方法传参:形参为父类引用，可以接受子类对象 animal.eat(); }3.方法返回:
public static Animal reAnimal(String type) { //返回一个子类对象 if("狗".equals(type)) { return new Dog("旺财",18); }else if("猫".equals(type)) { return new Cat("咪咪",18); }else { return null; } }向上转型可以让代码变得更加简单灵活，但无法访问子类特有的属性方法.
3.2 向下转型
在进行向上转型后，无法调用子类的方法，但有时可能需要调用子类方法，此时在还原为子类对象，成为向下转型.
放下转型具有不安全性
向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。
public static void main(String[] args) { Animal animal = new Dog("旺财",18); if(animal instanceof Cat) { Cat cat = (Cat)animal; } else if(animal instanceof Dog) { Dog dog = (Dog)animal; } }通过向下转型后就可以正常的调用子类方法.
3.3 避免在构造方法中调用重写方法.
class A { public A() { fun(); } public void fun() { System.out.println("A:fun"); }}class B extends A { int count = 10; @Override public void fun() { System.out.println("B:fun"+count); } public static void main(String[] args) { B b = new B(); }}这样的代码会出现很多问题.它先执行父类的构造方法，然后在构造方法中执行子类的重写方法，但因为子类还没有执行构造方法,子类的属性还没有被加载，所以这里输出的count不是10，而是默认值0.
结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.