JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例-低调大师

JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例

2018-04-03 580

JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例

一.多态

我们今天又要学习一个新的概念了，就是多态，它是面向对象的第三个特征，何谓多态？

定义

某一类事物的多种存在方式

比如

动物中的猫狗，人类中的男人，女人

我们可以把多态理解为事物存在的多种体现形态

当我们new一个猫类的时候，和new 一个动物，其实是一样的，多种形态变现

所以我们可以分这几部分分析

1. 多态的体现
1. 多态的前提
3.多态的好处
4.多态的应用

我们定义一个需求，描述动物，正常的逻辑应该是这样描述的

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */
        Cat c = new Cat();
        c.eat();
        dog d = new dog();
        d.eat();
    }
}

/**
 * 动物
 * 
 * @author LGL
 *
 */
abstract class Animal {

    // 吃什么不确定，抽象
    abstract void eat();
}

/**
 * 猫
 * 
 * @author LGL
 *
 */
class Cat extends Animal {

    @Override
    void eat() {
        System.out.println("猫吃鱼");
    }

}

/**
 * 狗类
 * 
 * @author LGL
 *
 */
class dog extends Animal {

    @Override
    void eat() {
        System.out.println("狗吃骨头");
    }

}

这个体系我们展现出来一个为题，我们为了使用猫吃东西和狗吃东西，得new两个对象，要是多来几只小动物，我不还得new死，所以我们要想一个解决办法，他们有一个共性，就是都是动物，我们可以这样转换

Animal a = new Cat();
a.eat();

因为也是动物类型，我们输出

这就是多态在程序中的表现

父类的引用指向了自己的子类对象，这就是多态的代码体现形式，人 = new 男人，换句话说，父类的引用也可以接收子类的对象，所以我们可以这样定义一个方法

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */
        AnimalEat(new Cat());
        AnimalEat(new dog());
    }

    public static void AnimalEat(Animal a) {
        a.eat();
    }
}

这样就方便了，这样也就体现了多态的好处：

多态的出现大大的提升了程序的扩展性

但是有前提的

必须类与类之间有关系，要么继承，要么实现
通常，还有一个前提就是存在覆盖

不过，有利有弊，还是会存在弊端的

提高了扩展性，但是只能使用父类的引用访问父类的成员，这是局限性，但是我们侧重扩展性

我们再返回前面说多态的转型，我们看这段代码

//类型提升
Animal a = new Cat();  
a.eat();

我们也叫作向上转型，

如果想要调属性，该如何操作（向下转型）？

强制将父类的引用转为子类类型

        Animal a = new Cat();
        a.eat();

        Cat c = (Cat)a;
        c.sleep();

也就是说，转型是强制将父类的引用，转为子类类型，向下转型。千万不要将父类对象转成子类对象，我们能转换的是父类引用指向子类对象的子类，多态自始至终都是子类对象在做着变化

那么你会了强转之后，你就说，我可以这样做

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */

        AnimalEat(new Cat());
        AnimalEat(new dog());

    }

    public static void AnimalEat(Animal a) {
        a.eat();

        Cat c = (Cat) a;
        c.sleep();
    }
}

这样是不是可以？我们看结果

这里报错了，提示的是狗类型不行转换成猫类型，的确，不能随便乱转。我们价格判断，怎么判断呢？条件语句该怎么写呢？这里我们又有一个关键字了instanceof

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */

        AnimalEat(new Cat());
        AnimalEat(new dog());

    }

    public static void AnimalEat(Animal a) {
        a.eat();

        //如果a的类型是Cat就执行
        if(a instanceof Cat){
            Cat c = (Cat) a;
            c.sleep();
        }

    }
}

这样我们加了判断之后，我们就可以知道

既然多态说了这么多，我们来看看多态的应用吧，还是以一个需求开始去分析

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：幼儿园有两个班 大班： 学习，睡觉 小班： 学习，睡觉 可以将两类事物进行抽取
         */
        SmallClass s = new SmallClass();
        s.study();
        s.sleep();

        BigClass b = new BigClass();
        b.study();
    }

}

/**
 * 学生类
 * 
 * @author LGL
 *
 */
abstract class Student {
    // 学习的内容不一样，抽象
    public abstract void study();

    // 睡觉
    public void sleep() {
        System.out.println("躺着睡");
    }
}

/**
 * 大班
 * 
 * @author LGL
 *
 */
class BigClass extends Student {

    @Override
    public void study() {
        System.out.println("学习大班知识");
    }

}

/**
 * 小班
 * 
 * @author LGL
 *
 */
class SmallClass extends Student {

    @Override
    public void study() {
        System.out.println("学习小班知识");
    }

    @Override
    public void sleep() {
        System.out.println("卧着睡");
    }

}

这个例子输出

你拿到一想，是不是根据上面的方法直接复用父类对象的引用？这里我们可以拿到一个单独的类去复用封装

/**
 * 封装工具类
 * 
 * @author LGL
 *
 */
class DoStudent {
    public void dosome(Student s) {
        s.study();
        s.sleep();
    }
}

这样我们使用

        DoStudent dos = new DoStudent();
        dos.dosome(new BigClass());
        dos.dosome(new SmallClass());

得到的结果

我们再来看下多态的代码特点，我们举个例子

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        zi z = new zi();
        z.method1();
        z.method2();
        z.method3();
    }
}

class Fu {
    void method1() {
        System.out.println("fu method1");
    }

