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

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

思考

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

推荐阅读更多精彩内容