精华内容
下载资源
问答
  • 多态案例

    2016-11-25 00:12:00
    多态案例 例一 . class Test1Demo { . public static void main(String[] args) { . Fu f = new Zi(); . //f.method(); //编译看左边,运行看右边,左边没有method方法,报错, . f...

    多态案例

    1. 例一
      1. . class Test1Demo {
      2. .         public static void main(String[] args) {
      3. .             Fu f = new Zi();
      4. . //f.method(); //编译看左边,运行看右边,左边没有method方法,报错,
      5. .             f.show();//编译看左边,运行看右边,父类有show,编译没问题,输出Zishow,如果Zi类没有show方法,则运行时发现子类没有去重写,则直接调用的是父类show输出FU show,子类把fu类show方法继承下来了
      6. .         }
      7. . }
      8.  
      9. . class Fu {
      10.   public void show() {
      11.     System.out.println("fu show");
      12.   }
      13. }
      14. . class Zi extends Fu {
      15. .     public void show() {
      16. .         System.out.println("zi show");
      17. .     }
      18. .
      19. .     public void method() {
      20. .         System.out.println("zi method");
      21. .     }
      22. . }
      23. .

      2:

      1. . class A {
      2. .         public void show() {
      3. .             show2(); // 调用了show2
      4. .         }
      5. .            public void show2() {
      6. .             System.out.println("");
      7. .         }
      8. . }
      9. . class B extends A { //子类继承了A
      10. .     public void show2() {
      11. .         System.out.println("");
      12. .     }
      13. . }
      14. . class C extends B {
      15. .     public void show() {
      16. .         super.show();
      17. .     }
      18. .     public void show2() {
      19. .         System.out.println("");
      20. .     }
      21. . }
      22. . public class Test2DuoTai {
      23. .     public static void main(String[] args) {
      24. .         A a = new B();//编译看做左边,b中没有show,但是继承了A类的show方法.
      25. .         a.show();//爱
      26. . //父类show方法调用show2,子类中有show2,则show2是子类的show2.就相当于把这个方法写到B类中看
      27. .         B b = new C();//编译看做左边,b中没有show,但是继承了A类的show方法.
      28. ..         b.show();//你
      29. //运行看的是右边,子类show,super.show(),调用父类show方法,调用show2,调用子类show2
      30.  
      31. . }
      32. . }

       

    转载于:https://www.cnblogs.com/wk520hll/p/6100111.html

    展开全文
  • Java__多态案例.mp4

    2021-07-09 15:04:16
    Java__多态案例.mp4
  • 多态案例详解 需求:主人养了一只狗和一只猫,需要给它们进行喂食,(使用父类作为方法形参,子类作为实参传递使用) 首先建立动物类(父类) public class Animal { String name; int weigth; public void eat() { ...

    多态

    何为多态?同一种事物,由于条件不同,产生的结果也不同。
    多态:同一个引用类型,使用不同的实例而执行不同操作
    多态实现的前提:1,必须要有继承关系. 2,必须有方法重写. 3,必须是从父类对象指向子类对象.
    优点:1,拥有良好的扩展性 2,方便维护 3,使代码的灵活性更高。
    何时使用:在不确定是哪个类的实例会被去使用时,使用多态。

    多态案例详解

    需求:主人养了一只狗和一只猫,需要给它们进行喂食,(使用父类作为方法形参,子类作为实参传递使用
    首先建立动物类(父类)

    public class Animal {
    String name;
    int weigth;
    public void eat() {
    	System.out.println("父类~吃肉");
    }
    public void run() {
    	System.out.println("父类~跑步");
    }
    }
    

    建立狗类(子类)

    public class Dog extends Animal {
    	public void eat() {//写入狗类的方法
    		System.out.println("狗在咬骨头");
    	}
    	public void run() {//写入狗类的特有方法
    		System.out.println("狗在跑");
    	}
    }
    

    建立猫类

    public class Cat extends Animal {
    	public void eat() {
    		System.out.println("猫在吃鱼");
    	}
    }
    

    然后,我们建立主人类

    public class Master {//主人类里放入主人需要做的事情
    	public void feed(Animal animal) {//用带参的方法指定父类类型 声明了一个animal变量
    		System.out.println("主人喂养");
    		animal.eat();
    		System.out.println("主人在溜");
    		animal.run();//猫类本身是没有run方法的,为了测试。
    	}
    }
    

    最后,进行测试,重点是这里我们要把对象实例化出来。

    public class Test {
    	public static void main(String[] args) {
    		//主人类对象
    		Master master = new Master();
    		//实例化宠物对象
    		Dog dog= new Dog();
    		Cat cat = new Cat();
    		master.feed(cat);//传入的参数进行的操作即为 cat.eat(); 把实参cat赋值与变量animal
    		master.feed(dog);
    	}
    }
    

    运行之后的结果为:我们先调用了主人类,然后使用主人类里的方法进行了子类方法的调用,如果子类没有这个方法,而父类有,那么会调用父类。(与继承一样,重写的方法优先级最高)
    在这里插入图片描述

    向上转型 <父类型> <引用变量名> = new <子类型>();(多态核心概念
    以上方的类为例
    Animal a = new Dog();
    此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法。
    注意:此时通过父类引用变量无法调用子类特有的方法,只能调用父类的属性方法
    向下转型 <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
    Animal a = new Dog();
    Dog dog = (Dog)a把引用父类的实例a强制转换为子类类型
    将一个指向 子类对象的父类引用 赋给一个子类的引用, 即:父类类型转换为 子类类型。需强制类 型转换
    注意:在向下转型的过程中,如果没有转换为真实子类类型,会出现类型转换 异常

    关注我,点赞它,你就可以收到我持续更新的Java知识,快快来到阿斗学Java,教你最简单的java学习方法

    展开全文
  • 多态案例三-电脑组装

    2021-05-27 19:52:54
    多态案例三-电脑组装 案例描述: 电脑的主要组成部件为CPU,显卡,内存条,将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商,创建电脑类提供让电脑工作的函数,并且调用每...

    多态案例三-电脑组装

    • 案例描述:
      电脑的主要组成部件为CPU,显卡,内存条,将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商,创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口,测试时组装三台不同的电脑进行工作。

    代码演示

    在这里插入代码片#include<iostream>
    using namespace std;
    
    //抽象不同零件类
    //抽象CPU类
    class CPU
    {
    public:
    	//抽象计算函数
    	virtual void cacluate()  = 0;
    };
    
    //抽象显卡类
    class videocaed
    {
    public:
    	//抽象计算函数
    	virtual void display() = 0;
    };
    
    //抽象内存条类
    class memory
    {
    public:
    	//抽象计算函数
    	virtual void storage() = 0;
    };
    
    //电脑类
    class computer
    {
    public:
    	computer(CPU *C,videocaed *v, memory *m)
    	{
    		m_cpu = C;
    		m_vc = v;
    		m_mem = m;
    	}
    
    	//工作函数
    	void work()
    	{
    		m_cpu->cacluate();
    
    		m_vc->display();
    
    		m_mem->storage();
    	}
    	//提供析构函数,释放三个电脑零件
    	~computer()
    	{
    		if (m_cpu != NULL)
    		{
    			delete m_cpu;
    			m_cpu = NULL;
    		}
    		if (m_vc != NULL)
    		{
    			delete m_vc;
    			m_vc = NULL;
    		}
    		if (m_mem != NULL)
    		{
    			delete m_mem;
    			m_mem = NULL;
    		}
    	}
    
    
    private:
    	CPU *m_cpu;//CPU的零件指针
    	videocaed *m_vc;//显卡零件指针
    	memory *m_mem;//内存条零件指针
    };
    
    //具体厂商
    //Intel厂商
    class intelcpu :public CPU
    {
    public:
    	virtual void cacluate()
    	{
    		cout << "intel的cpu开始计算了" << endl;
    
    	}
    };
    class intelvideocard :public videocaed
    {
    public:
    	virtual void display()
    	{
    		cout << "intel的显卡开始显示了" << endl;
    
    	}
    };
    class intelmemory :public memory
    {
    public:
    	virtual void storage()
    	{
    		cout << "intel的内存条开始存储了" << endl;
    
    	}
    };
    //Lenovo厂商
    class Lenovocpu :public CPU
    {
    public:
    	virtual void cacluate()
    	{
    		cout << "Lenovo的cpu开始计算了" << endl;
    
    	}
    };
    class Lenovovideocard :public videocaed
    {
    public:
    	virtual void display()
    	{
    		cout << "Lenovo的显卡开始显示了" << endl;
    
    	}
    };
    class Lenovomemory :public memory
    {
    public:
    	virtual void storage()
    	{
    		cout << "Lenovo的内存条开始存储了" << endl;
    
    	}
    };
    
    void test01()
    {
    	//第一台电脑零件
    	CPU *cpu = new intelcpu;
    	videocaed *ilvc = new intelvideocard;
    	memory *ilmem = new intelmemory;
    
    	//创建第一台电脑
    	computer *computer1 = new computer(cpu,ilvc, ilmem);
    	computer1->work();
    	delete computer1;
    
    	//创建第二台电脑
    	computer *computer2 = new computer(new Lenovocpu,new Lenovovideocard,new Lenovomemory);
    	computer2->work();
    	delete computer2;
    
    	//创建第三台电脑
    	computer *computer3 = new computer(new Lenovocpu, new intelvideocard, new Lenovomemory);
    	computer3->work();
    	delete computer3;
    
    }
    
    
    
    int main()
    {
    	test01();
    
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 多态案例二-制作饮品 案例描述: 制作饮品的大致流程为:

    多态案例二-制作饮品


    案例描述:
    制作饮品的大致流程为:煮水-冲泡-倒入杯中-加入辅料
    利用多态技术实现案例,提供抽象制作饮品基类,提供子类制作咖啡喝茶叶

    #include <iostream>
    using namespace std;
    //多态案例2 制作饮品
    class AbstractDrinking
    {
    public:
    	//煮水
    	virtual void Boil() = 0;
    	//冲泡
    	virtual void Brew() = 0;
    	//倒入杯中
    	virtual void PourInCup() = 0;
    	//加入辅料
    	virtual void PutSomething()= 0;
    	//制作饮品
    	void makeDrink()
    	{
    		Boil();
    		Brew();
    		PourInCup();
    		PutSomething();
    	}
    };
    //制作咖啡
    class Coffee :public AbstractDrinking
    {
    public:
    	//煮水
    	virtual void Boil()
    	{
    		cout << "煮水" << endl;
    	}
    	//冲泡
    	virtual void Brew()
    	{
    		cout << "冲泡咖啡" << endl;
    	}
    	//倒入杯中
    	virtual void PourInCup()
    	{
    		cout << "倒入杯中" << endl;
    	}
    	//加入辅料
    	virtual void PutSomething()
    	{
    		cout << "加入糖和牛奶" << endl;
    	}
    };
    //制作茶叶
    class Tea :public  AbstractDrinking
    {
    public:
    	//煮水
    	virtual void Boil()
    	{
    		cout << "煮水" << endl;
    	}
    	//冲泡
    	virtual void Brew()
    	{
    		cout << "冲泡茶叶" << endl;
    	}
    	//倒入杯中
    	virtual void PourInCup()
    	{
    		cout << "倒入杯中" << endl;
    	}
    	//加入辅料
    	virtual void PutSomething()
    	{
    		cout << "加入枸杞" << endl;
    	}
    };
    //制作函数
    void doWork(AbstractDrinking* abs)//
    {
    	abs->makeDrink();
    	delete abs;//释放
    }
    void test01()
    {
    	//制作咖啡
    	doWork(new Coffee);
    	//制作茶叶
    	doWork(new Tea);
    }
    int main()
    {
    	test01();
    }
    
    展开全文
  • 多态案例-计算器类普通实现多态实现 案列描述: 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类 多态的优点: 1.代码组织结构清晰 2.可读性强 3.利于前期和后期的扩展维护 普通实现 #include &...
  • 多态案例一计算器类 案例描述: 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类 多态的优点: 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 示例: //普通实现 class Calculator ...
  • 文章目录多态目标多态案例演练 目标 多态 面向对象三大特性 封装 根据职责 将 属性 和 方法 到一个抽象的 类 中 `定义类的准则 继承 实现代码的重用 ,相同的代码不需要重复的编写 设计类的技巧 子类针对...
  • 4.7.2 多态案例--计算器类案例描述多态的优点示例 案例描述 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类 多态的优点 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 ...
  • //多态案例二:饮品制作:煮水 泡水 // // // // // class AbstractDr { public: //煮水 virtual void Boil() = 0; //冲泡 virtual void Brew() = 0; //倒入杯中 virtual void PourCup() = 0; //加辅料 ...
  • 多态案例二-制作饮品 案例描述: 制作饮品的大致流程为:煮水 - 冲泡 - 倒入杯中 - 加入辅料 利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶叶 示例: //抽象制作饮品 class ...
  • 此资源为Java中多态组件相关案例及源代码,可用于辅助教师进行相关内容的备课,也可方便学生对相关内容进行学习及巩固。
  • 12.7.5 多态案例-制作饮品 制作饮品大致都是四个步骤: 煮水 - 冲泡 - 倒入杯中 - 加入辅料 不同的是, 制作咖啡时是冲泡咖啡,加入的辅料是牛奶 制作茶时,冲泡的时茶叶,加入的辅料是柠檬 我们写一个多态案例...
  • 多态案例二-制作饮品 案例描述:制作饮品的大致流程为:煮水 - 冲泡 - 倒入杯中 - 加入辅料 利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶叶。 #include <iostream> using namespace...
  • Java面向对象的多态案例 矩形:横坐标、纵坐标、长度、宽度; 圆形:横坐标、纵坐标、半径; 写一个方法要求既能打印矩形又能打印圆形图形父类:shapepublic class Shape { private int x; private int y; ...
  • 多态与多态案例

    2016-08-26 09:33:13
    多态的思想 面向对象3大概念 封装: 突破c函数的概念....用类做函数参数的时候,可以使用对象的属性 和对象的方法 继承: A B 代码复用 多态 : 可以使用未来... 多态很重要 实现多态的三个条件 好比C语言 间接...
  • 多态案例三-电脑组装 案例描述: 电脑主要组成部件为 CPU(用于计算),显卡(用于显示),内存条(用于存储) 将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商 创建电脑类...
  • 多态案例3-电脑组装 案例描述: 电脑主要组成部件为 CPU(用于计算),显卡(用于显示),内存条(用于存储)将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商创建电脑类...
  • //多态案例三-电脑组长 //案例描述: //电脑主要组成部件为CPU(用于计算),显卡(用于显示),内存条(用于存储) //将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel产商 /和Lenovo厂商...
  • C++多态案例

    2019-09-03 23:58:56
    案例: 当基类A中的虚函数f2()被基类的成员函数f1()调用,在派生类B中实现函数f2()的多态,在main()函数中定义一个类B的对象b,执行b.f1(),查看结果。 #include <iostream> #include<map> using ...
  • Java 多态案例

    2019-07-13 18:02:00
    多态的方式写一个宠物生病看医生的例子 |--实现方式 采用多态实现 |--代码内容 1 public class Pet { 2 private String name = "无名氏";// 昵称 3 private int health = 100;// 健康值 4 private ...
  • 多态案例实战

    2020-05-10 10:51:37
    积少成多
  • 多态案例1 计算机类

    2021-01-28 12:07:10
    案例描述: 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类普通写法多态技术 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类) 普通写法 #include <iostream> using ...
  • 多态案例-计算器类

    2021-02-02 17:09:53
    案例描述: 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类 多态的优点: 1.代码组织结构清晰 1.可读性强 1.利于前期和后期的扩展以及维护 代码示例: #include <iostream> using ...
  • #include<... 4.7.2 多态案例--计算器类 案例描述: 分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类 多态的优点: 代码组织结构清晰 可读性强 利于前期和后期的扩展.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,953
精华内容 8,781
关键字:

多态案例