多态性的案例（怎么来理解c#多态性，举个简单的例子吧！）

本文目录

• 怎么来理解c#多态性，举个简单的例子吧！
• c++最简单的多态例子，class A.classb
• 一个C#多态的例子
• JAVA基础谁给我举个例子，好一点的关于JAVA的多态
• 多态的例子
• 怎么来理解c#多态性，举个简单的例子吧
• 求java中几个继承与多态实例，并要有相应的题目！给我参考和练习下，本人新手，不宜难的
• C++多态性实验 定义一个抽象类—容器内container，其中定义了若干纯虚函数，实现求表面积，体积输出功能
• 求一个猫狗多态案例的java程序，谢谢
• 谁能跟我说几个JAVA多态，在现实生活中应用的例子，不要说代码和概念，就只说案例

怎么来理解c#多态性，举个简单的例子吧！

多态性是指相同的操作或方法可在用于多种类型的对象，并获得不同的结果。 如果多个子类继承同一个父类，不同子类的相同的方法可能有不同的表现形式并得到不同的结果。多态性允许每个对象以适合自身的方式去响应相同的消息。 多态性是通过继承来实现的。多态性增强了软件的灵活性和重用性在具有继承关系的类中，不同对象的相同的函数成员可以具有不同的实现，因而会产生不同的执行结果，这就是多态。 多态有两种: 一种是编译时的多态，也就是指方法的重载； 另一种是运行时的多态， 通过继承和虚成员来实现的。运行时的多态性是指系统在编译时不确定选用哪个重载方法，而是直到程序运行时，才根据实际情况决定采用哪个重载方法。

c++最简单的多态例子，class A.classb

C++中的多态（虽然多态不是C++所特有的，但是C++中的多态确实是很特殊的）分为静多态和动多态（也就是静态绑定和动态绑定两种现象），静动的区别主要在于这种绑定发生在编译期还是运行期，发生在编译期的是静态绑定，也就是静多态；发生在运行期的则是动态绑定，也就是动多态。静多态可以通过模板和函数重载来实现（之所说C++中的多态主要还是因为模板这个东西），下面举两个例子：1）函数模板template 《typename T》T max(const T& lsh, const T& rhs) { return (lsh 》 rhs) ? lsh : rhs;}返回两个任意类型对象的最大值（对象），前提是该类型能够使用》运算符进行比较，并且返回值是bool类型。使用：int a = 3; int b = 4;cout 《《 max(a, b) 《《 endl;float c = 2.4; float d = 1.2;cout 《《 max(c, d) 《《 endl;输出结果为： 4 2.4这种绑定发生在编译期，这是由于模板的实例化是发生在编译期的，即在编译时编译器发现你调用max(a, b)时就自动生成一个函数int max(const int& lsh, const int& rhs) { return (lsh 》 rhs) ? lsh : rhs;}即将所有的T替换成int;当你调用max(c, d)时就自动生成一个函数float max(const float& lsh, const float& rhs){ return (lsh 》 rhs) ? lsh : rhs;}之所以说开始的函数定义是函数模板，就是因为他就像个模子似的，你可以用铝作为原料也可以用石膏或者铜。2）函数重载：int max (int a, int b){ return (a 》 b) ? a : b;}int max (int a, int b, int c){ return max(max(a, b), c);}两个函数名称一样，参数类型或个数不完全相同，返回值一样（这个不重要）。使用：int a = 3, b = 4, c = 5;cout 《《 max(a, b) 《《 endl;cout 《《 max(a, b, c) 《《 endl;输出结果为： 4 5确定函数的过程也发生在编译器，当你使用max(a, b)，编译器发现只有两个参数，那么就调用只有两个参数的函数版本，当使用max(a, b, c)时，编译器则使用有3个参数的版本。通过上面的两个例子，你还可以使用更为方便的模板函数重载：template 《typename T》T max(const T& lsh, const T& rhs) { return (lsh 》 rhs) ? lsh : rhs;}template 《typename T》T max(const T& a, const T& b, const T& c){ return max(max(a, b), c);}使用float a = 3.6, b = 1.2, c = 7.8;cout 《《 max(a, b, c) 《《 endl;输出： 7.8通过参数个数和类型，编译器自动生成和调用对应得函数版本！动多态则是通过继承、虚函数(virtual)、指针来实现。class A {public: virtual void func() const { coust 《《 “A::func()” 《《 endl; }}class B : public A {public: virtual void func() const { coust 《《 “B::func()” 《《 endl; }}使用：A a* = B();a-》func();输出： B::func()编译期是不调用任何函数的，编译器编译到a-》func()时只是检查有没有语法问题，经过检查没有。编译器并不知道调用的是A版本的func()还是B版本的func()，由于a是一个指向B对象的指针，所以a只知道它指向的是一个A类型（或者能转换成A类型）的对象。通常集成体系就说明了（由于是公有继承）B是一种A。在运行期，a要调用a所指向对象的func()函数，就对它指向的对象下达调用func()的命令，结果a所指向的是一个B对象，这个对象就调用了自己版本（B版）的func()函数，所以输出时B::func()总结：在编译期决定你应该调用哪个函数的行为是静态绑定（static-binding)，这种现象就是静多态。在运行期决定应该调用哪中类型对象的函数的行为是动态绑定（dynamic-binding），这种现象就是动多态

