面向对象知识点整理

面向对象考试简述题整理

概述

1、  什么是面向对象？

从程序设计方法的角度看，面向对象是一种新的程序设计范型(paradigm)，其基本思想是使用对象、类、继承、封装、聚合、关联、消息、多态性等基本概念来进行程序设计。

面向对象方法是一种运用对象、类、继承、封装、聚合、关联、消息、多态性等概念来构造系统的软件开发方法。

2、 面向对象基本思想。

从现实世界中客观存在的事物出发来建立软件系统

充分运用人类日常的思维方法

对问题空间进行自然分割，以更接近人类思维的方式建立问题域模型，以便对客观实体进行结构模拟和行为模拟，从而使设计出的软件尽可能直接地描述现实世界。

构造出模块化的、可重用的、维护性好的软件，同时限制软件的复杂性和降低开发维护费用。

3、面向对象主要特点

用类和对象作为系统的基本构成单位。对象对应问题域中的事物，其属性与服务刻画了事物的静态特征和动态特征，它们之间的继承关系、聚合关系、消息和关联如实地表达了问题域中事物之间实际存在的各种关系。

因此，无论系统的构成成分，还是通过这些成分之间的关系而体现的系统结构，都可直接地映射问题域。

第一章面向对象思想

1、对象是独立存在的客观事物，它由一组属性和一组操作构成。属性和操作是对象的两大要素。属性是对象静态特征的描述，操作是对象动态特征的描述。

2、部分/整体关系中有两种方式：组合和聚合。

3、█组合与聚合的区别

组合关系中部分和整体的关系很紧密。聚合关系中则比较松散，一个部分对象可以属于几个整体对象。

4、消息和方法

在面向对象编程中，行为的启动是通过将“消息”传递给对此行为负责的代理(对象)来完成的。消息对行为的要求进行编码，并且随着执行要求所需的附加信息（参数）来一起传递。“接收器”就是消息发送的对象。如果接收器接受了消息，那么同时它也接受了消息所包含的行为责任。然后，接受器响应消息，执行相应的“方法”以实现要求。

5、消息传递与过程调用

每一条消息都有一个指定的接收器相对应；接收器就是消息发送的对象。过程调用没有指定的接收器。

消息的解释由接收器决定，并且随着接收器的不同而不同。

动态绑定。

6、信息隐藏

作为某对象提供的服务的一个用户，只需要知道对象将接受的消息的名字。

不需要知道怎么完成要求，需要执行哪些动作。

在接收到一条消息后，对象会负责将该项任务完成。

7、责任

用责任来描述行为。A对行为的要求仅表明他所期望的结果，C可随意选择使用的方法来实现所期待的目标，并在此过程中不受A的干扰。

提高了抽象水平，对象更加独立。

8、不干预原则

允许对象以任何它认为合适的不干涉其他对象的方式来完成任务，而不要干预它

9、类

根据抽象的原则对客观事物进行归纳和划分，只关注与当前目标相关的特征，把具有相同特征的事物归为一个类。它是一个抽象的概念。类是具有相同属性和相同操作（服务）的对象的集合。它包括属性和操作。

10、类和实例

所有对象都是类的实例。

在响应消息时调用何种方法由类的接收器来决定。

一个特定类的所有对象使用相同的方法来响应类似的消息。

每一个对象都是某个类的实例。类是一组相似的对象 。

类是对象相关行为的储存库(repository)。即同一个类的所有对象都能执行同样的动作。

11、改写

将子类中某一方法取与父类方法相同的名称，结合寻找方法的规则（当响应特定消息时）实现改写。

12、方法绑定与改写

接收器搜索并执行相应的方法以响应给定的消息。

如果没有找到匹配的方法，搜索就会传导到此类的父类。搜索会在父类链上一直进行下去，直到找到匹配的方法，或者父类链结束。

如果能在更高类层次找到相同名称的方法，所执行的方法就称为改写了继承的行为。

13、多态

多态性是指一般类中定义的属性和服务，在特殊类中不改变其名字，但通过各自不同的实现后，可以具有不同的数据类型或具有不同的行为。如不同花商送花方式。

多态可通过重载和类等级不同层次共享同一方法名字等方式来实现。

14、JAVA中的重写/改写和重载

重写一般是指父类和子类之间，子类重写了父类的一个方法，当然方法名是一样的，而且不能改变父类方法的返回值，比如说父类是返回String，子类重写了这个方法，想返回一个int，那是不行的，也得返回String。

重载是一个类里面，写了多了同名的方法，各个方法的返回值类型可以不一样。区分重载方法可以通过参数列表的个数，类型和顺序。

第二章抽象

1、抽象

