重写和多态

重写

概念：当父类提供的方法无法满足子类的需求时，可以在子类中定义和父类相同的方法，方法名和参数列表都要相同。

子类修改父类继承过来的方法，在子类对象调用该方法一定表现为该子类的表现形式。

方法重写的原则：

• 方法重写一定是在子类和父类之间；

• 方法名称、参数列表、返回值类型必须与父类相同；

• 访问修饰符可以与父类相同或是比父类更广泛，父类私有的方法不能被重写

构造方法能否被重写

• 一个类无法继承它自身(递归构造)

• 一个类可以继承它的同名类,但是一定是不同包的,后面继承的类一定要写父类的全路径

• 构造方法本身无法实现继承,所以构造方法无法被重写

创建子类对象的同时会不会创建父类对象

不会，创建子类对象会先调用父类的构造器，构造器是初始化对象而不是创建对象（当生成儿子的同时，不会生一个父亲）

多态

概念：父类引用指向子类对象，从而产生多种形态

• 二者具有直接或者间接的继承关系的时候，父类引用指向子类对象，即形成多态
• 父类引用仅可以调用父类所声明的属性和方法，不可调用子类独有的属性和方法

多态中的方法重写

如果子类重写了父类的方法，以父类类型引用调用此方法，优先执行父类中的方法还是子类中的方法？

在实际运行过程中，依旧要遵循重写的原则，如果子类重写了父类的方法，执行子类中重写后的方法，否则执行父类的方法。

多态的好处

• 提高了代码的维护性(继承保证)；

• 提高了代码的扩展性(由多态保证)；

• 把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。消除不同类型之间的耦合性

多态的应用

class Trainer{
    public void feed(Dog a){
            a.eat();
            }
     public void feed(Fish a){
            a.eat();
            }
     public void feed(Cat a){
            a.eat();
            }
  
}

​ 方法重载可以解决接收不同对象参数的问题但是其缺点也比较明显。首先随着子类的增加，Trainer类需要继续提供大量的方法重载，多次修改并重新编译源文件。其次，每一个feed方法与某一种具体类型形成了密不可分的关系，耦合太高。

• 使用父类作为方法形参，实现多态。

  调用方法时，可传递的参数类型包括：本类型对象+ 其所有的子类对象

  package com.company.day04;
  
  public class Polymorphic {
      public static void main(String[] args) {
  //向上转型：将一个父类的引用指向一个子类对象
  /* Animal a = new Dog();
  a.eat();
  System.out.println(a instanceof Dog);
  //向下转型
  Animal b = new Dog();
  Dog d = (Dog)b;//强制类型转换
  d.kanjia();*/
  //饲养员类new一个饲养员对象
          Trainer t = new Trainer();
  //向上转型（狗狗转为动物）
  //同样的对象调同样的方法传同样的参数，得到的结果截然不同
          Animal a = new Dog();
  //饲养员喂养动物
          t.feed(a);
  //a.sleep();
  //同样的对象调同样的方法传同样的参数，得到的结果截然不同
          a = new Penguin();
          t.feed(a);
  //同样的对象调同样的方法传同样的参数，得到的结果截然不同
          a = new Monkey();
          t.feed(a);
      }
  }
  
  //饲养员
  class Trainer{
      //使用父类类型作为参数
      public void feed(Animal a){
          a.eat();
          if(a instanceof Dog){
              Dog s = (Dog)a;
              s.kanjia();
          }
      }
  }
  //动物
  abstract class Animal{
      public abstract void eat();
      public void sleep(){
          System.out.println("---------一动不动睡着了-------");
      }
  }
  //狗狗
  class Dog extends Animal{
      @Override
      public void eat(){
          System.out.println("--------dog eat------");
      }
      //子类特有的方法
      public void kanjia(){
          System.out.println("-----看家----");
      }
  }
  //企鹅
  class Penguin extends Animal{
      @Override
      public void eat(){
          System.out.println("--------penguin eat------");
      }
  }
  class Monkey extends Animal{
      @Override
      public void eat(){
         System.out.println("-----------monkey eat--------");
      }
  }
  
  
  

