运行时多态和编译时多态

多态：多态的概念比较简单，就是同一 *** 作作用于不同的对象，可以有不同的解释，产生不同

的执行结果。

运行时多态：重写就是一种运行时多态。只有在运行过程中才能清楚调用的是具体的那个方法。

重写的情况：

public class Dog {

        public void bark(){

            Systemoutprintln("woof ");

        }

  private static  class Hound extends Dog{

        public void sniff(){

            Systemoutprintln("sniff ");

        }

        public void bark(){

            Systemoutprintln("bowl"); }

    }

    public static void main(String [] args){

            Dog dog = new Hound();

            dogbark();

            Dog dog1=new Dog();

            dog1bark();

        }

    }

输出结果是：

bowl

woof

父类引用指向子类对象情况：

public class Parent{

public void call(){

sout("im Parent");

}

}

public class Son extends Parent{// 1有类继承或者接口实现

public void call(){// 2子类要重写父类的方法

sout("im Son");

}

}

public class Daughter extends Parent{// 1有类继承或者接口实现

public void call(){// 2子类要重写父类的方法

sout("im Daughter");

}

}

public class Test{

public static void main(String[] args){

Parent p = new Son(); //3父类的引用指向子类的对象

Parent p1 = new Daughter(); //3父类的引用指向子类的对象

pcall();

p1call();

}

}

输出结果是：

im son

im Daughter

同样是 Parent 类的实例，pcall 调用的是 Son 类的实现、p1call 调用的是 Daughter 的实现。这里因为是自己定义的，所以可以在new对像的过程中就能明白p是son，p1是daughter。但是有的时候，我们无法直观看到new对象的过程。比如说工厂模式、Spring的ioc。所以只有在程序运行的过程才能够清楚具体调用的是谁的方法。

编译时多态：Java中重载就是一种编译时多态。程序处在编译期间，通过参数的不同来决定具体调用的是那个方法。

思考：重载一定是发生在同一个类中吗？子类是否可重载父类的方法？

多态首先是建立在继承的基础上的，先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。

简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

：

多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。C++中的多态性具体体现在运行和编译两个方面。运行时多态是动态多态，其具体引用的对象在运行时才能确定。编译时多态是静态多态，在编译时就可以确定对象使用的形式。

多态：同一 *** 作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板（重载和多态无关）。

OC中的多态：不同对象对同一消息的不同响应子类可以重写父类的方法。

多态就是允许方法重名 参数或返回值可以是父类型传入或返回。

多态也指生物学中腔肠动物的特殊的生活方式。水螅态与水母态的世代交替现象。

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。

使用继承性的结果就是当创建了一个类的家族，在认识这个类的家族时，就是把子类的对象当作基类的对象，这种认识又叫作upcasting（向上转型）。这样认识的重要性在于：我们可以只针对基类写出一段程序，但它可以适应于这个类的家族，因为编译器会自动找出合适的对象来执行 *** 作。这种现象又称为多态性。而实现多态性的手段又叫称动态绑定(dynamic binding)。

简单的说，建立一个父类对象的引用，它所指对象可以是这个父类的对象，也可以是它的子类的对象。java中当子类拥有和父类同样的函数，当通过这个父类对象的引用调用这个函数的时候，调用到的是子类中的函数。

多态是一种编程技巧

它增加论了程序的可扩展性

比如你要做个篮子放水果，你当然不希望造这样的篮子--苹果篮子，橘子篮子，梨篮子，正常人都会想，麻烦啊，我就造个篮子，什么都能放，干嘛造那么多啊？

回归程序：你造个篮子 basket（）；参数是水果 fruit，这样你调用的时候就可以这样 basket（fruit f）；然后往里放苹果啊，梨啊，什么都行，只要是水果类的子类

好处：这样设计你的程序，等你的参数变了的时候，只要还是水果，你就不用去改程序了，这就是可扩展性的体现

fruit f = apple a

这就是一个多态的应用

多态应用的三个条件：

继承 （apple当然继承了fruit）

子类对象指向父类引用（a是apple的一个对象，f是fruit类父类的一个引用）

重写（就是子类重写父类继承来的方法。父类实现了一个方法，他不一定适合子类，因为如果适合你也就不用重新定义一个类了，用父类就行了。这时就需要去重新写一个方法，实现新的功能）

另外,虚机团上产品团购,超级便宜

