精华内容
下载资源
问答
  • 多态案例
    2019-09-11 11:17:26

    示例代码:

    #include <iostream>
    using namespace std;
    
    
    // HeroFighter   AdvHeroFighter  EnemyFighter
    
    class HeroFighter
    {
    public:
    	virtual int power()
    	{
    		return 10;
    	}
    };
    
    
    class AdvHeroFighter : public HeroFighter
    {
    public:
    	virtual int power()
    	{
    		return 20;
    	}
    };
    
    
    class EnemyFighter
    {
    public:
    	int attack()
    	{
    		return 15;
    	}
    };
    
    
    
    
    
    
    int main()
    {
    
    	HeroFighter hf;
    	AdvHeroFighter  advhf;
    	EnemyFighter ef;
    
    	if (hf.power() > ef.attack())
    	{
    		cout << "hf   You win" << endl;
    	}
    	else
    	{
    		cout << "hf   Fucking Out !!!" << endl;
    	}
    
    	if (advhf.power() > ef.attack())
    	{
    		cout << "advhf    You win" << endl;
    	}
    	else
    	{
    		cout << "advhf    Fucking Out !!!" << endl;
    	}
    	
    	system("pause");
    	return 0;
    }
    
    
    
    上面的示例代码根本没有使用多态,要想使用多态,你应该按照使用多态的场景去做.
    #include <iostream>
    using namespace std;
    
    
    // HeroFighter   AdvHeroFighter  EnemyFighter
    
    class HeroFighter
    {
    public:
    	virtual int power()
    	{
    		return 10;
    	}
    };
    
    
    class AdvHeroFighter : public HeroFighter
    {
    public:
    	virtual int power()
    	{
    		return 20;
    	}
    };
    
    
    class EnemyFighter
    {
    public:
    	int attack()
    	{
    		return 15;
    	}
    };
    
    void PlayObj(HeroFighter *hf, EnemyFighter *ef)
    {
    	if (hf->power() > ef->attack())   // hf->power() 是会有多态发生
    	{
    		cout << "you win" << endl;
    	}
    	else
    	{
    		cout << "Fucking out !!!" << endl;
    	}
    }
    
    int main()
    {
    
    	HeroFighter hf;
    	AdvHeroFighter  advhf;
    	EnemyFighter ef;
    	PlayObj(&hf, &ef);
    	PlayObj(&advhf, &ef);
    	
    	system("pause");
    	return 0;
    }
    
    
    
    /*
    * 多态的条件:
    *	1.要有继承
    	2.要有虚函数重写
    	3.用父类指针(父类引用)指向子类对象
    */
    
    更多相关内容
  • C++多态案例

    2021-10-30 20:50:27
    多态简介 1.静态多态:函数重载和运算符重载属于静态多态,复用函数名 2.动态多态:派生类和虚函数实现运行多态 两者区别: 1.静态多态的函数地址早绑定——编译阶段确定函数地址 ...案例一.计算器 #include<ios

    多态简介

    1.静态多态:函数重载和运算符重载属于静态多态,复用函数名
    2.动态多态:派生类和虚函数实现运行多态

    两者区别:

    1.静态多态的函数地址早绑定——编译阶段确定函数地址
    2.动态多态函数地址晚绑定——运行阶段确定函数地址

    多态满足条件

    1.有继承关系
    2.子类重写父类中的虚函数

    多态使用条件

    父类指针或引用指向子类对象
    重写:函数返回值类型,函数名,参数列表完全一致称为重写

    多态的优点

    1.代码组织结构清晰
    2.可读性强
    3.利于前期和后期的扩展和维护

    案例一.计算器

    #include<iostream>
    using namespace std;
    
    class Calculator
    {
    public:
    	//纯虚函数,抽象类
    	virtual int get_Result() = 0;
    	int n_A=0;
    	int n_B=0;
    };
    class Addition :public Calculator
    {
    public:
    	int get_Result()
    	{
    		return n_A + n_B;
    	}
    };
    class Subtraction :public Calculator
    {
    	int get_Result()
    	{
    		return n_A - n_B;
    	}
    };
    class Multiplication :public Calculator
    {
    	int get_Result()
    	{
    		return n_A * n_B;
    	}
    };
    class Division :public Calculator
    {
    	int get_Result()
    	{
    		return n_A / n_B;
    	}
    };
    //测试加法
    void test()
    {
    	Calculator* p = new Addition;
    	p->n_A = 100;
    	p->n_B = 150;
    	cout << "n_A+n_B="
    		<< p->get_Result()
    		<< endl;
    	delete p;
    }
    //测试减法
    void test2()
    {
    	Calculator* p = new Subtraction;
    	p->n_A = 100;
    	p->n_B = 150;
    	cout << "n_A-n_B="
    		<< p->get_Result()
    		<< endl;
    	delete p;
    }
    int main()
    {
    	test();
    	test2();
    	return 0;
    }
    

    案例二.制作饮品

    #include<iostream>
    using namespace std;
    class AbstractDringking
    {
    public:
    	virtual void Boil() = 0;
    	virtual void Brew() = 0;
    	virtual void PourInCup() = 0;
    	virtual void Addmore() = 0;
    	virtual void Done() = 0;
    	//proceduer
    	void Procedure()
    	{
    		Boil();
    		Brew();
    		PourInCup();
    		Addmore();
    		Done();
    	}
    };
    class Coffee :public AbstractDringking
    {
    public:
    	virtual void Boil()
    	{
    		cout << "Heat the water" << endl;
    	}
    	virtual void Brew()
    	{
    		cout << "Brew coffee" << endl;
    	}
    	virtual void PourInCup()
    	{
    		cout << "Pour the coffee into the cup" << endl;
    	}
    	virtual void Addmore()
    	{
    		cout << "Add milk" << endl;
    	}
    	virtual void Done()
    	{
    		cout << "Your coffee is finished" << endl;
    	}
    };
    class Tea :public AbstractDringking
    {
    public:
    	void Boil()
    	{
    		cout << "Heat the water" << endl;
    	}
    	void Brew()
    	{
    		cout << "Brewing tea" << endl;
    	}
    	void PourInCup()
    	{
    		cout << "Pour the tea into the cup" << endl;
    	}
    	void Addmore()
    	{
    		cout << "Add medlar" << endl;
    	}
    	void Done()
    	{
    		cout << "Your tea is finished" << endl;
    	}
    };
    
    //Business function
    void DoWork(AbstractDringking* drink)
    {
    	drink->Procedure();
    	delete drink;
    }
    void test()
    {
    	AbstractDringking* p1 = new Coffee;
    	DoWork(p1);
    	cout << "--------------" << endl;
    	AbstractDringking* p2 = new Tea;
    	DoWork(p2);
    }
    int main()
    {
    	test();
    	return 0;
    }
    
    展开全文
  • C++ --多态案例之组装电脑

    千次阅读 2022-03-14 01:18:15
    C++的多态案例

    多态案例–组装三台电脑

    • 电脑零件基类CPU,显卡,内存条
    • 不同的厂商,如Intel,Lenovo等;
      • 三个零件基类,CPU,Videocard,Memory;不同厂商生产的零件来实现具体的功能。
    #include <iostream>
    using namespace std;
    //公共零件基类
    class CPU
    {
    public:
    	virtual void calculate() = 0;
    };
    class Videocare
    {
    public:
    	virtual void display() = 0;
    };
    class Memory
    {
    public:
    	virtual void storage() = 0;
    };
    //Intel生产的零件
    class IntelCPU : public CPU
    {
    public:
    	virtual void calculate()
    	{
    		cout << "IntelCPU is calculating\n";
    	}
    };
    class IntelVideocard : public Videocare
    {
    public:
    	virtual void display()
    	{
    		cout << "Intel Videocard is displaying\n";
    	}
    };
    class IntelMemory : public Memory
    {
    public:
    	virtual void storage()
    	{
    		cout << "Intel Memory is storaging\n";
    	}
    };
    //Lenovo生产的零件
    class LenovoCPU : public CPU
    {
    public:
    	virtual void calculate()
    	{
    		cout << "LenovoCPU is calculating\n";
    	}
    };
    class LenovoVideocard : public Videocare
    {
    public:
    	virtual void display()
    	{
    		cout << "Lenovo Videocard is displaying\n";
    	}
    };
    class LenovoMemory : public Memory
    {
    public:
    	virtual void storage()
    	{
    		cout << "Lenovo Memory is storaging\n";
    	}
    };
    //电脑组装
    class Computer
    {
    private:
    	CPU* cpu;
    	Videocare* vc;
    	Memory* memory;
    public:
    	Computer(CPU* cpu, Videocare* vc, Memory* memory)
    	{
    		this->cpu = cpu;
    		this->vc = vc;
    		this->memory = memory;
    	}
    	~Computer()
    	{
    		if (cpu != NULL)
    		{
    			delete cpu;
    			cpu = NULL;
    		}
    		if (cpu != NULL)
    		{
    			delete cpu;
    			cpu = NULL;
    		}
    		if (cpu != NULL)
    		{
    			delete cpu;
    			cpu = NULL;
    		}
    	}
    	void work()
    	{
    		cpu->calculate();
    		vc->display();
    		memory->storage();
    	}
    };
    //组装测试
    	//测试Intel零件
    void test1()
    {
    	CPU* intelCpu = new IntelCPU;
    	Videocare* intelVc = new IntelVideocard;
    	Memory* memory = new IntelMemory;
    	Computer computer(intelCpu, intelVc, memory);
    	computer.work();
    }
    	//测试Lenovo零件
    void test2()
    {
    	Computer computer(new LenovoCPU, new LenovoVideocard, new LenovoMemory);
    	computer.work();
    }
    void test3()
    {
    	Computer computer(new IntelCPU, new IntelVideocard, new LenovoMemory);
    	computer.work();
    }
    int main()
    {
    	cout << "------------测试1开始-----------\n";
    	test1();
    	cout << "------------测试2开始-----------\n";
    	test2();
    	cout << "------------测试3开始-----------\n";
    	test3();
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 利用C++中的多态知识,写一个简单的PK游戏代码,主要涉及多态、继承、虚函数等内容,熟悉C++基础知识
  • 此资源为Java中多态组件相关案例及源代码,可用于辅助教师进行相关内容的备课,也可方便学生对相关内容进行学习及巩固。
  • 学了面向对象中的封装、继承、多态,来进入代码演练一番吧~ package p1; public class TestAnimal { public static void main(String[] args) { //多态:父类型的引用存储子类型的对象. // 父类 Animal ...
    学了面向对象中的封装、继承、多态,来进入代码演练一番吧~
    

    在这里插入图片描述

    package p1;
    
    public class TestAnimal {
    	public static void main(String[] args) {
    
        	//多态:父类型的引用存储子类型的对象.
    
        	//  父类 Animal  子类 Dog
        	Animal a1=new Dog("柯基",3);
        	System.out.println("狗狗的信息:"+a1.getName()+"-"+a1.getAge());
    
        	//  父类 Animal  子类 Cate
        	Animal a2=new Cat("虎斑",3);
        	System.out.println("猫猫的信息:"+a2.getName()+"-"+a2.getAge());
    	}
    }
    
    //父类   动物
    class Animal{
    
    	//封装   属性私有化
    	private String name;
    	private int age;
    
    
    	//提供无参构造方法
    	public Animal(){}
    
    	//提供有参构造方法
    	public Animal(String name,int age){
        	this.name=name;
        	this.age=age;
        }
    
    
    	//set  设置/  get  获取
    	public String getName() {
        	return name;
        }
    
    	public void setName(String name) {
        	this.name = name;
    	}
    
    	public int getAge() {
        	return age;
        }
    
    	public void setAge(int age) {
        	this.age = age;
    	}
    }
    
    //子类   狗  ---  继承父类   动物
    class Dog extends Animal{
    
    	//提供无参构造方法
     	public Dog() {}
    
    	//提供有参构造方法
    	public Dog(String name, int age) {
        	super(name, age);
    	}
    }
    
    //子类   猫  ---  继承父类   动物
    class Cat extends Animal{
    
    	//提供无参构造方法
    	public Cat() {}
    
    	//提供有参构造方法
    	public Cat(String name, int age) {
        	super(name, age);
    	}
    }
    

    super的应用?

    super应用在子类中使用父类中内容.
    

    super.

    a. super. 应用在子类中的构造方法或是成员方法中,代表访问父类中的属性或是成员方法
    b. super.属性名      			访问父类中属性
       super.方法名(实参);   		访问父类中成员方法
    c. super.应用场景:当子类和父类定义了重名的属性或是成员方法时;
    				需要在子类中访问和父类重名内容,则需要利用 super. 区分 父类的属性和方法
    

    注意:

    创建每一个子类对象,jvm默认为每一个子类对象创建对应的一个父类对象
    

    super()

    a. super()/super(实参); 
       应用在子类的构造方法的第一行语句,代表创建子类对象时;
       告知jvm为子类对象创建对应父类对象时利用父类的哪一个构造方法完成对象的创建
    b. super():代表利用父类无参数的构造方法
       super(实参):代表利用父类有参数的构造方法
    c. 注意:super()必须使用在子类构造法的第一行语句
    d. 如果子类的构造方法第一行没有指定super()/super(实参),则默认在第一行添加super()
    

    Jvm默认添加

    super():子类构造方法第一行没有指定super()/super(实参),jvm默认添加
    this. 访问属性,如果成员变量和局部变量没有冲突时,直接利用 属性名访问成员时,默认 this.属性名
    当一个类中没有定义任何构造方法,jvm默认添加公开的无参数的构造方法
    

    super的案例

    // 父类
    class A{
    	public A(int n){
    		System.out.println("A(int n)");
    	}
    }
    
    // 子类
    class B extends A{
    	public B(){
    		super();
    		System.out.println("B()....");
    	}
    	public B(int n){
    		super(n);
    		System.out.println("B(int n)...子类有参数构造");
    	}
    }
    
    分析:
    	编译报错,错误原因在子类无参的构造方法第一行super()/super(实参)的应用;
    	Jvm默认在第一行添加super(),需要利用父类无参数的构造方法完成父类对象;
    	但是父类中只提供了有参数的构造方法,没有无参数的构造方法,编译报错。
    

    superthis的区别:

    super访问->代表父类对象,父类的属性、成员方法、构造方法
    super. : 应用在子类的构造方法或是成员方法中,访问父类的属性或是成员方法
    super(): 应用在子类的构造方法,代表 告知jvm创建父类对象利用父类的哪一个构造方法完成对象
    
    
    this访问->代表当前对象,自身的属性、成员方法、构造方法
    this. :应用在本类的构造方法或是成员方法中,访问当前对象属性或是成员方法
    this(): 应用在本类的构造方法,访问本类的其他构造方法
    
    展开全文
  • 02 多态案例-计算器.cpp
  • c++多态案例

    2021-09-13 09:18:15
    普通方式与多态对比普通方式写计算器类多态方式写计算器类 普通方式写计算器类 #include <iostream> #include<string> using namespace std; //普通方式写计算器 class calculator { public: ...
  • Java__多态案例.mp4

    2021-07-09 15:04:16
    Java__多态案例.mp4
  • C++:多态案例(一)

    2021-04-03 09:14:17
    } 多态的好处: 1.组织结构清晰 2.可读性强 3.对于前期和后期扩展以及维护性高 //利用多态实现 //实现计算器的抽象类 class ABcal { public: virtual int getR() { return 0; } int m_num1; int m_num2; }; //加法...
  • //4.7.3 多态案例 计算器类 #include<iostream> #include<string> using namespace std; //分别利用普通写法和多态技术实现计算器 //普通写法 class Calculator { public: int getResult(string oper)...
  • 多态案例-制作饮品

    千次阅读 2022-02-10 19:19:08
    #define _CRT_SECURE_NO_WARNINGS #include using namespace std;... } 运行结果: 案例总结: 1.纯虚函数不能实例化对象 2.父类指针或者引用指向子类的对象( AbstractDrinking * abs = new coffee; )
  • 174 多态案例/猫和狗

    2021-11-30 12:28:02
    174 多态案例/猫和狗 思路 动物类,变量/姓名 年龄,构造方法/无参的 带参的,成员方法/getter setter 吃饭 猫类,继承动物类,构造方法/无参的 带参的,成员方法/重写吃饭方法 狗类,继承动物类,构造方法/无参...
  • 多态案例-计算器案例

    2021-10-24 21:59:39
    3.3 利用多态实现 – 利于后期扩展,结构性非常好,可读性高, 效率稍微低,发生多态内部结构复杂 #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<string> using namespace std; //...
  • java多态基础案例,模拟USB设备。
  • 类 Class 类(Class) : 定义了一切事物的抽象特点 ...多态:由继承产生的多个不同的类,对同一个方法可以有不同的响应,比如猫和狗都可以继承自Animal,但是它们分别实现了自己的eat(吃)方法;此时针对某一
  • 面向对象之多态案例

    2019-09-07 11:43:12
    案例需求介绍 笔记本电脑(laptop)通常具备使用USB设备的功能。在生产时,笔记本都预留了可以插入USB设备的USB接口,但具体是什么USB设备,笔记本厂商并不关心,只要符合USB规格的设备都可以。 定义USB接口,...
  • 多态案例三-电脑组装

    2021-05-27 19:52:54
    多态案例三-电脑组装 案例描述: 电脑的主要组成部件为CPU,显卡,内存条,将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商,创建电脑类提供让电脑工作的函数,并且调用每...
  • 具体过程而是查看A中的方法,发现没有以B为参数的方法,但有以A为参数的方法,父类为形参,这里又是第一种形式的多态,于是就调用这个方法,但是这个方法在B中重写了,所以就会调用子类的方法输出“B and A”。...
  • JAVA多态案例(猫和狗)

    千次阅读 2021-03-19 21:13:37
    需求:请采用多态的思想实现猫和狗的案例,并在测试类中进行测试。 分析: (1)定义动物类(Animal) 成员变量:姓名、年龄; 构造方法:无参、带参 成员方法:get/set方法,吃饭() (2)定义猫类(Cat),继承动物...
  • 4.7.2 多态案例--计算器类案例描述多态的优点示例 案例描述 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类 多态的优点 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 ...
  • 4.7.4 多态案例二-制作饮品

    千次阅读 2022-02-18 10:44:23
    #include<iostream> using namespace std; class AbstractDrinking { public: //煮水 virtual void Boil()=0; //冲泡 virtual void Brew()=0; //倒入杯中 virtual void PourInCup()=0;... void makeDrink...
  • C++:多态案例(三)

    2021-04-03 19:24:26
    首先实现三种零件的基类: //CPU基类 class CPU { public: virtual void calculate() = 0; }; //显卡基类 class VideoCard { public: virtual void display() = 0;...注意这里已经发生了多态:父类的...
  • 多态案例实战

    2020-05-10 10:51:37
    积少成多
  • 封装 继承 多态
  • 利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶叶 #include<iostream> #include<string> using namespace std; class MakeDrink { public: virtual void boil() = 0; //煮水 ...
  • 多态与多态案例

    2016-08-26 09:33:13
    多态的思想 面向对象3大概念 封装: 突破c函数的概念....用类做函数参数的时候,可以使用对象的属性 和对象的方法 继承: A B 代码复用 多态 : 可以使用未来... 多态很重要 实现多态的三个条件 好比C语言 间接...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,901
精华内容 10,760
关键字:

多态案例