• 使用父类作为方法返回值，实现多态

  调用方法后，可得到的结果类型包括：本类型对象+其所有的子类对象

  public class Animal {
  
      String color;
      int age;
      boolean sex;
  
      public void eat(){
          System.out.println("i am eatting....");
      }
  
      public void sleep(){
          System.out.println("i am sleeping....");
          System.out.println("zzzzzz");
      }
  }
  public class Bird extends Animal{
  
      public void fly(){
          System.out.println("i am flying...");
      }
  }
  public class Dog extends Animal{
  
      public void run(){
          System.out.println("i am running...");
      }
  }
  //不使用多态
  public class MyAnimal {
  
      public Dog getAnimal01(){
          return new Dog();
      }
  
      public Bird getAnimal02(){
          return new Bird();
      }
  }
  //使用多态
  public class MyAnimal02 {
  
      public Animal getAnimal(String type){
          switch (type){
              case "dog":
                  return new Dog();
              case "bird":
                  return new Bird();
          }
          return new Animal();
      }
  }
  

向上转型（装箱）

父类引用中保存真实子类对象，称为向上转型。

• 将一个父类的引用指向一个子类对象，称为向上转型；

• 即子类型装换为父类型；

• 无需强制类型转换，可自动类型转换；

• 不会出现类型转换错误的异常；

• 有可能会损失子类新增的方法，因为受到类型限制；

• 此时通过父类引用变量调用的方法是子类覆盖或继承的方法；

  注意：仅可以调用父类所声明的属性和方法。

public class TestConvert{}
public static void main(String[] args) {
    //**父类引用中保存真实子类对象，称为向上转型。**
    Animal a = new Dog();
}
class Animal{
    public void eat(){
    System.out.print1n("动物在吃...");
    }
 }

class Dog extends Animal{
    public void eat(){
    System.out.print1n("狗在吃骨头...");
        }
    }
}

向下转型（拆箱）

• 父类型还原为子类型，只是把类型还原，并不是本质上修改类型；

• 目的是转换成子类型后，可以调用子类型特有的方法；

• 需要强制类型转换；

• 不安全可能会出现类型转换异常ClassCastException;

• 通常建议转换前使用instanceof判断一下；

  注意：只有转换回子类真实类型，才可调用子类独有的属性和方法。

public class TestConvert{}
public static void main(String[] args) {
    Animal a = new Dog();
    //将父类引用中的真实子类对象，强转回子类本身类型，称为向下转型
    Dog dog = (Dog)a;
}
class Animal{
    public void eat(){
    System.out.print1n("动物在吃...");
    }
 }

class Dog extends Animal{
    public void eat(){
    System.out.print1n("狗在吃骨头...");
        }
    }
}

类型转换异常

向下转型时，如果父类引用中的子类对象类型和目标类型不匹配，则会发生类型转换异常。

public class TestConvert{
public static void main(String[] args) {
    Animal a = new Dog();
    Cat cat = (Cat)a;//在这里编译报错 类型转换异常
    
}
class Animal{
    public void eat(){
    System.out.print1n("动物在吃...");
    }
 }

class Dog extends Animal{
    public void eat(){
    System.out.print1n("狗在吃骨头...");
        }
    }

class Cat extends Animal{
    public void eat(){
    System.out.print1n("猫在吃鱼...");
        }
    }
}

instanceof关键字

• 向下转型前，应判断引用中的对象真实类型，包装类型转换的正确性。
• 语法 父类引用instanceof 类型 //返回boolean类型结果；

public class TestConvert{
public static void main(String[] args) {
    Animal a = new Dog();
   
    if(a instanceof Dog){
        Dog dog = (dog)a;
        dog.eat;
    }
    
}

通过写笔记的方式加深对知识的理解。