精华内容
下载资源
问答
  • 封装和继承相对来说好理解一些,这篇文章主要来说一下 多态。 文章目录1、多态娱乐初始版:2、多态娱乐改进版: 1、多态娱乐初始版: 在介绍多态之前先来看一下之前不用多态多出现的问题,通过代码来详细看一下(不要慌,...

    Java 的三大特性是我们在刚接触 Java 的时候就一直在叨叨,那到底什么是 封装、继承
    、多态呢?封装和继承相对来说好理解一些,这篇文章主要来说一下 多态。

    1、多态娱乐初始版:

    在介绍多态之前先来看一下之前不用多态多出现的问题,通过代码来详细看一下(不要慌,代码很好懂):

    在这里插入图片描述

    代码搞起来:

    在这里插入图片描述

    Application.java

    package com.pxl.form.versionOne;
    
    import com.pxl.form.versionOne.ExperimentCourse;
    import com.pxl.form.versionOne.Teacher;
    
    public class Application {
    	public static void main(String[] args) {
    		Teacher teacher = new Teacher();
    		ExperimentCourse course = new ExperimentCourse();
    
    		teacher.Set(course);
    
    		System.out.println("今天上什么课?");
    
    		teacher.Answer();
    
    	}
    }
    

    Teacher.java

    package com.pxl.form.versionOne;
    
    public class Teacher {
    	private ExperimentCourse course;
    
    	public void Set(ExperimentCourse course) {
    		this.course = course;
    	}
    
    	public void Answer() {
    		System.out.println(course);
    	}
    }
    
    

    ExperimentCourse.java

    package com.pxl.form.versionOne;
    
    public class ExperimentCourse {
    	public String toString()
    	{
    		return "今天上实验课。";
    	}
    }
    
    

    问题错误:
    经过在 idea 编译器环境下执行 多态娱乐初始版 ,由于当前包下只有一个 ExperimentCourse 类,所以在 Application 类中进行调用方法的时候并不会出现什么问题,但是,当出现多个相关课程类的时候,例如 DataBaseCourse 的时候,我们就会发现其中的问题:

    package com.pxl.form;
    
    import com.pxl.form.versionTwo.Course;
    
    /**
     *  实现 Course 接口,重写 toString 方法
     */
    public class DataBaseCourse {
    	public String toString(){
    		String str = "上数据库课!";
    		return str;
    	}
    }
    

    在这里插入图片描述

    2、多态娱乐改进版:

    分析上面出现的问题,追根溯源,我们发现在Teacher类中依赖注入(调用Set方法)的时候属性只有ExperimentCourse 类的属性,所以当我们再调用set 方法的时候,必然是会报错的,可以发现,现在明确出现的问题就是一个 Teacher 类只能有一门课程,显然在实践生活中也是很少见的,那如何解决这个问题呢?
    我们发现,在 每门课程 都有相同的一些特征,“上xxx课”,这是我们是否可以让 Teacher 类中的属性成为一个 Course 类,这样每门课都去实现 Course 接口,在调用 Answer() 方法的时候就会去重写 传入的类 的 toString () 方法

    在这里插入图片描述

    通过上面的解决办法我们就会发现,当有一门新的课程的时候,我们不再需要去重新创建一个Teacher 类(之前的一个Teacher 类只能处理一门课程),只需要实现 Course 接口,然后通过 依赖注入的方式注入到 Teacher 类中即可

    在这里插入图片描述

    这就是多态的体现, 多态是同一个行为(上课)具有多个不同表现形式(课程)或形态的能力。
    多态就是同一个接口,使用不同的实例而执行不同操作

    代码搞起来:

    Application.java

    package com.pxl.form.versionTwo;
    
    public class Application {
    	public static void main(String[] args) {
    		Teacher wang = new Teacher();
    		
    		System.out.println("今天上什么课?");
    		Course c = new ExperimentCourse();
    		// 通过依赖注入的方式注入到 Teacher 类中
    		wang.Add(c);
    		// 会调用其重写后的 toString() 方法
    		wang.Answer();
    
    		System.out.println("今天上什么课?");
    		c = new TheoryCourse();
    		// 只需要注入不同的课程即可,因为每门课都实现了 Course 接口,所以只需 new 不同的 课程即可
    		wang.Add(c);
    		wang.Answer();
    
    		System.out.println("今天上什么课?");
    		c = new DataBaseCourse();
    		wang.Add(c);
    		wang.Answer();
    
    		System.out.println("哈哈,你可真...");
    		System.out.println("多态发生在哪里?");
    	}
    }
    

    Course

    package com.pxl.form.versionTwo;
    
    public interface Course{
    }
    
    

    DataBaseCourse

    package com.pxl.form.versionTwo;
    
    /**
     *  实现 Course 接口,重写 toString 方法
     */
    public class DataBaseCourse implements Course {
    	public String toString(){
    		String str = "上数据库课!";
    		return str;
    	}
    }
    

    ExperimentCourse

    package com.pxl.form.versionTwo;
    
    public class ExperimentCourse implements Course {
    	public String toString(){
    		String str = "上实验课!";
    		return str;
    	}
    }
    
    

    Teacher

    package com.pxl.form.versionTwo;
    
    public class Teacher {
    	// 声明一个 Course 属性
    	private Course course;
    	// 实际上是通过依赖注入的方式,调用该方法是传入的是什么课程就赋值为什么课程
    	public void Add(Course course){
    		this.course = course;
    	}
    	public void Answer(){
    		// 输出 对象的时候就会去调用默认的 toString 方法
    		System.out.println(course);
    	}
    }
    
    

    TheotyCourse

    package com.pxl.form.versionTwo;
    
    public class TheoryCourse implements Course {
    	public String toString(){
    		String str = "上理论课!";
    		return str;
    	}
    }
    

    相关代码和试验报告都已经上传到码云上,欢迎各位有兴趣的小伙伴踩点。

    展开全文
  • 面向对象---理解多态

    2019-03-25 20:22:11
    多态通俗来说,就是多种形态,完成某个行为,当不同的对象去完成某个行为时会产生不同的状态。二、多态的定义及实现 1、多态定义的构成条件 多态是在不同继承关系的类对象,去调用同一函数,产生了不同行为。 例如...

    一、多态的概念
    多态通俗来说,就是多种形态,完成某个行为,当不同的对象去完成某个行为时会产生不同的状态。
    二、多态的定义及实现
    1、多态定义的构成条件
    多态是在不同继承关系类对象,去调用同一函数产生了不同行为

    例如在火车站买票时,学生和成人分别去买票,学生买的是半价票,成人买的是全价票。同样是买票,但是不同的对象去买票时产生了不同的行为。

    在继承时要构成多态还有两个重要的条件:

    (1)调用函数的对象必须是指针或者引用;

    (2)被调用的函数必须是虚函数,且完成了虚函数的重写。

    首先解释一下第一个条件:

    class Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票-全价" << endl;
    	}
    };
    class Student :public Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票-半价" << endl;
    	}
    };
    void Func(Person p)
    {
    	p.BuyTicket();
    }
    int main()
    {
    	Person ps;
    	Student st;
    	Func(ps);
    	Func(st);
    	system("pause");
    	return 0;
    }

    观察上面这段代码,发现调用函数的对象不是指针或者引用,当把ps对象传过去时,p是对ps的一份拷贝;当把st对象传过去时,p是对st的切片,也就是只把父类的那一部分切了过去,根本上还是父类对象在调用。并不是不同继承关系的类对象,调用同一函数。可以看下面输出代码,发现买的都是全价票。

    对于为什么必须要传指针或者引用,我简单说一下,传指针是因为,传参的时候若传的是父类对象,指针则指向父类对象,若是子类,就指向子类对象;而引用是对象的别名,传哪个对象就是哪个对象的别名。

    总结一下:构成多态----->和对象有关;不构成多态----->跟类型有关。

    其次关于虚函数我做以下介绍:

    (1)虚函数的概念

    虚函数就是在成员函数前面加上virtual关键字。

    (2)虚函数的重写

    在派生类中有一个跟基类完全相同的虚函数,我们就称子类的虚函数重写了基类的虚函数,完全相同是指:函数名、参数、返回值都相同。另外虚函数的重写也叫虚函数的覆盖。

    (3)虚函数重写的例外

    重写虚函数的返回值可以不同,但是分别必须是基类指针和派生类指针或者基类引用和派生类引用。

    (4)不规范的函数重写行为

    在派生类中重写的成员函数可以不加virtual关键字,也是构成重写的,因为继承后基类的虚函数被继承下来在派生类中依旧保持虚函数属性,我们只是重写了它。

    (5)析构函数的重写行为

    基类中的析构函数如果是虚函数,那么派生类中的析构函数就重写了基类的析构函数。虽然基类和父类的析构函数名称不同,看起来不符合重写的规则,事实却并非如此,这里可以理解为编译器对析构函数的名称做了特殊处理,编译之后,析构函数的名称统一处理成了destructor,由此也说明基类的析构函数最好也写成虚函数。

    若不写成虚函数,未构成多态,则是普通函数的调用,只与类型有关:

    class Person
    {
    public:
    	 ~Person()
    	{
    		cout << "~Person" << endl;
    	}
    };
    class Student :public Person
    {
    public:
    	 ~Student()
    	{
    		cout << "~Student" << endl;
    	}
    };
    int main()
    {
    	Person* ps = new Person;
    	Person* st = new Student;
    	delete ps;
    	delete st;
    	system("pause");
    	return 0;
    }

    输出结果:

    可以看出,st是person类型的指针,虽然指向了子类的构造函数,但是只完成了切片,只拿到了子类中父类的那部分,调了父类的析构函数。此时子类并没有被析构,造成了内存泄露。需要注意的是析构时,底层是这样实现的,先重载了ps->distructor(),然后再free(ps)

    写成了虚函数,则构成了多态:

    三、接口继承和实现继承

    普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。所以如果不实现多态,就不要把函数定义成虚函数。

    四、抽象类

    抽象类从字面上可以理解为现实世界没有的,用来描述一些比较泛化的不具体的类别。

    在虚函数的后面写上=0,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象(也就是派生类继承了基类的纯虚函数),只有重写虚函数,派生类才能实例化出对象。纯虚函数规范了派生类必须重写,另外纯虚函数更体现了接口继承。

    下面 一段代码来演示一下抽象类:

    class Car
    {
    public:
    	virtual void Drive() = 0;
    };
    class Person :public Car
    {
    public:
    };
    
    int main()
    {
    	Person c;
    	system("pause");
    	return 0;
    }

    输出结果:

    可以看出上述代码执行出错,子类Person继承了父类的纯虚函数,是抽象类,不能实例化出对象,所以子类必须完成虚函数的重写,不然就没有意义。

    因此得出一个结论,纯虚函数是一种强制派生类重写虚函数的一种机制。

    在实际中,C++11提供override和final来修饰虚函数

    首先看一段代码:

    class Car
    {
    public:
    	virtual void Drive() = 0;
    };
    class Person :public Car
    {
    public:
    	void Drive() override
    	{
    		cout << "舒适" << endl;
    	}
    };
    
    int main()
    {
    	Person c;
    	c.Drive();
    	system("pause");
    	return 0;
    }

    输出结果:

    可以看出override修饰派生类虚函数强制完成重写。

    下面再介绍一下final关键字,它修饰基类的虚函数不能被派生类重写

    class Car
    {
    public:
    	virtual void Drive() final
    	{
    
    	}
    };
    class Person :public Car
    {
    public:
    	void Drive()
    	{
    		cout << "舒适" << endl;
    	}
    };
    
    int main()
    {
    	Person c;
    	c.Drive();
    	system("pause");
    	return 0;
    }

    输出结果:

    以上是关于多态的基础知识点,下篇博客将介绍多态的原理。

    展开全文
  • 【封装·继承·多态】个人通俗理解

    千次阅读 2016-07-28 15:17:06
    记得从前面试,老是记不住这三个概念,...而多态的意思就是:虽是同一个动作eat,但Male在实现的时候可以是站着吃饭,而Female在实现的时候可以是坐着吃饭,同一个方法可以有不同的实现,这就是面向对象中的多态
    • 记得从前面试,老是记不住这三个概念,容易混淆,这里特意记一下。

    1.封装

    所谓封装,就是将某些共同的东西提取出来成为一个抽象基类。例如:男人和女人都属于人类,他们共同的行为都有吃、喝、住、行,所以我们将这些共同行为封装在一个Human的基类,让它拥有吃、喝、住、行的方法。

    public abstract class Human{
    
        public abstract void eat();
    
        public abstract void drink();
    
        public abstract void live();
    
        public abstract void walk();
    }

    2.继承

    有了上面封装好的Human基类,我们就可以创建一个Male和Female类,来表示男人和女人,让Male和Female继承于Human类,这样Male类和Female类都拥有了Human的方法。Male和Female属于Human的子类,而在Java中,并不支持多继承,但可以重载多个接口(Interface)。

    public class Male extends Human {
    
        @Override
        public void eat() {
    
        }
    
        @Override
        public void drink() {
    
        }
    
        @Override
        public void live() {
    
        }
    
        @Override
        public void walk() {
    
        }
    }
    
    public class Female extends Human {
    
        @Override
        public void eat() {
    
        }
    
        @Override
        public void drink() {
    
        }
    
        @Override
        public void live() {
    
        }
    
        @Override
        public void walk() {
    
        }
    }

    3.多态

    从上面我们可以看到,继承了Human的Male和Female都分别要实现Human其中的四个方法。这是因为Human是抽象类(abstract关键字),并且其中的eat、drink、live、walk都是抽象方法,所以凡是继承它的子类都要实现这四个抽象方法。
    而多态的意思就是:虽是同一个动作eat,但Male在实现的时候可以是站着吃饭,而Female在实现的时候可以是坐着吃饭,同一个方法可以有不同的实现,这就是面向对象中的多态。

    展开全文
  • 面向对象的3大特性:继承,多态,封装。 多态就是同样的方法,不同的对象,处理结果不一样。就是Animals a=new Dog(); Animals a =new Cat(); a.eat();执行该方法会把Dog和Cat的eat()方法都输出。 ...

    面向对象的3大特性:继承,多态,封装。

    多态就是同样的方法,不同的对象,处理结果不一样。就是Animals a=new Dog(); Animals a =new Cat(); a.eat();执行该方法会把Dog和Cat的eat()方法都输出。

    展开全文
  • 多态的简单理解

    2020-06-09 16:45:24
    引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4编程技术内幕”...
  • 多态的定义和一些理解: (1)派生类对象的地址可以赋值给基类指针。对于通过基类指针调用基类和派生类中都有的同名、同参数表的虚函数的语句,编译时并不确定要执行的是基类还是派生类的虚函数;而当程序运行到该...
  • C#用趣图理解多态(用最通俗的方法讲解). 适合初学者入门多台
  • 通俗易懂的了解java的多态 还是要坚持学习啊 各种原因,一年多没写过博客了。疫情期间,在家隔离。还是要学习啊。定个目标,以后每周最少写一篇博客。记录学习,记录工作,记录生活! 什么是多态? 接下来我们来看看...
  • 多态是码农们必须要理解理解的一个基本思想, 是面向对象的基石。   但是很多人(包括我)第一次接触多态时都会困惑: 这东西有什么用处?   多态的例子在Java里非常简单,每个初学者都会遇到:      ...
  • 什么是多态?对于多态理解....

    千次阅读 2019-05-08 10:18:53
    简单理解:不同类的 对象 对同一消息 做出了不同的响应就叫做多态, 比如上课铃声响了,上体育课的学生跑到操场上站好,而上英语课的学生会在班级做好 一样. 多态的作用: 简单讲 就是 解耦.详细点说就是,多态是...
  • 多态:同一个对象,在不同时刻表现出来的不同形态 多态的前提和体现“ 有继承/实现关系 有方法重写,重写父类中的方法 假设cat里有变量:age weight Ainmal里有:age 有父类引用指向子类对象 即 Animal animal...
  • 多态理解与使用

    2021-12-05 14:51:17
    1、面向对象程序设计的三大支柱是封装、继承和多态。 2、对于多态的基础理解: 事物存在多种形态,现实事物经常会体现出很多种形态。例如猫属于猫科动物,狗属于犬科动物,但猫与狗都是属于动物,但同时他们也分别...
  • 封装、继承、多态 通俗理解

    千次阅读 2007-05-31 16:26:00
    比较抽象,只是一种概念,刚开始学的时候无需太过于深究,如果要你一... 继承,先说说我对类的理解,类起到的作用有:分类(你所用某个类创建的对象实际上该类的个案)和模板的作用,那么继承则起到了对类再次分类的作
  • 一、面向对象思想概述 在这之前,我们先来讲述面向过程。 面向过程:明确一个目的后,一步步亲自参与其中去实现它,这就是面向过程 举例:洗衣服:换下脏衣服----盛水----浸泡----手搓----漂清----晾干 面向对象:...
  • 如果敌人可以让你生气,那么就代表你还没有胜他的把握 ...算了,这毕竟是一篇技术文档,多态作为面向对象的特征之一,对于新手小白来说,这玩意理解起来就像鸡蛋明明是圆的,他非要让我们抽象的理解为方的,不.
  • 通俗理解,只要是 python 中可以进行操作的任何东西,都可以称为 “对象” 整数,浮点数 字符串 元组 字典 列表 通过自定义类创建的对象 在调用各种函数的时候需要进行参数的传递,其实传递的参数可以看成是...
  • 【C++】浅谈对多态理解

    千次阅读 2017-10-14 21:04:48
    浅谈对多态理解多态是C++中面向对象设计里一个重要的内容。所谓多态是指一个实体同时具有多种形式,通俗来讲就是同一个操作对于不同的对象,可以有不同的结果。
  • 多态(polymorphism = poly(复数) + morph(形态) + ism)的定义:同一操作作用于不同的对象上面,可以产生不同的解释和执行结果。 文字含义很容易理解,但往往在需要使用时却想不起它。真正的想要灵活使用一个设计...
  • C++面向对象之----多态

    2020-06-01 12:49:46
    多态是面向对象的三大特性之一,总结下多态的使用场景和虚表的一些注意到的点
  • Java之对象的多态性(使用生活中通俗的例子讲解)

    万次阅读 多人点赞 2018-04-03 12:48:49
    Java之对象的多态性多态概念 (Java)多态(英语:polymorphism),是指计算机程序运行时,相同的消息可能会送给多个不同的类别之对象,而系统可依据对象所属类别,引发对应类别的方法,而有不同的行为。简单来说,...
  • 多态理解

    2017-08-02 20:37:56
    这些天在啃框架,为啥突然将多态这个东西,看到周围同学似乎真的很难理解这个叫做多态的东西,我就讲讲我关于多态的一个理解,尽量做到通俗易懂。
  • java多态理解

    2021-03-13 17:55:40
    代码如下,猫狗继承自动物类,分别创建猫狗的实例,然后用猫狗的实例来创建一个lady的对象。...据说这个就是多态的简单例子,求解一个比较通俗易懂讲解!谢谢!public class TestPolymoph {public static void mai...
  • 最近培训的堂弟昨晚问了我一个问题,说多态是什么,我感觉是:一个类中,有几个方法,他们的方法名都是method,只不过他们的参数个数、类型或者返回值不同。然后他说:我们老师说:子类、父类之间,向上转型*&...
  • 通俗理解Java面向对象

    2020-09-21 17:00:38
    Java面向对象是Java中的核心思想,要想理解面向对象,首先要理解对象是什么。 对象 对象的英文为object,object的中文翻译为对象、物体、实体。也就是说,面向一个对象,就相当于面向一个物体或者一个实体。也就是说...
  • 首先要明白多态指的什么, 通俗点的话是 同一函数实现不同的功能,这点区别于多态。 我个人理解多态就是一些功能不同的函数可以使用统一函数名,也就是一个函数名可以调用内容不同功能不同的函数。 比如,将父...
  • 多态是Java面向对象的一个非常重要的机制,多态也被称为动态绑定,该机制是用于增强可扩展性而提出的。 多态的必要条件: 1.存在继承关系 2.对父类中的方法进行了重写 3.调用方法时,形参为父类引用 在实际运行...
  • 面向对象三大特性之一 多态

    千次阅读 2017-03-11 01:28:23
    通俗的讲,就是同一个东西表现出多种状态,在面向对象的描述中就是同一个函数接口,实现多种不同的表现方式。【静态多态】:编译器在编译期间完成的,编译器根据函数实参的类型(可能会进行隐式类型转换),可推断出要...
  • 多态的概念 面向对象的程序设计语言的三...(多态现实意义的理解:现实中也会出现事物的多种形态,比如张三既可以是律师,也可以是教师,还可以是人类,即出现多种形态。) 多态存在的前提:1.要有继承关系 ...
  • java多态理解

    2017-12-07 15:35:21
    多态的定义:指允许不同类的对象对同一消息做出不同的响应。   上面的说法可能有点难懂,借用网上一个实例: 比方说按下 F1 键这个动作,如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下...
  • Java多态理解

    2021-02-27 21:47:30
    商业转载请联系作者获得授权,非商业转载请注明出处。不请自来,C++的多态不太...先以教科书般举例说明,下文再举一个花木兰替父从军的例子帮助大家理解. 多态的存在有三个前提:1.要有继承关系2.子类要重写父类的方...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,258
精华内容 4,503
关键字:

对象的多态通俗理解