Java基础Day-Eight

Java多态

• 意味着允许不同类的对象对同一消息做出不同的响应

• 编译时多态（设计时多态）方法重载

• 运行时多态：程序运行时动态决定调用哪个方法

• 必要条件：满足继承关系、父类引用指向子类对象

程序中的继承

• 向上转型

  • 又叫隐式转型、自动转型

  • 父类引用指向子类实例

  • 可以调用子类重写父类的方法以及父类派生的方法

  • 无法调用子类独有方法

  • 注意：父类中的静态方法无法被子类重写，所以向上转型之后，只能调用到父类原有的静态方法

  • 小类转型为大类

  • Animal two=new Cat();

• 向下转型

  • 又叫强制类型转换

  • 子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法

  • 必须满足转型条件才能进行强转

  • Animal two=new Cat();
    Cat temp=(Cat)two;
    temp.eat();
    temp.run();
    temp.getMonth();

  • instanceof运算符

    • 判断左边的对象是否是右边类的实例

    • 返回true/false

    •     if(two instanceof Cat) {
                  Cat temp=(Cat)two;
                  temp.eat();
                  temp.run();
                  temp.getMonth();
                  System.out.println("two可以转换为Cat类型");
              }
              
              if(two instanceof Dog) {
                  Dog temp2=(Dog)three;
                  temp2.eat();
                  temp2.sleep();
                  temp2.getSex(); 
                  System.out.println("two可以转换为Dog类型");
              }
              
              if(two instanceof Animal) {
                  System.out.println("Animal");
              }
              
              if(two instanceof Object) {
                  System.out.println("Object");
              }

• 类型转换案例

      //方案1：编写方法，传入不同类型的动物，调用各自的方法
      public void feed(Cat cat) {
          cat.eat();
          cat.playBall();
      }
      
      public void feed(Dog dog) {
          dog.eat();
          dog.sleep();
      }
      //方案2：编写方法，传入动物的父类，方法中通过类型转换，调用指定子类的方法
      public void feed(Animal obj) {
          if(obj instanceof Cat) {
              Cat temp=(Cat)obj;
              temp.eat();
              temp.playBall();
          }
          else if(obj instanceof Dog) {
              Dog temp=(Dog)obj;
              temp.eat();
              temp.sleep();
          }

      /*
       * 饲养何种动物
       * 空闲时间多：养狗狗
       * 空闲时间不多：养猫咪
       */
      //方案1：
      public Dog hasManyTime() {
          System.out.println("主人休闲时间比较充足，适合养狗狗");
          return new Dog();
      }
      public Cat hasLittleTime() {
          System.out.println("主人平时比较忙碌，适合养猫咪");
          return new Cat();
      }
      //方案2：
      public Animal raise(boolean isManyTime) {
          if(isManyTime) {
              System.out.println("主人休闲时间比较充足，适合养狗狗");
              return new Dog();
          }
          else {
              System.out.println("主人平时比较忙碌，适合养猫咪");
              return new Cat();
          }
      }

抽象类

• Java中使用抽象类，限制实例化

• 不允许直接实例化，可以通过向上转型，指向子类实例

  public abstract class Animal{
      
  }

• 应用场景：某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

• 避免子类设计随意性和无意义父类的实例

抽象方法

    public abstract void eat();

• 抽象方法：不允许包含方法体；不需要具体实现

• 子类中需要重写父类的抽象方法，否则需要将子类也变为抽象类

• 包含抽象方法的类一定是抽象类，但是抽象类里可以没有抽象方法

• static final private不能与abstract并存

接口

• Java中只支持单继承

• 接口是一种规则，是对行为的抽象

• 用接口描述不同类型具有相似的行为特征

• 接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法

接口的定义和使用

• 接口用关键字interface来定义

  public interface 接口名{}

• 接口不能实例化

• 接口和类之间是实现关系，通过implements关键字表示

  public class 类名 implements 接口名{}

• 接口的子类（实现类）

  要么重写接口中的所有抽象方法

  要么是抽象类

• 接口和类的实现关系，可以单实现，也可以多实现

  public class 类名 implements 接口名1,接口名2{}

• 实现类还可以在继承一个类的同时实现多个接口

  public class 类名 extends 父类 implements 接口名1,接口名2{}