一个C#多态的例子

using System; //调用system类 和C下的include一样using System.Drawing; //调用system.drawing类using _05_Base; //调用自建类05_basenamespace _05_03 //命名空间 05_03{ public class Class_05_03 //公有类05_03{ public static void PrintArea(Shape shape) //公有类 静态 无返回值类 PrintArea(内部数据成员shape,把shape这个单词指定为shape类型，就象int i){ Console.WriteLine("Area of {0} is : {1}", shape.Name, shape.Area); //控制台输出 Area of {0} is : {1} 其中0为shape.Name的数据 1 为shape.Area的数据} public static void Main(String args) // 公有类 静态无返回值 主函数（）{ Point p = new Point(0, 0); 为point 分配一新的空间p(0,0)_05_Base.Rectangle r = new _05_Base.Rectangle(); // 分配一新的空间r ，用05_Base.Rectangle类化r.Name = "Rectangle r"; r.Width = 10; r.Height = 20; //以上3行为新分配的空间r 写入其类的对应值Square s = new Square(); s.Name = "Square s"; s.Side = 15; //用Square 类化s 分配空间 赋值Ellipse e = new Ellipse(); e.Name = "Ellipse e"; e.SemiMajorAxis = 10; e.SemiMinorAxis = 5; //用Ellipse类化e 分配空间 赋值Circle c = new Circle(); c.Name = "Circle c"; c.Radius = 6; Triangle t = new Triangle(); t.Name = "Triangle t"; t.Point1 = new Point(3, 3); t.Point2 = new Point(3, 0); // 这两个自己会看了把？？Shape; shapes = r; shapes = s; shapes = e; shapes = c; shapes = t; foreach(Shape shape in shapes)//Shape shape in shapes不懂这是什么意思 { shape.Position = p; PrintArea(shape); } } } }

JAVA基础谁给我举个例子，好一点的关于JAVA的多态

假设有一个类 叫 鸟类，它拥有属性翅膀，拥有方法鸣叫，如下public class Bird{ private Wing wing; public void moo(){ System.out.println("鸟叫声"); }}鸟类封装了 翅膀类和moo方法；另外有两个类都继承鸟类并重写了moo方法，分别是鹦鹉和麻雀如下：鹦鹉类：public class Parrot extends Bird{ public void moo(){ System.out.println("鹦鹉的叫声"); }}麻雀类：public class Sparrow extends Bird{ public void moo(){ System.out.println("麻雀的叫声"); }}方法重写应该懂吧，不懂自己找书看吧；然后你有个妻子她想听鸟叫，就有个妻子类public class Wife{ public void listen(Bird bird){ bird.moo(); } /*这时多态就很好的体现了，你妻子想听鸟叫，无论什么鸟都可以给她，但是你想让她和鹦鹉 *说话，你就买了一只鹦鹉传给listen方法，结果你妻子听到了鹦鹉的叫声，程序输出：鹦 *鹉的叫声 */ public static void main(String args) { new Wife().listen(new Parrot()); }}多态实现了动态绑定，让程序有了很好的扩展性，比如你以后想买一只燕子送给你妻子，就只需要写个燕子类Swallow继承Bird方法就可以了，而不需要再在妻子类里添加一个方法listen(Swallow swallow)……上面编码没用编译器，可能有错误，请谅解说得够详细了吧，感谢世界上有我这么好的人吧 ^_^

