2017.9.6学习小结 - 类的封装、继承与多态5

回顾

五、覆写

1.方法的覆写

2.属性的覆写

学习小结

六、多态的实现

1.多态的基本概念

静态多态，即同一种接口，不同的实现方式。

动态联编，即在程序运行阶段体现出现，也称为晚期联编（late bingding）。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月6日 下午9:41:03
 * @Description TODO 了解多态的基本概念
 */
public class P311_12_18 {
    public static void main(String[] args) {
        // 此处，父类对象由子类实例化
        Person20 p = new Student9();
        // 调用fun1()方法，观察此处调用的是哪个类里的fun1()方法
        p.fun1();
        p.fun2();
    }
}

class Person20 {
    public void fun1() {
        System.out.println("******--fun1()我来自父类Person20");
    }

    public void fun2() {
        System.out.println("******--fun2()我来自父类Person20");
    }
}

// Student9类扩展自Person20类，也就继承了Person类中的fun1()、fun2()方法
class Student9 extends Person20 {
    // 在这里覆写了Person20类中的fun1()方法
    public void fun1() {
        System.out.println("######--fun1()我来自子类Student9");
    }

    public void fun3() {
        System.out.println("######--fun3()我来自子类Student9");
    }
}

运行结果：

运行结果1

父类对象由子类实例化Person20 p = new Student9()，只是一对一的继承关系，并没有体现出“多”态来。

2.方法多态性

方法多态性体现在重载。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月6日 下午10:18:46
 * @Description TODO 对象多态性的使用
 */
public class P312_12_19 {
    // 定义了两个方法名完全相同的方法，该方法实现求和功能
    void sum(int i) {
        System.out.println("数字和为：" + i);
    }

    void sum(int i, int j) {
        System.out.println("数字和为：" + (i + j));
    }

    public static void main(String[] args) {
        P312_12_19 demo = new P312_12_19();
        demo.sum(1); // 计算一个数的和
        demo.sum(2, 3); // 计算两个数的和
    }
}

运行结果：

运行结果2

同一个方法（方法名相同）能够接受不同的参数，并完成多个不同类型的运算，因此体现了方法的多态性。

3.对象多态性

父与子对象之间的转型：

a.向上转型（Upcast）（自动转型）：安全的，但会丢失精度

父类 父类对象 = 子类实例；

b.向下转型（Downcast）（强制转型）：非安全的

子类 子类对象 = （子类）父类对象；

总结：
①向上转型自动完成；
②向下转型必须强制类型转换。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月6日 下午10:38:55
 * @Description TODO 使用多态
 */
public class P313_12_20 {
    public static void main(String[] args) {
        Animal a;
        Fish f = new Fish();
        Bird b = new Bird();
        Horse h = new Horse();
        a = f;
        a.move(); // 调用Fish的move()方法，输出“鱼儿游！”
        a = b;
        a.move(); // 调用Bird的move()方法，输出“鸟儿飞！”
        a = h;
        a.move(); // 调用Horse的move()方法，输出“马儿跑！”
    }
}

class Animal {
    public void move() {
        System.out.println("动物移动！");
    }
}

class Fish extends Animal {
    // 覆写了父类中的move方法
    public void move() {
        System.out.println("鱼儿游！");
    }
}

class Bird extends Animal {
    // 覆写了父类中的move方法
    public void move() {
        System.out.println("鸟儿飞！");
    }
}

class Horse extends Animal {
    // 覆写了父类中的move方法
    public void move() {
        System.out.println("马儿跑！");
    }
}

运行结果：

运行结果3

简单说。继承是子类使用父类的方法，而多态则是父类使用子类的方法（子类独有的方法除外）。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月6日 下午10:57:09
 * @Description TODO 父类对象找不到子类的扩充方法
 */
public class P315_12_21 {
    public static void main(String[] args) {
        A a = new B(); // 实例化子类对象
        a.print(); // 调用子类B的print()
        // a.getB(); // 这个方法父类无法找到
    }
}

class A {
    public void print() {
        System.out.println("******--父类A：public void print(){}");
    }
}

class B extends A {
    public void print() { // 方法覆写
        System.out.println("######--子类B：public void print(){}");
    }

    public void getB() { // 此方法为子类扩充的功能
        System.out.println("%%%%%%--子类B：public void getB(){},B类扩充方法。");
    }
}

运行结果：

运行结果4

a.getB(); // 这个方法父类无法找到
取消注释后：

运行结果5

在形式上，类定义的对象只能看到自己所属类中的成员。

思考

确实需要思考，不断的思考，没有思考，人就钝了。我续了饭团圈子。