抽象是指对于一个过程或者一件制品的某些细节有目的的隐藏，以便把其他方面、细节或者结构表达得更加清楚。(信息隐藏) 抽象，是控制复杂性时最重要的工具。

第四章类和方法

1、什么是封装

避免重复的代码

保护类受到不必要的修改

2、接口

不提供实现

接口定义新类型，可以声明变量

类的实例可以赋值给接口类型变量

3、向前定义

多个互相引用的类(相互递归)

Java全文扫描。C++向前定义

Java 语言在生成代码之前会扫描整个文件，这样，如果程序文件的前面部分引用在文件后面声明的类，就不会产生任何冲突。其他的语言，例如 C++，会从前到后地依次处理程序文件中的类和方法去。名称在使用之前必须至少进行部分定义

4、静态成员函数

成员函数。不能访问非静态成员。

无this

构造和析构函数不能为静态成员。

第五章消息、实例和初始化

1、消息

使用消息传递（message passing）这一术语来表示请求对象执行一项特定行为的动态过程

消息总是传递给某个称为接收器的对象

响应消息所执行的行为不是固定不变的，它们根据接收器类的不同而不同

广播，可响应可不响应

对象间相互请求或相互协作的途径。

2、消息传递语法

任何消息传递表达式都有 3 个确定的部分，包括接收器（receiver，消息传递的目的对象）消息选择器(message  selector，表示待传递的特定的消息文本)和用于响应消息的参数(argument)。

响应行为随接收器不同而不同。

3、静态类型语言，动态类型语言

