JAVA学习笔记Ⅳ——面向对象三特性之多态

文章目录

多态

多态应用示例
练习题

引用类型转换
抽象类
接口
UML简介
练习

面向对象三大特性：封装、继承、多态

多态

对象的多种形态

引用多态	对象多态
父类的引用可以指向本类的对象	创建本类对象时，调用的方法为本类方法
父类的引用可以指向子类的对象	创建子类对象时，调用的方法为子类重写的方法或继承的方法

多态应用示例

使用多态时，两个类一定要有一个继承关系

Animal.java

package com.template16;

public class Animal {
    public void eat(){
        System.out.println("动物具有吃的能力");
    }
}

Dog.java

package com.template16;

public class Dog extends Animal {
    public void eat(){
        System.out.println("狗可以啃骨头");
    }
    public void watchDoor(){
        System.out.println("狗具有看门的能力");
    }
}

Cat.java

package com.template16;

public class Cat extends Animal {

}

Initial.java

package com.template16;

public class Initial {
    public static void main(String[] args){
        Animal obj_1 = new Animal();
        Animal obj_2 = new Dog();
        Animal obj_3 = new Cat();
        //不允许子类对象指向父类引用，如下
        //Dog obj_3 = new Animal();

        //利用本类对象调用父类方法
        obj_1.eat();
        //利用本类对象调用子类方法
        obj_2.eat();
        //利用本类调用子类继承父类的方法
        //这种情况用于子类没有重写父类的方法
        obj_3.eat();
        //不能通过父类的引用调用子类独有的方法
        //obj_2.watchDoor();
    }
}

动物具有吃的能力
狗可以啃骨头
动物具有吃的能力

练习题

描述交通工具，其中汽车行驶在陆地，可装载 $n$ 人。轮船行驶在海洋，可装 $m$ 人。飞机行驶在空中，可装 $x$ 人。

Transport.java

package com.template17;

public class Transport {

    //父类func方法
    public void func() {
        System.out.println("交通工具可以运载客人");
    }

    public Transport(){
        func();
    }
}

bus.java

扫描二维码关注公众号，回复： 11542386 查看本文章

package com.template17;

public class Bus extends Transport {
    private int num;

    public Bus(int num) {
        setNum(num);
        System.out.println("汽车可以在陆地上载客"+getNum()+"人");
    }

