Java编程思想_面向对象之多态

1. 多态的概述

1.1 Java种实现多态的步骤

• 要有继承（或实现）关系
• 要有方法重写
• 父类引用指向子类对象

多态中调用成员方法是编译看左（左边的类型有没有这个成员）
运行看右（运行时具体用的是右边类中的成员）

1.2 多态的使用场景

父类型可以作为形参的数据类型，这样可以接收其任意的子类对象

image.png

1.3 多态中调用成员变量

多态中调用成员变量，遵循编译看左，运行也看左
所以下图返回结果分别是Animal和Dog

image.png

image.png

1.4 多态的好处和弊端

多态的好处：可维护性、可扩展性
多态的弊端：父类引用不能使用子类的特有成员

解决多态弊端的方法：通过类型转换实现
注意：只能在继承层次内转换，否则会报ClassCaseException异常
将父类对象转换成子类前，使用instanceof进行检查

image.png

2. 抽象类

image.png

抽象类中的成员比普通类多一种：抽象方法，其他和普通类一样
抽象类的子类如果是普通类，必须重写所有的抽象方法；如果是抽象类，则不用重写抽象方法

image.png

image.png

在开发中，子类一般有两个构造方法
子类的空参构造访问父类的空参构造
子类的全参构造访问父类的全参构造

package cn.case1;

public abstract class Employee {
    // 定义成员变量
    private String name;
    private double salary;
    private int id;

    public Employee() {
    }

    public Employee(String name, double salary, int id) {
        this.name = name;
        this.salary = salary;
        this.id = id;
    }

    // 定义成员方法
    public abstract void work();

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

// 子类Employee
package cn.case1;

public class Manager extends Employee{
    private double bouns;

    public Manager() {
        super(); // 可以不写
    }

    public Manager(String name, double salary, int id, double bouns) {
        super(name, salary, id);
        this.bouns = bouns;
    }

    @Override
    public void work() {
        System.out.println("Manager is working");
    }

    public double getBouns() {
        return bouns;
    }

    public void setBouns(double bouns) {
        this.bouns = bouns;
    }
}
// 子类Coder
package cn.case1;

public class Coder extends Employee{

    @Override
    public void work() {
        System.out.println("coder is working");
    }

    public Coder() {
        super(); // 可以不写
    }

    public Coder(String name, double salary, int id) {
        super(name, salary, id);
    }
}
// 测试类
package cn.case1;

public class Test {
    public static void main(String[] args) {

        Employee em = new Coder();
        em.work();

        Employee em2 = new Manager();
        em.work();

        // ===============================

        Coder co = new Coder("xiaoli：", 12000, 1001);
        System.out.println("Name：" + co.getName());
        System.out.println("Salary：" + co.getSalary());
        System.out.println("Id：" + co.getId());
        System.out.println("=============================");

        Manager ma = new Manager("xiaowang", 15000, 1000, 3000);
        System.out.println("Name：" + ma.getName());
        System.out.println("Salary：" + ma.getSalary());
        System.out.println("Id：" + ma.getId());
        System.out.println("Bonus：" + ma.getBouns());

    }
}

3. final关键字

final的作用：用于修饰类、方法和变量

final修饰的类：不能被继承，但是可以继承其他的类
final修饰的方法：不能被重写
final修饰的变量：是一个常量，值只能设置一次

4. static关键字

4.1 修饰成员变量

static修饰的成员变量被本类所有对象共享

image.png

public final static String DEPARTMENT_NAME = "开发部";

4.2 修饰成员方法

静态方法：静态方法中没有对象this，所以不能访问非静态成员
静态方法的使用场景：
如果某方法只访问静态成员，并且不需要通过对象名的形式调用，就可以考虑将其定义为静态方法

5. 接口

5.1 接口的概念

image.png

image.png

package cn.case2;

public interface Smoking {
    public abstract void smoke();
}

// 定义接口的实现类
package cn.case2;

public class Teacher implements Smoking{

    @Override
    public void smoke() {
        System.out.println("吸烟有害健康");
    }
}
// 测试类
package cn.case2;

public class Test {
    public static void main(String[] args) {
        Smoking sm = new Teacher();
        sm.smoke();
    }
}

5.2 接口的特点

image.png

接口和类之间的关系：
类与类之间：继承关系，只能单继承，不能多继承，但是可以多层继承
类与接口之间：实现关系，可以单实现，也可以多实现
接口与接口之间：继承关系，可以单继承，也可以多继承

对于一个类来讲，他的父类（继承的关系）定义的都是：共性内容
对于一个类来讲，他的父接口（实现的关系）定义的都是：扩展内容

image.png

5.3 接口成员的特点

接口不能实例化，也没有需要初始化的成员，所以接口中是没有构造方法的

image.png

image.png