JAVASE——面向对象高级（二）

面向对象高级（二）

一、多态

1.1 多态的概述

多态：是在继承、实现情况下的一种现象，表现为：对象多态、行为多态。

• 对象多态：父类变量 接收了 子类对象的现象

  // Teacher和Student都是People的子类
  People p1 = new Student();
  People p2 = new Teacher();

  p1和p2都是People类型，但是p1和p2指向的对象不一样。

• 行为多态：

  p1.run();
  p2.run();

  p1和p2都可以调用run方法，但是两个run方法表现的行为不一样。

1.2 多态的好处

1. 在多态形式下，右边的代码是解耦合的，更便于扩展和维护。

刚开始p1指向Student对象，run方法执行的就是Student对象的业务；假如p1指向Teacher对象 ，run方法执行的自然是Teacher对象的业务。

也就是说，等号的右边是可以根据需要的子类替换的。

2. 定义方法时，使用父类类型作为形参，可以接收一切子类对象，扩展行更强，更便利。

public class Test2 {
    public static void main(String[] args) {
        // 目标：掌握使用多态的好处
		Teacher t = new Teacher();
		go(t);

        Student s = new Student();
        go(s);
    }

    //参数People p既可以接收Student对象，也能接收Teacher对象。
    public static void go(People p){
        System.out.println("开始------------------------");
        p.run();
        System.out.println("结束------------------------");
    }

1.3 类型转换

多态的缺点：在多态形式下，不能调用子类特有的方法，比如在Teacher类中多了一个teach方法，在Student类中多了一个study方法，这两个方法在多态形式下是不能直接调用的。

多态形式下不能直接调用子类特有方法，但是转型后是可以调用的。这里所说的转型就是把父类变量转换为子类类型。格式如下：

if(父类变量名 instanceof 子类){
    子类 变量名 = (子类) 父类变量名;
}

原本是什么类型，才能还原成什么类型

二、final关键字

2.1 特点

final关键字是最终的意思，可以修饰类、修饰方法、修饰变量。

- final修饰类：该类称为最终类，特点是不能被继承
- final修饰方法：该方法称之为最终方法，特点是不能被重写。
- final修饰变量：该变量只能被赋值一次。

2.2 常量

常量：被static final 修饰的成员变量。 通常用于记录系统的配置信息。

如：public static final String SCHOOL_NAME = "Wendy"

三、抽象

在Java中有一个关键字叫abstract，它就是抽象的意思，它可以修饰类也可以修饰方法。注：抽象方法不允许由方法体。

3.1 抽象类

public abstarct class A{
    priavte String name;
    
    public A(){
    
    }
    
    public abstract void test();
    
}

• 抽象类是不能创建对象的，如果抽象类的对象就会报错

• 抽象类可以作为父类让子类继承。而且子类继承父类必须重写父类的所有抽象方法。

• 子类继承父类如果不复写父类的抽象方法，这个子类也必须是抽象类

  // B类继承A类，此时B类也是抽象类，这个时候就可以不重写A类的抽象方法
  public abstract class B extends A{
  
  }

3.2 好处

场景：要求两个对象 有共同的属性，也有一个行为，但是具体的行为实现方法不一样。这是，可以把这个行为写作一个抽象的方法。

抽象父类：

public abstract class Animal {
    private String name;

    //动物叫的行为：不具体，是抽象的
    public abstract void cry();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

子类Dog：

public class Dog extends Animal{
    public void cry(){
        System.out.println(getName() + "汪汪汪的叫~~");
    }
}

子类Cat：

public class Cat extends Animal{
    public void cry(){
        System.out.println(getName() + "喵喵喵的叫~~");
    }
}

测试类：

public class Test2 {
    public static void main(String[] args) {
        // 目标：掌握抽象类的使用场景和好处.
        Animal a = new Dog();
        a.cry();	//这时执行的是Dog类的cry方法
    }
}

1.用抽象类可以把父类中相同的代码，包括方法声明都抽取到父类，这样能更好的支持多态，一提高代码的灵活性。

2.反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去实现，以方便系统的扩展。

3.3 模板方法模式

设计模式是解决某一类问题的最优方案

模板方法模式解决了多个子类中有相同代码的问题

第1步：定义一个抽象类，把子类中相同的代码写成一个模板方法。
第2步：把模板方法中不能确定的代码写成抽象方法，并在模板方法中调用。
第3步：子类继承抽象类，只需要父类抽象方法就可以了。

四、接口

4.1 接口

Java提供了一个关键字interface，用这个关键字来定义接口这种特殊结构。格式如下

public interface A{
    //成员变量（常量）
    //成员方法（抽象方法）
}

例如：

public interface A{
    // 成员常量
    public static final String NAME = "Wendy";
    //抽象方法
    public abstract void test();
}

使用A类：

public class Test{
    public static void main(String[] args){
        //打印A接口中的常量
        System.out.println(A.SCHOOL_NAME);
        
        //接口是不能创建对象的
        A a = new A(); //错误
    }
}

• 接口类 是用来 被类实现(implements)的，我们称之为实现类
• 一个类可以实现多个接口，实现接口时必须重写接口的所有抽象方法。

4.2 接口的好处

• 弥补了 单继承的不足，一个类可以同时实现多个接口
• 让程序可以 面向接口编程

4.3 案例

考虑：

写一个 接口， 表示学生信息管理的两个功能。

写两个实现类，实现两套方案的业务实现。