Java 面向对象16种设计原则
一类的设计原则
1依赖倒置原则－Dependency Inversion Principle (DIP)
2里氏替换原则－Liskov Substitution Principle (LSP)
3接口分隔原则－Interface Segregation Principle (ISP)
4单一职责原则－Single Responsibility Principle (SRP)
5开闭原则－The Open-Closed Principle (OCP)
二包的设计原则
6重用发布等价原则－Release Reuse Equivalency Principle (REP)
7无环依赖原则－The Acyclic Dependencies Principle (ADP)
8稳定依赖原则－The Stable Dependencies Principle (SDP)
9稳定抽象等价原则－The Stable Abstractions Principle (SAP)
10共同封闭原则－The Common Closure Principle (CCP)
11全部重用原则－The Common Reuse Principle (CRP)
三扩展原则
12 迪米特法则－Least Knowledge Principle (LKP)
13 黑盒原则－BBP(Black Box Principle)
14 缺省抽象原则－DAP(Default Abstraction Principle)
15 接口设计原则－IDP(Interface Design Principle)
16 不要构造具体的超类原则－DCSP(Don't Concrete Supperclass Principle)
1. Dependency Inversion Principle (DIP) - 依赖倒置原则
依赖：在程序设计中，如果一个模块a使用或调用了另一个模块b，我们称模块a依赖模块b。高层模块与低层模块：往往在一个应用程序中，我们有一些低层次的类，这些类实现了一些基本的或初级的操作，我们称之为低层模块；另外有一些高层次的类，这些类封装了某些复杂的逻辑，并且依赖于低层次的类，这些类我们称之为高层模块。
依赖倒置原则的2个重要方针：
A. 高层模块不应该依赖于低层模块，二者都应该依赖于抽象
B. 抽象不应该依赖于细节，细节应该依赖于抽象
为什么叫做依赖倒置（Dependency Inversion）呢？
面向对象程序设计相对于面向过程（结构化）程序设计而言，依赖关系被倒置了。因为传统的结构化程序设计中，高层模块总是依赖于低层模块。
问题的提出：
Robert C. Martin在原文中给出了“Bad Design”的定义：
1. 系统很难改变，因为每个改变都会影响其他很多部分。
2. 当你对某地方做一修改，系统的看似无关的其他部分都不工作了。
3. 系统很难被另外一个应用重用，因为你很难将要重用的部分从系统中分离开来。
导致“Bad Design”的很大原因是“高层模块”过分依赖“低层模块”。一个良好的设计应该是系统的每一部分都是可替换的。如果“高层模块”过分依赖“低层模块”，一方面一旦“低层模块”需要替换或者修改，“高层模块”将受到影响；另一方面，高层模块很难可以重用。
比如，一个Copy模块，需要把来自Keyboard的输入复制到Print，即使对Keyboard和Print的封装已经做得非常好，但如果Copy模块里直接使用Keyboard与Print，Copy任很难被其他应用环境（比如需要输出到磁盘时）重用。
问题的解决：
为了解决上述问题，Robert C. Martin提出了OO设计的Dependency Inversion Principle (DIP) 原则。
DIP给出了一个解决方案：在高层模块与低层模块之间，引入一个抽象接口层。
High Level Classes（高层模块）--> Abstraction Layer（抽象接口层）--> Low Level Classes（低层模块）
抽象接口是对低层模块的抽象，低层模块继承或实现该抽象接口。
这样，高层模块不直接依赖低层模块，高层模块与低层模块都依赖抽象接口层。
当然，抽象也不依赖低层模块的实现细节，低层模块依赖（继承或实现）抽象定义。
Robert C. Martin给出的DIP方案的类的结构图：
PolicyLayer-->MechanismInterface(abstract)--MechanismLayer-->UtilityInterface(abstract)--UtilityLayer 类与类之间都通过Abstract Layer来组合关系。
2. Liskov Substitution Principle (LSP) - 里氏替换原则
所有引用基类的地方必须能透明地使用其子类的对象。也就是说，只有满足以下2个条件的OO 设计才可被认为是满足了LSP原则：
A 不应该在代码中出现if/else之类对子类类型进行判断的条件。以下代码就违反LSP定义。
if (obj typeof Class1) {
do something
} else if (obj typeof Class2) {
do something else
}
B 子类应当可以替换父类并出现在父类能够出现的任何地方，或者说如果我们把代码中使用基类的地方用它的子类所代替，代码还能正常工作。
里氏替换原则LSP是使代码符合开闭原则的一个重要保证。同时LSP体现了：
1）类的继承原则：如果一个继承类的对象可能会在基类出现地方出现运行错误，则该子类不应该从该基类继承，或者说，应该重新设计它们之间的关系。
2）动作正确性保证：从另一个侧面上保证了符合LSP设计原则的类的扩展不会给已有的系统引入新的错误。
类的继承原则：
Robert C. Martin举了Rectangle和Square的例子。这里沿用这个例子，但用Java语言对其加以重写，并忽略了某些细节只列出下面的精要部分来说明里氏替换原则对类的继承上的约束。
1.class Rectangle {
2. double width;
3. double height;
4.
5. public double getHeight() {
6. return height;
7.}
8. public void setHeight(double height) {
9. this.height = height;
10.}
11. public double getWidth() {
12. return width;
13.}
14. public void setWidth(double width) {
15. this.width = width;
16.}
17.}
18.
19.class Square extends Rectangle {
20. public void setHeight(double height) {
21. super.setHeight(height);
22. super.setWidth(height);
23.}
24.
25. public void setWidth(double width) {
26. super.setHeight(width);
27. super.setWidth(width);
28.}
29.}
这里Rectangle是基类，Square从Rectangle继承。这种继承关系有什么问题吗？
假如已有的系统中存在以下既有的业务逻辑代码：
void g(Rectangle r) {
r.setWidth(5);
r.setHeight(4);
if (r.getWidth() * r.getHeight() != 20) {
throw new RuntimeException();
}
}
则对应于扩展类Square，在调用既有业务逻辑时：
Rectangle square = new Square();
g(square);
时会抛出一个RuntimeException异常。这显然违反了LSP原则。
动作正确性保证：
因为LSP对子类的约束，所以为已存在的类做扩展构造一个新的子类时，根据LSP的定义，不会给已有的系统引入新的错误。
Design by Contract
根据Bertrand Meyer提出的Design by Contract（DBC：基于合同的设计）概念的描述，对于类的一个方法，都有一个前提条件以及一个后续条件，前提条件说明方法接受什么样的参数数据等，只有前提条件得到满足时，这个方法才能被调用；同时后续条件用来说明这个方法完成时的状态，如果一个方法的执行会导致这个方法的后续条件不成立，那么此方法也不应该正常返回。
现在把前提条件以及后续条件应用到继承子类中，子类方法应该满足：
１）前提条件不强于基类．
２）后续条件不弱于基类．
换句话说，通过基类的接口调用一个对象时，用户只知道基类前提条件以及后续条件。因此继承类不得要求用户提供比基类方法要求的更强的前提条件，亦即，继承类方法必须接受任何基类方法能接受的任何条件（参数）。同样，继承类必须顺从基类的所有后续条件，亦即，继承类方法的行为和输出不得违反由基类建立起来的任何约束，不能让用户对继承类方法的输出感到困惑。这样，我们就有了基于合同的LSP，基于合同的LSP是LSP的一种强化。
在很多情况下，在设计初期我们类之间的关系不是很明确，LSP则给了我们一个判断和设计类之间关系的基准：需不需要继承，以及怎样设计继承关系。
3. Interface Segregation Principle (ISP) - 接口分隔原则
不能强迫用户去依赖那些他们不使用的接口。换句话说，使用多个专门的接口比使用单一的总接口总要好。它包含了2层意思：
1）接口的设计原则：接口的设计应该遵循最小接口原则，不要把用户不使用的方法塞进同一个接口里。
如果一个接口的方法没有被使用到，则说明该接口过胖，应该将其分割成几个功能专一的接口。
2）接口的依赖（继承）原则：如果一个接口a依赖（继承）另一个接口b，则接口a相当于继承了接口b的方法，那么继承了接口b后的接口a也应该遵循上述原则：不应该包含用户不使用的方法。反之，则说明接口a被b给污染了，应该重新设计它们的关系。
如果用户被迫依赖他们不使用的接口，当接口发生改变时，他们也不得不跟着改变。换而言之，一个用户依赖了未使用但被其他用户使用的接口，当其他用户修改该接口时，依赖该接口的所有用户都将受到影响。这显然违反了开闭原则，也不是我们所期望的。
下面我们举例说明怎么设计接口或类之间的关系，使其不违反ISP原则。
假如有一个Door，有lock，unlock功能，另外，可以在Door上安装一个Alarm而使其具有报警功能。用户可以选择一般的Door，也可以选择具有报警功能的Door。
有以下几种设计方法：
ISP原则的违反例：
方法一：
在Door接口里定义所有的方法。图：
但这样一来，依赖Door接口的CommonDoor却不得不实现未使用的alarm()方法。违反了ISP原则。
方法二：
在Alarm接口定义alarm方法，在Door接口定义lock，unlock方法，Door接口继承Alarm接口。
跟方法一一样，依赖Door接口的CommonDoor却不得不实现未使用的alarm()方法。违反了ISP 原则。
遵循ISP原则的例：
方法三：通过多重继承实现
Adapter设计模式的实现。
第2）种方案更具有实用性。
这种设计遵循了ISP设计原则。
方法四：通过委托实现
在Alarm接口定义alarm方法，在Door接口定义lock，unlock方法。接口之间无继承关系。CommonDoor实现Door接口，
AlarmDoor有2种实现方案：
1）同时实现Door和Alarm接口。
2）继承CommonDoor，并实现Alarm接口。该方案是继承方式的
小结
Interface Segregation Principle (ISP)从对接口的使用上为我们对接口抽象的颗粒度建立了判断基准：在为系统设计接口的时候，使用多个专门的接口代替单一的胖接口。
4. Single Responsibility Principle (SRP) - 单一职责原则
永远不要让一个类存在多个改变的理由。换句话说，如果一个类需要改变，改变它的理由永远只有一个。如果存在多个改变它的理由，就需要重新设计该类。
SRP（Single Responsibility Principle）原则的核心含意是：只能让一个类有且仅有一个职责。这也是单一职责原则的命名含义。
为什么一个类不能有多于一个以上的职责呢？
如果一个类具有一个以上的职责，那么就会有多个不同的原因引起该类变化，而这种变化将影响到该类不同职责的使用者（不同用户）：
1，一方面，如果一个职责使用了外部类库，则使用另外一个职责的用户却也不得不包含这个未被使用的外部类库。
2，另一方面，某个用户由于某原因需要修改其中一个职责，另外一个职责的用户也将受到影响，他将不得不重新编译和配置。这违反了设计的开闭原则，也不是我们所期望的。
职责的划分
既然一个类不能有多个职责，那么怎么划分职责呢？
Robert.C Martin给出了一个著名的定义：所谓一个类的一个职责是指引起该类变化的一个原因。如果你能想到一个类存在多个使其改变的原因，那么这个类就存在多个职责。
Single Responsibility Principle (SRP)的原文里举了一个Modem的例子来说明怎么样进行职责的划分，这里我们也沿用这个例子来说明一下：
SRP违反例：
Modem.java
interface Modem {
public void dial(String pno); //拨号
public void hangup(); //挂断
public void send(char c); //发送数据
public char recv(); //接收数据
}
咋一看，这是一个没有任何问题的接口设计。但事实上，这个接口包含了2个职责：第一个是连接管理（dial, hangup）；另一个是数据通信（send, recv）。很多情况下，这2个职责没有任何共通的部分，它们因为不同的理由而改变，被不同部分的程序调用。
所以它违反了SRP原则。
下面的类图将它的2个不同职责分成2个不同的接口，这样至少可以让客户端应用程序使用具有单一职责的接口：
让ModemImplementation实现这两个接口。我们注意到，ModemImplementation又组合了2个职责，这不是我们希望的，但有时这又是必须的。通常由于某些原因，迫使我们不得不绑定多个职责到一个类中，但我们至少可以通过接口的分割来分离应用程序关心的概念。
事实上，这个例子一个更好的设计应该是这样的，如图：
小结
Single Responsibility Principle (SRP)从职责（改变理由）的侧面上为我们对类（接口）的抽象的颗粒度建立了判断基准：在为系统设计类（接口）的时候应该保证它们的单一职责性。
5. The Open-Closed Principle (OCP) - 开闭原则
开闭原则（OCP：Open-Closed Principle）是指在进行面向对象设计（OOD：Object Oriented Design）中，设计类或其他程序单位时，应该遵循：
- 对扩展开放（open）
- 对修改关闭（closed）
开闭原则是判断面向对象设计是否正确的最基本的原理之一。根据开闭原则，在设计一个软件系统模块（类，方法）的时候，应该可以在不修改原有的模块（修改关闭）的基础上，能扩展其功能（扩展开放）。
A 扩展开放：某模块的功能是可扩展的，则该模块是扩展开放的。软件系统的功能上的可扩展性要求模块是扩展开放的。
B 修改关闭：某模块被其他模块调用，如果该模块的源代码不允许修改，则该模块修改关闭的。软件系统的功能上的稳定性，持续性要求是修改关闭的。
这也是系统设计需要遵循开闭原则的原因：
1）稳定性。开闭原则要求扩展功能不修改原来的代码，这可以让软件系统在变化中保持稳定。2）扩展性。开闭原则要求对扩展开放，通过扩展提供新的或改变原有的功能，让软件系统具有灵活的可扩展性。
遵循开闭原则的系统设计，可以让软件系统可复用，并且易于维护。
开闭原则的实现方法
为了满足开闭原则的对修改关闭（closed for modification）原则以及扩展开放（open for extension）原则，应该对软件系统中的不变的部分加以抽象，在面向对象的设计中，
A 可以把这些不变的部分加以抽象成不变的接口，这些不变的接口可以应对未来的扩展；
B 接口的最小功能设计原则。根据这个原则，原有的接口要么可以应对未来的扩展；不足的部分可以通过定义新的接口来实现；
C 模块之间的调用通过抽象接口进行，这样即使实现层发生变化，也无需修改调用方的代码。
接口可以被复用，但接口的实现却不一定能被复用。接口是稳定的，关闭的，但接口的实现是可变的，开放的。可以通过对接口的不同实现以及类的继承行为等为系统增加新的或改变系统原来的功能，实现软件系统的柔软扩展。
简单地说，软件系统是否有良好的接口（抽象）设计是判断软件系统是否满足开闭原则的一种重要的判断基准。现在多把开闭原则等同于面向接口的软件设计。
开闭原则的相对性
软件系统的构建是一个需要不断重构的过程，在这个过程中，模块的功能抽象，模块与模块间的关系，都不会从一开始就非常清晰明了，所以构建100%满足开闭原则的软件系统是相当困难的，这就是开闭原则的相对性。但在设计过程中，通过对模块功能的抽象（接口定义），模块之间的关系的抽象（通过接口调用），抽象与实现的分离（面向接口的程序设计）等，可以尽量接近满足开闭原则。
6. Release Reuse Equivalency Principle (REP) - 重用发布等价原则
包的内部关系方面（聚合性）的原则，重用粒度等价于发布粒度。重用主要是从用户的观点来看的。对用户来说，使用某个发布单位（组件，类，类群等），如果作者因为某种原因对其作了修改而发布了一个新的版本，用户会期望在升级为新版本之后，不会影响到原系统的正常运作。
也就是说，对于一个可重用（能供其它用户或系统使用）的元素（组件，类，类群等），作者应该承诺新版本能够兼容旧版本。否则，用户将拒绝使用该元素。
Robert C. Martin给出的对重用的定义：
代码可以看作为可重用的代码，当且仅当：
- 它的使用者（下称用户）无需看它的源代码
- 用户只需联结静态库或包含动态库
- 当库发生改变（错误纠正，功能增强）时，用户只需要得到一个新的版本便能集成到原有的系统
怎么做到重用呢？
一个组件要做到能够重用，它必须有一个得到良好设计的结构，它所包含所有元素必须也是可以重用的。
因为如果一个为重用而设计的发布单位里，包含了不可重用的元素，当不可重用的元素发生改变时，用户也不得不改变原有系统以适应新的版本。这显然违反了重用的定义规则。
也就是说，一个为重用目的而设计的发布单位里，不能包含不可重用的元素；如果包含了不可重用的元素，它将变得不可重用。
发布单位
当用户使用的重用组件被作者修改后，用户希望得到通知，然后决定是否升级或升级的时机。为了能使升级后的系统也能正常运作，用户也希望作者有一个规范的发布，包括版本号，类库的说明等等。
一旦用户决定升级新版本，不管这些修改是否影响到用户，用户也不得不包含新版本所包含的所有类库。
REP规定重用粒度不能小于发布粒度，所有重用元素也必须被一起发布。
发布粒度可以为包（组件）或类等实体，但一个应用往往包含了很多类，所以，具有更大的尺度的包（组件）更加适合作为发布粒度。
重用发布等价原则为我们指明了包的设计方针：一个包中的元素（类）要么都可重用，要么都不可重用。
小结
重用发布等价原则（REP）从用户观点的角度上为我们规范了包设计的原则：在设计包时，包中应该包含的元素要么都可以重用，要么都不可以重用。
7. The Acyclic Dependencies Principle (ADP) - 无环依赖原则
包之间的依赖结构必须是一个直接的无环图形（DAG）。也就是说，在依赖结构中不允许出现环（循环依赖）。换成另一个说法是：包间依赖不能是一个环状形式。包间关系方面（耦合性）的原则
包的依赖
如果一个包A 中的类引用了包B中的类，我们称包A依赖包B。
“依赖”在具体的程序语言中表现为，如果A依赖B，C/C++语言则在A包的文件/类中通过#include 语句包含B包中的文件/类；Java语言则A包的类中通过import语句引入B包中的类。
图1（包A依赖包B）
虚线表示一种依赖关系，箭头表示依赖的方向，箭头所在的一侧就是被依赖的包。
包的循环依赖
我们上面讨论了并用图形表示了包之间的依赖关系。如果存在2个或2个以上的包，它们之间的依赖关系图出现了环状，我们就称包之间存在循环依赖关系。
也就是说它们的依赖结构图根据箭头的方向形成了一个环状的闭合图形。如图：
图2：包的循环依赖
如图：A依赖B，B依赖C，C依赖A，形成了一个环状依赖。
包的非循环依赖原则
包是一个比较合适的发布粒度，当修改了包中的代码（类，模块等）并发布新的版本时，我们需要把该包以及它所依赖的其它包一起发布。发布之后，还需要验证系统是否能在新发布的版本下正常运作。
如果多个包之间形成了循环依赖，比如如图2，A依赖B，B依赖C，C依赖A，我们修改了B并需要发布B的一个新的版本，因为B依赖C，所以发布时应该包含C，但C同时又依赖A，所以又应该把A也包含进发布版本里。也就是说，依赖结构中，出现在环内的所有包都不得不一起发布。它们形成了一个高耦合体，当项目的规模大到一定程度，包的数目变多时，包与包之间的关系便变得错综复杂，各种测试也将变得非常困难，常常会因为某个不相关的包中的错误而使得测试无法继续。而发布也变得复杂，需要把所有的包一起发布，无疑增加了发布后的验证难度。
循环依赖的打破方法
如果包的依赖形成了环状结构，怎么样打破这种循环依赖呢？
有2种方法可以打破这种循环依赖关系：第一种方法是创建新的包，第二种方法是使用DIP（依赖倒置原则）和ISP（接口分隔原则）设计原则。
方法一：创建新的包
比如对于图2这种依赖结构：
图2：包的循环依赖
包C要依赖包A，必定A中包含有A，C共通使用的类，把这些共同类抽出来放在一个新的包D 里。这样就把C依赖A变成了C依赖D以及A依赖D，从而打破了循环依赖关系。如图：
这样，包的依赖关系就从A->B->C->A变成了：
A->B->C->D
A->D
方法二：DIP与ISP设计原则
ISP（接口分隔原则）可以剔除美用到的接口。DIP（依赖倒置原则）在类的调用之间引入抽象层。
如图,，包A依赖包B（因为包A中的类U使用了包B中的类X）；反过来，包B又依赖包A（因为包B中的类Y使用了包A中的类V）
包A，包B之间就形成了一种循环依赖。
我们使用DIP设计原则为V抽象一个接口IVforY，并把该接口放在B包中。
这样就把Y对V的调用转化为：
V继承IVforY
Y调用IVforY
如图：
这样一来，包B中的类就不依赖任何包A中的类了。
小结
无环依赖原则（ADP）为我们解决包之间的关系耦合问题。在设计包结构时，不能有循环依赖。
8. The Stable Dependencies Principle (SDP) - 稳定依赖原则
一个设计中的包之间的依赖应该朝着稳定的方向进行。一个包只应该依赖那些比自己更稳定的包。换成另一个说法是：朝着稳定的方向进行依赖。包之间的关系方面（耦合性）的原则。
包的依赖
如果一个包A 中的类引用了包B中的类，我们称包A依赖包B。
“依赖”在具体的程序语言中表现为，如果A依赖B，C/C++语言则在A包的文件/类中通过#include 语句包含B包中的文件/类；Java语言则A包的类中通过import语句引入B包中的类。
图1（包A依赖包B）
虚线表示一种依赖关系，箭头表示依赖的方向，箭头所在的一侧就是被依赖的包。
包的稳定依赖原则
包应该依赖比自己更稳定的包。因为如果依赖一个不稳定的包，那么当这个不稳定的包发生变化时，本身稳定的包也不得不发生变化，变得不稳定了。
所谓稳定，在现实生活中是指一个物体具有稳固不变的属性使它很难发生变化。应用到软件概念上，我们认为一个软件是稳定的，是因为这个软件很难发生改变，或更确切地说，是不需要发生改变。一个设计良好，能应对各种变化不需要修改的软件当然是稳定的了，但事实上，往往一个软件常常需要对应某个事先没有预测到的用户需求而不得不发生改变，当这种改变发生时，能把修改控制在最小的范围之内，并能稳定的工作（包括软件本身以及依赖它的其它软件实体等），我们也会认为该软件是相对稳定的。
怎么样让一个软件足够稳定呢？一个确切的方法是，让大量其它软件的包依赖它。一个包被很多其他包依赖是非常稳定的，这是因为被依赖的包为了协调其他包必须做很多的工作来对应各种变化（责任的负担者）。
图1：稳定的包X
我们认为X是稳定的，因为：
- X被很多其他包依赖。相当于责任担当着。
- X没有依赖别的包，它是独立的。
相反，下面列出了一个非常不稳定的包Y，如图：
图2：不稳定的包Y
我们认为Y是不稳定的，因为：
- Y没有被其他的包所依赖。不是责任的担当着。
- Y依赖很多别的包。
包的稳定性的判断原则
可以通过下面的方法来判断一个包的稳定系数：
Ca：Afferent Coupling。向心耦合。依赖该包（包含的类）的外部包（类）的数目（i.e. incoming dependencies）。
Ce：Efferent Coupling。离心耦合。被该包依赖的外部包的数目（i.e. outgoing dependencies）。I：Instability。不稳定性。I=Ce/(Ce+Ca)。它的值处于[0，1]之间。
如图1，X的Ce=0，所以不稳定性I=0，它是稳定的。相反，如图2，Y的Ce=3，Ca=0，所以它的不稳定性I=1，它是不稳定的。
SDP要求一个包的不稳定性I要大于它所依赖的包的不稳定性。换句话说，沿着依赖的方向，包的不稳定性应该逐渐降低，稳定性应该逐渐升高。
稳定依赖原则（SDP）为我们解决包之间的关系耦合问题。在设计包结构时，包应该只依赖比自己更稳定的包。
9. The Stable Abstractions Principle (SAP) - 稳定抽象等价原则
最稳定的包应该是最抽象的包。不稳定的包应该是具体的包。包的抽象程度跟它的稳定性成正比。稳定的包应该是抽象的包。
包的稳定抽象等价原则
我们在The Stable Dependencies Principle (SDP) - OO设计的稳定依赖原则一文中谈到了包的稳定性：不容易改变的包应该具有更好的稳定性。
一个包的抽象程度越高，它的稳定性就越高。反之，它的稳定性就越低。一个稳定的包必须是抽象的，反之，不稳定的包必须是具体的。
稳定的包的构成
抽象类或接口通过子类继承扩展行为，这表示抽象类或接口比它们的子类更具有稳定性。总之，为了构成稳定的包，应该提高包内的抽象类或接口的比率；它们的子类可以放在另一个不稳定的包内，该包依赖上述稳定的包，从而遵循了稳定依赖原则（SDP）。
理想的体系结构应该是：
不稳定的（容易改变的）包处于上层
- 它们是具体的包实现
稳定的（不容易改变的）包处于下层
- 不容易改变，但容易扩展
- 接口比实现（具体的运行代码）在内在特性上更具有稳定性
图1：遵循稳定依赖原则（SDP）的理想的体系结构
小结
稳定抽象等价原则（SAP）为我们解决包之间的关系耦合问题。在设计包结构时，稳定的包应该是抽象的（由抽象类或接口构成），不稳定的包应该是具体的（由具体的实现类构成）。
10. The Common Closure Principle (CCP) - 共同封闭原则
一个包中所有的类应该对同一种类型的变化关闭。一个变化影响一个包，便影响了包中所有的类。一个更简短的说法是：一起修改的类，应该组合在一起（同一个包里）。包的内部关系方面（聚合性）的原则
如果必须修改应用程序里的代码，我们希望所有的修改都发生在一个包里（修改关闭），而不是遍布在很多包里。
CCP原则就是把因为某个同样的原因而需要修改的所有类组合进一个包里。如果2个类从物理上或者从概念上联系得非常紧密，它们通常一起发生改变，那么它们应该属于同一个包。
CCP跟开闭原则（OCP: Open Closed Principle）有着很深的渊源关系，CCP的“关闭”（closure）就是OCP所提倡的：classes should be closed for modification but open for extension. 类应该对修改关闭，对扩展开放。但我们知道，100%的“关闭”是不现实的，我们在设计系统时，只能尽量地保持对大多数可预见的修改关闭。
CCP延伸了OCP的“关闭”概念，当因为某个原因需要修改时，把需要修改的范围限制在一个最小范围内的包里。CCP原则帮助我们决定哪些类应该被放到同一个包里。
小结
共同封闭原则（CCP）从软件功能的角度上为我们规范了包设计的一个原则：在设计包时，相互之间紧密关联的类应该放在同一包里。
11. The Common Reuse Principle (CRP) - 全部重用原则
包的所有类被一起重用。如果你重用了其中的一个类，就重用全部。换成另一个比较浅显易懂的说法：没有被一起重用的类不应该被组合在一起。CRP原则帮助我们决定哪些类应该被放到同一个包里。包的内部关系方面（聚合性）的原则
依赖一个包就是依赖这个包所包含的一切。当一个包发生了改变，并发布新的版本，使用这个包的所有用户都必须在新的包环境下验证他们的工作，即使被他们使用的部分没有发生任何改变。因为如果包中包含有未被使用的类，即使用户不关心该类是否改变，但用户还是不得不升级该包并对原来的功能加以重新测试。
“不能强迫用户去依赖那些他们不使用的接口”，把这个概念应用到更广范围的包上，就是CRP 的基本理念：不要把用户不使用的类一起组合进包里。
CRP与REP一样，都是从方便用户重用的角度去设计包，重用者是他们的受益者，CCP则让系统的维护者受益。CCP让包尽可能大（CCP原则加入功能相关的类），CRP则让包尽可能小（CRP 原则剔除不使用的类）。它们的出发点不一样，但不相互冲突。CRP保证了包的内部具有很高的聚合性。
全部重用原则（CRP）从用户的角度上为我们规范了包设计的一个原则：在设计包时，相互之间没有紧密关联的类不应该放在同一包里。
12. Least Knowledge Principle (LKP) -迪米特法则
迪米特法则（Law of Demeter，LoD）也称为最少知识原则（Least Knowledge Principle，LKP）。一个对象应该对其他对象有最少的了解。通俗地讲，一个类应该对自己需要耦合或调用的类知道得最少，你（被耦合或调用的类）的内部是如何复杂都和我没关系，那是你的事情，我就知道你提供的public方法，我就调用这么多，其他的一概不关心。
含义：
?只和朋友交流
朋友类的定义是这样的：出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。下面的代码在方法体内部依赖了其他类，这严重违反迪米特法则
01 public class Teacher {
02
03 public void commond(GroupLeader groupLeader) {
04 List
05
06 for (int i = 0; i < 20; i++) {
07 listGirls.add(new Girl());
08 }
09
10 groupLeader.countGirls(listGirls);
11 }
12
13 }
方法是类的一个行为，类竟然不知道自己的行为与其他类产生了依赖关系，这是不允许的。正确的做法是：
1 public class Teacher {
2
3 public void commond(GroupLeader groupLeader) {
4 groupLeader.countGirls();
5 }
6
7 }
01 public class GroupLeader {
02
03 private List
04
05 public GroupLeader(List
06 this.listGirls = _listGirls;
07 }
08
09 public void countGirls() {
10 System.out.println("女生数量是：" + listGirls.size());
11 }
12
13 }
注意：一个类只和朋友交流，不与陌生类交流，不要出现getA().getB().getC().getD()这种情况（在一种极端情况下允许出现这种访问，即每一个点号后面的返回类型都相同），类与类之间的关系是建立在类间的，而不是方法间，因此一个方法尽量不引入一个类中不存在的对象，当然，JDK API提供的类除外。
?朋友间也是有距离的
一个类公开的public属性或方法越多，修改时涉及的面也就越大，变更引起的风险扩散也就越大。因此，为了保持朋友类间的距离，在设计时需要反复衡量：是否还可以再减少public方法和属性，是否可以修改为private、package-private（包类型，在类、方法、变量前不加访问权限，则默认为包类型）、protected等访问权限，是否可以加上final关键字等。
注意：迪米特法则要求类“羞涩”一点，尽量不要对外公布太多的public方法和非静态的public变量，尽量内敛，多使用private、package-private、protected等访问权限。
?是自己的就是自己的
如果一个方法放在本类中，既不增加类间关系，也对本类不产生负面影响，就放置在本类中。
?谨慎使用Serializable
最后，迪米特法则的核心观念就是类间解耦，弱耦合，只有弱耦合了以后，类的复用率才可以提高。
简答题 1、传统的结构化程序设计的优点和缺点是什么？ 优点： （1）这种程序设计方法力求算法描述准确。 （2）对每一子过程模块容易进行程序正确性证明。 缺点： （1）这种程序设计方法本质上是面向“过程”的，而“过程”和“操作”又是不稳定和多变的，因此不能直接反映人类求解问题的思路。 （2）程序代码可重用性差。程序中除少数标准库函数外，每设计一个程序时，程序员几乎从零做起。即使重用代码，通常也是通过拷贝或编辑重新生成一份。 （3）维护程序的一致性困难。该种方法将数据与对数据进行处理的程序代码分离。 2、什么是对象？ 每个对象都具有属性（Attribute）和方法（Method）这两方面的特征。对象的属性描述了对象的状态和特征，对象的方法说明了对象的行为和功能，并且对象的属性值只应由这个对象的方法来读取和修改，两者结合在一起就构成了对象的完整描述。 3、什么是消息？ 在面向对象的程序设计中，由于对象描述了客观实体，它们之间的联系通过对象间的联系来反映。当一个对象需要另外一个对象提供服务时，它向对方发出一个服务请求，而收到请求的对象会响应这个请求并完成指定的服务。这种向对象发出的服务请求就称为消息。4、什么是多态性？ 所谓多态性是指当程序中的其他部分发出同样的消息时，按照接收消息对象的不同能够自动执行类中相应的方法。其好处是，用户不必知道某个对象所属的类就可以执行多态行为，从而为程序设计带来更大方便。 5、什么是面向对象的程序设计方法? 这种方法将设计目标从模拟现实世界的行为转向了模拟现实世界中存在的对象及其各自的行为。 在OOP中，将“对象”作为系统中最基本的运行实体，整个程序即由各种不同类型的对象组成，各对象既是一个独立的实体，又可通过消息相互作用，对象中的方法决定要向哪个对象发消息、发什么消息以及收到消息时如何进行处理等。 6、面向对象方法的特点是什么？ （1）OOP以“对象”或“数据”为中心。由于对象自然地反映了应用领域的模块性，因此具有相对稳定性，可以被用作一个组件去构成更复杂的应用，又由于对象一般封装的是某一实际需求的各种成分，因此，某一对象的改变对整个系统几乎没有影响。 （2）引入了“类”（class）的概念。类与类以层次结构组织，属于某个类的对象除具有该类所描述的特性外，还具有层次结构中该类上层所有类描述的全部性质，OOP中称这种机制为继承。 （3）OOP方法的模块性与继承性，保证了新的应用程序设计可在原有对象的数据类型和功能的基础上通过重用、扩展和细化来进行，而不必从头做起或复制原有代码，这样，大大减少了重新编写新代码的工作量，同时降低了程序设计过程中出错的可能性，达到了事半功倍的效果。 7、面向对象的程序设计方法与结构化程序设计方法的比较 （1）传统的结构化程序设计方法以过程为中心构造应用程序，数据和处理数据的过程代码是分离的、相互独立的实体，设计出的程序可重用代码少，且当代码量增加时维护数据和代码的一致性困难。
《面向对象程序设计》 大作业 题目学生成绩管理系统 学院 专业 班级 姓名 指导教师 2015 年11 月11 日
目录 一大作业的目的 (1) 二大作业的内容............................ . .. (2) 三大作业的要求与数据............... ...... . (3) 四大作业应完成的工作.................. . (4) 五总体设计（包含几大功能模块）........... . (5) 六详细设计（各功能模块的具体实现算法——流程图） (6) 七调试分析（包含各模块的测试用例，及测试结果） (7) 八总结 (8) 十参考资料 (9)
一大作业的目的 《面向对象程序设计》是一门实践性很强的课程，通过大作业不仅可以全方位检验学生知识掌握程度和综合能力，而且还可以进一步加深、巩固所学课程的基本理论知识，理论联系实际，进一步培养自己综合分析问题和解决问题的能力。更好地掌握运用C++语言独立地编写、调试应用程序和进行其它相关设计的技能。 二大作业的内容 对学生信息(包括学号、语文、数学、英语、平均分)进行管理,包括学生成绩的信息输入、输出、查询、删除、排序、统计、退出.将学生的成绩信息进行记录，信息内容包含：（1）学生的学号（2）学生的姓名（3）学生的成绩。假设，现收集到了一个班学生的所有成绩信息，要求用C语言编写一个简单的成绩管理系统，可进行录入、查询、修改和浏览等功能。学习相关开发工具和应用软件，熟悉系统建设过程。 三大作业的要求与数据 1、用C++语言实现系统； 2、对学生信息(包括学号、姓名、语文、数学、英语、平均分)进行管理,包括学生成绩的信息输入、输出、查询、删除、排序、统计、退出. 3、学生信息包括：其内容较多，为了简化讨论，要求设计的管理系统能够完成以下功能： (1) 每一条记录包括一个学生的学号、姓名、3门课成绩 (2)、成绩信息录入功能：(成绩信息用文件保存，可以一次完成若干条记录 的输入。) (3)、成绩信息显示浏览功能：完成全部学生记录的显示。 (4)、查询功能：完成按姓名查找学生记录，并显示。 (5)成绩信息的删除:按学号进行删除某学生的成绩. (6)、排序功能：按学生平均成绩进行排序。 (7)、应提供一个界面来调用各个功能,调用界面和各个功能的操作界面应尽可能清晰美观!
结构化分析设计与面向对象分析设计比较研究 重庆工商大学计算机科学与技术08软件龚霞 指导老师康世瀛 中文摘要：解析了结构化方法和面向对象方法这两种软件开发方法具有的分析设计过程，讨论了各自在不同软件开发中的应用及局限性，提出了在选用面向对象开发大型软件系统的同时可结合结构化方法。 关键词：软件开发；结构化方法；面向对象方法 Abstract：This paper anatomizes the analysis and design process of Structural method and objected-oriented method,discusses their applications and disadvantages and proposes that structural method can also be used while developing the large-scale software systems in selecting the objected-oriented method. Key words：software-development;objected-oriented method;structural method 一、引言 结构化方法由E.Yourdon和L.L.Constantine在1978年提出，结构化方法又可称为面向功能的软件开发方法或面向数据流的软件开发方法。结构化方法是建立在软件生存周期的模型基础上的一种软件开发方法，相对于早期的个体化开发方法无疑是前进了一大步。 由于传统的生命周期开发学存在下面的问题：生产率提高的幅度远不能满足需求，软件的重用度很低，软件难以维护，软件往往不能满足用户的需求。所以出现了面向对象软件开发方法。这是一种自底向上和自顶向下相结合的方法，而且它以对象建模为基础，从而不仅考虑了输入、输出数据结构，实际上也包含了所有对象的数据结构，所以面向对象的软件开发方法彻底实现了PAM没有完全实现的目标。不仅如此，面向对象技术在需求分析、可维护性和可靠性这三个软件开发的关键环节和质量指标上有了
实验一熟悉VC++IDE开发环境 一、实验目的 1、熟悉VC++6.0集成开发环境，熟练掌握VC++6.0项目工作区、各种编辑器、菜单栏和工具栏的使用。 2、掌握如何编辑、编译、连接和运行一个C++程序。 3、通过运行简单的C++程序，初步了解C++源程序的结构和特点。 二、实验要求 1、分析下列程序运行的结果。 程序一： #include 2015秋季学期计算机科学与技术本科 《面向对象程序设计技术》作业题 （在电大在线该课程讨论区跟帖提交，注明姓名和学号以记录成绩）选择题 1.可以在本类及派生类的成员函数中进行访问的访问控制修饰符是（B） A.private B.protected C.public 2.在IDE中将编程项目采用多文件结构下，类的定义一般放在（A） A.头文件 B.程序文件 C.主程序文件 3.内联成员函数在类外定义时要将其和类定义一起放在（A） A.头文件 B.程序文件 C.主程序文件 4.下面哪个内存区域是C++中的运行时动态内存分配区域？( D ) A.代码区 B.栈区 C.数据区 D.堆区 5.对象作为函数参数使用时，一般使用（A）形式 A.引用 B.指针 C.对象拷贝 6.同类的多个不同对象的数据成员值各有不同，但不同对象可以共享类的成员函数代码， 实际调用成员函数时，是通过（B ）来区分不同对象的。 A.显式给出不同对象不同地址 B.隐含的this指针 C.引用 7.下面哪一种情况不会自动调用拷贝构造函数。（E） A.用一个对象初始化另一个对象时 B.当一个对象作为值传递给一个函数时 C.当一个对象作为值从一个函数返回之前，该对象被拷贝到栈区 D.函数调用结束后，栈区中的返回对象拷贝给主调程序的对象 E.建立指向对象的指针并初始化指针值时 8.下列哪些对象的数据成员类型可以不用初始化表的方式进行初始化（D） A.常量数据成员 B.引用数据成员 C.类中对象成员 D.一般数据成员 9.下列哪一种类设计一般无需在类中设计静态数据成员以使建立的多个对象共享静态数 据数据成员。( D ) A.一个链表类的头指针和尾指针 B.一个学生类中用于保存建立了多少个学生对象的计数器 C.银行帐号类中的年利率 D.一般只用于建立一个对象的类 10.一个类中的公有（public）性质的静态数据成员，以下哪一种访问方式是错误的（D） A.对象名.静态数据成员名 B.指向对象的指针—>静态数据成员名 C.类名::静态数据成员名 D.类名.静态数据成员名 11.下列哪一个运算符不能够被类所重载（E） A.“.”成员访问运算符 B.“*”成员指针访问运算符 C.“::”域运算符 D.“？:”条件运算符 E.“=”赋值运算符 第1章面向对象软件开发概述 1．简述面向过程问题求解和面向对象问题求解的异同。试列举出面向对象和面向过程的编程语言各两种。 答：面向过程问题求解，以具体的解题过程为研究和实现的主体，其思维特点更接近于计算机；面向对象的问题求解，则是以“对象”为主体，“对象”是现实世界的实体或概念在计算机逻辑中的抽象表示，更接近于人的思维特点。 面向过程的编程语言：C，Pascal，Foratn。 面向对象的编程语言：C++，Java，C#。 2．简述对象、类和实体及它们之间的相互关系。尝试从日常接触到的人或物中抽象出对象的概念。 答：面向对象技术中的对象就是现实世界中某个具体的物理实体在计算机逻辑中的映射和体现。类是同种对象的集合与抽象。类是一种抽象的数据类型，它是所有具有一定共性的对象的抽象，而属于类的某一个对象则被称为是类的一个实例，是类的一次实例化的结果。如果类是抽象的概念，如“电视机”，那么对象就是某一个具体的电视机，如“我家那台电视机”。 3．对象有哪些属性?什么是状态?什么是行为?二者之间有何关系?设有对象“学生”，试为这个对象设计状态与行为。 答：对象都具有状态和行为。 对象的状态又称为对象的静态属性，主要指对象内部所包含的各种信息，也就是变量。每个对象个体都具有自己专有的内部变量，这些变量的值标明了对象所处的状态。 行为又称为对象的操作，它主要表述对象的动态属性，操作的作用是设置或改变对象的状态。 学生的状态：姓名、性别、年龄、所在学校、所在系别、通讯地址、电话号码、入学成绩等； 学生的行为：自我介绍、入学注册、选课、参加比赛等。 4．对象间有哪三种关系?对象“班级”与对象“学生”是什么关系?对象“学生”与对象“大学生”是什么关系? 答：对象间可能存在的关系有三种：包含、继承和关联。 对象“班级”与对象“学生”是包含关系。 对象“学生”与对象“大学生”是继承关系。 5．有人说“父母”和“子女”之间是继承的关系。这种说法是否正确?为什么? 答：“父母”和“子女”之间不是面向对象意义上的“继承”关系。因为这里的继承关系是“is a”的关系，“男人”与“人”之间可以说是继承关系。 6．面向对象的软件开发包括哪些过程?OOA模型包括哪三个层次?OOD模型在OOA模型的基础上引入了哪些工作? 答：面向对象的软件开发过程可以大体划分为面向对象的分析(Object Oriented analysis，OOA)、面向对象的设计(Object oriented design，OOD)、面向对象的实现(Object oriented programming，OOP)三个阶段。 面向对象的分析的主要作用是明确用户的需求，并用标准化的面向对象的模型规范地表述这一需求，最后将形成面向对象的分析模型。 面向对象的设计将在OOA模型的基础上引入界面管理、任务管理和数据管理三部分的内容。 7．面向对象的程序设计方法有哪些优点? 答：由于对象的概念能够以更接近实际问题的原貌和实质的方式来表述和处理这些问题，所以面向对象的软件开发方法比以往面向过程的方法有更好的灵活性、可重用性和可扩展性，使得上述“分析—设计—实现”的开发过程也更加高效、快捷。 第一章 1.选择题 (1)软件工程的概念是在（）年被首次提出的。 A.1949 B.1968 C.1972 D.1989 (2)下列不属于软件工程的目标的一项是（） A.提高软件产品的质量 B.提高软件产品的可靠性 C.减少软件产品的需求 D.控制软件开发成本 (3)软件危机产生的主要原因是（） A.软件工具落后 B.软件生产能力不足 C.对软件认识不够 D.软件本身的特点及开发方法 (4)人们公认的第一门面向对象编程语言是（）。 A. Simula B. Smalltalk C. C++ D. Java (5)下列编程语言中不支持面向对象的特性的是（）。 A. C++ B. ANSI C C. Java D. Objetive c (6)下列选项中不是面向对象方法的相关原则的是（） A.封装 B.继承 C.多态 D.结构 (7)（）是面向对象方法中用来描述”对客户隐藏对象的属性和实现细节”的概念。 A.封装 B.继承 C.多态 D.抽象 (8)下列选项中不属于面向对象方法的优势之-的是（）。 A.复用性强 B.改善了软件结构 C.软件的执行效率更高 D.抽象更符合人类的思维习惯 2.判断题 (1)软件就是程序，编写软件就是编写程序。对错 (2)软件危机的主要表现是软件需求增加，软件价格上升。对错 (3) C语言对面向对象的发展起到了重要作用。对错 (4)面向对象方法中的对象是从客观世界中抽象出来的一个集合体。对错 (5)面向对象可以保证开发过程中的需求变化完全不会导致系统结构的变化。对错 (6)面向对象方法就是使用面向对象的程序设计语言进行编程。对错 (7)对象的自治性指的是对象是完全封闭的,不受任何外界影响。对错 (8)类是面向对象程序中的构造单位，也是面向对象程序设计语言的基本成分。对错 第二章 1.选择题 1.选择题 (1)下列关于模型的表述，不正确的项是（）。 A.建模语言只能是图形表示的 B.模型所描绘的系统蓝團既可以包括详细的计划，也可以包括系统的总体计划 C.模型可以帮助开发组生成有用的工作产品 D.最好的模型总是与现实世界联系密切 (2) UML的全称是（）。 A. Unify Modeling L.anguage B. Unified Modeling Language 《面向对象程序设计》第12章在线测试剩余时间：59:56 答题须知：1、本卷满分20分。 2、答完题后，请一定要单击下面的“交卷”按钮交卷，否则无法记录本试卷的成绩。 3、在交卷之前，不要刷新本网页，否则你的答题结果将会被清空。 第一题、单项选择题（每题1分，5道题共5分） 1、面向对象的程序设计语言必须具备的关键要素是( ) A、抽象和封装 B、抽象和多态性 C、抽象、封装、继承和多态性 D、抽象、封装和继承性 2、封装性应具有的条件是（） A、有一个清晰的边界 B、有确定的接口 C、受保护的内部实现 D、以上所有 3、OOD的作用是（） A、提取需求 B、逻辑建模 C、求解域建模 D、分析用例 4、按钮与电梯按钮的关系是（） A、部分与整体 B、一般与特殊 C、实例连接 D、消息连接 5、面向对象模型不包括（） A、静态模型 B、对象模型 C、功能模型 D、动态模型 第二题、多项选择题（每题2分，5道题共10分） 1、部分与整体的关系有（）方式 A、组合 B、联合 C、聚合 D、整合 2、对象之间存在的关系包括（） A、部分与整体 B、一般与特殊 C、实例连接 D、消息连接 3、关于多态的说法正确的是（） A、不同类型的对象接收相同的消息产生不同的行为 B、多态的成员函数需要定义为虚函数 C、在C++中通过基类指针调用虚函数实现多态 D、多态是指对象的多种表现形式 4、关于软件生命周期的说法正确的是（） A、开发程序就是直接编码 B、在程序设计之前需要先进行软件设计 C、软件投入使用后软件生命周期结束 D、软件维护也是软件生命周期的一个阶段 5、下面关于面向对象的特征说法正确的是（） A、每一个对象都具有唯一的标识 B、任何类的划分都是客观的，程序员必须遵守其规定 C、继承性是子类自动共享父类数据结构和方法的机制 D、多态是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的 结果 第三题、判断题（每题1分，5道题共5分） 1、面向对象开发技术分三个阶段：面向对象分析，面向对象设计和面向对象实现。 正确错误 2、面向对象的要素包括抽象、封装。 学号：姓名： 第三章面向对象程序设计作业 一、判断题 1、一个Java源程序可有多个类，但只仅有一个public类，而且程序名与public类名相同。对 2、如果类A和类B在同一个包中，则除了私有成员外，类A可以访问类B中所有的成员。对 3、接口中的成员变量全部为常量，方法为抽象方法。对 4、抽象类可以有构造方法，可以直接实例化。错 5、对static方法的调用可以不需要类实例。对 6、包含抽象方法的类一定是抽象类。对 7、方法中的形参可以和方法所属类的属性同名。对 8、接口无构造器，不能有实例，也不能定义常量。错 9、类的实例对象的生命周括实例对象的创建、使用、废弃、垃圾的回收。对 10、Java应用程序的入口main方法只有一种定义法。对 二、选择题 1、下列答案正确的是（A ） A) 在同一个Java源文件中可以包含多个类，只能有一个被声明为public B) 在同一个Java源文件中只能包含一个类，并被声明为public C) 在同一个Java源文件中可以包含多个类，都可以被声明为public D) 在同一个Java源文件中可以包含多个类，只能有一个被声明为default 2、Java实现动态多态性是通过（ B ）实现的。 A) 重载B) 覆盖 C) 接口D) 抽象类 3、下列哪一个是正确的方法重载描述（ A ） A) 重载方法的参数类型必须不同 B) 重载方法的参数名称必须不同 C) 返回值类型必须不同 D) 修饰词必须不同 4、final关键字不可以用来修饰（ D ） A) 类B) 成员方法 C) 域D) 接口 5、接口的所有成员方法都具有（ B ）属性 A) private, final B) public, abstract C) static, protected D) static 6、Java的封装性是通过（A ）实现的 A) 访问控制B) 设计内部类 C) 静态域和静态方法D) 包 7、下列接口或类不属于.*包的是（ D ） A) Collection B)Vector C) Map D) Integer 8、下述哪一组方法，是一个类中方法重载的正确写法（ A ） A) int addValue( int a, int b ){return a+b;} 1 什么是面向对象程序设计，它与传统的结构式程序有什么不同。 面向对象程序设计是一种适用于设计、开发各类软件的范型。它是将软件看成是一个由对象组成的社会：这些对象具有足够的智能，能理解从其他对象接受的信息，并以适当的行为作出响应；允许低层对象从高层对象继承属性和行为。通过这样的设计思想和方法，将所模拟的现实世界中的事物直接映射到软件系统的解空间。 与传统的结构式程序设计相比，面向对象程序设计吸取了结构式程序设计的一切优点（自顶向下、逐步求精的设计原则）。而二者之间的最大差别表现在： ·面向对象程序采用数据抽象和信息隐藏技术使组成类的数据和操作是不可分割的，避免了结构式程序由于数据和过程分离引起的弊病。 · 面向对象程序是由类定义、对象（类实例）和对象之间的动态联系组成的。而结构式程序是由结构化的数据、过程的定义以及调用过程处理相应的数据组成的 2 用面向对象方法建立模型的思维过程是怎样的。 用面向对象方法建立拟建系统的模型的过程就是从被模拟现实世界的感性具体中抽象要解决的问题概念的过程。这种抽象过程分为知性思维和具体思维两个阶段，其中：·知性思维是从感性材料中分解对象，抽象出一般规定，形成了对对象的普遍认识。·具体思维是从知性思维得到出的一般规定中揭示的事物的深刻本质和规律，其目的是把握具体对象的多样性的统一和不同规定的综合。 3 解释以下概念： ①对象：在现实世界中，对象就是可以感觉到的实体。每个对象具有一个特定的名字以 区别于其他对象；具有一组状态用来描述它的某些特性；具有一组操作，每一个操作决定对象的一种功能或行为（为自身服务的操作和为其他对象提供服务的操作）。而在面向对象系统中，对象是可以标识的存储区域。每个对象的状态被保存在此区域中，而实现一类对象行为的操作（代码）被保存在另外相关的存储器区域中。 ②消息：消息是要求某个对象执行其某种功能操作（方法）的规格说明。因此，消息是 由消息的接收者、消息要求提供的操作（消息名）和必要的参数组成的。 ③类：在现实世界中，类是对一组具有共同特性（属性和行为）的客观对象的抽象。而 在面向对象系统中，类是由程序员自定义的具有特定结构和功能的类型，是一种代码共享的手段。 ④实例：任何一个对象都是该对象所属类的一个具体实例。 ⑤公有消息：是由对象外向对象发送的消息，用于激活该对象的某种方法。 ⑥私有消息：是由对象向自身发送的消息，用于内部操作；该类消息不能从对象外向该 对象发送。 ⑦消息序列：在面向对象系统中一个事件的发生总会有多个对象的多次相互作用才能完 成，使得这些对象能够相互作用的消息组成的序列被称为消息序列。 4 类与实例的关系如何？ 类是创建对象的模板，而对象是实现类的实例。属于同一类的不同实例必须具有： ·相同的操作集合； ·相同的静态属性集合； ·不同的对象名和属性动态值。 1.11 习题 1.Java起源于___________年 2.Java的特点包含：__________、___________、___________、___________和___________。 3.Java体系结构包含： A.Java编程语言 B.Java类文件格式 C.Java API D.JVM。 4..javac的作用是： A.将源程序编译成字节码 B.将字节码编译成源程序 C. 解释执行Java字节码 D.调试Java代码 5.什么是Java虚拟机? 6.编写一个Java程序，输出“Hello Java！” 答案： 1.1995 2. 简单性、一次开发到处运行、分布式、健壮性、安全性 3. ABCD 4. A 5. JVM是Java虚拟机（Java Virtual Machine）的缩写，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能模拟来实现的。 6. Public class MyClass { public static void main(String[] args) { System.out.println("Hello Java！"); } } 2.11 习题 1．Java的基本数据类型包含___________、___________、___________、___________、___________、___________、___________和___________。 2．变量主要用来___________，是用标识符命名的数据项，是程序运行过程中可以改变值的量。 3.下面哪些表示符是正确的？ A.MyWorld B.parseXML 1、什么面向对象？ 面向对象不仅是以些具体的软件开发技术与策略，而且以一套关于如何看待软件系统与现实世界的关系，以什么观点来研究问题并进行求解，以及如何进行系统构造的软件方法学。 2、软件开发方法学的基本方法有哪些？ 1）软件工程和瀑布方法学2）新方法学：螺旋式、迭代式、递增式、合并式3）面向对象方法学：UML、RUP、XP 3、为什么需要OOA、OOD。 OOA就是运用面向对象的方法进行需求分析，OOA加强了对问题域和系统责任的理解，有利于人员之间的交流，对需求变化的适应性较强，很好的支持软件复用。 OOD就是运用面向对象的方法进行系统设计，OOD．符合人们习惯的思维方法，便于分解大型的复杂多变的问题；易于软件的维护和功能的增减；可重用性好；与可视化技术相结合，改善了工作界面。 4、从概念层次、规格层次、实现层次三个角度如何理解对象的概念？ 从概念层次来看，一个对象就是一系列的责任； 从规格层次来看，一个对象是一系列可以被其他对象或该对象自己调用的方法；从实现层次来看，一个对象是一些代码和数据。 5、如何绘制类图和对象图？简述其步骤。 类图绘制：1发现类，找到备选类，确定候选类2关联分析，确定关联关系，多重性分析3职责分析4限定与修改，导航性分析，约束，限定符; 对象图绘制：1发现类和对象2对其细化，分析，确定关系。 6、简述重定义方法与重载的区别。 重定义：1参数列表必须完全与被重写的方法相同2返回类型必须一直域被重写的方法的类型相同3访问修饰符的限制一定要大于被重写方法的访问修饰符4重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查性异常：重载：1必须有不同参数列表2可以有不同的返回类型，只要参数列表不同即可3可有不同访问修饰符4可抛出不同的异常。 7.简述抽象方法与虚方法的联系与区别 虚方法有一个实现部分可以为子类实现有共同的方法，并为派生提供了覆盖该方法的选，抽象方法只是强制派生覆盖方法；抽象方法只能在抽象类中声明，而虚方法不是；抽象方法不能声明方法实体，虚方法可以；包含抽象方法的类不能实例化，但虚方法可以。 8、简述使用继承的规则。 1)、不要过度使用；2)、子类应是超类的一个类型；3)、子类应是超类的扩展； 4)、尽量少从具体类继承，最好继承接或抽象类。 网络教育课程考试复习题及参考答案 面向对象程序设计 一、填空题： 1.创建类的对象时，使用运算符___________给对象分配内存空间。 2.Java通过来区分重载函数。 3.在子类中使用保留字_ _可调用被子类覆盖的父类中的方法。 4.使用保留字可以从一个构造方法中调用同一个类的另一个构造方法。 5.抽象类用修饰符定义。 6.类的数据成员的访问权限修饰符一般为 7.访问权限修饰符按照访问权限的大小从大到小分别为、、 、。 8.定义类的构造方法不能有，其名称与名相同。 9.抽象方法是的特征是。 10.Java中的所有异常都是从继承来的。 11.对象引用中存储的内容是。 12.下列程序段执行后， String str1 = new String("Java"); String str2 = new String("Java"); if (str1.equals(str2)) { System.out.println("They are equal"); } else { System.out.println("They are not equal"); } 输出结果为：。 13.下面循环执行后的sun值为 int count =0, sum = 0; while ( count <10 ) { sum += count; count ++; } 14.Java语言中关键字_ _表示双精度类型。 15.保留字_ _用于导入包中的类到程序中，供程序中使用。 16.Java语言中继承是用保留字表示。 17.面向对象程序设计中，类是指。 18.对象包含和。 19.若有类定义： class B extends A{ … } 则类B是类A的_ 。 20.Java语言中, 通常把可能发生异常的方法调用语句放到try块中，并用紧跟其后的_ 块来捕 获和处理异常。 21.多态是指。 22.声明常量时使用修饰符。 23.Java中异常抛出使用保留字。 24.一个类成员或者方法前面加上了修饰符，那说明该数据成员和方法可以直接通过类名 来访问和调用。 面向对象分析/设计课程大作业 银行业务处理系统 13级软件学院测试班 1367004029 曾丹 1.需求分析 随着社会经济的发展，信息化程度的不断深入，银行的传统业务己愈来愈不能满足银行客户的需要。 现今，人们的金融意识、科技意识己经有了很大的提高，在紧张忙碌的生活中，己越来越来不习惯每月奔忙于各银行营业柜台之问去排队缴各种各样的费用了；同时，各种经营单位如电信、移动、供电、煤气、自来水、证券等等一是为了提高服务质量、方便客户，二是为了减轻自己日趋繁重的工作量，纷纷委托银行为其开展代收代付业务：同时，随着我国加入世贸组织的日益临近，我国的银行业将面临更加激烈的同业竞争，如何提供更多的金融产品和更优质的服务，如 何吸引更多的客户，如何利用计算机技术加强银行帐户信息管理、进行银行业务再造，提高银行的工作效率和业务竟争能力是摆在各家银行面前的一个迫切需要解诀的问题。 近几年来，各商业银行加快了与社会各业的合作，利用自身的网点优势和业务特点，为其提供各种高效、快捷的代收代付业务，也就是中间代理业务，目前以与广大人民群众生活密切相关的各项缴费业务如水电费、电话费、手机费等代收业务为主，这些业务开展方式多种多样，但一般都离不开计算机的高效管理支持。 随着代理业务不断发展，业务品种越来越多，各项业务做法互有差异，这就对银行的电子化水平和相应的管理水平提出了更高的要求。如何利用电子化的手段构建一个高效统一的、通用灵活的系统来管理各种各样的业务，是每个商业银行所要研究的课题。支持决策系统的，需要在数据库的基础上，进行联机分析处理，每次处理的数据量大，响应时间长。 特别是银行每天要处理大量的存取款事件，做好存取款是银行工作重要的环节，然而要有效处理必须要有良好的程序和数据管理系统来建立一个良好的软件系统来实现快速、有效、准确、安全的处理银行事物。 主要用于银行的储蓄卡管理系统，它可以帮助我们有效、准确、并且高效实现的完成存取事件。此系统操作方便效率、安全性高，只要客户开户并设定好密码就可以轻松的实现存取款。 系统实现的主要有储蓄卡开户管理、存取款管理、用户查询历史数据显示、注销等功能。 储蓄卡开户管理模块：卡号、姓名、开户金额、身份证号、地址、电话、密码、确认密码和保存组成。（开户金额必须是数字，密码和确认密码必须一样是六位数字） *注销模块：一旦注销该卡号就不存在且余额提醒你取出。 通过该银行账户管理系统地运行，使办公人员可以轻松快捷的完成对账户管理的任务，提高账目管理效率，使银行的账目管理工作系统化、规范化、自动化。 该银行帐目管理信息系统，优点是设计过程思路清晰、模块划分简洁，设计各阶段分工明确。经过实践证明，该划分是合理的，极大得提高了本系统的实现。 第二章2-4 #include int *p,*init; int countp=0; int countn=0; p = new int[20]; init = p; for(int i=0;i<20;i++) { cin>>*p; p++; } p = p-20; for( i=0;i<20;i++) { if(*p>0) countp++; if(*p<0) countn++; cout<<*p<<" "; p++; } cout<<"正数有:"< 习题一 5、分析下面程序运行的结果。 # 9、输入以下程序，进行编译，观察编译情况，如果有错误，请修改程序，在进行编译，直到没有错误，然后进行连接和运行，分析运行结果。 修改后的程序如下： #include 【练习题】类的成员变量： 猜数字游戏：一个类A有一个成员变量v，有一个初值100。定义一个类，对A 类的成员变量v进行猜。如果大了则提示大了，小了则提示小了。等于则提示猜测成功。 【练习题】类的成员变量： 请定义一个交通工具(Vehicle)的类，其中有: 属性：速度(speed)，体积(size)等等 方法：移动(move())，设置速度(setSpeed(int speed))，加速speedUp(),减速speedDown()等等. 最后在测试类Vehicle中的main()中实例化一个交通工具对象，并通过方法给它初始化speed,size的值，并且通过打印出来。另外，调用加速，减速的方法对速度进行改变。 【练习题】类的成员变量与方法、构造方法 在程序中，经常要对时间进行操作，但是并没有时间类型的数据。那么，我们可以自己实现一个时间类，来满足程序中的需要。 定义名为MyTime的类，其中应有三个整型成员：时（hour），分（minute），秒（second），为了保证数据的安全性，这三个成员变量应声明为私有。 为MyTime类定义构造方法，以方便创建对象时初始化成员变量。 再定义diaplay方法，用于将时间信息打印出来。 为MyTime类添加以下方法： addSecond(int sec) addMinute(int min) addHour(int hou) subSecond(int sec) subMinute(int min) subHour(int hou) 分别对时、分、秒进行加减运算。 【练习题】构造方法 编写Java程序，模拟简单的计算器。 定义名为Number的类，其中有两个整型数据成员n1和n2，应声明为私有。编写构造方法，赋予n1和n2初始值，再为该类定义加（addition）、减（subtration）、乘（multiplication）、除（division）等公有成员方法，分别对两个成员变量执行加、减、乘、除的运算。 在main方法中创建Number类的对象，调用各个方法，并显示计算结果。 【练习题】构造方法： 编写Java程序，用于显示人的姓名和年龄。 定义一个人类（Person），该类中应该有两个私有属性，姓名（name）和年龄（age）。定义构造方法，用来初始化数据成员。再定义显示（display）方法，将姓名和年龄打印出来。 一、选择题（每小题2分，共40分） 1、C++是（）。 A. 面向对象的程序设计语言 B. 面向过程的程序设计语言 C. 既支持面向对象的程序设计又支持面向过程的程序设计的混合型语言 D. 非结构化的程序设计语言 2、面向对象程序设计思想的主要特征中不包括（）。 A. 封装性 B. 多态性 C. 继承性 D. 功能分解，逐步求精 3、若定义：string str; 当语句cin>>str; 执行时，从键盘输入： Microsoft Visual Studio 6.0! 所得的结果是str=（）。 A. Microsoft Visual Studio 6.0! B. Microsoft C. Microsoft Visual D. Microsoft Visual Studio 6.0 4、考虑下面的函数原型声明：void testDefaulParam(int a,int b=7,char z='*'); 下面函数调用中，不合法的是（）。 A. testDefaulParam(5); B. testDefaulParam(5,8); C. testDefaulParam(5,'#'); D. testDefaulParam(0,0,'*'); 5、下列语句中，将函数int sum(int x, int y)正确重载的是（）。 A. float sum(int x, int y); B. int sum(int a, int b); C. float sum(float x, float y); D. double sum(int y, int x); 6、下列表示引用的方法中，（）是正确的。 已知：int a=1000; A. int &x=a; B. char &y; C. int &z=1000; D. float &t=&a; 7、在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（）。 A. 内联函数 B. 重载函数 C. 递归调用 D. 嵌套调用 8、下列有关C++类的说法中，不正确的是（）。 A. 类是一种用户自定义的数据类型 B. 只有类中的成员函数或类的友元函数才能存取类中的私有成员 C. 在类中，如果不做特别说明，所有成员的访问权限均为私有的 D. 在类中，如果不做特别说明，所有成员的访问权限均为公用的 9、已知X类，则当程序执行到语句：X array[3];时，调用了（）次构造函数。 A. 0 B. 1 C. 2 D. 3 10、下面说法中，正确的是（） A. 一个类只能定义一个构造函数，但可以定义多个析构函数 B. 一个类只能定义一个析构函数，但可以定义多个构造函数 C. 构造函数与析构函数同名，只要名字前加了一个求反符号（~） D. 构造函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以 11、已知：print( )函数是一个类的常成员函数，它无返回值，下列表示中，（）是正确的。2016年电大面向对象程序设计技术-作业题
JAVA语言与面向对象程序设计课后习题答案
UML面向对象分析与设计、建模与设计课后选择判断
面向对象程序设计第12章在线测试
面向对象程序设计(答案)
什么是面向对象程序设计
Java面向对象程序设计—习题和答案
面向对象分析与设计简答题
面向对象程序设计复习题及参考答案
面向对象程序设计大作业(C++)
面向对象程序设计课后答案完整版
面向对象程序设计作业参考答案
Java面向对象编程上机-练习题汇总
《面向对象程序设计C 》期末试卷及标准答案(A)
相关主题
文本预览