精华内容
下载资源
问答
  • 多态意味着很多形式

    2016-09-15 15:55:00
    1 import java.util.*; 2 3 public class SixDuo { 4 public void eat(){ 5 System.out.println("狗狗吃骨头"); 6 } 7 public static void main(String[] args){ 8 ArrayL...
     1 import java.util.*;
     2 
     3 public class SixDuo {
     4     public void eat(){
     5         System.out.println("狗狗吃骨头");
     6     }
     7     public static void main(String[] args){
     8         ArrayList<Object> myAL = new ArrayList<Object>();
     9         SixDuo Dogc = new SixDuo();
    10         Object obj = new Object();
    11         myAL.add(Dogc); //加入myAL
    12         myAL.add(obj);
    13         Object o = myAL.get(0); //取出在myAL里排第一位的Dogc
    14         SixDuo d1 = (SixDuo)o; //将类型转换成SixDuo
    15         d1.eat();
    16         if(o instanceof SixDuo){ //为了防止o取出的不一定是SixDuo类型而进行判断
    17             SixDuo d2 = (SixDuo) o;
    18             d2.eat();
    19         }
    20     }
    21     
    22 }

    转载于:https://www.cnblogs.com/saimeco/p/5874948.html

    展开全文
  • 多态

    2019-08-23 15:49:16
    多态意味着父类变量可以指向子类对象,简单来说,多态意味着父类的变量可以引用子类的对象。 同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的...

    多态

    多态意味着父类变量可以指向子类对象,简单来说,多态意味着父类的变量可以引用子类的对象。

    同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。

    方法可以在沿着继承链的多个类中实现。
    匹配方法的签名和绑定方法的实现是两个不同的问题。引用变量的声明类型决定了编译是匹配哪个方法。在编译是,编译器会根据参数类型。参数个数和参数顺序找到匹配的方法。一个方法可能在沿着继承连的多个类中实现。Java虚拟机在运行时动态绑定方法的实现,这是由变量的实际类决定的。

    展开全文
  • C++ 多态

    2018-11-17 16:08:41
    C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。 下面的实例中,基类 Shape 被派生为两个类,如下所示: #include &lt;iostream&gt; using namespace std; class Shape ...

    C++ 多态

    多态按字面的意思就是多种形态。当类之间存在层次结构,并且类之间是通过继承关联时,就会用到多态。

    C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。

    下面的实例中,基类 Shape 被派生为两个类,如下所示:

    #include <iostream> 
    using namespace std;
     
    class Shape {
       protected:
          int width, height;
       public:
          Shape( int a=0, int b=0)
          {
             width = a;
             height = b;
          }
          int area()
          {
             cout << "Parent class area :" <<endl;
             return 0;
          }
    };
    class Rectangle: public Shape{
       public:
          Rectangle( int a=0, int b=0):Shape(a, b) { }
          int area ()
          { 
             cout << "Rectangle class area :" <<endl;
             return (width * height); 
          }
    };
    class Triangle: public Shape{
       public:
          Triangle( int a=0, int b=0):Shape(a, b) { }
          int area ()
          { 
             cout << "Triangle class area :" <<endl;
             return (width * height / 2); 
          }
    };
    // 程序的主函数
    int main( )
    {
       Shape *shape;
       Rectangle rec(10,7);
       Triangle  tri(10,5);
     
       // 存储矩形的地址
       shape = &rec;
       // 调用矩形的求面积函数 area
       shape->area();
     
       // 存储三角形的地址
       shape = &tri;
       // 调用三角形的求面积函数 area
       shape->area();
       
       return 0;
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    Parent class area
    Parent class area

    导致错误输出的原因是,调用函数 area() 被编译器设置为基类中的版本,这就是所谓的静态多态,或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定,因为 area() 函数在程序编译期间就已经设置好了。
    但现在,让我们对程序稍作修改,在 Shape 类中,area() 的声明前放置关键字 virtual,如下所示:

    class Shape {
       protected:
          int width, height;
       public:
          Shape( int a=0, int b=0)
          {
             width = a;
             height = b;
          }
          virtual int area()
          {
             cout << "Parent class area :" <<endl;
             return 0;
          }
    };

    修改后,当编译和执行前面的实例代码时,它会产生以下结果:

    Rectangle class area
    Triangle class area

    此时,编译器看的是指针的内容,而不是它的类型。因此,由于 tri 和 rec 类的对象的地址存储在 *shape 中,所以会调用各自的 area() 函数。

    正如您所看到的,每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。有了多态,您可以有多个不同的类,都带有同一个名称但具有不同实现的函数,函数的参数甚至可以是相同的。

    虚函数

    虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时,会告诉编译器不要静态链接到该函数。

    我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数,这种操作被称为动态链接,或后期绑定

    纯虚函数

    您可能想要在基类中定义虚函数,以便在派生类中重新定义该函数更好地适用于对象,但是您在基类中又不能对虚函数给出有意义的实现,这个时候就会用到纯虚函数。

    我们可以把基类中的虚函数 area() 改写如下:

    class Shape {
       protected:
          int width, height;
       public:
          Shape( int a=0, int b=0)
          {
             width = a;
             height = b;
          }
          // pure virtual function
          virtual int area() = 0;
    };

     

    展开全文
  • c++多态

    2021-05-07 19:10:48
    C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。 #include<iostream> using namespace std; class shape { protected: double width; double length; public: shape(double ...

    多态按字面的意思就是多种形态。当类之间存在层次结构,并且类之间是通过继承关联时,就会用到多态。
    C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。

    #include<iostream>
    using namespace std;
    class  shape
    {
    protected:
    	double width;
    	double length;
    public:
    	 shape(double a,double b);
    	// void area()
    	// {
    	//	 cout << "parent class" << endl;
    	// }
    	//~ shape();
    	virtual void area()
    	 {
    		 cout << "parent class" << endl;
    	 }
    	 ~shape();
    };
    shape::shape(double length,double width)
    {
    	this->length = length;
    	this->width = width;
    }
    class  rectangle :public shape
    {
    public:
    	rectangle(double length, double width) :shape(length, width)
    	{
    
    	}
    	//void area()
    	//{
    	//	cout << "rectangle class" << endl;
    	//}
    	virtual void area()
    	{
    		cout << "rectangle class" << endl;
    	}
    };
    class  triangle:public shape
    {
    public:
    	triangle(double length, double width) :shape(length, width)
    	{
    
    	}
    	//void area()
    	//{
    	//	cout << "tritangle class" << endl;
    	//}
     virtual void area()
    	{
    		cout << "tritangle class" << endl;
    	}
    };
    int main()
    {
    	shape* pshape=new rectangle(1,2);
    	pshape->area();
    	pshape = new triangle(2, 3);
    	pshape->area();
    	return 0;
    }
    
    

    导致错误输出的原因是,调用函数 area() 被编译器设置为基类中的版本,这就是所谓的静态多态,
    或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定,因为 area() 函数在程序编译期间就已经设置好了。
    但现在,让我们对程序稍作修改,在 Shape 类中,area() 的声明前放置关键字 virtual

    修改后,编译器看的是指针的内容,而不是它的类型。因此,由于 tri 和 rec 类的对象的地址存储在 *shape 中,所以会调用各自的 area() 函数。
    正如您所看到的,每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。有了多态,
    您可以有多个不同的类,都带有同一个名称但具有不同实现的函数,函数的参数甚至可以是相同的。

    虚函数
    虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时,会告诉编译器不要静态链接到该函数。

    我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数,这种操作被称为动态链接,或后期绑定。

    纯虚函数
    您可能想要在基类中定义虚函数,以便在派生类中重新定义该函数更好地适用于对象,
    但是您在基类中又不能对虚函数给出有意义的实现,这个时候就会用到纯虚函数。
    1、纯虚函数声明如下: virtual void funtion1() = 0; 纯虚函数一定没有定义,纯虚函数用来规范派生类的行为,即接口。
    包含纯虚函数的类是抽象类,抽象类不能定义实例,
    但可以声明指向实现该抽象类的具体类的指针或引用。
    2、虚函数声明如下:virtual ReturnType FunctionName(Parameter) 虚函数必须实现,如果不实现,编译器将报错,错误提示为:
    error LNK * ***: unresolved external symbol “public: virtual void __thiscall ClassName::virtualFunctionName(void)”
    3、对于虚函数来说,父类和子类都有各自的版本。由多态方式调用的时候动态绑定。
    4、实现了纯虚函数的子类,该纯虚函数在子类中就编程了虚函数,子类的子类即孙子类可以覆盖该虚函数,由多态方式调用的时候动态绑定。
    5、虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。
    6、在有动态分配堆上内存的时候,析构函数必须是虚函数,但没有必要是纯虚的。
    7、友元不是成员函数,只有成员函数才可以是虚拟的,因此友元不能是虚拟函数。但可以通过让友元函数调用虚拟成员函数来解决友元的虚拟问题。
    8、析构函数应当是虚函数,将调用相应对象类型的析构函数,因此,如果指针指向的是子类对象,将调用子类的析构函数,然后自动调用基类的析构函数。

    C++多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数;
    形成多态必须具备三个条件:
    1、必须存在继承关系;
    2、继承关系必须有同名虚函数(其中虚函数是在基类中使用关键字Virtual声明的函数,在派生类中重新定义基类中定义的虚函数时,会告诉编译器不要静态链接到该函数);
    3、存在基类类型的指针或者引用,通过该指针或引用调用虚函数;

    展开全文
  • C++多态

    2019-04-12 20:03:04
    C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。 静态链接(静态多态) 函数调用在程序执行前就准备好了。有时候这也被称为早绑定。 #include <iostream> using namespace std;...
  • Java 多态

    2021-05-18 14:29:25
    目录多态的基本概念多态存在的三个必要条件继承重写父类引用指向子类对象(向上转型)多态的实现多态的优缺点 ...多态意味着父类的变量可以指向子类对象。多态是同一个行为具有多个不同表现形式或形态的能力,就是同一
  • Python多态

    2013-10-21 10:58:58
    多态是面向对象语言的一个基本特性,多态意味着变量并不知道引用的对象是什么,根据引用对象的不同表现不同的行为方式。
  • java多态

    2020-11-24 16:21:36
    简单来说,多态意味着父类型的变量可以引用子类型的变量。 2、多态的前提条件 要有继承关系 要有方法重写 要有父类引用指向子类对象 3、多态的优点 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 ...
  • c++ 多态

    2019-09-28 15:41:28
    一、多态 ...C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数 #include <iostream> using namespace std; class Shape { protected: int width, heigh...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,703
精华内容 18,281
关键字:

多态意味着