方法覆盖（重写），多态

1. 方法覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型，参数一样，那么我们就说子类的这个方法覆盖了父类的方法。

2. package com.hspedu.override_;
   
   public class Dog extends Animal{
       //1.因为Dog是Animal的子类
       //2.Dog的cry方法和Animal的cry定义形式一样（名称，返回类型，参数）
       //3.这时我们就说Dog的cry方法，重写了Animal的cry方法
       public void cry(){
           System.out.println("小狗汪汪叫...");
       }
   }
   

3. 子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样。

4. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类

   1. 例:父类返回类型是Object，子类返回类型是String

      public Object getInfo(){
      
      }
      public String getInfo(){
      
      }

5. 子类方法不能缩小父类方法的访问权限

   1. 就是父类里有一个public void Dog(){}，你子类中方法覆盖Dog(){}的访问修饰符不能比public小，要不然就是缩小父类方法的访问权限。不允许

   2. public>protected>默认>private

6. 多态：方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的

   1. 解决：代码复用性不高，代码不好维乎

   2. 方法的多态，重写和重载就体现多态。重载就是方法的参数列表不同，传入不同的参数就会调用不同的方法，就体现多态。重写子类和父类创建对象，这两个对象调用它们自己的重写的方法也是多态的体现。

7. 对象的多态

   1. 一个对象的编译类型和运行类型可以不一致

      Animal animal = new Dog();//父类的引用指向子类的对象
      //animal编译类型是Animal，运行类型Dog
      
      animal = new Cat(); animal的运行类型变成了Cat，编译类型仍然是Animal

   2. 编译类型在定义对象时，就确定了，不能改变

   3. 运行类型是可以变化的

   4. 编译类型看定义时=号的左边，运行类型看=号的右边。

   5. package com.hspedu.ploy_.objectpoly_;
      
      public class PolyObject {
          public static void main(String[] args) {
              //体验对象多态特点
              //animal 编译类型就是Animal，运行类型Dog
              Animal animal = new Dog();
              //因为运行时,执行到该行时，animal运行类型是Dog，所以cry就是Dog的cry
              animal.cry();//小狗汪汪叫
      
              //animal 编译类型Animal，运行类型是Cat
              animal = new Cat();
              animal.cry();//小猫喵喵叫
          }
      }
      class Dog extends Animal{
          public void cry(){
              System.out.println("Dog cry(),小狗汪汪叫...");
          }
      }
      class Cat extends Animal{
          public void cry(){
              System.out.println("Cat cry(),小猫喵喵叫...");
          }
      }
      class Animal{
          public void cry(){
              System.out.println("Animal 动物叫");
          }
      
      }
      

      方法看运行类型，属性看编译类型

8. 多态，方法的参数可以接受指定类型参数的子类。

   1. 多态的前提是：两个对象存在继承关系

9. 多态的向上转型

   1. 本质：父类的引用指向子类的对象

   2. 语法：父类类型   引用名  =  new   子类类型（）；

   3. 特点：编译类型看左边，运行类型看右边。可以调用父类中的所有成员（遵守访问权限），不能调用子类中特有成员（在编译阶段，能调用哪些成员是由编译类型来决定的），最终运行效果看子类的具体实现（运行的时候，先看运行类型，运行类型是子类，这也是遵循子类没有，再找父类）。

10. 多态的向下转型

    1. 语法：子类类型   引用名   =   （子类类型）父类引用；

    2. 只能强转父类的引用，不能强转父类的对象

    3. 要求父类的引用必须指向的是当前目标类型的对象。

    4. 当向下转型后，可以调用子类类型中所有的成员。

    5. 
       Animal animal = new Cat();//这里animal对象是指向Cat的
       
       Cat cat = (Cat) animal;
       //1.cat的编译类型 Cat，运行类型 Cat
       //2.要求父类的引用必须指向的是当前目标类型的对象。就是animal之前指向的对象必须是Cat
       
       //如果
       Dog dog = (Dog) animal;//不可以，因为animal之前不是指向Dog类型的对象
       

11. 多态注意事项细节

    1. package com.hspedu.ploy_.detail_;
       
       public class PolyDetail02 {
           public static void main(String[] args) {
               //属性没有重写之说！属性的值看编译类型
               Base base = new Sub();//向上转型
               System.out.println(base.count);//10
               Sub sub = new Sub();
               System.out.println(sub.count);//20
           }
       
       
       
       }
       class Base{//父类
           int count = 10;//属性
       }
       class Sub extends Base{
           int count = 20;
       }

       属性没有重写之说！属性的值看编译类型

    2. package com.hspedu.ploy_.detail_;
       
       public class PolyDetail03 {
           public static void main(String[] args) {
               BB bb = new BB();
               //instanceof比较操作符，用于判断对象的运行类型是否为
               //XX类型或XX类型的子类型
               System.out.println(bb instanceof BB);//true
               System.out.println(bb instanceof AA);//true
               //aa 编译类型AA，运行类型BB
               AA aa = new BB();
               System.out.println(aa instanceof AA);//true
               System.out.println(aa instanceof BB);//true
               AA cc = new AA();
               System.out.println(cc instanceof BB);//false
               
       
               String str = "hello";
               System.out.println(str instanceof Object);//true
       
           }
       }
       class AA{
       
       }
       class BB extends AA{
       
       }
       
       

       instanceof比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

        

12. 练习

     方法看运行类型，属性看编译类型