    void method2() {
        System.out.println("fu method2");
    }
}

class zi extends Fu {
    void method1() {
        System.out.println("zi method1");
    }

    void method3() {
        System.out.println("zi method3");
    }

}

你能告诉我打印的结果吗？

我们现在用多态的思想去做

你会知道，3是引用不了的，我现在把报错的的地方注释掉，然后你能告诉我运行的结果吗

我们可以总结出特点（在多态中成员函数的特点）

在编译时期。参阅引用型变量所属的类是否有调用的方法，如果由，编译通过。如果没有编译失败
在运行时期，参阅对象所属的类中是否有调用的方法
简单总结就是成员函数在多态调用时，编译看左边，运行看右边

我们再在子类和父类中都定义一个int值分别是5和8

我们这么输出

        Fu f = new zi();
        System.out.println(f.num);

        zi z = new zi();
        System.out.println(z.num);

输出多少呢？

这里就总结出

在多态中，成员变量的特点:无论编译和运行，都参考左边（引用型变量所属）
在多态中，静态成员变量的特点：无论编译和运行，都参考左边

我们把学到的应用在案例上

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard b = new MainBoard();
        b.run();
    }
}

/**
 * 主板
 * 
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

}

我们程序这样写，无疑看出来很多弊端，我想上网，看电影，他却没有这功能，我们要怎么去做，我们重新设计程序，再增加

/**
 * 网卡
 * 
 * @author LGL
 *
 */
class NetCard {
    public void open() {
        System.out.println("打开网络");
    }

    public void close() {
        System.out.println("关闭网络");
    }
}

但是这样，还是主板的耦合性是在是太强了，不适合扩展，所以，这个程序一定不是一个好的程序我，我们重新设计，用一个标准的接口

import javax.print.attribute.standard.MediaName;

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard m = new MainBoard();
        m.run();
        // 没有设备，有设备的话之类传进去
        m.userPCI(null);

    }
}

/**
 * 扩展接口
 * 
 * @author LGL
 *
 */
interface PCI {
    public void open();

    public void close();
}

/**
 * 主板
 * 
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

    public void userPCI(PCI p) {
        if (p != null) {
            p.open();
            p.close();
        } else {
            System.out.println("没有设备");
        }

    }

}

我们现在不管增加听音乐还是上网的功能，只要实现PCI的接口，就可以实现，我们现在增加一个上网功能，该怎么做？


//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard m = new MainBoard();
        m.run();
        // 没有设备
        m.userPCI(null);

        // 有设备
        m.userPCI(new NetCard());

    }
}

/**
 * 扩展接口
 * 
 * @author LGL
 *
 */
interface PCI {
    public void open();

    public void close();
}

/**
 * 主板
 * 
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

    public void userPCI(PCI p) {
        if (p != null) {
            p.open();
            p.close();
        } else {
            System.out.println("没有设备");
        }

    }

}

/**
 * 网卡
 * 
 * @author LGL
 *
 */
class NetCard implements PCI {
    public void open() {
        System.out.println("打开网络");
    }

    public void close() {
        System.out.println("关闭网络");
    }
}

这样我们运行

现在的主板是不是扩展性特别强，这就是多态的扩展性

原文地址http://www.bieryun.com/2720.html

微信关注我们

原文链接：https://yq.aliyun.com/articles/576015

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

JAVA之旅（七）——final关键字 , 抽象类abstract，模板方法模式，接口interface，implements，特点，扩展

JAVA之旅（七）——final关键字 , 抽象类abstract，模板方法模式，接口interface，implements，特点，扩展一.final 我们来聊聊final这个关键字 final可以修饰类，方法和变量 final修饰的类不可以被继承 final修饰的方法不可以被覆盖 final修饰的变量是一个常量，只能被赋值一次内部类只能访问被final修饰的局部变量 final，故名思意，就是最终的意思，由以上的五种特性，不过final的出现，也是有弊端的，他破坏了封装性，对继承有了挑战，为了避免被继承，被子类复写功能，还有，当你描述事物时，一些数据的出现值是固定的，那么，这时为了增强阅读行，都给这个值起个名字方便阅读，而这值不需要改变，就会用到final去修饰，作为常量，常量的书写规范是所有字母都大写，如果由多个单词组成，单词间通过下划线链接！而且内部类定义在类中的局部位置只能访问该局部被final修饰的局部变量 final大家只要记住他的特性就行二.抽象类这个抽象类应该是属于继承的下半部分的，我们看一个标注的代码 //公共的类类名 public class Hell...

2018-04-04

610

JAVA之旅（九）——Object类，equals，toString，getClass，内部类访问规则，静态内部类,内部类原则，匿名内部类一.Object类 Object是什么呢？我们可以翻阅JAVA API文档看他的介绍上面介绍说，object是类层次结构的根类，也就是超类 Object：是所有对象的直接后者间继承关系，传说中的老祖宗，你父亲还有父亲，你父亲的父亲还有父亲是爷爷，这是继承关系，但是你的祖宗却只有一位，该类中定义的肯定是所有对象都具备的功能 class Demo { // extends Object } 1.equals 我们可以用equals去比较两个对象是否相同 //公共的类类名 public class HelloJJAVA { // 公共的静态无返回值 main方法数组 public static void main(String[] str) { // 比较 Demo1 demo1 = new Demo1(); Demo2 demo2 = new Demo2(); System.out.println(demo1.equals(demo2));...

2018-04-04

611

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。