1

1436141288

V1

2022/03/13阅读:33主题:全栈蓝

多态&抽象&接口

学完这个

1.多态

1.1 多态的概念

  • 什么是多态
    • 同一个对象,在不同时刻表现出来的不同形态
  • 多态的前提
    • 要有继承或实现关系
    • 要有方法的重写
    • 要有父类引用指向子类对象

1.2多态中的成员访问特点

  • 成员访问特点

    • 成员变量 编译看父类,运行看父类
    • 成员方法 编译看父类,运行看子类
  • 案例

    • 动物类
     public class Animal {
     public int age = 10;

     public void eat() {
         System.out.println("动物吃东西"
         }
    }
  • 猫类
      public class Cat extends Animal {
        public int age = 20;
        public int weight = 10;
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼"
        }
    
        public void playGame() {
            System.out.println("猫玩游戏"
        }
      }

1.3多态的好处和弊端

  • 好处
    • 提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作
  • 弊端
    • 不能使用子类的特有成员

1.4多态中的转型

  • 向上转型
    • 父类引用指向子类对象就是向上转型
  • 向下转型
    • 格式:子类型 对象名 = (子类型)父类引用
  • 代码
   //描述动物类,并抽取共性eat方法
 abstract class Animal {
  abstract void eat();
 }
  
 // 描述狗类,继承动物类,重写eat方法,增加lookHome方法
 class Dog extends Animal {
  void eat() {
   System.out.println("啃骨头");
  }
 
  void lookHome() {
   System.out.println("看家");
  }
 }
 
 // 描述猫类,继承动物类,重写eat方法,增加catchMouse方法
 class Cat extends Animal {
  void eat() {
   System.out.println("吃鱼");
  }
 
  void catchMouse() {
   System.out.println("抓老鼠");
  }
 }
 
 public class Test {
  public static void main(String[] args) {
   Animal a = new Dog(); //多态形式,创建一个狗对象
   a.eat(); // 调用对象中的方法,会执行狗类中的eat方法
   // a.lookHome();//使用Dog类特有的方法,需要向下转型,不能直接使用
   
   // 为了使用狗类的lookHome方法,需要向下转型
 // 向下转型过程中,可能会发生类型转换的错误,即ClassCastException异常
   // 那么,在转之前需要做判断 
   if( !a instanceof Dog){ // 判断当前对象是否是Dog类型
      System.out.println("类型不匹配,不能转换"); 
      return
   } 
   Dog d = (Dog) a; //向下转型
   d.lookHome();//调用狗类的lookHome方法
  }
 }
  • 多态总结
  • 什么时候使用向上转型: 当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作,这时就可以使用向上转型。

如:Animal a = new Dog(); a.eat();

  • 什么时候使用向下转型 当要使用子类特有功能时,就需要使用向下转型。

如:Dog d = (Dog) a; //向下转型

d.lookHome();//调用狗类的lookHome方法

向下转型的好处:可以使用子类特有功能。

弊端是:需要面对具体的子类对象;在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。 如:if( !a instanceof Dog){…}

2.抽象类

2.1 抽象类的概述

  • 当我们在做子类共性功能抽取时,有些方法在父类中并没有具体的体现,这个时候就需要抽象类了! 在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类!

2.2 抽象类的特点

  • abstract关键字修饰
  //抽象类的定义
 public abstract class 类名 {}

 //抽象方法的定义
 public abstract void eat();
  • 抽象类中不一定有抽象方法,有抽象方法的一定是抽象类

  • 抽象类不能实例化

    • 那咋整?通过子类对象实例化抽象类,以抽象类多态的方式完成这个操作就OK。
  • 抽象类的子类

    • 要么重写抽象类里面的方法
    • 要么,一样作为抽象类

2.3抽象类的成员特点

  • 成员的特点

    • 成员变量
      • 既可以是常量
      • 也可以是变量
    • 构造方法
      • 空参
      • 有参
    • 成员方法
      • 普通方法
      • 抽象方法(abstract)
  • 例子

 public abstract class Animal {
  private int age = 20;
    private final String city = "北京";
    public Animal() {}
 
    public Animal(int age) {
        this.age = age;
    }
    public void show() {
        age = 40;
        System.out.println(age);
 //        city = "上海";
        System.out.println(city);
    }
 
    public abstract void eat();
 
 }

3接口

3.1 接口的概述

其实就是比抽象类更抽象的东西,是个规范代码的模板

3.2接口的特点

  • 使用关键字interface修饰
  public interface 接口名 {}
  • 类实现接口用implements表示
    public class 类名 implements 接口名 {}
  • 接口不能实例化
    • 接口只能够参照多态的方式,通过实现类对象实例化。其中,多态的形式:具体类多态,抽象类多态,接口多态
  • 接口的子类
    • 要么重写接口中的所有抽象方法
    • 要么子类也是抽象类

3.3 接口的成员特点

  • 成员特点
    • 成员变量
      • 只能是常量,默认修饰符: public static final
    • 构造方法
      • 没有,因为接口只要是扩展功能的,而没有具体存在
    • 成员方法
      • 只能是抽象方法
      • 默认修饰符: public abstract

3.4 接口的总结

  1. 接口用来个别具体类的实现,会自动继承接口中的抽象方法给这类继承他的类。
  2. 接口解耦性非常棒,一个优秀的系统,耦合性越低越好
  3. 接口中的方法一定都会被继承他的类实现,如果少继承了或者没有继承会报错。
  4. 接口在Java中拥有多继承的意义,因为c++里有多继承,而Java为了完整的面对对象就拒绝了多继承,使用接口。

别跑,还有一个点 接口用实现类实现其方法,便于无损替换,维护很方便 这里打个比方例如 你采用List list = new ArrayList (); 有一天觉得ArrayList线程安全问题困扰了你,需要换成LinkedList ,这时候只需要更换指向就可以了。 (此处摘抄自简书作者@博博_ )

学完了这个,我只想说

分类:

后端

标签:

Java

作者介绍

1
1436141288
V1