设计模式(Design Patterns)可复用面向对象软件的基础
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。本章系Java之美[从菜鸟到高手演变]系列之设计模式，我们会以理论与实践相结合的方式来进行本章的学习，希望广大程序爱好者，学好设计模式，做一个优秀的软件工程师！
一、设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：
二、设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。
三、Java的23中设计模式
从这一块开始，我们详细介绍Java中23种设计模式的概念，应用场景等情况，并结合他们的特点及设计模式的原则进行分析。
1、工厂方法模式（Factory Method）
工厂方法模式分为三种：
11、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：
举例如下：（我们举一个发送邮件和短信的例子）
首先，创建二者的共同接口：
[java]view plaincopy
1.public interface Sender {
2.public void Send();
3.}
其次，创建实现类：
[java]view plaincopy
1.public class MailSender implements Sender {
2.@Override
3.public void Send() {
4. System.out.println("this is mailsender!");
5. }
6.}
[java]view plaincopy
1.public class SmsSender implements Sender {
2.
3.@Override
4.public void Send() {
5. System.out.println("this is sms sender!");
6. }
7.}
最后，建工厂类：
[java]view plaincopy
1.public class SendFactory {
2.
3.public Sender produce(String type) {
4.if ("mail".equals(type)) {
5.return new MailSender();
6. } else if ("sms".equals(type)) {
7.return new SmsSender();
8. } else {
9. System.out.println("请输入正确的类型!");
10.return null;
11. }
12. }
13.}
我们来测试下：
1.public class FactoryTest {
2.
3.public static void main(String[] args) {
4. SendFactory factory = new SendFactory();
5. Sender sender = factory.produce("sms");
6. sender.Send();
7. }
8.}
输出：this is sms sender!
22、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。关系图：
将上面的代码做下修改，改动下SendFactory类就行，如下：
[java]view plaincopy public class SendFactory {
public Sender produceMail(){
1.return new MailSender();
2. }
3.
4.public Sender produceSms(){
5.return new SmsSender();
6. }
7.}
测试类如下：
[java]view plaincopy
1.public class FactoryTest {
2.
3.public static void main(String[] args) {
4. SendFactory factory = new SendFactory();
5. Sender sender = factory.produceMail();
6. sender.Send();
7. }
8.}
输出：this is mailsender!
33、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
[java]view plaincopy
1.public class SendFactory {
2.
3.public static Sender produceMail(){
4.return new MailSender();
5. }
6.
7.public static Sender produceSms(){
8.return new SmsSender();
9. }
10.}
[java]view plaincopy
1.public class FactoryTest {
2.
3.public static void main(String[] args) {
4. Sender sender = SendFactory.produceMail();
5. sender.Send();
6. }
7.}
输出：this is mailsender!
总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不
能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。
2、抽象工厂模式（Abstract Factory）
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。
请看例子：
[java]view plaincopy
1.public interface Sender {
2.public void Send();
3.}
两个实现类：
[java]view plaincopy
1.public class MailSender implements Sender {
2.@Override
3.public void Send() {
4. System.out.println("this is mailsender!");
5. }
6.}
[java]view plaincopy
1.public class SmsSender implements Sender {
2.
3.@Override
4.public void Send() {
5. System.out.println("this is sms sender!");
6. }
7.}
两个工厂类：
[java]view plaincopy
1.public class SendMailFactory implements Provider {
2.
3.@Override
4.public Sender produce(){
5.return new MailSender();
6. }
7.}
[java]view plaincopy
1.public class SendSmsFactory implements Provider{
2.
3.@Override
4.public Sender produce() {
5.return new SmsSender();
6. }
7.}
在提供一个接口：
[java]view plaincopy
1.public interface Provider {
2.public Sender produce();
3.}
测试类：
[java]view plaincopy
1.public class Test {
2.
3.public static void main(String[] args) {
4. Provider provider = new SendMailFactory();
5. Sender sender = provider.produce();
6. sender.Send();
7. }
8.}
其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！
3、单例模式（Singleton）
单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM 中，该对象只有一个实例存在。这样的模式有几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类：
[java]view plaincopy
1.public class Singleton {
2.
3./* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
4.private static Singleton instance = null;
5.
6./* 私有构造方法，防止被实例化 */
7.private Singleton() {
8. }
9.
10./* 静态工程方法，创建实例 */
11.public static Singleton getInstance() {
12.if (instance == null) {
13. instance = new Singleton();
14. }
15.return instance;
16. }
17.
18./* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
19.public Object readResolve() {
20.return instance;
21. }
22.}
这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对getInstance方法加synchronized关键字，如下：
[java]view plaincopy
1.public static synchronized Singleton getInstance() {
2.if (instance == null) {
3. instance = new Singleton();
4. }
5.return instance;
6. }
但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个：
[java]view plaincopy
1.public static Singleton getInstance() {
2.if (instance == null) {
3.synchronized (instance) {
4.if (instance == null) {
5. instance = new Singleton();
6. }
7. }
8. }
9.return instance;
10. }
似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。但是，这样的情况，还是有可能有问题的，看下面的情况：在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就可能出错了，我们以A、B两个线程为例：
a>A、B线程同时进入了第一个if判断
b>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
c>由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized 块。
d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized 块并将结果返回给调用该方法的程序。
e>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。
所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化：[java]view plaincopy
1.private static class SingletonFactory{
2.private static Singleton instance = new Singleton();
3. }
4.public static Singleton getInstance(){
5.return SingletonFactory.instance;
6. }
实际情况是，单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式：
[java]view plaincopy
1.public class Singleton {
2.
3./* 私有构造方法，防止被实例化 */
4.private Singleton() {
5. }
6.
7./* 此处使用一个内部类来维护单例 */
8.private static class SingletonFactory {
9.private static Singleton instance = new Singleton();
10. }
11.
12./* 获取实例 */
13.public static Singleton getInstance() {
14.return SingletonFactory.instance;
15. }
16.
17./* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
18.public Object readResolve() {
19.return getInstance();
20. }
21.}
其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。也有人这样实现：因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字，也是可以的：
[java]view plaincopy
1.public class SingletonTest {
2.
3.private static SingletonTest instance = null;
4.
5.private SingletonTest() {
6. }
7.
8.private static synchronized void syncInit() {
9.if (instance == null) {
10. instance = new SingletonTest();
11. }
12. }
13.
14.public static SingletonTest getInstance() {
15.if (instance == null) {
16. syncInit();
17. }
18.return instance;
19. }
20.}
考虑性能的话，整个程序只需创建一次实例，所以性能也不会有什么影响。补充：采用"影子实例"的办法为单例对象的属性同步更新
[java]view plaincopy
1.public class SingletonTest {
2.
3.private static SingletonTest instance = null;
4.private Vector properties = null;
5.
6.public Vector getProperties() {
7.return properties;
8. }
9.
10.private SingletonTest() {
11. }
12.
13.private static synchronized void syncInit() {
14.if (instance == null) {
15. instance = new SingletonTest();
16. }
17. }
18.
19.public static SingletonTest getInstance() {
20.if (instance == null) {
21. syncInit();
22. }
23.return instance;
24. }
25.
26.public void updateProperties() {
27. SingletonTest shadow = new SingletonTest();
28. properties = shadow.getProperties();
29. }
30.}
通过单例模式的学习告诉我们：
1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。
2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。
到这儿，单例模式基本已经讲完了，结尾处，笔者突然想到另一个问题，就是采用类的静态方法，实现单例模式的效果，也是可行的，此处二者有什么不同？
首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态了。因为接口中不允许有static修饰的方法，所以即使实现了也是非静态的）
其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载，是因为有些类比较庞大，所以延迟加载有助于提升性能。
再次，单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。
最后一点，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你可以在里面随心所欲的实现一些其它功能，但是静态类不行。从上面这些概括中，基本可以看出二者的区别，但是，从另一方面讲，我们上面最后实现的那个单例模式，内部就是用一个静态类来实现的，所以，二者有很大的关联，只是我们考虑问题的层面不同罢了。两种思想的结合，才能造就出完美的解决方案，就像HashMap采用数组+链表来实现一样，其实生活中很多事情都是这样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是，结合各个方法的优点，才能最好的解决问题！
4、建造者模式（Builder）
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码：
还和前面一样，一个Sender接口，两个实现类MailSender和SmsSender。最后，建造者类如下：
[java]view plaincopy
1.public class Builder {
2.
3.private List
4.
5.public void produceMailSender(int count){
6.for(int i=0; i 7. list.add(new MailSender()); 8. } 9. } 10. 11.public void produceSmsSender(int count){ 12.for(int i=0; i 13. list.add(new SmsSender()); 14. } 15. } 16.} 测试类： [java]view plaincopy 1.public class Test { 2. 3.public static void main(String[] args) { 4. Builder builder = new Builder(); 5. builder.produceMailSender(10); 6. } 7.} 从这点看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。 5、原型模式（Prototype） 原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类： [java]view plaincopy 1.public class Prototype implements Cloneable { 2. 3.public Object clone() throws CloneNotSupportedException { 4. Prototype proto = (Prototype) super.clone(); 5.return proto; 6. } 7.} 很简单，一个原型类，只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB，因为此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object类中，clone()是native的，具体怎么实现，我会在另一篇文章中，关于解读Java 中本地方法的调用，此处不再深究。在这儿，我将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念： 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。 深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。 此处，写一个深浅复制的例子： [java]view plaincopy 1.public class Prototype implements Cloneable, Serializable { 2. 3.private static final long serialVersionUID = 1L; 4.private String string; 5. 6.private SerializableObject obj; 7. 8./* 浅复制 */ 9.public Object clone() throws CloneNotSupportedException { 10. Prototype proto = (Prototype) super.clone(); 11.return proto; 12. } 13. 14./* 深复制 */ 15.public Object deepClone() throws IOException, ClassNotFoundException { 16. 17./* 写入当前对象的二进制流 */ 18. ByteArrayOutputStream bos = new ByteArrayOutputStream(); 19. ObjectOutputStream oos = new ObjectOutputStream(bos); 20. oos.writeObject(this); 21. 22./* 读出二进制流产生的新对象 */ 23. ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray() ); 24. ObjectInputStream ois = new ObjectInputStream(bis); 25.return ois.readObject(); 26. } 27. 28.public String getString() { 29.return string; 30. } 31. 32.public void setString(String string) { 33.this.string = string; 34. } 35. 36.public SerializableObject getObj() { 37.return obj; 38. } 39. 40.public void setObj(SerializableObject obj) { 41.this.obj = obj; 42. } 43. 44.} 45. 46.class SerializableObject implements Serializable { 47.private static final long serialVersionUID = 1L; 48.} 要实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。 我们接着讨论设计模式，上篇文章我讲完了5种创建型模式，这章开始，我将讲下7种结 构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 其中对象的适配器模式是各种模式的起源，我们看下面的图： 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。首先，我们来看看类的适配器模式，先看类图： 核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过 Adapter类，将Source的功能扩展到Targetable里，看代码： [java]view plaincopy 1.public class Source { 2. 3.public void method1() { 4. System.out.println("this is original method!"); 5. } 6.} [java]view plaincopy 1.public interface Targetable { 2. 3./* 与原类中的方法相同 */ 4.public void method1(); 5. 6./* 新类的方法 */ 7.public void method2(); 8.} [java]view plaincopy 1.public class Adapter extends Source implements Targetable { 2. 3.@Override 4.public void method2() { 5. System.out.println("this is the targetable method!"); 6. } 7.} Adapter类继承Source类，实现Targetable接口，下面是测试类： [java]view plaincopy 1.public class AdapterTest { 2. 3.public static void main(String[] args) { 4. Targetable target = new Adapter(); 5. target.method1(); 6. target.method2(); 7. } 8.} 输出： this is original method! this is the targetable method! 这样Targetable接口的实现类就具有了Source类的功能。 对象的适配器模式 基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图： 只需要修改Adapter类的源码即可： [java]view plaincopy 1.public class Wrapper implements Targetable { 2. 3.private Source source; 4. 5.public Wrapper(Source source){ 6.super(); 7.this.source = source; 8. } 9.@Override 10.public void method2() { 11. System.out.println("this is the targetable method!"); 12. } 13. 14.@Override 15.public void method1() { 16. source.method1(); 17. } 18.} 测试类： [java]view plaincopy 1.public class AdapterTest { 2. 3.public static void main(String[] args) { 4. Source source = new Source(); 5. Targetable target = new Wrapper(source); 6. target.method1(); 7. target.method2(); 8. } 9.} 输出与第一种一样，只是适配的方法不同而已。 第三种适配器模式是接口的适配器模式，接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看一下类图： 这个很好理解，在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以致于有时我们在一些实现类中并不是都需要。看代码： [java]view plaincopy 1.public interface Sourceable { 2. 3.public void method1(); 4.public void method2(); 5.} 抽象类Wrapper2： [java]view plaincopy 1.public abstract class Wrapper2 implements Sourceable{ 2. 3.public void method1(){} 4.public void method2(){} 5.} [java]view plaincopy 1.public class SourceSub1 extends Wrapper2 { 2.public void method1(){ 3. System.out.println("the sourceable interface's first Sub1!"); 4. } 5.} [java]view plaincopy 1.public class SourceSub2 extends Wrapper2 { 2.public void method2(){ 3. System.out.println("the sourceable interface's second Sub2!"); 4. } 5.} 面向对象与设计模式的关系 自从GOF出了那本《设计模式》之后，再这四五年中，设计模式一词已经成了架构设计的代言，随后阎宏博士在中国道家思想与《建筑永恒之道》的基础之上，使用中国四大名著中的故事，为我们谱写了一本《Java与模式》，王永刚与王永武与为我们送来了一本《道法自然》更加为初学设计模式的朋友们带来了福音。 设计模式是在面向对象的基础之上，对软件的架构进行合理的组合，按照一定的原则“依赖倒置、李式代换、帝米特法则”使软件架构达到一种松散耦合、以求得对变化的适用。 所以设计模式的前提就是面向对象，其利用接口对模块进行隔离（门面模式、桥梁模式），利用多态对变化进行封装（策略模式、状态模式、装饰模式）、对创建进行合理规划（静态工厂模式、工厂模式、单例模式、多例模式）如果不能很好得掌握面向对象（OO）就更谈不上利用设计模式的成熟思想。 我们公司主要对国有大中企业的内部管理及物流状况进行开发，比如现在这个项目，是为一个政企不分的大型老国有企业，我们的开发建立在他们的体制改革基础之上，变化是常常发生的，因为他们的业务本身就在变化的过程中。 像这样的大型系统，如果不利用面向对象与设计模式的成熟思 想，很难对几百万行的代码进行控制。 在开发中，我们对于从业人员的要求必须得能看懂我做的UML 图，设计中在关键点上我会采用适合设计模式：比如策略、门面、状态、工厂、装饰、桥梁... 而这些设计模式是建立在很强的OO思想之上的，如果对于OO 都不能很好的掌握，更谈不上设计模式了。比如针对接口编成，多态性的应用，以及满足“李式代换、底米特法则等等”。如果不能用OO与设计模式的术语进行有效的沟通，那么对于项目的管理与技术沟通都是存在问题的。 在一些复杂的地方，如果一点点讲明是很麻烦并且很浪费时间的，如果说在这一个采用了“装饰模式”，假如对方能很快明白装饰模式是怎么一会儿事，那么他就可以快速的跟据UML图把这几个类做出来。 第1章习题答案 名词解释 抽象：抽象(Abstract)就是忽略事物中与当前目标无关的非本质特征，而强调与当前目标有关的本质特征，从而找出事物的共性，并把具有共性的事物划为一类。面向对象方法中的抽象，是指对具体问题(对象)进行概括，抽出一类对象的公共性质并加以描述的过程。 封装：面向对象方法中的封装就是把将抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。 消息：消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。 填空题 (1) 面向过程的结构化程序设计方法面向对象程序设计方法 (2) 顺序选择循环 (3) 程序=数据结构+算法程序=对象+消息 (4) 过程类 (5) 抽象性封装性继承性多态性 选择题 (1) B (2) C (3) D (4) C (5) D (6) A (7) A (8) B C (9) A D 判断题 (1) t (2) f (3) f (4)f (5) t (6) f (7) f (8) t 简答题 (1) 结构化程序设计方法着眼于系统要实现的功能，从系统的输入和输出出发，分析系统要做哪些事情，进而考虑如何做这些事情，自顶向下地对系统的功能进行分解，来建立系统的功能结构和相应的程序模块结构，有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。 随着程序规模与复杂性的增长，这种面向过程的结构化程序设计方法存在明显的不足之处。首先是数据安全性问题，由于数据被每个模块所共用，因此是不安全的，一旦出错，很难查明原因。其次是可维护性及可重用性差，它把数据结构和算法分离为相互独立的实体，一旦数据结构需要改变时，常常要涉及整个程序，修改工作量极大并容易产生新的错误。每一种相对于老问题的新方法都要带来额外的开销。另外，图形用户界面的应用程序，很难用过程来描述和实现，开发和维护也都很困难。 (2) 面向对象的程序设计方法中，将程序设计为一组相互协作的对象（Object）而不是一组相互协作的函数。在程序中，属性用数据表示，用来描述对象静态特征；行为用程序代码实现，用来描述对象动态特征。可见，在面向对象的程序设计方法中，对象是数据结构和算法的封装体。对象之间存在各种联系，它们之间通过消息进行通信。程序可表示为： 程序=对象+消息 在面向对象程序设计中，它着重于类的设计。类正是面向对象语言的基本程序模块，通过类的设计，来完成实体的建模任务。类通过一个简单的外部接口，与外界发生关系。一个类中的操作不会处理到另一个类中的数据，这样程序模块的独立性、数据的安全性就有了良好的保障。程序的执行取决于事件发生的顺序，由顺序产生的消息来驱动程序的执行。不必预先确定消息产生的顺序，更符合客观世界的实际。并且面向对象程序设计方法提供了软件重用、解决大问题和复杂问题的有效途径，具有抽象性、封装性、继承性和多态性等特点。 第3章面向对象程序设计基础 第3章面向对象程序设计基础 【1】什么是Java程序使用的类？什么是类库？ 答：类是将一类事物的特性描述出来，然后如果用这个类来定义对象，则该对象就拥有了这个类所描述的所有特性。 在Java系统中，系统定义好的类根据实现的功能不同，可以划分成不同的集合，每个集合称为一个包，所有包合称为类库。 【2】如何定义方法？在面向对象程序设计中方法有什么作用？ 答：方法的定义由两部分组成：方法声明和方法体。 方法的声明如下： 返回值类型方法名（参数类型形式参数1，参数类型形式参数2…）{ 程序代码； 返回值； } 在面向对象程序设计中，方法的作用是完成对类和对象属性操作。 【3】简述构造方法的功能和特点。下面的程序片段是某学生为student类编写的构造方法，请指出其中的错误。 void Student(int no,String name) { studentNo=no; studentName=name; return no; } 答：构造方法的功能是：构造方法是一个特殊的方法，主要用于初始化新创建的对象； 特点：构造方法的方法名要求与类名相同，用户不能直接调用，只能通过new运算符调用，而且构造方法是不返回任何数据类型，甚至也不返回void数据类型，即不能在构造方法前加void。 错误之处：（1）构造方法Student()前不能加void，（2）不能用return语句,(3)类名Student 首字母S改成小写s. 【4】定义一个表示学生的student类，包括的域有学号、姓名、性别、年龄，包括的方法有获得学号、姓名、性别、年龄及修改年龄。编写Java程序创建student类的对象及测试其方法的功能。 class Student { String id; String name; String sex; int age; void talk(){ 软件度量考试复习 测量定义：用数字或符号来表示真实世界中实体属性从而根据定义的规则来表示实体的过程。度量定义：由用户和设计者一同设想的用来在可信和有意义的方式中显露出的的选择的特性。软件度量的定义：用来量化软件产品，软件开发资源和/或软件开发过程的度量。包括可直接测量的对象如代码行，也包括通过测量计算得到的对象如软件质量。 1．测量有哪些尺度类型？各有何区别？ 答：测量有标定尺度、类型尺度、序列尺度、间隔尺度、比例尺度、绝对尺度。标定和类型尺度属于语言尺度(Linguistic)。标定尺度给出了唯一且不含糊的概念名称并且定义技术也属于标定尺度；类型尺度识别实体中已经定义且命名的类型或种类（categories），也叫绝对标定尺度。序列尺度估计已测量的实体的值并将他们按顺序重组排列，值和顺序均表达为字符或符号。间隔尺度、比例尺度和绝对尺度属于定量尺度。间隔尺度用于发现增长间隔而不是比例，没有不合理的0间隔（后半句话翻译不好）；比例尺度允许比例的计算并且允许合理的0参考点；绝对尺度用于计数(count)，只有一种可能的绝对属性测量。 测量作为一个过程，有哪些阶段？ 答：测量作为过程，有3个阶段：感知(Cognitive)、语义(Semantic)、数字化(Quantitative)。2．软件度量的实体有哪些？如何采用GQM定义度量框架？GQM中如何描述目标？ 答：软件度量的实体类型： ①过程（process）：软件开发中活动的集合。不同的软件开发模式中，所采用的流程和活动也不一样； ②产品（product）：软件过程活动的结果，可以是一个程序、一个软件文档或其他任何 交付物； ③资源（resource）：实施这些活动所需要的对象，可能是人力、设备、时间等。 GQM定义度量框架： 1。确定目标；2。细化感兴趣的问题列表；3。定义需要回答这些问题的度量标准；4。 开发数据收集和分析的工具和机制；5。收集并验证数据；6。通过事后剖析的方式分析数据以评估是否与目标一致，并为其后的改善提供意见；7。为利益相关者提供反馈信息。 GQM中如何描述目标： GQM中目标有4个部分：一个感兴趣的对象（一个实体）、一个意图、一个观点、一个对环境和约束的描述。 3．在度量数据的频域分析中，如何描述测量数据的散步度？ 答：散步度描述了被测量（观察）数据在数据集中是怎样分布的。主要通过以下3个参数来反映：极差是资料组（数据集）中最高和最低值之差；方差测量观察值的波动范围；标准差是方差的平方根。 4．什么是功能点分析？特征点、对象点、和功能点有何不同？ 答：功能点分析是对产品中为调整的函数数量(UFC)及值调整因子(VAF)的分析计算。 FP=UFC*VAF。生产率=FP/人月。文档=文档页数/FP。 特征点分析扩展了功能点计数到实时和TLC环境(MIS&RT&SC)。当应用的算法数量及逻辑数据文件数相同时，功能点和特征点产生相同的结果；应用于MIS项目时，结果通常完全相同；当应用于更复杂的系统软件形态时，特征点的计数要高的显著的多。 XXX有限公司软件复用指南 *变化状态：A——增加，M——修改，D——删除 1.目的 指导项目组选择设计指南。 2.适用范围 适用于公司软件开发的设计过程。 3.裁减指南 本过程文件中的过程裁减应依据《组织标准过程裁减指南》的规定。 4.参考文件 本过程文件的编写依据是美国软件工程研究院（SEI）的集成成熟度模型软件分支1.1版本（CMMI-SW V1.1）。 5.术语和缩写 复用:就是将已有的软件成分用于构造新的软件系统。可以被复用的软件成分一般称作可复用构件，无论对可复用构件原封不动地使用还是作适当的修改后再使用，只要是用来构造新软件，则都可称作复用。软件复用不仅仅是对程序的复用，它还包括对软件生产过程中任何活动所产生的制成品的复用，如项目计划、可行性报告、需求定义、分析模型、设计模型、详细说明、源程序、测试用例等等。如果是在一个系统中多次使用一个相同的软件成分，则不称作复用，而称作共享；对一个软件进行修改，使它运行于新的软硬件平台也不称作复用，而称作软件移值。 6.职责 7.软件复用的特点和现状 软件复用就是将已有的软件成分用于构造新的软件系统。可以被复用的软件成分一般称作可复用构件，无论对可复用构件原封不动地使用还是作适当的修改后再使用，只要是用来构造新软件，则都可称作复用。软件复用不仅仅是对程序的复用，它还包括对软件生产过程中任何活动所产生的制成品的复用，如项目计划、可行性报告、需求定义、分析模型、设计模型、详细说明、源程序、测试用例等等。如果是在一个系统中多次使用一个相同的软件成分，则不称作复用，而称作共享；对一个软件进行修改，使它运行于新的软硬件平台也不称作复用，而称作软件移值。 目前及近期的未来最有可能产生显著效益的复用是对软件生命周期中一些主要开发阶段的软件制品的复用，按抽象程度的高低，可以划分为如下的复用级别： （1）代码的复用 包括目标代码和源代码的复用。其中目标代码的复用级别最低，历史也最久，当前大部分编程语言的运行支持系统都提供了连接（Link）、绑定(BI n DI ng) 等功能来支持这种复用。源代码的复用级别略高于目标代码的复用，程序员在编程时把一些想复用的代码段复制到自己的程序中，但这样往往会产生一些新旧代码不匹配的错误。想大规模的实现源程序的复用只有依靠含有大量可复用构件的构件库。如”对象链接及嵌入”（OLE）技术，既支持在源程序级定义构件并用以构造新的系统，又使这些构件在目标代码的级别上仍然是一些独立的可复用构件，能够在运行时被灵活的得新组合为各种不同的应用。 （2）设计的复用 设计结果比源程序的抽象级别更高，因此它的复用受实现环境的影响较少，从而使可复用构件被复用的机会更多，并且所需的修改更少。这种复用有三种途径，第一种途径是从现有系统的设计结果中提取一些可复用的设计构件，并把这些构件应用于新系统的设计；第二种途径是把一个现有系统的全部设计文档在新的软硬件平台上重新实现，也就是把一个设计运用于多个具体的实现；第三种途径是独立于任何具体的应用，有计划地开发一些可复用的设计构件。 C++面向对象程序设计教程课后题答案 1.1 什么是面向对象程序设计? 面向对象程序设计是一种新的程序设计范型.这种范型的主要特征是: 1.3 现实世界中的对象有哪些特征？请举例说明。 现实世界中的对象具有以下特征： 1) 每一个对象必须有一个名字以区别于其他对象； 2) 用属性来描述对象的某些特征； 3) 有一组操作，每组操作决定对象的一种行为； 4) 对象的行为可以分为两类：一类是作用于自身的行为，另一类是作用于其他对象的行为。 例如一个教师是一个对象。每个教师对象有自己的名字来和别的教师区别。教师具有编号，姓名，年龄，职称，专业等属性。教师拥有走路，吃饭，授课等行为操作。走路，吃饭是作用于自身的行为，授课是作用于其他对象的行为。 1.4 什么是消息？消息具有什么性质？ 操作。人们在使用洗衣机的时候只需要按下对应的按钮，而不用关心具体的内部实现。这就是封装。 1.6 什么是继承？请举例说明。 继承就是允许派生类使用基类的数据和操作，同时，派生类还可以增加新的操作和数据。 例如：哺乳动物是一种热血、有毛发、用奶哺育幼崽的动物；狗是有犬牙、食肉、特定的骨骼结构、群居的哺乳动物。狗就继承了哺乳动物。 1.7 若类之间具有继承关系，则他们之间具有什么特征？ 若类之间具有继承关系，则他们之间具有下列几个特征： 1) 类间具有共享特征（包括数据和操作代码的共享）； 1.10 面向对象程序设计的主要优点是什么？ 1.可提高程序的重用性； 2.可控制程序的复杂性； 3.可改善程序的可维护性； 4.能够更好地支持大型程序设计； 5.增强了计算机处理信息的范围； 能够很好地适应新的硬件环境。 精品文档 1、在用例分析模型使用UML用例图中,用例与参与者之间的关系是 （A）通信(或者关联) （B）泛化（C）实现 (D)使用 2、UML用例图中,用例之间有三种关系,以下属于用例之间关系的是 （A）包含（B）实现（C）通信（D）参与 3、UML类图中,表示整体与局部关系的是 （A）聚合（B）依赖（C）关联（D）继承 4、在某信息系统中，存在如下的业务陈述：①一个客户提交0个或多个订单；②一个订单由一 个且仅由一个客户提交。系统中存在两个类：“客户”类和“订单”类。对应每个“订单”类和“客户”类之间是 （A）关联（B）依赖（C）聚集（D）继承 5、和都能够表示对象之间的交互,因此他们被合称为交互图 （A）顺序图类图（B）协作图状态图 （C）顺序图协作图（D）类图状态图 6、UML顺序图以二维图表来显示交互。纵向是时间轴，时间自上而下。横向显示了代表协作中 单个对象的分类角色。每个对象用方框表示，对象的名字在方框内部，并在名字的下方加下划线。每个分类角色表现为垂直列。在角色存在的时间内，显示为虚线 （A）生命线（B）协作消息（C）激活（D）对象 7、Machine软件公司为Benz公司的一款跑车设计了一个过程控制的紧急按钮，该按钮的功能根 据汽车的行驶状态不同，而具有不同的功能，比如汽车静止时，该按钮可以快速启动汽车； 当汽车的时速超过200km/h时，该按钮可以在2秒内将车平稳地停下来；当汽车向后行驶时，该按钮可以立即刹车，基于以上功能考虑，架构师Bob在设计该按钮时，应该采用哪种设计模式 （A）命令模式（B）状态模式（C）观察者模式 (D) 外观模式详细8、 River软件公司开发一个Web服务器，该服务器能够根据客户端的请求，执行相应的处理， 还可以对同时到达的请求排队，并对成功执行的每个请求记录日志。系统设计师Bob在设计该系统时，应该使用哪个设计模式以更好地支持对请求的处理 （A）适配器模式（B）观察者模式（C）命令模式 (D) 外观模式 软件复用与构件技术简介 北京第三届优秀软件构件评选 北京第三届优秀软件构件评选 软件企业的现状与问题 为什么需要软件复用 为什么需要软件复用 面向对象程序设计教程（C++语言描述）题解与课程设计指导 第1章 面向对象程序设计概论 一、名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。 二、填空题 （1）目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种重要的程序设计方法。 （2）结构化程序设计方法中的模块由顺序、选择和循环3种基本结构组成。（3）在结构化程序设计方法中，程序可表示为程序=数据结构+算法；而面向对象的程序设计方法，程序可表示为程序=对象+消息。 （4）结构化程序设计方法中的基本模块是过程；而面向对象程序设计方法中的基本模块是类。 （5）面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、选择题（至少选一个，可以多选） （1）面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （2）面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制叫做（C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （3）在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （4）面向对象程序设计中，对象与对象之间的通信机制是（C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与C语言的关系的描述中，（D ）是错误的。 A. C语言是C++的一个子集 B. C语言与C++是兼容的 C. C++对C语言进行了一些改进 D. C++和C语言都是面向对象的 【结果分析】 C语言是面向过程的。C++语言是一种经过改进的更为优化的C语言，是一种混合型语言，既面向过程也面向对象。 （6）面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依存、不可分割的整体来处理。 软件的复用技术及开发方法 软件的复用技术及开发方法 2.1软件的复用技术 软件复用是指在开发新的软件系统时，对已有的软件或软件模块重新使用，该软件可以是己经存在的软件，也可以是专门的可复用组件〔8〕。软件可复用性的高低影响到生产效率的高低、软件质量的好坏和系统可维护性的好坏。在软件工程中面临的问题不是缺乏复用，而是缺乏广泛的、系统的复用。软件复用包括构造可复用软件和用可复用软件进行构造。构造可复用软件，一方面可以从现存的软件系统中抽取，另一方面通过改写或重新设计来实施。 Jones将软件复用的对象分为4种数据复用、体系结构复用、设计复用和程序复用。这样，软件复用可在实现层、设计层和体系结构层三个层次上实现。实现层软件复用是指对己有的程序代码进行复用，它包括源代码组件形式。设计层软件复用是指对已有的软件系统的设计信息进行复用。而体系结构层软件复用是最有效的软件复用，它主要是软件体系结构形式化的复用，即将软件的框架组织，全局结构设计作为复用对象。可复用的软件体系结构则通常是显式地复用软件体系结构，并通过集成其他软件体系结构，建立新的更高层次的体系结构。 面向对象的软件复用机制主要有两种:继承和对象组合。 （1）继承 继承是指子类可以从父类中直接获得某些特征和行为的能力，继承可作为代码复用和概念复用的手段。作为代码复用的手段是指:子类通过继承父类的行为，一些代码就不必重写;作为概念复用的手段是指:子类共享父类的方法定义。作为代码复用和概念复用手段的继承机制，在面向对象技术中，通过面向对象技术的一些主要机制来实现对“支持可维护性的可复用性”的支持。这些面向对象的主要机制是:数据的抽象化、封装和多态性。通过运用这些机制，继承可以在高层次上提供(相对于传统的低层次复用)可复用性:数据的抽象化和继承关系使得概念或定义可以复用;多态性使得实现和应用可以复用;而抽象化和封装可以保持和促进系统的可维护性。这样一来，复用的焦点不再集中在函数和算法等具体实现细节上，而是集中在最重要的含有宏观商业逻辑的抽象层次上。换言之，复用的焦点发生了“倒转”。发生复用焦点的倒转并不是因为实现细节的复用并不重要，而是因为这些细节上的复用己经做的很好了，并且这种复用在提高复用性的同时提高了软件的可维护性。由于继承关系直接继承的是接口，同时也继承实现，因而实际上父类的内部实现对子类而言是可见的，属于白盒复用方式。 （2）对象的组合 对象组合是指新的复杂功能可以通过组装或组合对象来获得。这种复杂的功能由对象组合来获得的设计思想与过程化程序设计思想是相似的，在过程化程序设计中，一个复杂的功能模块可以分解为更细小的和更简单的功能模块，整体功能是各个局部功能的聚集。在面向对象系统中，系统是由对象构成，因此复杂的功能或者说能完成更复杂功能的对象，可以通过功能较简单的对象的组装或组合来实现。对象组合方式是从整体与局部的角度来考虑软件复用思想的。 对象组合要求对象具有良好的接口定义，使用对象的接口来使用对象的功能，并往往运用赋值多态来获得具体对象，对象的内部功能是不可见的，对象只以“黑盒”的形式出现，属于黑盒复用方式。 面向对象程序设计教程（C++吾言描述）题解与课程设计指导 面向对象程序设计概论 一、 名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公 共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的 单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对 象要求另一个对象实施某种操作的一个请求。 二、 填空题 （ 1） 目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种 重要的程序设计方法。 （2） 结构化程序设计方法中的模块由顺序、选择和循环 3 种基本结构组成。 （ 3） 在结构化程序设计方法中，程序可表示为程序 =数据结构 +算法； 而面向 对象的程序设计方法，程序可表示为程序 =对象 +消息。 （ 4） 结构化程序设计方法中的基本模块是过程； 而面向对象程序设计方法 中的基本模块是类。 （ 5） 面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、 选择题（至少选一个，可以多选） （ 1） 面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （ 2） 面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制 叫做（ C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （ 3） 在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （ 4） 面向对象程序设计中，对象与对象之间的通信机制是（ C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与 C 语言的关系的描述中，（D ）是错误的。 A. C 语言是C++勺一个子集 B. C 语言与C++是兼容的 C. C++对C 语言进行了一些改进 D. C++和C 语言都是面向对象的 【结果分析】 C 语言是面向过程的。C++吾言是一种经过改进的更为优化的 C 语言，是一种混 合型语言，既面向过程也面向对象。 （ 6） 面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依 存、不可分割的整体来处理。 A. 算法 B. 信息 C. 数据隐藏 D. 数据抽象 第1 Object- Orien ted Programmi ng C++ 主讲成长生 东华大学计算机科学与技术学院 第一章概述 § 1.1 面向对象程序设计的基本思想 C++是基于C语言发展的，又冲破C语言局限的面向对象的程序设计语言。它与Java 语言都作为当前计算机科学的主流语言, 越来越受到用户的欢迎。 要弄清楚什么是面向对象的程序设计, 首先了解和回顾传统的 （ Pascal（或C））结构化程序设计方法及其设计思想、程序结构及特点。SP（Structure Programming）是60 年代诞生的针对当时爆发的所谓”软件危机” , 为此发展形成了现代软件工程学的基础。 SP的总的设计思想是： . 自顶向下、层次化 . 逐步求精、精细化 程序结构是按功能划分基本模块的树型结构, 使模块间的关系尽可能简单独立。因此SP的程序的基本特点是： . 按层次组织模块（战略上划分战役） . 每一模块只有一个入口, 一个出口 ?代码和数据分离（程序=数据结构+算法） 归纳得到： SP 把数据和过程（代码、函数）分离为相互独立的实体, 用数据代表问题空间中的客体借以表示实际问题中的信 息; 程序代码则用来处理加工这些数据。程序员在编程时 必须时刻考虑所要处理的数据结构和类型。对不同的数据格式即使要作同样 的处理计算, 或者要对相同的数据格式作不同的处理都必须编写不同的程序（如两个整型数和两个浮点数相加）。这样的编程方法，即传统的SP方法设计出来的程序或系统其可重用的成分很少。其次把数据和代码作为不同的分离实体时, 总存在着用错误的数据调用正确的程序模块, 或用正确的数据调用错误的程序模块的危险, 从而使数据与程序始终保持兼容, 已成为程序员 的一个沉重的负担。在开发一个大型软件课题中, 当工程进入到 后期若用户改变了方案要求, 很容易使技术人员的前期工作受到摧毁性的打击，使其前功尽弃。为克服以上的弊端或者该SP方法难以控制处理的矛盾而产生了面向对象程序设计方法, 即Object —Oriented Programming ----------- OOP从二十世纪六十年代提出对象 的雏形, 到七十年代美国国防部的专用语言Ada 语言, 直到当前国际上流行的高品味的Java 和C++（Tc++,Balandc++ 及Vc++）, , 应该讲OOP方法与技术吸取了SP的一切优点，同时又正视和顺应现实世界由物质和意识二部分组成。映射到面向对象的解空间就是: 具体事物—对象; 抽象概念—类。 OOP的基本原理是用问题领域的模型来模拟大千世界，从而设计出尽可能直接、自然地表示问题求解方法的软件, 这样的软件由对象组成, 而对象则是完整反映客观世界事物具有不可分割的静态属性（”数据结构” ）与动态行为（”方法” ）的。而且它们是既有联系又 软件复用技术 -标准化文件发布号：（9456-EUATWK-MWUB-WUNN-INNUL-DDQTY-KII 论使用复用设计 1、引言 复用是活动，而不是对象。在创建软件相关的系统的语境中，复用仅仅是非常简单的任何过程，该过程通过复用来自以前开发工作的某些东西来生产(或帮助生产)一个系统。那么，唯一的问题是：复用什么、什么是导致成功复用的过程。 在软件工程的范围内，复用既是旧概念，也是新概念。程序员从最早的计算时代已开始复用概念、对象、论据、抽象和过程，但是我们复用的途径是特定的。 本文对软件复用的讨论，将从以下四个方面进行： 1）软件工程师可以获得一系列可复用的软件制品，这些包括软件的技术表示(例如，规约、体系结构模型、设计和代码)、文档、测试数据，甚至包括过程相关的任务(如，检查技术)。 2）复用过程包括两个并发的子过程：领域工程和软件工程。领域工程的目的是在特定应用领域中标识、构造、分类和传播一组软件制品。然后，软件工程可在新系统开发中选取这些软件制品作为复用。 3）构件复用为软件质量、开发者生产率、以及整个系统成本带来了固有的收益，然而，在复用过程模型被广泛地用于软件产业前，必须克服很多障碍。 4）对可复用构件的分析、设计技术采用和在良好的软件工程实践中使用的相同原则和概念。可复用构件应该在一个环境中设计，该环境为每个应用领域建立标准数据结构、接口协议和程序体系结构。 2、可复用的软件制品 软件复用不仅仅涉及源代码，但是，还涉及多少东西呢？CaperJones定义了可作为复用候选的十种软件制品： 项目计划。软件项目计划的基本结构和许多内容(例如，SQA 计划)均是可以跨项目复用的。这样减少了用于制定计划的时间，也减低了和建立进度表、风险分析和其他特征相关的不确定性。 成本估计。因为经常不同项目中含有类似的功能，所以有可能在极少修改或不修改的情况下，复用对该功能的成本估计。 体系结构。即使当考虑不同的应用领域时，也很少有截然不同的程序和数据体系结构。因此，有可能创建一组类属的体系结构模板(例如，事务处理体系结构)，并将那些模板作为可复用的设计框架。 需求模型和规约。类和对象的模型和规约是明显的复用的候选者，此外，用传统软件工程方法开发的分析模型(例如，数据流图)也是可复用的。 设计。用传统方法开发的体系结构、数据、接口和过程化设计是复用的候选者，更常见的是，系统和对象设计是可复用的。 源代码。验证过的程序构件(用兼容的程序设计语言书写的)是复用的候选者。 用户和技术文档。即使特定的应用是不同的，也经常有可能复用用户和技术文档的大部分。 用户界面。可能是最广泛被复用的软件制品，GUI 软件经常被复用。因为它可占到一个应用的60％的代码量，因此，复用的效果非常显著。 面向对象程序设计教学大纲西北民族大学数学与计算机科学学院 制定的时间：二〇一二年五月 面向对象程序设计教学大纲 一、课程基本资料 主讲教师：曹永春、蔡正琦、顿毅杰 主教材：《C++面向对象程序设计》中国铁道出版社，陈维兴、林小茶编著，第2版，2009 辅助教材： 1．《C++编程思想》机械工业出版社，美Bruce Eckel，Chuck Alliso著，刘宗田，袁兆山，潘秋菱等译; 第1版，2011年 2. 《C++程序设计教程》机械工业出版社，美H.M.Deitel P.J.deitel 薛万鹏等译，2000年 3．《C++程序设计语言》，机械工业出版社，美Bjarne Stroustrup 著，裘宗燕译，2005年 4．《C++面向对象程序设计习题解析与上机指导》清华大学出版社，陈维兴主编，第2版，2009年 实验教材及参考书： 同上 课程性质：学科选修课 学分：4分 课时：72学时，其中理论课54学时，上机实验18学时 先修课程：计算机导论、C语言程序设计 课程结构：多媒体教学，课堂讨论、课内实验、课后作业 评价方案:（考核依据、评分的办法、权重的分布） ?平时成绩：10% 课堂表现（课堂提问、考勤、作业等） ?实验成绩：20%（实验报告、实验考试） ?期中成绩：20%（闭卷考试） .期末成绩：50%（闭卷考试） 参考书目: 名称编著者出版社出版年月《C++编程思想》刘宗田，袁兆山，潘 机械工业出版社2011年 秋菱等译 机械工业出版社2000年 《C++程序设计教程》H.M.Deitel, P.J.deitel 著，薛万鹏等译 《C++程序设计语言》Bjarne Stroustrup 机械工业出版社2005年 著，裘宗燕译 陈维兴主编清华大学出版社2009年 《C++面向对象程序设计 习题解析与上机指导》 推荐刊物： 1、《计算机学报》 2.《软件学报》 3.《程序员杂志》 4.《码农周刊》 5.《快乐码农》 相关网站： 1. 中国计算机学会https://www.wendangku.net/doc/d517070928.html,/sites/ccf/ 2. 计算机爱好者协会https://www.wendangku.net/doc/d517070928.html,/forum.php 3.C语言中文网https://www.wendangku.net/doc/d517070928.html,/cpp 5.中国悠悠期刊网https://www.wendangku.net/doc/d517070928.html,/ 6. 中国知网https://www.wendangku.net/doc/d517070928.html,/ 文献 1.谭浩强.C程序设计.第4版.北京:清华大学出版社,2010 面向对象程序设计基本概念 面向对象设计是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，是建立在“对象”概念基础上的方法学。所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统。 对象：对象是要研究的任何事物。从一本书到一家图书馆，单的整数到整数列庞大的数据库、极其复杂的自动化工厂、航天飞机都可看作对象，它不仅能表示有形的实体，也能表示无形的（抽象的）规则、计划或事件。对象由数据（描述事物的属性）和作用于数据的操作（体现事物的行为）构成一独立整体。从程序设计者来看，对象是一个程序模块，从用户来看，对象为他们提供所希望的行为。 类：类是对象的模板。即类是对一组有相同数据和相同操作的对象的定义，一个类所包含的方法和数据描述一组对象的共同属性和行为。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类可有其子类，也可有其它类，形成类层次结构。 消息：消息是对象之间进行通信的一种规格说明。一般它由三部分组成：接收消息的对象、消息名及实际变元。 面向对象主要特征： 封装性：封装是一种信息隐蔽技术，它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性（对象能接受哪些消息，具有那些处理能力），而对象的内特性（保存内部状态的私有数据和实现加工能力的算法）对用户是隐蔽的。封装的目的在于把对象的设计者和对象者的使用分开，使用者不必知晓行为实现的细节，只须用设计者提供的消息来访问该对象。 继承性：继承性是子类自动共享父类之间数据和方法的机制。它由类的派生功能体现。一个类直接继承其它类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类只有一父类）和多重继承（一个类有多个父类）。类的对象是各自封闭的，如果没继承性机制，则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。 多态性：对象根据所接收的消息而做出动作。同一消息为不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。例如：Print消息被发送给一图或表时调用的打印方法与将同样的Print消息发送给一正文文件而调用的打印方法会完全不同。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。在OOPL中可通过在派生类中重定义基类函数（定义为重载函数或虚函数）来实现多态性。 面向对象设计原则和23个 设计模式的笔记 面向对象三大特点： ---------------------------------- 封装： ------------------ 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 不关注处理过程了，只有对象和其职能。 只允许设定的对象访问自身信息，其余私人信息隐藏。 作用：封装可以隐藏实现细节，使得代码模块化，局域化，简单； 继承： ------------------ 继承的父类最好是接口，最好连属性都没有。 少用实现继承（库内使用较多），多用组合。 忘了多重继承，除非实现多接口。 作用：扩展已有代码模块；代码重用（库内使用较多），多态的基础 多态： ------------------ 静态--编程时采用父类型-针对接口编程 动态--执行时才实际映射成具体的子类 作用：静态时针对接口编程，执行时才体现实际的效果 面向对象设计原则： ------------------------------------ 单一职责原则（SRP）： ------------------ 就一个类而言，应该仅有一个引起它变化的原因；当职责越多，耦合越多，易遭破坏 软件设计真正要做的就是发现职责并将这些职责相互分离 把职责分离到单独的类中,因为每一个类都是变化的轴线，当需求变化时,该变化会反映为类的职责的变化，如果一个类承担了多余一个的职责,那么引起他变化的原因就会有多个。职责定义为“变化的原因”。 如果一个类承担的职责过多,就等于把这些职责耦合在了一起,一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力，这种耦合会导致脆弱的设计，当变化发生时，设计会受到意想不到的破坏。 另一方面，如果应用程序的变化方式总是导致这两个职责同时变化，那么就不必分离它们，实际分离它们就会导致不必要的复杂性的臭味。 SRP是所有原则中最简单的也是最难以正确应用的原则之一。 开放封闭原则： ------------------ 软件实体应该可以扩展，但是不可修改。 软件要容易维护又不容易出问题的最好方法是多扩展，少修改。 无论模块多么封闭，都会有无法封闭的变化，事先构造抽象隔离这些变化。 面对新需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码。 浅谈软件复用技术的四个关键问题 [摘要]软件危机是指在计算机软件的开发和维护过程中所遇到的一系列严重问题。60年代出现的软件危机导致了有关软件复用的研究。软件复用是指重复使用“为了复用目的而设计的软件”的过程。通过软件复用，在应用系统开发中可以充分利用已有的开发成果，消除了包括分析、设计、编码、测试等在内的许多重复劳动，从而提高了软件开发的效率。同时，通过复用高质量的已有开发成果，避免了重新开发可能引入的错误，从而提高了软件的质量。 [关键词]软件复用技术软件危机软件复用 一、引言 软件复用的概念是由McI1roy在1968年的NATO软件工程会议上提出的。McI1roy提出了发展以可复用源代码软件构件为基础的软件工业和利用COTS (Component Off The Shelf)构件工业化生产软件的观点。软件复用被认为是解决所谓“软件危机”的技术上可行的、现实的解决方案。软件复用的对象包括软件开发过程中所使用和产生的各种资源：源代码、各种文档、测试数据、设计方法、体系结构等等，总称可复用构件。软件复用是为了改善软件生产的资金投入大、开发周期长、软件产品失败率高等不能满足市场需求的现状，充分利用已有的高质量软件产品和部件，经过组装集成快速搭建应用软件系统的软件开发理论。经历了结构化程序设计、面向对象技术、软件构件技术的发展，软件复用已经成为加速软件工业化早日实现的重要力量。 二、面向对象技术 面向对象技术提供了新的认知和表示世界的思想和方法。面向对象方法就是用对象来作为描写客观信息的基本单元，它包括封装在一起的对象标识、对象属性和对象操作。面向对象技术是以对象为基础来构件系统的，可以通过一个指向对象的指针或对它的引用，就可以访问这个对象的所有数据和方法，用面向对象技术建造起来的系统不仅易于管理和使用，而且源代码的可读性高。如果没有对象，在程序中必须保存大量的变量和一个个孤立的函数，然后在这些没有多大关连的变量和函数之间进行变量传递，这不仅给编程增加了很大的复杂性，而且使得程序的可读性极差。通过把这些有关连的变量和函数封装在一个对象中，大大的简化了编程的复杂性，提高了程序可读性，并且提供了一种抽象，该抽象是可扩展性的关键。正是因为面向对象技术的特点，封装和继承使得面向对象技术成为了软构件技术的基础。 面向对象技术具有以下一些特性能够使它和软件复用相结合： （一）对象是可重用构件的雏形，面向对象技术中，对象(类)已经充当了构成系统的基本单元，由于它的一系列特有的性质，使它具有了可重用构件的雏形； 实验一C++ 基础 1.1 实验目的 1．了解并熟悉开发环境，学会调试程序； 2．熟悉 C++ 中简单的标准输入输出函数的使用方法； 3．理解 const 修饰符的作用并学会应用； 4．理解内联函数的优缺点并学会其使用场合； 5．理解并学会函数重载； 6．理解并熟练掌握使用 new 和 delete 来分配内存； 7．理解并熟练掌握引用的使用方法。 1.2 实验内容 1.2.1 程序阅读 1．理解下面的程序并运行，然后回答问题。 #include int x1 = 0; int x2 = 0; double di = 0.0; double d2 = 0.0; x1 = max_def(5,6); x2 = max_def(2,3,4); di = max_def(2.1,5.6); d2 = max_def(12.3,3.4,7.8); -------------------------------- cout面向对象和设计模式关系
面向对象程序设计教程 (马石安版)
第3章 面向对象程序设计基础
软件度量复习要点、考点_daisy
软件复用指南-模板1
C++面向对象程序设计教程第版—陈维兴林小茶课后习题答案
面向对象模拟题(东软)
软件复用与构件技术简介
李 戈
北京大学 信息科学技术学院 软件研究所 2008年10月16日
支持单位： 北京市科学技术委员会 主办： 北京软件行业协会 北京软件与信息服务业促进中心 北京软件产业基地公共技术支撑体系 承办： 北京软件产品质量检测检验中心 北京大学
z
提升北京市软件企业的核心竞争力 –帮助企业提高软件开发技术与研发能力，提 高软件开发效率，降低软件开发成本 推动以企业为主体、产学研相结合的技术创新体 系的建设 促进北京软件产业的变革，使软件产业走上工程 化、工业化的发展轨道
z
z
z
现状：
– 软件系统的规模和复杂度不断提高 – 对生产效率和产品质量的要求不断提高
z
问题 问题：
– 如何提高软件生产的效率？ – 如何掌控软件产品的质量？ – 生产效率 与 产品质量 怎可得兼？
z
应用软件系统的一般开发模式
设计 实现 测试 运行
需求分析
z
基本特征：应用系统的开发总是从头开始
– 每个应用系统的开发均涉及大量的重复劳动
? ? ? ? ?
用户需求获取的重复 需求分析、设计的重复 编码实现的重复 测试工作的重复 文档工作的重复
z
应用系统的构成成分分类
– 探讨应用系统的本质，其构成成分可分为：
? ? ?
特定于计算机系统的构成成分 应用系统所属领域的共性构成成分 每个应用系统的特有构成成分
系统专用的构成成分 软件系统的 构成成分 领域共用的构成成分 通用的系统构成成分面向对象程序设计教程答案
软件的复用技术及开发方法
面向对象程序设计教程答案
面向对象程序设计完整版
软件复用技术
《面向对象程序设计》教学大纲资料
面向对象程序设计基本概念
面向对象设计原则和23个设计模式的笔记
浅谈软件复用技术的四个关键问题
面向对象程序设计实验
- Java面向对象编程基础
- 《C++面向对象程序设计基础》实验报告
- 面向对象程序设计的基本思想
- 1结构化程序设计基础和面向对象程序设计基础部分
- 第2章 面向对象程序设计基础
- 面向对象程序设计基本思想
- 第1章 面向对象程序设计基础
- 面向对象程序设计基础详解
- 第7章 面向对象的程序设计基础
- 第3章 C#面向对象程序设计基础
- 面向对象程序设计习题及答案
- 面向对象程序设计基本概念
- c面向对象程序设计MFC简单计算器实验报告
- JAVA面向对象程序设计基础知识--知识回顾与疑点解析
- 第3章 面向对象程序设计基础
- 2Java第二单元练习题-面向对象程序设计基础资料
- Java面向对象程序设计基础
- java面向对象程序设计基础知识总结
- 面向对象程序设计完整版
- 第4章 面向对象程序设计基础 源代码