精华内容
下载资源
问答
  • 继承性

    2013-07-11 14:42:07
    继承性 1.  基类和派生 1)  继承的几个特性   若间具有继承关系,它们应该有下列几个特性: (1)间具有共享特征。 (2)间具有细微的差别。 (3)间具有层次结构。   2)  ...

    类的继承性

    1.  基类和派生类

    1)  继承的几个特性

     


    若类间具有继承关系,它们应该有下列几个特性:

    (1)类间具有共享特征。

    (2)类间具有细微的差别。

    (3)类间具有层次结构。

     

    2)  派生类的概念

    引入继承的目的,是为了能使代码重用。如果可以利用已编制的程序段,将可以提高编程的效率及程序的可读性。下面通过类CPoint和类CCircle之间的关系来说明C++中类的继承性,通过继承实现了代码的重用。

     


    class CPoint

    {

    private

        int color

    protected

        int x,y

    public

        void show()

        void SetPosition()

    }

     

     

    class CCircle

    {

    private

        int radius

    protected

        int x,y

        int width

    public

        void show()

        void SetPosition()

        double Circumfrence()

    }


     

    类CPoint和类CCircle中的数据成员有许多是相同的,成员函数或者是完全相同的,或者是功能相同的。例如成员变量x、y在类CPoint中表示点的位置,在类CCircle中也如此。又如成员函数SetPosition()的功能是设置成员变量x和y的值,因而在两个类中代码是完全相同的,而成员函数show()在类CPoint中显示一个点,而在类CCirlce中是显示一个圆,因而show()在两个类中的功能是不一样的,其代码显然也是不一样的。由以上分析可以看到类CCircle可以由类CPoint作适当修改和扩充得到,也就是说类CCircle可以从类CPoint继承而来,因而类CCircle可以写成如下形式,图8.2表示了此两个类的继承关系。


     

     

     

     

     

      8.2 类的继承性

    class CCirlce:public CPoint

    {

    private

        int radius

    protected

        int width

    public

        double Circumfrence()

        void show()

    }

    上面的写法中在类名CCirlce后增加了“:public CPoint”,说明类CCircle是从类CPoint继承而来的。这样,凡是在类CPoint中已定义的成员都可以被类CCirlce继承,因而在类CCirlce中只定义了扩充的或将修改的成员数据或函数。CCircle的成员除了新定义的之外,还包含了从类CPoint中继承来的数据成员和成员函数。通常称类CPoint是类CCirlce的基类,或父类、上级类;称类CCircle是类CPoint的派生类或子类、下级类、导出类。

     

    3)  派生类的定义

        派生类的定义格式为:

    class派生类名:继承方式基类名

    {

       定义派生类成员;

    }

        如果是多重继承,派生类的定义格式在后面叙述。

        上述定义中继承方式可以是三个关键字之一:public、private、protected,缺省值为private。派生类有以下几个特点:

    (1)在基类基础上提供新的成员。

    (2)隐藏基类的成员。

    (3)重新定义基类中的成员函数。

     

    2.  单继承

    1)  派生类对基类的继承关系

    在派生类的定义中都必须指明对基类的继承方式,这将决定派生类对基类的访问性质。下面叙述派生类在三种继承方式下是如何继承基类成员的。

    (1)   公有继承方式(public

    基类中的私有成员不可访问(invisible),所谓不可访问就是派生类无法直接使用基类中的私有成员,基类中其它成员访问权限不变。

    (2)   保护继承方式(protected

    基类中的私有成员不可访问,其它成员的访问权限都变成保护的(protected)。

    (3)   私有继承方式(private

    基类中的私有成员不可访问,其它成员的访问权限都变成私有的(private)。

    派生类对基类的访问权限归结起来如表8.1所示。

     

     

     

    表8.1:不同继承方式下派生类对基类的访问权限

    继承方式

    基类访问权限

    派生类访问权限

    public

    (公有继承)

    public

    protected

    private

    public

    protected

    不可访问

    protected

    (保护继承)

    public

    protected

    private

    protected

    protected

    不可访问

    private

    (私有继承)

    public

    protected

    private

    private

    private

    不可访问

     

    例8.1 公有继承示例

    //ex8_1.cpp

    #include "iostream.h"

    class CBass

    {

        int x;

    public:

        void SetX(int i){x=i;}

        int GetX(){return x;}

    };

    class CDerivate:public CBass

    {

        int y;

    public:

        void SetY(int i){y=i;}

        int GetY(){return y;}

        int GetXY(){return y*GetX();}

    };

    void main()

    {

        CBass a;

        CDerivate b;

        a.SetX(5);

        b.SetX(6);

        b.SetY(7);

        cout<<a.GetX()<<endl;

        cout<<b.GetX()<<","<<b.GetY()<<","<<b.GetXY()<<endl;

    }

    程序运行结果为:

        5

        6,7,42

        程序中类CDerivate是类CBass的派生类,是从类CBass公有继承而来,因而在类CDerivate中除新定义的成员外,还继承了基类CBass中的所有成员。图8.5说明了派生类CDerivate是如何继承基类CBass中的成员的,以及继承后类CDerivate中各成员的访问权限。


     

     

     

     

     

     

     

     

     

               8.5 基类与派生类

        由图8.5可知,首先派生类全盘继承了基类中的成员,它们在类中构成了一个独立的块,它们的全体称为派生类的基类子块,简称为基类子块。显然,基类子块内的各成员保持了原先的关系,同时它们还要参与派生类的相关操作。基类子块在派生类中的访问权限可由继承方式及基类子块原先的访问权限共同确定。根据表8.1可以重新确定基类子块成员在派生类中的访问权限。在本例中,由于是公有继承,基类子块中除私有成员外,其它成员的访问权限不变,因而由继承而得到的成员函数SetX()、GetX()仍是公有的,而私有数据成员x是不可访问的。注意:不可访问的意思是指成员变量x虽然存在于派生类CDerivate中,但在派生类中是不可见的,若要显示或更改成员变量x的值,必须通过基类子块中的接口函数才行。本例程序中定义了基类CBass的对象a和派生类CDerivate的对象b,语句:“b.SetX(6);”说明将对对象b的数据成员x赋值,在对象b中没有直接定义成员函数SetX(),但它已从基类中继承而得到成员函数SetX(),该函数是公有的,因而可在主函数中直接调用,不会发生语法错误。进一步分析可以看到,成员函数b.SetX()将对不可访问的成员变量x赋值,对于基类子块而言,SetX()就是一个公有的接口函数,因而它可以访问私有成员x。同理b.GetX()也是个公有接口函数,因而它也可以访问私有成员x。

     

    2)  protected的含义

    例8.3 指出程序中的语法错误

    //ex8_3

    #include "iostream.h"

    class CBass

    {

        int x;

    protected:

        int y;

    public:

        int z;

        void SetX(int i){x=i;}

        void SetY(int i){y=i;}

        void SetZ(int i){z=i;}

    };

    class CDerivate:public CBass

    {

    public:

        void PrintX(){cout<<x<<endl;}//错误:x是不可访问成员

        void PrintY(){cout<<y<<endl;}

        void PrintZ(){cout<<z<<endl;}

    };

    void main()

    {

        CBass A;

        CDerivate B;

        A.SetX(1);

        A.SetY(2);

        A.SetZ(3);

        cout<<A.x<<endl;//错误:不能访问私有成员x

        cout<<A.y<<endl;//错误:不能访问保护成员y

        cout<<A.z<<endl;

        B.SetX(4);

        B.SetY(5);

        B.SetZ(6);

        B.PrintX();//错误:成员函数Print()出错

        B.PrintY();

        B.PrintZ();

        cout<<B.x<<endl;// 错误: x是不可访问成员

        cout<<B.y<<endl;// 错误: 不能访问保护成员y

        cout<<B.z<<endl;


     

     

     

     

     

     

     

     

     

     

      图8.7 例8.3中的派生类

    }

        图8.7中标明了例题中基类子块成员在派生类的访问权限。    程序中主要存在以下两种语法错误:

    (1)  在类外直接使用了类的私有成员或不可访问成员,例如派生类的成员函数

    void PrintX(){Cout<<x<<endl;}使用了不可访问的成员x。主函数中的语句"Cout<<A.x<<endl;"和"Cout<<B.x<<endl;"在类外使用私有成员或不可访问成员x。

    (2)  在类外直接使用了类的保护成员,例如程序中语句:"Cout<<A.y<<endl;"和"Cout<<B.y<<endl;"在类外使用了保护数据成员y。

    删除出错语句,运行程序所得结果为:

        3

        5

        6

        6

        本例在基类CBass中定义了protected(保护)成员y,y可以在派生类CDerivate中被使用,但在类外不可使用。在派生类成员函数 “PrintY(){Cout<<y<<endl;}” 中可以直接使用基类子块中的保护成员y,但不可以在类外使用保护成员y,因而主函数中语句“Cout<<B.y<<endl;”将导致语法错误。当希望基类中的成员可以被派生类的成员使用而不可以在类外被使用,这时可以令成员的访问性质为保护的(protected)。

        通常讲,保护成员对类内成员相当于公有成员,对类外或对象相当于私有成员。在无继承的情况下,保护成员与私有成员的性质完全一样,在存在继承的情况下,保护成员就具有了二重性,有时呈现私有成员的性质,有时呈现公有成员的性质。当讨论的重心是:派生类对象对由继承而得到的成员的访问特性(亦称水平继承)问题时,保护成员呈现为私有成员性质。当讨论的重心是:派生类成员对由继承而得到的成员的访问特性(亦称垂直水平继承)问题时,保护成员呈现为公有成员性质。上节中提出的基类子块概念能方便地处理保护成员的二重性问题。在继承情况下,通过重新确定基类子块各成员的访问性质,从而化解了因继承方式引起的问题,基类子块内各成员除因同名被屏蔽以外,其它各成员与对象的关系与无继承时的情况完全一样。唯一要注意的是这时增加了一种新的访问性质:不可访问性。

     

    3)  派生类的构造函数和析构函数

    每个类中都有显式或隐式的构造函数和析构函数,创建派生类时,派生类将全盘继承基类的数据成员和成员函数,但不继承构造函数和析构函数。因而用户要么在派生类中重新定义构造函数和析构函数,要么使用系统提供的缺省构造函数和析构函数。由于派生类继承了基类的所有成员,在进行初始化时,派生类除了对自身数据成员进行初始化外,还必须对基类子块数据成员进行初始化,因而就涉及到如何在派生类中调用基类的构造函数问题。对于析构函数也有同样的问题。本节主要讨论由于继承引起的这些问题。

        派生类的构造函数的一般格式如下:

        派生类构造函数名(参数总表):基类构造函数(参数表),对象成员名(参数表)

        {   派生类构造函数体    ;  }

        由上述格式可以看到,在派生类构造函数的初始化表中将显式调用基类构造函数,对基类子块数据成员进行初始化,如果派生类中存在对象成员,其初始化也在初始化表中进行。

        析构函数是不带参数的,不存在初始化表,因而其格式与以前叙述的析构函数完全一样。在执行派生类的析构函数后,系统将自动调用基类析构函数。

        派生类中构造函数的调用次序如下:基类的构造函数,成员对象的构造函数,派生类构造函数。析构函数的调用次序与构造函数的调用次序相反,依次为:派生类的析构函数,对象成员的析构函数,基类的析构函数。

       

        例8.4 写出程序运行结果

    //ex8_4.cpp

    #include "iostream.h"

    class CBass

    {

        int x;

    public:

        CBass()

        {

            x=0;

            cout<<"Default bass constructor called.\n";

        }

        CBass(int i)

        {

            x=i;

            cout<<"Bass constructor called.\n";

        }

        ~CBass(){cout<<"Bass destructor called.\n";}

        void Print() const {cout<<x<<endl;}

    };

    class CDerivate:public CBass

    {

        int y;

    public:

        CDerivate()

        {

            y=0;

            cout<<"Default derivate constructor called.\n";

        }

        CDerivate(int i,int j):CBass(j)

        {

            y=i;

            cout<<"Derivate constructor called.\n";

        }

        ~CDerivate(){cout<<"Derivate destructor called.\n";}

        void Print()

        {

            CBass::Print();

            cout<<y<<endl;

        }

    };

    void main()

    {

        CDerivate A,B(5,10);

        A.Print();

        B.Print();

    }

     

    程序运行结果为:

    Default bass constructor called.

    Default derivate constructor called.

    Bass constructor called.

    Derivate constructor called.

    0

    0

    10

    5

    Derivate destructor called.

    Bass destructor called.

    Derivate destructor called.

    Bass destructor called.

     

    程序中派生类CDerivate的构造函数为:

        CDerivate(int x,int y):CBass(j)

        {

            y=i

            Cout<<"Derivate constructor called";

        }

    构造函数的初始化表中显式调用了基类的构造函数CBass(j),对基类子块中的数据成员赋值,基类构造函数中有一个参数,派生类中也有一个数据成员,因而派生类构造函数有两个参数,它们将分别对基类子块和派生类的数据成员进行初始化。

        程序的输出结果说明了构造函数和析构函数的调用次序。程序中定义了派生类对象A,由于没有初始值,因而将调用无参构造函数,在执行派生类的构造函数前,将先调用基类构造函数,再执行派生类构造函数,从而形成程序结果中的头两句:

        Default bass constructor called.

        Default bass constructor called.

    这些运行结果清楚地表明了构造函数和析构函数的调用次序。类似地可以分析对象B建立和撤消时,是如何调用构造函数和析构函数的。

    3.  多重继承

    展开全文
  • java中继承性和多态性实例

    千次阅读 2015-12-04 12:45:34
    题目描述: 编写一个程序(Fruit.java),其中有三个:Fruit,Orange、Apple,其中,Orange、Apple是Fruit的子类: (1)Fruit有eat()和main()(入口函数)两个方法,没有数据域,其中eat()中用this.getClass()...

    题目描述:

    编写一个程序(Fruit.java),其中有三个类:Fruit,Orange、Apple,其中,Orange、Apple是Fruit的子类:

    (1)类Fruit有eat()和main()(入口函数)两个方法,没有数据域,其中eat()中用this.getClass()显示当前对象的类名。 main()中随机生成这三种对象(用for和switch语句),共生成20个(把20定义为常量)对象,并用Fruit数组存放,然后用foreach循环对所有这些对象执行eat。

    (2)类Orange有一个方法eat,没有数据域,其中,eat()显示" The orange tastes a little sour"。

    (3)类Apple没有数据域和方法。

    提示: 随机数产生方法
                  import java.util.Random;

                  Random rnd=new Random(50); // 局部变量rnd初始化50为种子

                 intn= rnd.nextInt(100);         //返回0~99之间的随机数


    参考输出:



    代码:

    import java.util.*;
    import  java.util.Random;
    
    class Fruit{
     public void eat()
      {
    	  System.out.println("Eat " + this.getClass());
      }
     
      public static void main(String[] args){
    	  final int end = 20;
    	  Fruit fruits[] = new Fruit[end];
    	  
    	//产生种子:注意要用当前时间做种子才能产生变化的随机数,不然每次是固定的一个数!
    	  Random rnd= new Random(System.currentTimeMillis());  
    	for(int i=0;i < end;i++)
    	{
    		int n= rnd.nextInt(3); //产生0~2之间的随机数
    		switch(n)
    		{
    			case 0:
    				fruits[i] = new Fruit();
    				break;
    			case 1:
    				fruits[i] = new Orange();
    				break;
    			case 2:
    				fruits[i] = new Apple();
    				break;
    			default:
    				break;
    		}
    	}
    	for(Fruit f:fruits)
    	{
    		f.eat();
    	}
      }
    }
    
    class Orange extends Fruit{
    	//@override
    	public void eat()
    	{
    		System.out.println("The orange tastes a little sour");
    	}
    
    }
    
    class Apple extends Fruit{
    }
    
    

    运行结果截图:


    展开全文
  • 通过继承机制,可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员,而且还同时拥有旧的成员。我们称已存在的用来派生新为基类,又称为父类。由已存在的派生出的新称为...
    通过继承机制,可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员,而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类,又称为父类。由已存在的类派生出的新类称为派生类,又称为子类。

      在C++语言中,一个派生类可以从一个基类派生,也可以从多个基类派生。从一个基类派生的继承称为单继承;从多个基类派生的继承称为多继承。

      派生类的定义格式

      单继承的定义格式如下:

       class <派生类名>:<继承方式><基类名>
        {
         <派生类新定义成员>
        };

      其中,<派生类名>是新定义的一个类的名字,它是从<基类名>中派生的,并且按指定的<继承方式>派生的。<继承方式>常使用如下三种关键字给予表示:

       public 表示公有基类;

       private 表示私有基类;

       protected 表示保护基类;

      多继承的定义格式如下:

       class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
        {
         <派生类新定义成员>
        };

      可见,多继承与单继承的区别从定义格式上看,主要是多继承的基类多于一个。

      派生类的三种继承方式

       公有继承(public)、私有继承(private)、保护继承(protected)是常用的三种继承方式。

      1. 公有继承(public)

      公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的。

      2. 私有继承(private)

      私有继承的特点是基类的公有成员和保护成员都作为派生类的私有成员,并且不能被这个派生类的子类所访问。

      3. 保护继承(protected)

      保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员,并且只能被它的派生类成员函数或友元访问,基类的私有成员仍然是私有的。

      下面列出三种不同的继承方式的基类特性和派生类特性。

      不同继承方式的基类和派生类特性

    继承方式 基类特性 派生类特性
    公有继承 public public
    protected
    private
    protected
    不可访问
    私有继承 public private
    protected
    private
    private
    不可访问
    保护继承 public protected
    protected
    private
    protected
    不可访问

      为了进一步理解三种不同的继承方式在其成员的可见性方面的区别,下面从三种不同角度进行讨论。

      对于公有继承方式:
     
      (1) 基类成员对其对象的可见性:

      公有成员可见,其他不可见。这里保护成员同于私有成员。

      (2) 基类成员对派生类的可见性:

      公有成员和保护成员可见,而私有成员不可见。这里保护成员同于公有成员。

      (3) 基类成员对派生类对象的可见性:

      公有成员可见,其他成员不可见。

      所以,在公有继承时,派生类的对象可以访问基类中的公有成员;派生类的成员函数可以访问基类中的公有成员和保护成员。这里,一定要区分清楚派生类的对象和派生类中的成员函数对基类的访问是不同的。

      对于私有继承方式:

      (1) 基类成员对其对象的可见性:

      公有成员可见,其他成员不可见。

      (2) 基类成员对派生类的可见性:

      公有成员和保护成员是可见的,而私有成员是不可见的。

      (3) 基类成员对派生类对象的可见性:

      所有成员都是不可见的。

      所以,在私有继承时,基类的成员只能由直接派生类访问,而无法再往下继承。

      对于保护继承方式:

      这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言,对基类成员有不同的可见性。

      上述所说的可见性也就是可访问性。关于可访问性还有另的一种说法。这种规则中,称派生类的对象对基类访问为水平访问,称派生类的派生类对基类的访问为垂直访问。

      一般规则如下

       公有继承时,水平访问和垂直访问对基类中的公有成员不受限制;

       私有继承时,水平访问和垂直访问对基类中的公有成员也不能访问;

       保护继承时,对于垂直访问同于公有继承,对于水平访问同于私有继承。

      对于基类中的私有成员,只能被基类中的成员函数和友元函数所访问,不能被其他的函数访问。

      基类与派生类的关系

      任何一个类都可以派生出一个新类,派生类也可以再派生出新类,因此,基类和派生类是相对而言的。

      基类与派生类之间的关系可以有如下几种描述:

       1. 派生类是基类的具体化

       类的层次通常反映了客观世界中某种真实的模型。在这种情况下,不难看出:基类是对若干个派生类的抽象,而派生类是基类的具体化。基类抽取了它的派生类的公共特征,而派生类通过增加行为将抽象类变为某种有用的类型。

       2. 派生类是基类定义的延续

       先定义一个抽象基类,该基类中有些操作并未实现。然后定义非抽象的派生类,实现抽象基类中定义的操作。例如,虚函数就属此类情况。这时,派生类是抽象的基类的实现,即可看成是基类定义的延续。这也是派生类的一种常用方法。

       3. 派生类是基类的组合

       在多继承时,一个派生类有多于一个的基类,这时派生类将是所有基类行为的组合。

      派生类将其本身与基类区别开来的方法是添加数据成员和成员函数。因此,继承的机制将使得在创建新类时,只需说明新类与已有类的区别,从而大量原有的程序代码都可以复用,所以有人称类是“可复用的软件构件”。
    展开全文
  •  当一个类继承另一个类时,被继承的类称为父类或基类;该类被称为子类或派生类。  【特点】:  ⑴、传递;(即类B继承类A,类C继承类B,故类C同时拥有类A和类B的成员。)  ⑵、相对;(当描述一个类时,...

    1、继承:面向对象编程中提供的子类可以沿用父类某些行为和特征的一种方式。

          当一个类继承另一个类时,被继承的类称为父类或基类;该类被称为子类或派生类。      

    【特点】:

           ⑴、传递性;(即类B继承类A,类C继承类B,故类C同时拥有类A和类B的成员。)

           ⑵、相对性;(当描述一个类时,不能简单的定义该类是父类还是子类,而需要相对于其他类来言。)

           ⑶、单根性。(c#明确规定一个类只能有一个父类,但可以有多个子类。)

    【注意】:

    1、若一个类没有继承任何类,则自动继承Object类。(Object类是一切类的根类,它定义了所有类最基本的方法和属性)

    2、子类继承了父类的属性和方法,但是子类并没有继承父类的私有字段

    3、子类并没有继承父类的构造函数,但是。子类会默认的调用父类无参数的构造函数,创建父类对象,让子类可以使用父类中的成员。所以,如果在父类中重新写了一个有参数的构造函数之后,那个无参数的就被干掉了,子类调用不到,所以子类会报错。

    解决办法:

    1)、在父类中重新写一个无参数的构造函数。

    2)、在子类中显示的调用父类的构造函数,使用关键字:base()

     

    2、base和this关键字:(不能在静态方法中使用)

      ⑴、base关键字:用于在子类中指代其父类对象的引用,其含义类似于“父类”。

        【语法】:base(参数列表):用于在子类中调用父类中的构造方法;

              base.成员名称:用于在子类中调用父类中的成员。

      ⑵、this关键字:用于在类中指代类的对象的引用,其含义类似于“自己”。

        【语法】:this.成员名称:用于在本类中调用自己的成员。

     

    3、访问修饰符protected:(专门用于继承关系的访问修饰符)可以在当前类的内部以及该类的子类中访问。

     

     

    展开全文
  • C#中继承性 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述 在C#中,的继承遵循以下原则。 (1)派生只能从一个中继承,即单继承。 (2)的继承是可以传递的,...
  • 关于类的组合和继承

    千次阅读 2015-08-22 22:15:12
    【出处】... ... 在我们对现实中的某些事物抽象成时,可能会形成很复杂的,为了更简洁的进行软件开发,我们经常把其中相对比较独立的部分拿出来定义成一个个简单的,这些比较简单的又可
  • 05-CSS样式表的继承性和层叠性

    千次阅读 多人点赞 2019-10-07 16:09:30
    CSS的继承性 CSS的层叠性 计算权重 权重问题大总结 CSS样式表的冲突的总结 权重问题深入 同一个标签,携带了多个类名 !important标记 CSS的继承性 我们来看下面这样的代码,来引入继承性: 上方代码中,我们...
  • Python3 类继承 导入类

    千次阅读 2017-06-17 17:14:03
    参考文件:《Python编程...Car,Car.py文件#!/usr/local/python3.6.1/bin/python3 class Car(): """一次模拟汽车的简单尝试""" odometer_reading = 0 def __init__(self, make, model, year): """初始化描述汽车
  • C++继承特性

    千次阅读 2014-08-04 15:10:15
    整个c++程序设计全面围绕面向对象的方式进行,继承特性是c++的一个非常非常重要的机制,继承特性可以使一个新获得其父的操作和数据结构,程序员只需在新中增加原有中没有的成分。下面我们简单的来说一下...
  • 继承总结

    2016-03-11 21:44:28
    has-a表示的包含关系,用于描述一个由多个“部件”构成。C++实现has-a的关系用成员表示,即一个中的数据成员是另一种已经定义的。 uses-a表示一个部分地使用另一个。在面向对象的技术中,这种关系...
  • 继承,抽象

    2013-07-06 16:40:39
     好处:提高了代码的复用,让之间产生了关系。  将对象中的共性内容不断地向上抽取,就形成了关系,就有了继承,有了子父类。  继承特点:  java中只能但继承,多继承的机制被java语音改良了。 ...
  • java 类继承与接口继承

    千次阅读 2012-11-30 14:19:41
    在阅读《设计模式--可复用面向对象软件的基础》的时候才对“类继承和接口继承的区别”产生了很大的困惑。搜索也没有什么好解释,这里是我的理解! 1.《设计模式》重要的两段话 -------------- 一个对象的类...
  • 面向对象的继承性和多态性

    千次阅读 2015-09-14 21:02:36
     继承是面向对象的一个重要的特性,继承性反映的是两个之间的一种关系。在面向对象的程序设计中,根据已有派生出新的这种现象,我们称之为的继承机制。既当一个具有另一个的所有方法和属性时,我们称之...
  • python继承与多态

    千次阅读 2018-07-03 20:43:23
    python继承的特点:总是从某个类继承。如果没有继承类,则继承自object类python继承的优点:减少代码量;拥有父类的所有功能,只需要编写子类附加的功能即可。python继承类Student类需要有name和gender属性,因为...
  • C#继承机制

    2013-10-10 19:21:52
    个人觉得写的很经典的一篇文章,关于C#继承机制。 转过来 供自己学习之用 ================================================================ 一. 继承基础知识  为了提高软件模块的可复用和可扩充...
  • 通过继承机制,可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员,而且还同时拥有旧的成员。我们称已存在的用来派生新为基类,又... 派生的定义格式 单继承的定义格式
  • 派生与基类之间的关系(is-a) @1 派生继承基类的数据成员和部分方法成员,并将其加入派生的相应...public、private、protected区域的划分只是对可见的一种描述,并不是真正实现上按这种方式进行划分。...
  • 派生类继承基类的成员

    千次阅读 2014-10-28 10:02:09
    这个过程,称为继承的,涉及一个基类和派生类:派生类继承基类的成员,在其上可以添加自己的成员。 例如,让我们想象一系列的类来描述多边形两种:矩形和三角形。这两个多边形具有某些共同的特性,如需计算面积的...
  • 友元继承

    千次阅读 2012-04-17 20:40:37
    C++ Primer中有如下描述:友元关系不能继承。基类的友元对派生的成员没有特殊访问 权限。如果基类被授予友元关系,则只有基类具有特殊访问权限,该基类的派生不能访问授予友元关系的。  然而通过实践发现,...
  • C#继承-什么是继承

    千次阅读 2010-11-22 15:33:00
    任何类都可以从另外一个类继承,遵循的原则是:一个类派生出来的子类具有这个类所有的公共属性和方法。 C#提供了类的继承机制,创建新类所根据的基础类称为基类或父类,新建的类称为派生类或子类。继承是实现...
  • c++学习继承性、类图、Makefile

    千次阅读 2019-01-22 09:01:02
    面对对象编程 – 继承性(继承 – 事物的相似性)(扩展性、代码重用性) UML 类图 — 关于StarUML的学习教程 ​   StarUML(简称SU),是一种创建UML类图,生成类图和其他类型的统一建模语言(UML)图表的工具。...
  • 继承extends与 抽象 abstract

    千次阅读 2018-05-01 11:51:29
     1:子类可以访问父类的非私有成员 2:可以在子类中添加子类特有成员 继承的作用 1)继承可以提供代码的复用:父类中的一个方法,所有的子类的都用 2)提供了程序的可扩展1:Java支持单继承 a:一个子类只能有一个...
  • linux 中C++继承

    千次阅读 2016-10-24 19:35:54
    10.1 C++类继承简介 C++中类作为一种自定义类型的数据结构,在面向对象程序设计思想中有着相当重要的作用。类代表一类事物的集合,与现实社会相似,类类型同样具有继承实现的可能。现实社会中事物的继承性随处可见...
  • TypeScript、接口、继承

    万次阅读 2017-11-01 17:20:38
    TS引入了 Class()这个概念,作为对象的模板。通过class关键字,可以定义。  基本上,TS的 class 可以看作只是一个语法糖,它的绝大部分功能,ES5 都可以做到,新的 class 写法只是让对象原型的写法更加清晰...
  • 继承方式

    2009-10-13 21:24:00
    关于继承,不同继承方式,对于派生成员以及基类的可见 收藏 本文来自CSDN博客http://blog.csdn.net/jnucstan/archive/2007/05/20/1617799.aspx通过继承机制,可以利用已有的数据类型来定义新的数据类型。...
  • java 继承体系

    千次阅读 2016-01-15 18:18:41
    如果A继承了一个抽象B(抽象B已经实现了接口C),为什么还要实现接口C呢? 1、问题描述 详细描述见:http://segmentfault.com/q/1010000004314755?_ea=566429 2、原因分析 假设……仅仅是假设……下面所...
  • Python继承

    万次阅读 2010-11-24 18:54:00
    内建函数issunclass和isinstance,可...继承 import math #class Point class Point: def __init__(self, xValue, yValue): self.X = xValue self.Y = yValue #class Circle class Circle(Point):
  • 抽象 接口区别 多态 继承 封装

    千次阅读 2014-10-16 11:48:37
    声明方法的存在而不去实现它的被叫做抽象(abstract class),它用于要创建一个体现某些基本行为的,并为该声明方法,但不能在该中实现该的情况。不能创建abstract 的实例。然而可以创建一个变量,其...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 324,673
精华内容 129,869
关键字:

关于类的继承性的描述