多态的例子

在C++中： classA{public:    A(){}    virtual void foo()    {        cout《《ThisisA.《《endl;    }};classB:publicA{public:    B(){}    void foo()    {        cout《《ThisisB.《《endl;    }};int main(intargc,char*argv){    A* a = new B();    a-》foo();    if(a != NULL)    delete a;    return0;}这将显示：This is B.如果把virtual去掉，将显示：This is A.前面的多态通过使用虚函数virtual void foo()来实现。在java中：多态，是面向对象的程序设计语言最核心的特征。多态，意味着一个对象有着多重特征，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。从程序设计的角度而言，多态可以这样来实现（以java语言为例）： public interface Parent//父类接口{    public void simpleCall();}public class Child_A implements Parent{    public void simpleCall();    {    //具体的实现细节；    }}public class Child_B implements Parent{    public void simpleCall();    {    //具体的实现细节；    }}//当然还可以有其他的实现然后，我们就可以看到多态所展示的特性了：Parent pa = new Child_A();pa.simpleCall()则显然是调用Child_A的方法；Parent pa = new Child_B();pa.simpleCall()则是在调用Child_B的方法。所以，我们对于抽象的父类或者接口给出了我们的具体实现后，pa 可以完全不用管实现的细节，只访问我们定义的方法，就可以了。事实上，这就是多态所起的作用，可以实现控制反转这在大量的J2EE轻量级框架中被用到，比如Spring的依赖注入机制。

怎么来理解c#多态性，举个简单的例子吧

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

多态的定义：同一消息可以根据发送对象的不同而采用多种不同的行为方式。

多态的作用：消除类型之间的耦合关系。

实例：

public abstract class Operation{    public abstract decimal GetResult(decimal va, decimal vb);}public class OperationAdd : Operation{    public override decimal GetResult(decimal va, decimal vb)    {        return va + vb;    }}public class OperationSub : Operation{    public override decimal GetResult(decimal va, decimal vb)    {        return va - vb;    }}public class OperationMul : Operation{    public override decimal GetResult(decimal va, decimal vb)    {        return va * vb;    }}public class OperationDiv : Operation{    public override decimal GetResult(decimal va, decimal vb)    {        return va / vb;    }}public static class OperationFactory{    public static Operation Create(string operate)    {        switch (operate)        {            case "+":                return new OperationAdd();            case "-":                return new OperationSub();            case "*":                return new OperationMul();            case "/":                return new OperationDiv();            default:                throw new ArgumentException("Unknown operator");        }    }} static void Main(string args){    var operation = OperationFactory.Create("-");    var result = operation.GetResult(34, 9);    Console.WriteLine(result.ToString());}

求java中几个继承与多态实例，并要有相应的题目！给我参考和练习下，本人新手，不宜难的

JAVA中一个抽象类抽象方法继承与对象多态性的例子 面向对象的三大特点：封装，继承，多态。在JAVA中我们总是尽可能地让一个类继承一个抽象类，这样大大的节省代码方便开发。一个继承与对象多态性的例子：声明一个Person 类。Student 类，Worker类分别继承Person。人有姓别，年龄，学生有特有的成绩属性，工人有特有的工资。所有属性都用private封装abstract class Person{private String name;private int age;public Person(String name,int age){ this.setName(name); this.setAge(age); }public void setName(String name){ this.name=name; } public void setAge(int age){ this.age=age; } public String getName(){ return this.name; } public int getAge(){ return this.age; }public void say(){ System.out.println(this.getContent()); } public abstract String getContent();}class Worker extends Person{ private float salary; public Worker(String name,int age,float salary){ super(name,age); this.setSalary(salary); } public void setSalary(float salary){ this.salary=salary; } public float getSalary(){ return this.salary; } public String getContent(){ return "工人信息------》姓名："+super.getName()+",年龄："+super.getAge()+"，工资："+this.getSalary(); } } class Student extends Person{ private float score; public Student(String name,int age,float score){ super(name,age); this.setScore(score); } public void setScore(float score){ this.score=score; } public float getScore(){ return this.score; } public String getContent(){ return "学生信息------》姓名："+super.getName()+", 年龄："+super.getAge()+",成绩："+this.getScore(); } } public class OODemo11{ public static void main(String args){ Person p=null; p=new Student("张三",23,90); p.say(); p=new Worker("李师傅",26,3000); p.say(); } }运行结果：学生信息------》姓名：张三, 年龄：23,成绩：90.0工人信息------》姓名：李师傅,年龄：26，工资：3000.0

