Java面向对象-003-多态

Java 多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

//多态性是对象多种表现形式的体现
/*
    现实中，比如我们按下 F1 键这个动作：
    
        如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
        如果当前在 Word 下弹出的就是 Word 帮助；
        在 Windows 下弹出的就是 Windows 帮助和支持。

    同一个事件发生在不同的对象上会产生不同的结果。
 */

一、 多态的优点

// 1. 消除类型之间的耦合关系

// 2. 可替换性

// 3. 可扩充性

// 4. 接口性

// 5. 灵活性

// 6. 简化性

二、多态存在的三个必要条件

//  继承

//  重写

//  父类引用指向子类对象 比如：Parent p = new Child();

//当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

 

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

public class Test {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法

        Animal a = new Cat();  // 向上转型
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();        // 调用的是 Cat 的 work
        
        //输出结果：
        //吃鱼
        //抓老鼠
        //吃骨头
        //看家
        //吃鱼
        //抓老鼠
    }

    public static void show(Animal a)  {
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}

三、虚方法

/* 文件名 : Employee.java */
public class Employee {
    private String name;
    private String address;
    private int number;
    public Employee(String name, String address, int number) {
        System.out.println("Employee 构造函数");
        this.name = name;
        this.address = address;
        this.number = number;
    }
    public void mailCheck() {
        System.out.println("邮寄支票给： " + this.name
                + " " + this.address);
    }
    public String toString() {
        return name + " " + address + " " + number;
    }
    public String getName() {
        return name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String newAddress) {
        address = newAddress;
    }
    public int getNumber() {
        return number;
    }
}

 

/* 文件名 : Salary.java */
public class Salary extends Employee
{
    private double salary; // 全年工资

    public Salary(String name, String address, int number, double salary) {
        super(name, address, number);
        setSalary(salary);
    }
    public void mailCheck() {
        System.out.println("Salary 类的 mailCheck 方法 ");
        System.out.println("邮寄支票给：" + getName()
                + " ，工资为：" + salary);
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double newSalary) {
        if(newSalary >= 0.0) {
            salary = newSalary;
        }
    }
    public double computePay() {
        System.out.println("计算工资，付给：" + getName());
        return salary/52;
    }
}

 

/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
    public static void main(String [] args) {
        Salary s = new Salary("员工 A", "北京", 3, 3600.00);
        Employee e = new Salary("员工 B", "上海", 2, 2400.00);
        System.out.println("使用 Salary 的引用调用 mailCheck -- ");
        s.mailCheck();
        System.out.println("\n使用 Employee 的引用调用 mailCheck--");
        e.mailCheck();
        //Employee 构造函数
        //Employee 构造函数
        //使用 Salary 的引用调用 mailCheck --
        //Salary 类的 mailCheck 方法
        //邮寄支票给：员工 A ，工资为：3600.0
        //
        //使用 Employee 的引用调用 mailCheck--
        //Salary 类的 mailCheck 方法
        //邮寄支票给：员工 B ，工资为：2400.0
    }
}

//例子解析
/*
    实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。

    当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。

    因为 e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法 。

    在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。

    以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
 */

//重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。

 

四、多态的实现方式

//方式一：重写：

//Java 重写(Override)与重载(Overload)。

 

//方式二：接口

//  1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

//

//  2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口。

 

//方式三：抽象类和抽象方法

五、Java语言的向上转型和向下转型

/*
 Java语言的向上转型和向下转型
 1.向上转型：子-> 父类
 2.向下转型：父->子类
 注意：无论是向上转型还是向下转型，两个类之间必须要有继承关系
 使用多态的好处：
  1.代码之间的耦合度降低
  2.项目的扩展能力增强
 多态的条件是：
   1.有继承或实现
   2.有方法的覆盖或实现
   3.父类对象(接口)指向子类对象
 */
public class Test01 {

    //向上转型又被称为:自动类型转换
    //父类型的引用指向子类对象
    // 程序分为两个阶段:绵译阶段,运行阶段
    // 程序编译阶段只知道a1是一个Anima1类型
    //程序在实际运行的时候是Cat类型
    Animal animal = new Cat();
    //程序在编译阶段animal被编译器看做是 Anima1类型
    //所以程序在编译阶段animal引用绑定的是Anima1中的eat方法
    // 程序在运行的时候堆中的对象实际上是cat型,而cat已经重写了eat方法所以程序在运行时阶段对象绑定的方法是Cat中的eat方法(动态绑定)
    //animal.eat();

    //向下转型 强制类型转换
    Animal animal2 = new Cat();
    Cat cat = (Cat)animal2;
    //cat.move();

    //向上转型
    Animal animal3 = new Dog();
    //Cat cat2 = (Cat)animal3;//报错java.lang.ClassCastException
    }

    在做强制类型转换的时候，程序是有风险的
    为了避免ClassCastException Java中使用 InstanceOf 是否是同一个类相当于OC isKindOfClass

    //用法
    //instanceOf运算符的运算结果是boolean 类型 返回true/false
    public static void main(String[] args){
        Test01 test01 = new Test01();
        test01.instanceTest();
    }

    public void instanceTest() {
        Animal a4 = new Dog();
        System.out.println(a4 instanceof Dog);//true两个对象是同一个类型
    }

接口和抽象类的区別

//a)接口描述了方法的特持征,不给出实现,一方面解決java的单继重可题,实现了强大的可接插件

//b)抽象类提供了部分实现,抽象类是不能被实例化的,抽象类的存在主要是可以把公共的代码移抽象类中

//c)面向接口编程,而不要面向具体编程(面向抽象编程,而不要向具体编程）

//d)优先选择接口(因为继承抽象类后,比类将无法再继承,所以会失此类的灵活性

 

类之间的关系

1.泛化关系是和之的承关及接口写接口之间的承关系

2.实现关系关对按口的实现

3.关联关系 类与类之间何的连接,一个可以知道另一个类的属性和方法,在java语百中使用成员变量体现

4.聚合关系

5.合成关系

6.依赖关系