静态：类型和变量联系在一起(Java,C++,C#,Pascal)

动态：变量看作名称标识，类型和数值联系在一起。(SmatllTalk,Python)

动态类型语言与静态类型语言之间的差异在于变量或数值是否具备类型这种特性。

4、静态类型语言与动态类型语言在高效性与灵活性方面

在消息传递这方面，静态类型语言和动态类型语言之间存在显著的差异。一方面，静态类型语言在编译时使用接收器的类型来检查选择器，以理解它所接收的消息。另一方面，动态类型语言在编译时则没有办法去核实这一消息。

5、静态类性语言

编译时作出内存分配决定。不必运行时刻重新分配。

控制类型错误。

PlayingCard aCard;   

 aCard.someFunction();

6、动态类型语言

Function max(a,b){

    if (a<b)

        then returnb;

  return a;

}

7、伪变量

大多数面向对象语言中，接收器并不出现在方法的参数列表中，而是隐藏于方法的定义之中。只有当必须从方法体内部去存取接收器的数值时，才会使用伪变量。

Java,C++:this

Eiffel:Current

Smalltalk,object-c:self

它不需要被声明，也不能被更改。

8、对象自身引用

this隐含指向调用成员函数的对象。

9、Java:new仅创建数组。数组包含的对象必须独立创建。

第八章继承和替换

1、※扩展与简化

继承在程序语言中的含义如下：子类所具有的数据和行为总是作为与其相关的父类的属性的扩展( extension) （即更大的集合）。子类具有父类的所有属性以及其他属性。另一方面，由于子类是父类的更加特殊（或受限制）的形式，在某种程度上，子类也是父类的收缩( contraction)。

这种把继承作为一种扩展同时也作为一种收缩的思想，正是面向对象技术强大的原因，同时也会在正常的部署中引起混淆 。

2、继承的作用

代码复用

概念复用。共享方法的定义。

3、通过(is-a)检验规则检验两个概念是否为继承关系

4、类中public和protected类型的成员，其子类能访问；父类中private类型的成员，其子类不能访问，只能自己类内部使用。

5、在静态类型语言中父类和子类数据类型的关系？

①子类实例必须拥有父类的所有数据成员。

②子类的实例必须至少通过继承实现父类所定义的所有功能。

这样，在某种条件下，如果用子类实例来替换父类实例，那么将会发现子类实例可以完全模拟父类的行为，二者毫无差异。

6、█替换原则

指如果类B是类A的子类，那么在任何情况下都可以用类B来替换类A，而外界毫无察觉。

7、子类型*

指符合替换原则的子类关系。

区别于一般的可能不符合替换原则的子类关系

8、改写

子类有时为了避免继承父类的行为，需要对其进行改写

语法上：子类定义一个与父类有着相同名称且类型签名相同的方法。

运行时：变量声明为一个类，它所包含的值来自于子类，与给定消息相对应的方法同时出现于父类和子类。

改写与替换结合时，想要执行的一般都是子类的方法。

9、接口

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。与类一样，接口可以继承于其他接口，甚至可以继承于多个父接口。虽然继承类和实现接口并不完全相同，但他们非常相似，因此使用继承这一术语来描述这两种行为。

第十章静态行为和动态行为

1、静态类和动态类

变量的静态类是指用于声明变量的类。静态类在编译时就确定下来，并且再也不会改变。

变量的动态类指与变量所表示的当前数值相关的类。动态类在程序的执行过程中，当对变量赋新值时可以改变。

对于静态类型面向对象编程语言，在编译时消息传递表达式的合法性不是基于接收器的当前动态数值，而是基于接收器的静态类来决定的。

2、向下造型（反多态）

做出数值是否属于指定类的决定之后，通常下一步就是将这一数值的类型由父类转换为子类。这一过程称为向下造型，或者反多态，因为这一操作所产生的效果恰好与多态赋值的效果相反。

3、方法绑定

响应消息时对哪个方法进行绑定是由接收器当前所包含的动态数值来决定的。

4、多态变量

如果方法所执行的消息绑定是由最近赋值给变量的数值的类型来决定的，那么就称这个变量是多态的。Java,Smalltalk等变量都是多态的。

第十四章多态及软件复用

1、※多态的形式

重载：(也称为专用多态(ad  hoc polymorphism))用于描述一个函数名称（或者方法名称）有多种不同实现方式的情况。通常可以在编译时基于类型签名来区分各个重载函数的名称。

改写：(或者包含多态(inclusionpolymorphism))是重载的一种特殊情况。只发生在有关父类与子类之间关系的上下文中。改写方法具有相同名称、相同的类型签名。

多态变量(polymorphic  variable)：（或者赋值多态（assignment polymorphism））是指声明为一种类型，但实际上却可以包含另一种类型数值的变量。当多态变量用作参数时建立的函数将展现纯多态(pure polymorphism)。//声明与包含不同。

泛型（或模板）提供了一种创建通用工具的方法，可以在特定的场合将其特化。

2、最常用的软件复用机制：继承和组合。

3、组合

提供了一种利用已存在的软件组件来创建新的应用程序的方法。

对象是数据（数据值）和行为的封装。在通过使用组合复用已存在的数据抽象来创建新数据类型时，新数据结构的部分状态只是已存在的数据结构的一个实例。

4、█组合与继承的比较

组合是较为简单的一种技术。优点是清楚地指示出在特定的数据结构中需要执行哪些操作。无需考虑列表类所定义的所有操作。

继承无法知道一个方法是否可以合法地应用于集合。

使用继承构建数据抽象的代码的简洁性是继承的一个优点

继承无法防止用户使用父类的方法来操纵新的数据结构：FirstElement

第十五章重载

1、重载是在编译时执行的，而改写是在运行时选择的。

2、多个过程（或函数、方法）允许共享同一名称，且通过该过程所需的参数数目、顺序和类型来对它们进行区分。即使函数处于同一上下文，这也是合法的。

3、关于重载的解析，是在编译时基于参数值的静态类型完成的。不涉及运行时机制。

4、造型：自动类型转换和强制类型转换

自动类型转换是一种隐式的类型转换，它发生在无需显式引用的程序中。强制类型转换表示程序员所进行的显式类型转换。

5、x是y的父类  

上溯造型  

X a=new X();

Y b=new Y();

a=b;  //将子类对象造型成父类对象，相当做了个隐式造型：a = (X)b;

下溯造型

X a=new X();

Y b=new Y();

X a1=b；

Y b1=(Y)a1 ；

6、作为转换的替换

类型转换：“类型的改变”，替换原则将引入一种传统语言所不存在的另外一种形式的类型转换。

发生在类型为子类的数值作为实参用于使用父类类型定义对应的形参的方法中时。

7、█匹配原则

找到所有可能进行调用的方法，即各个参数可以合法地赋值给各个参数类型的所有方法。如果找到一个在调用时可以完全匹配所使用的参数类型的方法，那么就执行这个方法。

如果第一步所产生的集合中，某个方法的所有参数类型都可以赋值给集合中的另一个方法的所有参数类型，那么就将第二个方法从集合中移走。重复以上操作，直至无法实现进一步的缩减为止。

如果只剩下一个方法，那么这个方法就非常明确了，调用这个方法即可。如果剩余的方法不止一个，那么调用就产生歧义了，此时编译器将报告错误。

第十六章改写

1、如果子类的方法具有与父类的方法相同的名称和类型签名，称子类的方法改写了父类的方法。

2、改写可看成是重载的一种特殊情况。

由于重载也涉及一个方法名称和两个或更多个方法体

3、█改写和重载的差异

①对于改写来说，方法所在的类之间必须符合父类/子类继承关系，而对于简单的重载来说，并无此要求。

②如果发生改写，两个方法的类型签名必须匹配。

③重载方法总是独立的，而对于改写的两个方法，有时会结合起来一起实现某种行为。

④重载通常是在编译时解析的，而改写则是一种运行时机制。对于任何给定的消息，都无法预言将会执行何种行为，而只有到程序实际运行的时候才能对其进行确定。

4、改写并不能改变方法的可存取性。

如果一个方法在父类中为public，那么不允许在子类中将该方法声明为private。反之亦然。

5、█代替与改进——两种不同的关于改写的解释方式

代替（replacement）：在程序执行时，实现代替的方法完全覆盖父类的方法。即，当操作子类实例时，父类的代码完全不会执行。

改进(refinement)：实现改进的方法将继承自父类的方法的执行作为其行为的一部分。这样父类的行为得以保留且扩充。

这两种形式的改写都很有用，并且经常在一种编程语言内同时出现

如：几乎所有的语言在构造函数中都使用改进语义。即，子类构造函数总是调用父类的构造函数，来保证父类的数据字段和子类的数据字段都能够正确地初始化化。

第十七章多态变量

1、多态变量是指可以引用多种对象类型的变量。

这种变量在程序执行过程可以包含不同类型的数值。

对于动态类型语言，所有的变量都可能是多态的。

对于静态类型语言，多态变量则是替换原则的具体表现。

2、多态变量形式

简单变量

接收器变量

纯多态(多态方法)

3、多态变量在框架中的作用

多态接收器功能的强大之处表现在消息传递与改写相结合时。这种结合是软件框架开发的关键。

一般框架系统中的方法分为两大类：

①在父类中定义基础方法，被多个子类所继承，但不被改写；

②父类定义了关于多种活动的方法，但要延迟到子类才实现。

4、接收器变量多态性的展现

当执行基础方法时，接收器实际上保存的是一个子类实例的数值。

当执行一个改写方法时，执行的是子类的方法，而不是父类的方法。

第二十一章框架

1、框架开发的一个重要基础是以完全不同的两种方式来使用继承—复用、特化

2、类的方法可以分为两大类

基本方法：它定义于父类，通过继承但却不对其改写的方式成为子类的一部分。体现了对问题的现存的解决方案。代码复用。

特化方法：为了适合于子类的特定环境，改变了其在父类中的行为。用于特定应用的解决方案。概念复用。

面向对象的设计原则

1、设计目标

可扩展性(Extensibility):新功能易加入系统。

灵活性(Flexibility):允许代码修改平稳发生，不会涉及很多其他模块。

可插入性(Pluggability):容易将一个类换为另一个具有同样接口的类。

2、软件复用重要性

较高的生产率

较高的软件质量

恰当使用复用,可改善系统的可维护性

3、抽象化和继承:使概念和定义可复用

多态:使实现和应用可复用

抽象化和封装:可保持和促进系统的可维护性

4、面向对象设计中，可维护性复用是以设计原则和设计模式为基础的。

5、面向对象设计原则

开闭原则OCP:Open-ClosedPrinciple

里氏替换原则LSP:LiskovSubstitution Principle

依赖倒转原则DIP:DependencyInversion Principle

接口隔离原则ISP:InterfaceSegregation Principle

组合复用原则CRP:CompositoinResuse Principle

迪米特法则LoD:Lawof Demeter

单一职责原则（SRP)