C++多态性实验 定义一个抽象类—容器内container，其中定义了若干纯虚函数，实现求表面积，体积输出功能

这样：

#include《iostream》

using namespace std;

class container //定义抽象类conyainer

{public:

container(........)

virtual xx(){}; //虚函数

virtual xx(){}; //虚函数

virtual void xxx() const =0; //纯虚函数

private:

.......

};

class xxxx:public container //公用派生类xxxx

{public:

vitual xxxxx{....} //对虚函数再定义

扩展资料：

注意事项

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person.Person买票就是全价，而Student买票就是半价。

那么在继承中要构成多态还需要两个条件：

1、调用函数的对象必须是指针或者引用。

2、被调用的函数必须是虚函数，且完成了虚函数的重写。

虚函数：在类的成员函数前加virtual关键字。

class Person{public:

virtual void BuyTicket()

{

cout 《《 "买票-全价" 《《 endl;

}};

虚函数的重写：派生类中有一个跟基类的完全相同的虚函数，就称子类的虚函数重写了基类的虚函数。“完全相同”是指：函数名、参数、返回值都相同。另外，虚函数的重写也叫做虚函数的覆盖。

求一个猫狗多态案例的java程序，谢谢

代码如下：

abstract class Animal {public abstract void eat();} class Cat extends Animal {@Overridepublic void eat() {System.out.println("爱吃鱼");}public void play() {System.out.println("玩王者荣耀");}}class Dog extends Animal {@Overridepublic void eat() {System.out.println("爱啃骨头");}public void lookDoor() {System.out.println("看门");}}public class App {public static void main(String argv) {Cat cat = new Cat();cat.eat();cat.play();Dog dog = new Dog();dog.eat();dog.lookDoor();}}

谁能跟我说几个JAVA多态，在现实生活中应用的例子，不要说代码和概念，就只说案例

有一个比较经典的多态实例：

有一个Animal类，它有Cat，和Dog两个子类，在Animal中有个say方法，当Cat调用这个方法的时候输出的是“小猫喵喵喵”，当Dog调用这个方法时，输出的是“小狗汪汪汪”，这就是Java多态的实现。

1、定义一种动物，该类型的动物有叫的属性。

2、分别定义猫，狗，鸟，都继承于该动物，都有叫的属性。

3、分别表示出各个具体小动物的叫声，例如猫的叫声：喵、狗的叫声：汪、鸟的叫声：咻，点是叫声，实现各个具体小动物用的叫声的方法是用的同一个函数名称，就是动物的叫声函数。

多态：

这个案例网上是没有的，属于无忌独创，当时在帮孩子辅导作业，小学科学，里面有一点内容是关于人的牙齿，说牙齿分为：门齿、犬齿、臼齿。

问闺女，为什么这么分呢？闺女说牙齿虽然都是用来咬食物，但是食物种类很多，咬碎需要的工具也不一样，门齿用来切割食物，如：苹果、梨；犬齿用来撕碎食物。

如肉类；臼齿用来磨碎食物，如犬齿撕碎的肉类，就需要再用臼齿来磨碎，然后送到食道，胃，小肠，大肠进行消化。我恍然大悟，这不就是Java面向对象里的多态吗？多完美啊。

这也很好说明了为什么会有多态出现，因为生活中就存在太多这种例子，所以需要多态来匹配解决。