精华内容
下载资源
问答
  • 面向对象程序设计与面向过程程序设计_面向对象程序设计_面向对象的理解
    千次阅读
    2021-05-23 01:19:44

    面向对象程序设计与面向过程程序设计

    4、Call Bs function f()

    Call Bs function g()

    Call Cs function g()

    一、单项选择题 (在每小题的备选答案中选出一个正确的答案。每小题2分,共30分)

    1.cout是I0流库预定义的

    A 类 B 对象 C 包含文件 D 常量

    2. 类的定义如下,试问类B的对象占据内存多少整形单元空间?

    class A {int b; protected: int a; public: A(int n){a=n;};};class B: public A {int c;};

    A 2B 3C 4D 7

    3. 类的析构函数的作用是

    A 一般成员函数 B 类的初始化 C 对象的初始化 D 对象扫尾处理

    4.面向对象程序设计中的数据隐藏指的是

    A.输入数据必须输入保密口令B.数据经过加密处理

    C. 对象内部数据结构上建有防火墙 D.对象内部数据结构的不可访问性

    5.有如下的对类“CSample”的说明,其中是错误的。面向对象程序设计与面向过程程序设计

    class CSample {

    A.int a=23;

    B.CSample();

    public:

    C.CSample(int val);

    D.~ CSample();

    }

    6.拷贝(复制)构造函数的作用是

    A.进行数据类型的转换B.用对象调用成员函数

    C.用对象初始化对象D.用一般类型的数据初始化对象

    7. C++对C语言作了很多改进,即从面向过程变成为面向对象的主要原因

    A.增加了一些新的运算符B.允许函数重载,并允许设置缺省参数

    C.规定函数说明符必须用原型D.引进了类和对象的概念

    8. 下列不是描述类的成员函数的是

    A.构造函数B.析构函数

    C.友元函数D.拷贝构造函数

    9. 通常,拷贝构造函数的参数是

    A.某个对象名B.某个对象的成员名

    C.某个对象的引用名 D.某个对象的指针名

    10. 如果类A被说明成类B的友元,则

    A.类A的成员即类B的成员B.类B的成员即类A的成员

    C.类A的成员函数不得访问类B的成员 D.类B不一定是类A的友元

    11. 假定AB为一个类,则执行AB x;语句时将自动调用该类的

    A.有参构造函数B.无参构造函数

    C.拷贝构造函数D.赋值构造函数

    12. 对于任何一个类,析构函数最多有个

    A. 0B. 1C. 2D. n

    13. 下列特性中,C与C++共有的是

    A.继承B.封装

    C.多态性D.函数定义不能嵌套

    14. 要禁止修改指针p本身,又要禁止修改p所指向的数据,这样的指针应定义为

    A.const char *p=“ABCD”;B.char const *p=“ABCD”;

    C.char *const p=“ABCD”;D.const char * const p=“ABCD”;

    15. 当一个类的某个函数被说明为virtual时,该函数在该类的所有派生类中

    A.都是虚函数B.只有被重新说明时才是虚函数

    C.只有被重新说明为virtual时才是虚函数D.都不是虚函数

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/jisuanjixue/article-29265-1.html

    更多相关内容
  • C++面试题-面向对象-面向对象概念

    千次阅读 2019-01-11 00:16:27
    C++面试题-面向对象-面向对象概念 问:说说C++和C的主要区别? 答: C语言属于面向过程语言,通过函数来实现程序功能。而C++是面向对象语言,主要通过类的形式来实现程序功能。 使用C++编写的面向对象应用程序比...

    C++面试题-面向对象-面向对象概念

    问:说说C++C的主要区别?

    答:

    1. C语言属于面向过程语言,通过函数来实现程序功能。而C++是面向对象语言,主要通过类的形式来实现程序功能。
    2. 使用C++编写的面向对象应用程序比C语言编写的程序更容易维护、扩展性更强。
    3. C++多用于开发上层应用软件,而C语言代码体积小、执行效率高,多编写系统软件和嵌入式开发。

    例如:Windows操作系统、Linux操作系统大部分内核都是用C语言编写的。从名称上,可以说C++C语言的超集,它兼容C语言,同时扩充了许多内容,例如面向对象、STL模板库等。总之,C语言属于面向过程编程语言,侧重于函数;而C++属于面向对象编程语言,侧重于类。

     

    问:面向对象的程序设计思想是什么?

    答:把数据结构和对数据结构进行操作的方法封装形成一个个的对象。

     

    问:面向对象与面向过程分别是什么?

    答:

    面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了;以过程为中心的编程思想,以算法进行驱动。

    面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。以对象为中心,以消息进行驱动。

     

    问:面向过程与面向对象的优缺点?

    答:

    面向过程

    1. 优点:性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源,比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发,性能是最重要的因素。
    2. 缺点:没有面向对象易维护、易复用、易扩展。

    面向对象

    1. 优点:易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统更加灵活、更加易于维护。
    2. 缺点:性能比面向过程低。

     

    问:面向对对象与面向过程的区别?

    答:

    1. 面向过程的思维方式是分析综合。面向对象的思维方式是构造。
    2. 面向过程的程序设计有挑战性,技巧性强。面向对象主要在于对象抽象有技术性,抽象完了后,任何人都可以做后面的工作了。
    3. 对面向过程而言,数据是独立的。在面向对象中,对象本身就提供了存储数据的空间(类的数据成员),这样就是函数的参数传递简单多了,而且提供了数据封装后,数据的访问也变可靠了。

     

    问:什么是对象?

    答:对象是指现实世界中各种各样的实体。它可以指具体的事物也可以指抽象的事物。

     

    问:对象都具有二方面特征是什么?分别是什么含义?

    答:对象都具有的特征是:静态特征和动态特征。

    静态特征是指能描述对象的一些属性,动态特征是指对象表现出来的行为。

     

    问:什么是类?

    答:类是一种复杂的数据类型,它是将不同类型的数据和与这些数据相关的操作封装在一起的集合体。类的基本思想是数据抽象和封装。数据抽象是一种依赖于接口和实现分离的编程(以及设计)技术。类的接口包括用户所能执行的操作:类的实现则包括类的数据成员、负责接口实现的函数以及定义类所需的各种私有函数。

    封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节,也就是说,类的用户只能使用接口而无法访问实现部分。类想要实现数据抽象和封装,需要首先定义一个抽象数据类型。在抽象数据类型中,由类的设计者负责考虑类的实现过程;(摘自《Primer c++第五版》)

    关于接口和实现分离的技术(某网友的博客文章):https://blog.csdn.net/starlee/article/details/610825

     

    问:写出结构体定义与声明的几种形式?

    答:struct为结构体关键字,tag为结构体的标志,member-list为结构体成员列表,其必须列出其所有成员;variable-list为此结构体声明的变量。

    struct tag {

     member-list

    } variable-list ;

    在一般情况下,tagmember-listvariable-list3部分至少要出现2个。以下为示例:

    1. // 此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c。同时又声明了结构体变量s1,这个结构体并没有标明其标签。

    struct {

        int a;

        char b;

        double c;

    } s1;

    2. // 同上声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c,结构体的标签被命名为SIMPLE,没有声明变量。

    struct SIMPLE{

        int a;

        char b;

        double c;

    };

    // SIMPLE标签的结构体,另外声明了变量t1t2t3

    struct SIMPLE t1, t2[20], *t3;

    3.// 也可以用typedef创建新类型

    typedef struct{

        int a;

        char b;

        double c;

    } Simple2;

    //现在可以用Simple2作为类型声明新的结构体变量

    Simple2 u1, u2[20], *u3;

    4.// 此结构体的声明包含了其他的结构体

    struct COMPLEX{

        char string[100];

        struct SIMPLE a;

    };

    // 此结构体的声明包含了指向自己类型的指针

    struct NODE{

        char string[100];

        struct NODE *next_node;

    };

    5. struct B;   

    // 对结构体B进行不完整声明

    // 结构体A中包含指向结构体B的指针

    struct A{

        struct B *partner;

        //other members;

    };

    // 结构体B中包含指向结构体A的指针,在A声明完后,B也随之进行声明

    struct B{

        struct A *partner;

        //other members;};

     

    问:类与结构体的区别是什么?

    答:

    1. 只有结构体存在于C语言,结构体和类都存在于C++
    2. C中结构体只涉及到数据结构,在C++中结构体和类体现了数据结构和算法的结合。也就是说在C++中,结构体还可以包含函数,而C语言中不可以。
    3. C语言中结构体没有成员函数,可以被声明为变量、指针和数组等。在C++中由于对结构体进行了扩充,获取了很多功能,当然还可以包含函数。
    4. 访问机制,结构体默认访问的机制是public,而类默认访问机制是private
    5. class继承默认是private继承,而从struct继承默认是public继承。
    6. C++的结构体声明不必有struct关键字,而C语言的结构体声明必须带有关键字(使用typedef别名定义除外)。
    7. 结构体是值类型,而类是引用类型。
    8. 结构体和类同样可以能够继承和实现多态。
    9. C++中,结构体可以继承类,类同样也可以继承结构体,继承过程中注意访问权限。
    10. class”这个关键字还用于定义模板参数,就像“typename”。但关键字“struct”不用于定义模板参数。这一点在Stanley B.Lippman写的Inside the C++ Object Model有过说明。
    11. struct更适合看成是一个数据结构的实现体,class更适合看成是一个对象的实现体。
    12. 实例化的类存储在内存的堆内,而结构存储在栈内,结构的执行效率相对较高。
    13. 结构体没有析构函数。

     

    问:哪种使用的情况下适合结构体还是类?

    答:

    1. 在表示诸如点、矩形等主要用来存储数据的轻量级对象时,首选struct
    2. 在表示数据量大、逻辑复杂的大对象时,首选class
    3. 在表现抽象和多级别的对象层次时,class是最佳选择。

     

    问:什么是抽象?

    答:抽象的作用就是表示同一类事物的本质。例如在c/c++中,数据类型就是对一批具体的数的抽象。

    类是对象的抽象,而对象则是类的特例,或者说是实例。

    抽象包括两个方面:一是过程抽象,二是数据抽象。

     

    问:什么是封装?

    答:封装是指可以对一个对象进行封装处理,把它的一部分属性和功能对外界屏蔽,也就是说从外界是看不到的,甚至是不可见的。

    封装的特点:

    1. 将有关的数据和操作代码封装在一个对象中,形成一个基本单位,各个对象之间相对独立,互不干扰。
    2. 将对象中某些部分对外隐蔽,只留下少数接口,以便与外界联系,接收外界的消息。这种对外界屏蔽的做法称为消息屏蔽。

     

    问:继承的作用?

    答:采用继承的方法可以很方便地利用一个已有的类建立一个新的类,这就可以重用已有软件中的一部分甚至大部分,节省了编程工作量。

     

    问:类的特性?

    答:封装(维护性),继承(复用性)和多态(扩展性)。抽象,不属于类的特性,特点是灵活性。

     

    问:抽象类是什么?作用是什么?

    答:抽象类是一种特殊的类,它是为了抽象和设计的目的为建立的,它处于继承层次结构的较上层。

    1. 抽象类的定义:称带有纯虚函数的类为抽象类。
    2. 抽象类的作用:抽象类的主要作用是将有关的操作作为结果接口组织在一个继承层次结构中,由它来为派生类提供一个公共的根,派生类将具体实现在其基类中作为接口的操作。所以派生类实际上刻画了一组子类的操作接口的通用语义,这些语义也传给子类,子类可以具体实现这些语义,也可以再将这些语义传给自己的子类。
    3. 使用抽象类时注意:抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出。如果派生类中没有重新定义纯虚函数,而只是继承基类的纯虚函数,则这个派生类仍然还是一个抽象类。如果派生类中给出了基类纯虚函数的实现,则该派生类就不再是抽象类了,它是一个可以建立对象的具体的类。抽象类是不能定义对象的。

     

    问:什么是接口类?特点是什么?

    答:接口类就是只提供接口不提供实现的类,就是接口类,接口类和抽象类对C++而言,没有什么区别。

    接口类有如下特点:

    1. 子类来实现接口类中没有实现的所有接口。
    2. 接口方法前面有virtual关键词修饰,并且等于0
    3. 只能被继承,不能独自生成对象。

     

    问:什么是友元类?

    答:类可以允许其他类或者函数访问它的非公有成员,方法是令其他类或者函数成为它的友元(friend)。如果类想把一个函数作为它的友元,只需要增加一条以friend关键字开始的函数声明语句即可。

     

    问:多重继承与多继承的区别?

    答:多继承是指一个子类继承多个父类。多继承对父类的个数没有限制,继承方式可以是公共继承、保护继承和私有继承。

    多重继承特点总结如下:

    1. 多重继承与多继承不同,当B类从A类派生,C类从B类派生,此时称为多重继承
    2. 当实例化子类时,会首先依次调用所有基类的构造函数,最后调用该子类的构造函数;销毁该子类时,则相反,先调用该子类的析构函数,再依次调用所有基类的析构函数。
    3. 无论继承的层级有多少层,只要它们保持着直接或间接的继承关系,那么子类都可以与其直接父类或间接父类构成 is a的关系,并且能够通过父类的指针对直接子类或间接子类进行相应的操作,子类对象可以给直接父类或间接父类的对象或引用赋值或初始化。

     

    问:在头文件中进行类的声明,在对应的实现文件中进行类的定义有什么意义?

    答:这样可以提高编译效率。因为这样不仅文件的代码设计方便,而且只需要编译一次就能够生成.obj文件。再次应用该类的地方,就不会重新编译了。

     

    问:如何定义两个类互为成员的情况?以下代码正确吗?

    class A

    {

    public:

    private:

     B m_B;

    };

    class B

    {

    private:

    A m_A;

    };

    答:不正确。因为在类A之前,没有发现类B的定义,直接使用了类B,但是却没有发现类B的定义,而只是发现了类B的声明。修改代码为:

    classB

    class A

    {

    public:

    private:

     B *m_B;//或者B m_B();

    };

    class B

    {

    private:

    A m_A;

    };

    分析:

    本题笔者认为主要考点是类的定义与声明的区别。

    B m_B只是类B的声明,而 B *m_B;//或者B m_B();是类B的定义。

    当我们new出一个对象(B *m_B),就会自动调用构造函数完成初始化,也就完成了类的定义。

    当我们B m_B()时,由于m_B()意思是调用了类B默认的构造函数,完成类的定义。

    类的定义与类的声明区别就在于定义时是自动调用了构造函数,因此才真正创建一个对象m_B,而声明并没有调用构造函数,所以也没有创建对象,只是声明而已。

     

    问:成员变量有哪些访问方式(或者访问控制方式)?

    答:成员变量根据访问权限有privateprotectpublic 3种访问方式。

     

    问:C++中的private的成员变量可以由哪些函数访问?

    答:private只能由本类中的成员函数或者友元函数来访问。

    展开全文
  • 面向对象的一些基本核心概念

    千次阅读 2016-12-19 12:00:27
    封装是面向对象的特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。 1.2继承 面向对象编程...

    1.面向对象的三个基本特征是:封装、继承、多态。

    o_OOBase.gif

    1.1封装

    封装最好理解了。封装是面向对象的特征之一,是对象和类概念的主要特性。

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    1.2继承

    面向对象编程 (OOP) 语言的一个主要功能就是 “ 继承 ” 。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

    通过继承创建的新类称为“子类”或“派生类”。

    被继承的类称为 “ 基类 ” 、 “ 父类 ” 或 “ 超类 ” 。

    继承的过程,就是从一般到特殊的过程。

    要实现继承,可以通过 “ 继承 ” ( Inheritance )和 “ 组合 ” ( Composition )来实现。

    在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。

     

    继承概念的实现方式有三类:实现继承、接口继承和可视继承。

    Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力;

    Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力;

    Ø         可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力。

    在考虑使用继承时,有一点需要注意,那就是两个类之间的关系应该是 “ 属于 ” 关系。例如, Employee 是一个人, Manager 也是一个人,因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类,因为腿并不是一个人。

    抽象类仅定义将由子类创建的一般属性和方法,创建抽象类时,请使用关键字 Interface 而不是 Class 。

    OO 开发范式大致为:划分对象 → 抽象类 → 将类组织成为层次化结构 ( 继承和合成 ) → 用类与实例进行设计和实现几个阶段。

    1.3多态

    多态性( polymorphisn )是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。

    实现多态,有二种方式,覆盖,重载。

    覆盖,是指子类重新定义父类的虚函数的做法。

    重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。

    其实,重载的概念并不属于 “ 面向对象编程 ” ,重载的实现是:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数: function func(p:integer):integer; 和 function func(p:string):integer; 。那么编译器做过修饰后的函数名称可能是这样的: int_func 、 str_func 。对于这两个函数的调用,在编译器间就已经确定了,是静态的(记住:是静态)。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!真正和多态相关的是 “ 覆盖 ” 。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态(记住:是动态!)的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(晚邦定)。结论就是:重载只是一种语言特性,与多态无关,与面向对象也无关!引用一句 Bruce Eckel 的话: “ 不要犯傻,如果它不是晚邦定,它就不是多态。 ”

    那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了 —— 代码重用。而多态则是为了实现另一个目的 —— 接口重用!多态的作用,就是为了类在继承和派生的时候,保证使用 “ 家谱 ” 中任一类的实例的某一属性时的正确调用。

    2.泛化、聚合、组合和依赖的概念解析

    2.1泛化( Generalization )

    o_Generalization.gif

    图表 泛化

    在上图中,空心的三角表示继承关系(类继承),在 UML 的术语中,这种关系被称为泛化( Generalization )。 Person( 人 ) 是基类, Teacher( 教师 ) 、 Student( 学生 ) 、Guest( 来宾 ) 是子类。

    若在逻辑上 B 是 A 的“一种”,并且 A 的所有功能和属性对 B 而言都有意义,则允许 B 继承 A 的功能和属性。

    例如, 教师是人, Teacher 是 Person 的“一种”( a kind of )。 那么类 Teacher 可以从类 Person 派生(继承)。

    如果 A 是基类, B 是 A 的派生类,那么 B 将继承 A 的数据和函数。

    如果类 A 和类 B 毫不相关,不可以为了使 B 的功能更多些而让 B 继承 A 的功能和属性。

    若在逻辑上 B 是 A 的“一种”( a kind of ),则允许 B 继承 A 的功能和属性。

    2.2聚合(组合)

    o_aggregationBase.gif

    图表 组合

    若在逻辑上 A 是 B 的“一部分”( a part of ),则不允许 B 从 A 派生,而是要用 A 和其它东西组合出 B 。

    例如,眼( Eye )、鼻( Nose )、口( Mouth )、耳( Ear )是头( Head )的一部分,所以类 Head 应该由类 Eye 、 Nose 、 Mouth 、 Ear 组合而成,不是派生(继承)而成。

    聚合的类型分为无、共享 ( 聚合 ) 、复合 ( 组合 ) 三类。

    2.3聚合( aggregation )

     

    o_aggregation.gif

    图表 共享

    上面图中,有一个菱形(空心)表示聚合( aggregation )(聚合类型为共享),聚合的意义表示 has-a 关系。聚合是一种相对松散的关系,聚合类 B 不需要对被聚合的类 A负责。

    2.4组合( composition )

    o_composition.gif

    图表 复合

    这幅图与上面的唯一区别是菱形为实心的,它代表了一种更为坚固的关系 —— 组合( composition )(聚合类型为复合)。组合表示的关系也是 has-a ,不过在这里, A 的生命期受 B 控制。即 A 会随着 B 的创建而创建,随 B 的消亡而消亡。

    2.5依赖 (Dependency)

    o_Dependency.gif

    图表 依赖

    这里 B 与 A 的关系只是一种依赖 (Dependency) 关系,这种关系表明,如果类 A 被修改,那么类 B 会受到影响。

    3接口与抽象类有什么区别

    abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。

    3.1理解抽象类

    abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?

    在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。

    在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。

    3.2从语法定义层面看abstract class和interface

    在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。

    使用abstract class的方式定义Demo抽象类的方式如下:

    abstract class Demo { 
    abstract void method1(); 
    abstract void method2(); 
    … 

    使用interface的方式定义Demo抽象类的方式如下:

    interface Demo { 
    void method1(); 
    void method2(); 
    … 
    }

    在abstract class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract class。

    从编程的角度来看,abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。

    首先,abstract class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

    其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会 增加一些复杂性,有时会造成很大的麻烦。

    在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那么可能就只需要修改定义在abstract class中的默认行为就可以了。

    同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了"one rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。

    3.3从设计理念层面看abstract class和interface

    上面主要从语法定义和编程的角度论述了abstract class和interface的区别,这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。

    前面已经提到过,abstarct class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is a"关系,即父类和派生类在概念本质上应该是相同的(参考文献〔3〕中有关于"is a"关系的大篇幅深入的论述,有兴趣的读者可以参考)。对于interface 来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。

    考虑这样一个例子,假设在我们的问题领域中有一个关于Door的抽象概念,该Door具有执行两个动作open和close,此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型,定义方式分别如下所示:

    使用abstract class方式定义Door:

    abstract class Door { 
    abstract void open(); 
    abstract void close(); 
    }

    使用interface方式定义Door:

    interface Door { 
    void open(); 
    void close(); 
    }

    其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

    如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢(在本例中,主要是为了展示abstract class和interface反映在设计理念上的区别,其他方面无关的问题都做了简化或者忽略)?下面将罗列出可能的解决方案,并从设计理念层面对这些不同的方案进行分析。

    解决方案一:

    简单的在Door的定义中增加一个alarm方法,如下:

    abstract class Door { 
    abstract void open(); 
    abstract void close(); 
    abstract void alarm(); 
    }

    或者

    interface Door { 
    void open(); 
    void close(); 
    void alarm(); 
    }

    那么具有报警功能的AlarmDoor的定义方式如下:

    class AlarmDoor extends Door { 
    void open() { … } 
    void close() { … } 
    void alarm() { … } 
    }

    或者

    class AlarmDoor implements Door { 
    void open() { … } 
    void close() { … } 
    void alarm() { … } 

    这种方法违反了面向对象设计中的一个核心原则ISP(Interface Segregation Priciple),在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变(比如:修改alarm方法的参数)而改变,反之依然。

    解决方案二:

    既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用abstract class方式定义;两个概念都使用interface方式定义;一个概念使用abstract class方式定义,另一个概念使用interface方式定义。

    显然,由于Java语言不支持多重继承,所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的,但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

    如果两个概念都使用interface方式来定义,那么就反映出两个问题:1、我们可能没有理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用interface方式定义)反映不出上述含义。

    如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系在本质上是"is a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:

    abstract class Door { 
    abstract void open(); 
    abstract void close(); 

    interface Alarm { 
    void alarm(); 

    class AlarmDoor extends Door implements Alarm { 
    void open() { … } 
    void close() { … } 
    void alarm() { … } 
    }

    这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系,interface表示的是"like a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

    小结

    1. abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。
    2. 在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。
    3. abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。 
    4. 实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
    5. 接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。
    6. 抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值。 
    7. 接口中的方法默认都是 public,abstract 类型的。

    结论

      abstract class 和 interface 是 Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概 念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法,希望读者朋友能够细细体会。



    原文出处:http://www.cnblogs.com/xwdreamer/archive/2011/10/24/2296951.html

    展开全文
  • 浅谈面向对象方法学

    千次阅读 热门讨论 2020-05-15 18:00:32
    一、面向对象的基本概念 对象、类、实例、消息、方法 二、面向对象的基本特征 封装、继承、多态 三、面向对象的建模 对象模型、动态模型、功能模型 四、面向对象设计 五、面向对象的实现 设计风格 测试策略...

    目录

    一、面向对象的基本概念

    对象、类、实例、消息、方法

    二、面向对象的基本特征

    封装、继承、多态

    三、面向对象的建模

    对象模型、动态模型、功能模型

    四、面向对象设计

    五、面向对象的实现

    设计风格

    测试策略

    六、面向对象方法学的优点与缺点

    优点

    缺点


    一、面向对象的基本概念

    对象、类、实例、消息、方法

    对象对象能够表示现实或抽象的事物,具有良好定义的责任和良好定义的行为,以及良好 定义的接口。

    对象具有封装性、自治性、通信性、被动性、暂存性、持久性

    类的定义是具有相同属性和务的一组对象的集合,它为属于该类的全部对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分

    实例每个对象都属于一个类,属于某个类的对象称为该类的一个实例,类和对象间具有 instance-of 关系。

    类是静态概念,对象是动态概念。类是 对象之上的抽象,有了类之后,对象则是类的具体化,是类的实例

    消息消息就是向对象发出的服务请求,它应含有提供服务的对象标识、服务标识、输入信息和回答信息。

    消息用来请求对象处理或回答某些信息的要求,消息统一了数据流和控制流。程序的执行是靠在对象间传递消息来完成的。

    方法方法(method)也称作行为(behavior),指定义于某一特定类上的操作与法则。

    面向对象的设计方法放弃了传统语言中控制结构的概念,以往的一切控制结构的功能都可以通过对象及其相互间传递消息来实现

    二、面向对象的基本特征

    封装、继承、多态

    封装:封装是面向对象方法的一个重要原则,它有两个含义:第一个含义是,把对象的全部 属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象);第二个含义也称作信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界,只保留有限的对外接口使之与外部发生联系。

    继承:继承是一种使用户得以在一个类的基础上建立新的类的技术。新的类自动继承旧类的属性和行为特征,并可具备某些附加的特征或某些限制。

    继承是面向对象语言中功能最强大、最有代表性的特性。首先,继承使新的类变得简洁明了;其次,通过继承可以重复使用和扩展那些经过测试的已有的类,实现重用。最后,是利用继承可以增强处理的一致性。

    多态:在收到消息时对象要予以响应,不同的对象收到同一消息可以产生完全不同的结果, 这一现象叫做多态。

    三、面向对象的建模

            所谓模型,就是为了理解事物而对事物做出的一种抽象,是对事物的一种无歧义的书 面描述。通常,模型由一组图示符号和组织这些符号的规则组成,利用它们来定义和描述 问题域中的术语和概念。更进一步讲,模型是一种思考工具,利用这种工具可以把知识规范地表示出来。

           面向对象的建模不仅仅是新的编程语言的汇总,而是一种新的思维方式,一种关于计 算和信息结构化的新思维。面向对象的建模,把系统看做是相互协作的对象,这些对象是结构和行为的封装,都属于某个类,那些类具有某种层次化的结构。系统的所有功能通过 对象之间相互发送消息来获得。面向对象的建模可以视作一个包含以下元素的概念框架: 抽象、封装、模块化、层次、分类、并行、稳定、可重用和可扩展性。

    对象模型、动态模型、功能模型

    对象模型:对象模型表示静态的、结构化的系统的“数据性质”。

    面向对象方法强调围绕对象而 不是围绕功能来构造系统。对象模型为建立动态模型和功能模型,提供了实质性的框架。

    动态模型:动态模型表示瞬时的、行为化的系统的“控制”性质,它规定了对象模型中的对象的合法变化序列通常,用状态图来描绘对象的状态、触发状态转换的事件以及对象的行为(对事件的响应)。

    功能模型:功能模型表示变化的系统的“功能”性质,它指明了系统应该“做什么”,因此更直接地反映了用户对目标系统的需求。 通常,功能模型由一组数据流图组成。

    三者之间的关系:它使用数据结构(对象模型),执行操作(动态模型),并且完成效据值的变化 (功能模型)。

    四、面向对象设计

    准则模块化、抽象化、信息隐藏和封装、对象的高内聚和弱耦合、可扩充性、可重用性。

    面向对象设计的内容

    五、面向对象的实现

    设计风格

    1. 提高可重用性
    2. 提高方法的内聚、降低耦合
    3. 减小方法的规模
    4. 保持方法的一致性
    5. 尽量做到全面覆盖  
    6. 分开策略方法和实现方法
    7. 利用继承机制
    8. 提高可扩充性
    9. 封装实现策略
    10. 慎用公有方法
    11. 控制方法的规模

    测试策略

    六、面向对象方法学的优点与缺点

    优点

    1.与人类习惯的思维方法一致

    2.稳定性好

    3.可重用性好

    4.可拓展性

    5.可维护性

    缺点

    1.面向对象需要更关注需求、分析和设计

    2.面向对象需要完全改变每一个人的思想

    3面向对象需要改变软件开发文化

    4.面向对象的许多优点是长期的

    5.面向对象要求先在培训、教育和工具上投资

    6.面向对象要求更多的测试工作

    7.面向对象技术不能保证能构造出正确的系统

    展开全文
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是...
  • 关于依赖注入,描述正确的是(BC)

    千次阅读 2020-08-04 22:15:24
    C、依赖注入能够降低系统各组件的依赖关系,提倡面向接口编程 D、Spring的依赖注入和控制反转是完全不同的两个概念 2、(多) 对于Spring的AOP的实现方式下列选项说法错误的是(AD) d A、Spring的Advice采用特定的aop...
  • 面向对象分析,结合面向对象的方法学对需求分析阶段进行具体分析的总结
  • 面向对象概念0 目录8 UML-18.1 面向对象概念8.1.1课堂重点8.1.2测试与作业8 下一章 0 目录 8 UML-1 8.1 面向对象概念 8.1.1课堂重点 8.1.2测试与作业 1填空(2分)在面向对象方法中,对于客观事物的...
  • c++面向对象和c面向过程的一些概念

    千次阅读 2017-01-18 14:02:46
    1.面向对象和面向过程的概念 面向过程是分析解决问题的步骤,然后用函数把这些步骤一步一步的实现,然后在使用的时候一一调用则可。 面向对象是把构成问题的事务分解成各个对象,而建立对象的目的也不是为了完成一...
  • 面向对象编程及其三大特性

    万次阅读 2019-06-11 11:39:23
    编程语言分为面向过程编程、函数式编程和面向对象编程。其实python就是一种面向对象编程,那么我们先了解一下它们的特点和优缺点以及它们的区别是什么。 面向过程编程:“面向过程”(Procedure Oriented)是一种以...
  • 面向对象期末测试题(带答案).doc

    千次阅读 2021-03-13 02:28:21
    面向对象期末测试题(带答案)济南大学2009~2010 学年第二学期课程考试试卷课 程 java面向对象程序设计 授课教师考试时间 考试班级学 号 姓 名题号一二三四五总 分审核人得分一、填空题(每空2分,共20分)1.Java源...
  • 描述面向对象系统开发中的泛化与泛型的基本概念,着重讨论了泛化的识别与描述过程以及泛型的实现方法.通过实例分析,说明了泛化与泛型在面向对象分析与设计中的重要作用.正确理解泛化、泛型与继承的区别与联系,...
  • 以非耍流氓的方式讨论C++中的面向对象编程

    千次阅读 多人点赞 2022-01-18 02:14:10
    老规矩,先解释一下标题,我承认有点...其实C++面向对象编程的问题,很多大牛都讨论过,但是因为人家是大牛,所以文字描述居多,很少给出代码。人家毕竟是阅近天下**, 心中早已无码。我个人认为讨论编程的问题,如果.
  • 面向对象分析和设计基本概念

    千次阅读 2014-10-12 11:54:31
     面向对象分析和设计基本概念  面向对象是基于一种哲学思想,它认为:客观实体和实体之间的联系构成了现实世界的所有问题,而每一个实体都可以抽象为对象。这种思想尽可能地按照人类认识世界的方法和思维方式来...
  • C++面向对象基础

    万次阅读 多人点赞 2018-05-20 12:40:59
    面向对象基础面向对象三大特性封装性:数据和代码捆绑在一起,避免外界干扰和不确定性访问。封装可以使得代码模块化。优点:确保用户代码不会无意间破坏封装对象的状态被封装的类的具体实现细节可以随时改变,而无须...
  • 面向对象的程序设计读书笔记

    千次阅读 2017-10-17 23:33:02
    面向对象概念相关 面向对象的三大特性:继承、封装和多态。继承,共性放到父类,特性放到子类。封装,对象有一个明确的边界,声明公开,实现隐藏,实现的更改,对对象的使用没有影响。多态,子类的对象可以放到父类...
  • 第十章:面向对象分析(2)

    千次阅读 2022-03-28 16:16:15
    泛化关系和类找那个的泛化概念是一样的,于用例继承父用例的行为和含义,还可以增加或覆盖父用例的行为,子用例可以出现在任何父用例出现的位置(父和子均有具体的实例) 也可以重载它,用例之间的泛化关系表示意图...
  • 全方位深入理解JavaScript面向对象

    万次阅读 多人点赞 2018-03-30 10:13:16
    面向对象的基本概念 JavaScript对象属性 理解JavaScript中的函数对象与普通对象 理解prototype和proto 理解原型和原型链 详解原型链相关的Object方法 了解如何用ES5模拟类,以及各种方式的优缺点 了解如何用ES6实现...
  • 第四讲:面向对象程序设计方法及类、对象的概念  掌握:面向对象程序设计的方法及特点;类的声明的对象的定义理解:对象的封装、抽象、继承与多态性四个特快性的概念;类和对象的作用;面向对象和面向过程的程序...
  • 面向对象程序设计步骤

    千次阅读 2017-08-21 10:03:09
    面向对象程序设计的第一步,就是在问题领域中识别出有效的对象,然后从识别出的对象中抽象出类来。面对纷繁复杂的现实问题,往往存在多种对象划分的方式,而不同的划分会带来类的设计以至于程序结构的各种不同。对象...
  • 1、对象和类概念对象:任何一个对象都应该具备两个要素:属性、行为。在C++中每个对象都有数据(体现了‘属性’)和函数(用来对数据进行操作,以实现某些功能)两部分组成。类:具有共性的实体的抽象。类是对象的...
  • 你好,我是前阿里手淘...一些新人在学习JavaScript面向对象时,往往也会有疑惑:为什么JavaScript(直到ES6)有对象的概念,但是却没有像其他的语言那样,有类的概念呢?为什么在JavaScript对象里可以自由添加属性...
  • 第6章课后答案 面向对象需求分析

    千次阅读 2020-05-31 22:07:18
    2.下面关于数据流图建模规则的描述正确的是()。 环境图建模的目标是分析清楚系统的外部实体。 0层图是对系统的第一次功能分解,只需定义出分解得到的“过程”即可。 软件系统在分层建模时,分解的层数越多越好。 ...
  • Java面向对象练习题含解析(三)

    万次阅读 多人点赞 2021-04-07 20:30:11
    31、以下关于类的描述中,错误的是( ) A、在面向对象的思想中最核心就是对象,为了在程序中创建对象,首先需要定义一个类 B、定义类的关键字是Interface C、类中的方法叫成员方法,成员方法又分为实例方法与类...
  • 面向对象方法,OO方法所具有的模块化、信息封装与隐蔽、抽象性、继承性、多样性等独特之处,这些优异特性为研制大型软件、提高软件可靠性、可重用性、可扩充性和可维护性提供了有效的手段和途径。Java主要特征:封装性...
  • 软件工程——面向对象设计详解

    千次阅读 2021-02-23 14:42:48
    软件工程——面向对象设计详解面向对象设计过程面向对象设计准则体系结构模块及依赖性接口及其依赖性包及其依赖性构件及其依赖性人机交互部分的设计用户界面设计步骤界面设计目标界面设计工作流 面向对象设计过程 ...
  • 面向对象设计的七大设计原则详解

    万次阅读 多人点赞 2018-10-03 12:32:21
    文章目录面向对象的七大设计原则简述七大原则之间的关系一、开闭原则(The Open-Closed Principle ,OCP)概念理解系统设计需要遵循开闭原则的原因开闭原则的实现方法一个符合开闭原则的设计开闭原则的相对性二、 ...
  • R语言面向对象指南

    万次阅读 2015-09-21 21:53:00
    面向对象指南:这一章主要介绍怎样识别和使用 R 语言的面向对象系统(以下简称 OO)。R 语言主要有三种 OO 系统(加上基本类型)。本指南的目的不是让你精通 R 语言的 OO,而是让你熟悉各种系统,并且能够准确地区分...
  • 软件工程之面向对象方法学

    千次阅读 热门讨论 2019-11-17 20:16:50
    面向对象方法学概述 面向对象方法学的优点 面向对象方法的基本思想是从现实世界中客观存在的事物出发来...对象是对现实世界实体的正确抽象,它是由描述内部状态表示静态属性的数据以及可以对这些数据施加的操作,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,875
精华内容 38,350
关键字:

关于面向对象概念的描述正确