文章目录
- 多态
 - 多态实现的条件
 - 重写
 - 向上转移和向下转型
 - 向上转型
 - 向下转型
 
- 多态的优缺点
 - 避免在构造方法种调用重写的方法
 
多态
一种事物,多种形态。
 多态的概念:去完成某个行为,当不同对象去完成时会产生出不同的状态。
多态实现的条件
1.必须再继承体系下。
 2.子类必须要对父类中的方法进行重写。
 3.通过父类的引用调用重写的方法。

当我们发生向上转型之后,此时通过父类引用只能访问父类自己的成员,不能访问到子类特有的成员。
重写
重写需要满足三个条件:
- 方法名称相同。
 - 参数列表相同。
 - 返回值相同。
 
class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" 正在吃饭!");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫!");
    }
    @Override
    public void eat(){
        System.out.println(name+" 正在吃狗粮!");
    }
}
 

 编译器可以生成:
 
 
 

class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" 正在吃饭!");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫!");
    }
    @Override
    public void eat(){
        System.out.println(name+" 正在吃狗粮!");
    }
}
class Bird extends Animal{
    public String wing;//翅膀
    public void fly(){
        System.out.println(name+" 正在飞!");
    }
    @Override
    public void eat(){
        System.out.println(name+" 正在吃鸟粮!");
    }
}
public static void main(String[] args) {
       Animal animal1 = new Dog();
       animal1.name = "小黄";
       animal1.eat();
	System.out.println("=================");
       Animal animal2 = new Bird();
       animal2.name = "圆圆";
       animal2.eat();
}
 

 静态绑定:也称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
 动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。

重写需要注意:
- private修饰的方法不能被重写。
 - static修饰的方法不能被重写。
 - 子类的访问修饰限定权限要大于等于父类的权限。 
private < 默认 < protected < public - 被final修饰的方法不能被重写,此时这个方法被称作密封方法。

 
向上转移和向下转型
向上转型
实际就是创建一个子类对象,将其当成父类对象来使用。
- 直接赋值
 
class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" 正在吃饭!");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫!");
    }
}
public class Test2 {
    public static void main1(String[] args) {
        Dog dog = new Dog();
        dog.name = "小黄";
        dog.eat();
        dog.wangwang();
        Animal animal = dog;
    }
}
 
- 方法传参
 
class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" 正在吃饭!");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫!");
    }
}
public class Test2 {
    public static void func(Animal animal){
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        func(dog);
    }
}
 
3.方法返回值
class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" 正在吃饭!");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫!");
    }
}
public class Test2 {
    public static Animal func2(){
        return new Dog();
    }
    public static void main(String[] args) {
        func2();
    }
}
 
优点:让代码实现更简单灵活。
 缺陷:不能调用到子类特有的方法。
向下转型
class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" 正在吃饭!");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫!");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        //向下转型
        Dog dog = (Dog)animal1;
        dog.name = "小黄";
        dog.wangwang();
    }
}
 
向下转型非常不安全,比如:
 
解决方法:Java中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为true,则可以安全转换。
if(animal1 instanceof Dog){
     //向下转型
     Dog dog = (Dog)animal1;
     dog.name = "小黄";
     dog.wangwang();
}
 
可以理解为判断animal1这个引用,是不是引用Dog对象。
多态的优缺点
class Shap{
    public  void draw(){
        System.out.println("画图形!");
    }
}
class Rect extends Shap{
    @Override
    public void draw() {
        System.out.println("画矩形!");
    }
}
class Cycle extends Shap{
    @Override
    public void draw() {
        System.out.println("画圆!");
    }
}
class Flower extends Shap{
    @Override
    public void draw() {
        System.out.println("画一朵花❀!");
    }
}
public class Test3 {
    public static void drawMap(Shap shap){
        shap.draw();
    }
    public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        drawMap(rect);
        drawMap(cycle);
        drawMap(new Flower());
    }
}
 

class Shap{
    public  void draw(){
        System.out.println("画图形!");
    }
}
class Rect extends Shap{
    @Override
    public void draw() {
        System.out.println("画矩形!");
    }
}
class Cycle extends Shap{
    @Override
    public void draw() {
        System.out.println("画圆!");
    }
}
class Flower extends Shap{
    @Override
    public void draw() {
        System.out.println("画一朵花❀!");
    }
}
public class Test3 {
    public static void drawMap2(){
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        //c r c r f
        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();
            }
        }
    }
    public static void main(String[] args) {
        drawMap2();
    }
}
 

多态实现:
public static void drawMap3(){
  Rect rect = new Rect();
  Cycle cycle = new Cycle();
  Flower flower = new Flower();
  Shap [] shaps = {cycle,rect,cycle,rect,flower};
  for(Shap shap:shaps){
      shap.draw();
  }
}
 
多态好处:
- 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else。
 - 可扩展能力更强如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低。
 
多态缺陷:代码的运行效率降低。
- 属性没有多态性:当父类和子类都有同名属性的时候,通过父类引用,只能引用父类自己的成员属性。
 - 构造方法没有多态性。
 
避免在构造方法种调用重写的方法
下面我们看一段有坑的代码:
class B {
    public B() {
// do nothing
        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 Test4 {
    public static void main(String[] args) {
        D d = new D();
    }
}
 
当在父类的构造方法当中去调用父类和子类重写的方法的时候,此时会调用子类的。
 num为0是因为父类此时还没有走完,就来到了打印阶段。

 结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。



