6、开闭原则

软件组成实体应该是对扩展可扩展的，但是对修改是关闭的。

7、依赖倒转原则

抽象不应当依赖于细节，细节应当依赖于抽象。

8、█使用接口的优点

Client不必知道其使用对象的具体所属类。

一个对象可以很容易地被(实现了相同接口的)的另一个对象所替换。

对象间的连接不必硬绑定(hardwire)到一个具体类的对象上，因此增加了灵活性。

松散耦合 (loosens coupling)。

增加了重用的可能性。

提高了(对象)组合的机率，因为被包含对象可以是任何实现了一个指定接口的类。

9、组合复用原则

组合优先原则：优先使用(对象)组合，而非(类)继承

10、█组合的优点

容器类仅能通过被包含对象的接口来对其进行访问。

“黑盒”复用，因为被包含对象的内部细节对外是不可见。

封装性好。

实现上的相互依赖性比较小。

每一个类只专注于一项任务。

通过获取指向其它的具有相同类型的对象引用，可以在运行期间动态地定义(对象的)组合。

11、█组合的缺点

从而导致系统中的对象过多。

为了能将多个不同的对象作为组合块(composition block)来使用，必须仔细地对接口进行定义。

12、█继承的优点

容易进行新的实现，因为其大多数可继承而来。

易于修改或扩展那些被复用的实现。

13、█继承缺点

破坏了封装性，因为这会将父类的实现细节暴露给子类。

“白盒”复用，因为父类的内部细节对于子类而言通常是可见的。

当父类的实现更改时，子类也不得不会随之更改。

从父类继承来的实现将不能在运行期间进行改变。