建立抽象父类Car，提供抽象Sale()方法，另三种车继承此Car并重写Sale()方法，另建立CarShop类，建立一个Saler(Car CarInfo)，每次调用时传入建立的三种车的实例对象，另一个Total方法是把Car类中Count属性和Price属性计算一下。是在C#的控制台程序下写的，其实方法思路很多。

    {

        static void Main(string[] args)

        {

            CarShop carShop = new CarShop();

            carShopSaler(carShopBWMSaler); //出售BWM

            carShopSaler(carShopBWMSaler);

            carShopSaler(carShopCheryQQSaler); //出售CheryQQ

            carShopSaler(carShopAudiSaler); //出售Audi

            carShopSaler(carShopAudiSaler);

            carShopSaler(carShopAudiSaler);

            carShopTotal(); //统计

            ConsoleReadLine();

        }

    }

    //==============================

    //抽象父类

    public abstract class Car

    {

        //建立的车销售量

        public int Count { get; set; }

        //建立的单价

        public int Price { get; set; }

        //建立抽象的车销售方法

        public abstract void Sale();

    }

    //BWM车类

    public class BWM : Car

    {

        //重写即多态，BWM的自己的销售方法

        public override void Sale()

        {

            ConsoleWriteLine("出售一辆BWM车！");

        }

        //BWM类实例化对象时，将销售量和单价重置

        public BWM()

        {

            Count = 0;

            Price = 100000;

        }

    }

    //QQ车类

    public class CheryQQ : Car

    {

        //重写QQ自己的销售方法

        public override void Sale()

        {

            ConsoleWriteLine("出售一辆CheryQQ车！");

        }

        //QQ类实例化对象时，将销售量和单价重置

        public CheryQQ()

        {

            Count = 0;

            Price = 50000;

        }

    }

    //Audi车类

    public class Audi : Car

    {

       //重写Audi自己的销售方法

        public override void Sale()

        {

            ConsoleWriteLine("出售一辆Audi车！");

        }

        //Audi类实例化对象时，将销售量和单价重置

        public Audi()

        {

            Count = 0;

            Price = 80000;

        }

    }

    //CarShop类

    public class CarShop

    {

        //建立本店的BWM销售者，属性

        private BWM _bwmSaler = new BWM();

        public BWM BWMSaler { get { return _bwmSaler; } }

        //建立本店的QQ销售者

        private CheryQQ _cheryQQSaler = new CheryQQ();

        public CheryQQ CheryQQSaler { get { return _cheryQQSaler; } }

        //建立本店的Audi销售者

        private Audi _audiSaler = new Audi();

        public Audi AudiSaler { get { return _audiSaler; } }

        //本店的销售方法，参数为要销售本店的哪个产品，即上面定义的三个销售者

        public void Saler(Car CarInfo)

        {

            //由于三个车都是继承的Car这个抽象类，而每个子类都重写了抽象类的

            //Sale()方法，从而实现了多态调用

            CarInfoSale();

            CarInfoCount++; //每次销售量+1

        }

        public void Total()

        {

            //简单的统计

            ConsoleWriteLine("BWM已经销售了：{0}台，总销售额：{1}元", BWMSalerCount, BWMSalerCount  BWMSalerPrice);

            ConsoleWriteLine("CheryQQ已经销售了：{0}台，总销售额：{1}元", CheryQQSalerCount, CheryQQSalerCount  CheryQQSalerPrice);

            ConsoleWriteLine("Audi已经销售了：{0}台，总销售额：{1}元", AudiSalerCount, AudiSalerCount  AudiSalerPrice);

        }

    }

c++是一种编程语言，当然只有一种。但是基于c++的编程平台有很多种。

在这些平台上编程序，用的语言是c++的，但是在一些细节上会有所不同。我接触过的主要有vc++，symbian c++，borland c++，它们都是基于c++的，但是编程风格或方式稍有不同。

你学c++要打好基础，先学好c++语言。看书的时候可以找一些书名为“c++编程语言”之类的书，只有在学好c++语言后，才可以去具体的学习某个平台的编程教程。

一般来说，多态分为两种，静态多态和动态多态。静态多态也称编译时多态，主要包括模板和重载。而动态多态则是通过类的继承和虚函数来实现，当基类和子类拥有同名同参同返回的方法，且该方法声明为虚方法。

当基类对象，指针，引用指向的是派生类的对象的时候，基类对象，指针，引用在调用基类的虚函数，实际上调用的是派生类函数。这就是动态多态。

静态多态的实现。

静态多态靠编译器来实现，简单来说就是编译器对原来的函数名进行修饰，在c语言中，函数无法重载，是因为，c编译器在修饰函数时，只是简单的在函数名前加上下划线”_” ,不过从gcc编译器编译之后发现函数名并不会发生变化。

而c++编译器不同，它根据函数参数的类型，个数来对函数名进行修饰，这就使得函数可以重载，同理，模板也是可以实现的，针对不同类型的实参来产生对应的特化的函数，通过增加修饰，使得不同的类型参数的函数得以区分。

#include<iostream>

#include<cmath>

using namespace std;

class Shape{

private:

public:

virtual double S() = 0;

virtual double C() = 0;

};

class Tri: public Shape{

private:

double r1,r2,r3;

public:

Tri(double d1 = 0, double d2 = 0, double d3 = 0):r1(d1),r2(d2),r3(d3){};

double S(){return(sqrt(05(r1 + r2 + r3)05(r1 - r2 + r3)05(r1 + r2 - r3)05(- r1 + r2 + r3)));}

double C(){ return (r1 + r2 + r3);}

};

class Cir: public Shape{

private:

double rad;

public:

Cir(double dd):rad(dd){};

double S(){ return (314 rad rad);}

double C(){ return (2 314 rad);}

};

int main(){

Shape a = new Tri(3,4,5);

Shape b = new Cir(2);

cout << a->C() << endl;

cout << a->S() << endl;

cout << b->C() << endl;

cout << b->S() << endl;

return 0;

};

以上就是关于运行时多态和编译时多态全部的内容，包括:运行时多态和编译时多态、什么是多态、什么是多态，多态的概念，多态的体现，多态的应用等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！