    public void func() {
        System.out.println("这是汽车的方法");
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

AirPlane.java

package com.template17;

public class AirPlane extends Transport {
    private int num;

    public AirPlane(int num) {
        setNum(num);
        System.out.println("飞机可以在天上载客"+num+"人");
    }

    public void func() {
        System.out.println("这是飞机的方法");
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

Boat.java

package com.template17;

public class Boat extends Transport {
    private int num;

    public Boat(int num) {
        setNum(num);
        System.out.println("船可以在水上载客"+getNum()+"人");
    }

    public void func() {
        System.out.println("这是船的方法");
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

Initial.java

package com.template17;

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

        Transport trans = new Transport();
        Transport boat = new Boat(100);
        Transport bus = new Bus(200);
        Transport airPlane = new AirPlane(300);

        //不使用参数将使用继承父类的func方法
        boat.func();
        trans.func();
        bus.func();
        airPlane.func();
    }
}

引用类型转换

引用类型转换
向上类型转换（隐式/自动类型转换），是小类型到大类型的转换
向下类型转换（强制类型转换），是大类型到小类型的转换
instanceof 运算符，来解决引用对象的类型，避免类型转换的安全性问题

向上类型转换不存在风险

Animal.java

package com.template18;

public class Animal {
}

Cat.java

package com.template18;

public class Cat extends Animal {
}

Dog.java

package com.template18;

public class Dog extends Animal {
}

Initial.java

package com.template18;

public class Initial {
    public static void main(String[] args){
        //利用子类的引用指向这个对象
        Dog dog = new Dog();
        //利用父类引用指向之类对象
        //如此则做了自动类型提升(向上类型转换)
        Animal animal = dog;
        //再次将父类引用转换为子类引用
        //显然实际上这句代码是不存在任何风险的，因为最开始
        //就是使用父类引用创建的，但是计算机不允许我们这么做
        //Dog dog2 = animal;(×)这时需要强制类型转化
        Dog dog2 = (Dog)animal;
        //不能将animal强制转换为cat，因为初始为Dog对象，Dog
        //与Cat是两个不同的类型，因此两个不同类型对象不能互相转换
        //Cat cat = (Cat)animal;

        //通过instanceof运算符可以避免类型转换的安全性问题
        //可以通过它判断一个应用是否是某个类型或某个类型的子类型（返回bool值）
        if(animal instanceof Cat){
            Cat cat = (Cat)animal;
        }else{
            System.out.println("无法进行类型转换");
        }
    }
}

无法进行类型转换

抽象类

名词	说明
语法定义	抽象类前使用abstract关键字修饰，则该类为抽象类
应用场景	1.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法 2.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性
作用	限制规定子类必须实现某些方法，但不关注实现细节
使用规则	1.abstract定义抽象类 2.abstract定义抽象方法，只有声明，不需要实现 3.包含抽象方法的类是抽象类 4.抽象类中可以包含普通的方法，也可以没有抽象方法 5.抽象类不能直接创建，可以定义引用变量

抽象类是约束子类必须具有哪些方法，并不关注子类如何去实现的。抽象类的目的不关注子类的实现，但必须要约束子类必须有哪些特征。

Telphone.java

package com.template19;

public abstract class Telphone {
    public abstract void call();
    public abstract void message();
}

SmartPhone.java

package com.template19;

public class SmartPhone extends Telphone {
    @Override
    public void call() {
        System.out.println("通过语音来打电话");
    }

    @Override
    public void message() {
        System.out.println("通过语音发短信");
    }
}

CellPhone.java

package com.template19;

public class CellPhone extends Telphone {
    @Override
    public void call() {
        System.out.println("通过键盘来打电话");
    }

    @Override
    public void message() {
        System.out.println("通过键盘发短信");
    }
}

Initial.java

package com.template19;

public class Initial {
    public static void main(String[] args){
        //抽象类不能被实例化
        //Telphone telPhone = new Telphone();
        Telphone tel1 = new CellPhone();
        tel1.call();
        tel1.message();
        Telphone tel2 = new SmartPhone();
        tel2.call();
        tel2.message();
    }
}

通过键盘来打电话
通过键盘发短信
通过语音来打电话
通过语音发短信

抽象类不能实例化

接口

名词	说明
接口概念	1.接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成 2.类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法
接口定义	和类定义不同，定义接口不需要使用`class`关键字，而是使用`interface`关键字常量：接口中的属性是常量，即使定义时不添加`public`、`static`、`final`修饰符，系统也会自动加上方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加`public`、`abstract`修饰符，系统也会自动加上
接口定义的基本语法	[修饰符] interface 接口名 [extends 父接口1, 父接口2…] { 零到多个常量定义… 零到多个抽象方法的定义… } 接口就是用来被继承、被实现，修饰符一般建议用public 注意：不能使用private和protect修饰接口
使用接口	一个类可以实现一个或多个接口，实现接口使用`implements`关键字。JAVA中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以补充。接口命名通常在首字母位置加上I以示区别接口在使用过程当中，还经常与匿名内部类配合使用【匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称，匿名内部类是指在使用类时并不关注类的名字，仅仅在使用时定义的。】
继承父类实现接口的语法	[修饰符] class 类名 extends 父类 implements 接口1，接口2… { 类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。 } 如果要继承父类，继承父类必须在实现接口之前

没有显示的写出abstract系统会自动加上，类是单继承，但接口可以多继承，继承多个父接口，接口中的变量都是常量，即使我们在定义时未加上public static final，系统也会自动加上。通常来讲，我们一般不写。

如果继承了抽象类，就必须实现抽象类里面的抽象方法。如果遵守了一个接口，就必须实现接口中的抽象方法

接口中方法不能有方法体，同时方法的访问修饰符不能是 private 和 protected

Telphone.java

package com.template20;

public abstract class Telphone {
    public abstract void call();
    public abstract void message();
}

SmartPhone.java

package com.template20;

public class SmartPhone extends Telphone implements IPlayGame{
    @Override
    public void call() {
        System.out.println("通过语音来打电话");
    }

    @Override
    public void message() {
        System.out.println("通过语音发短信");
    }

    @Override
    public void playGame() {
        System.out.println("具有玩游戏的功能");
    }
}

Psp.java

package com.template20;

public class Psp implements IPlayGame{
    @Override
    public void playGame() {
        System.out.println("通过键盘发短信");
    }
}

IPlayGame.java

package com.template20;

public interface IPlayGame {
    public void playGame();
}

Initial.java

package com.template20;

public class Initial {
    public static void main(String[] args){
        Telphone tel2 = new SmartPhone();
        tel2.call();
        tel2.message();

        IPlayGame ip1 = new SmartPhone();
        ip1.playGame();
        IPlayGame ip2 = new Psp();
        ip2.playGame();

        //匿名内部类
        IPlayGame ip3 = new IPlayGame() {
            @Override
            public void playGame() {
                System.out.println("使用匿名内部类的方式实现接口");
            }
        };
        ip3.playGame();

        //直接new接口
        new IPlayGame(){
            public void playGame() {
                System.out.println("使用匿名内部类的方式实现接口2");
            }
        }.playGame();
    }
}

通过语音来打电话
通过语音发短信
具有玩游戏的功能
通过键盘发短信
使用匿名内部类的方式实现接口
使用匿名内部类的方式实现接口2

UML简介

面向对象

UML 概念：Unified Modeling Language（UML），又称统一建模语言或标准建模语言，是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持

UML 2.2中一共定义了14中图示（diagrams)。

常用UML图示

用例图（The Use Case Diagram）	序列图（The Sequence Diagram）	类图（The Class Diagram）
用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求等信息	序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互	UML 类图、业务逻辑和所有支持结构一同被用于定义全部的代码结构

练习

美国人说英语，中国人说中文，通过创建两个对象实现

Persion.java

package com.exercise1;

public class Person {
    public void say(){
        System.out.println("人类具有说话的能力");
    }
}

American.java

package com.exercise1;

public class American extends Person {
    @Override
    public void say() {
        System.out.println("美国人说英语");
    }
}

Chinese.java

package com.exercise1;

public class Chinese extends Person {
    @Override
    public void say(){
        System.out.println("中国人说中国话");
    }
}

AAmerican.java

package com.exercise1;

public class AAmerican extends APerson{
    public void say(){
        System.out.println("美国人说英语");
    }
}

AChinese

package com.exercise1;

public class AChinese extends APerson{
    public void say(){
        System.out.println("中国人说中国话");
    }
}

APersion.java

package com.exercise1;

public abstract class APerson {
    public abstract void say();
}

Test.java

package com.exercise1;

public class Test {
    public static void main(String[] args){
        Chinese p = new Chinese();
        American p2 = new American();
        p.say();
        p2.say();

        //利用多态的方法
        Person pp = new Chinese();
        Person pp2 = new American();
        pp.say();
        pp2.say();

        //利用抽象类方法
        APerson ppp = new AChinese();
        APerson ppp2 = new AAmerican();
        ppp.say();
        ppp2.say();
    }
}

中国人说中国话
美国人说英语
中国人说中国话
美国人说英语
中国人说中国话
美国人说英语