多态的分类

多态一般分为两种：重写式多态和重载式多态。

重载式多态，也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道，方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。

但是这里是有歧义的，有的人觉得不应该把重载也算作多态。因为很多人对多态的理解是：程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，这种情况叫做多态。 这个定义中描述的就是我们的第二种多态—重写式多态。并且，重载式多态并不是面向对象编程特有的，而多态却是面向对象三大特性之一（如果我说的不对，记得告诉我。。）。

我觉得大家也没有必要在定义上去深究这些，我的理解是：同一个行为具有多个不同表现形式或形态的能力就是多态，所以我认为重载也是一种多态，如果你不同意这种观点，我也接受。

重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。 这种多态通过函数的重写以及向上转型来实现，我们上面代码中的例子就是一个完整的重写式多态。我们接下来讲的所有多态都是重写式多态，因为它才是面向对象编程中真正的多态。

更多内容参考：Java 中的多态

多态引用时，构造子类对象时的构造方法的调用顺序

1，先调用超类的构造方法，多重超类首先调用最远超类的方法；

2，然后再执行当前子类的构造方法；

调用时需要谨慎处理调用方法

类的属性变量是能重写（覆盖）

class Animal{
   public int age;
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public double age;
   public void move(){
       age = 10.00;
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}

class Cat extends Animal{
   public void move(){
       super.age = 3;
      System.out.println("猫可以跳");
   }
}
 
public class TestOverride{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      Dog c = new Dog();
      Cat d = new Cat();
      
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      c.move();//执行 Dog 类的方法
      d.move();//执行 Cat 类的方法
      Object aValue = a.age;
      Object bValue = b.age;
      Object cValue = c.age;
      System.out.println("The type of "+a.age+" is "+(aValue instanceof Double ? "double" : (aValue instanceof Integer ? "int" : "")));
      System.out.println("The type of "+b.age+" is "+(bValue instanceof Double ? "double" : (bValue instanceof Integer ? "int" : "")));
      System.out.println("The type of "+c.age+" is "+(cValue instanceof Double ? "double" : (cValue instanceof Integer ? "int" : "")));// 覆盖age属性
      System.out.println("The age of cat  is "+d.age);
     
   }
}

编译值：

动物可以移动
狗可以跑和走
狗可以跑和走
猫可以跳
The type of 0 is int
The type of 0 is int
The type of 10.0 is double
The age of cat  is 3

对于多态，可以总结以下几点：

一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）;

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

对于重写和重载的一些浅薄认识。

重写：我从我的父亲继承了一个中餐馆，但是我觉得中餐馆不够，于是我又在中餐馆的基础上加了个西餐馆。

class Chinese{
  public void style(){
    System.out.printhl("赣菜中餐馆");
  }
}

class western extends Chinese{
  public void style(){
    System.out.printhl("西餐厅");
  }
}

餐厅还是那个餐厅，只是我继承过来加入了自己独有的方法。

重载：本来我只开了一个赣菜馆，但是我觉得菜系不够，于是我又增加了川菜、粤菜....

public class Chinese{
  public void style(){
    System.out.printhl("赣菜中餐馆");
  }
   
  public void style(int a){
    System.out.printhl("a川菜中餐馆");
  }
  
   public void style(String b){
    System.out.printhl("b粤菜中餐馆");
  }
}

做饭的方法并没有改变，只是参数不同，返回的值也不一样。