河北师范大学软件体系结构期末复习.docx

1、河北师范大学软件体系结构期末复习填空题30 简答题20设计题40（给出一个环境） 综合题10（体系结构的题）第一章 概述1. 模式：由一个特定环境，一个问题，一个解决方案三部分组成的规则2. 第一个设计模式单例模式1) 要解决的问题：一个类只产生一个对象2) 解决方法：static静态变量3) 示例：Form1.cs:public partial class Form1 : Form private void button1_Click(object sender, EventArgs e) OtherForm tf = OtherForm.getOnly(); tf.Text = this

2、is other form; tf.Show(); OtherForm.cs:public partial class OtherForm : Form static OtherForm onlyone;/ 静态变量 3. 好的系统设计满足的三个性质：1) 可扩展性 2) 灵活性 3) 可插入性4. 面向对象设计原则：1) 单一职责原则：一个类只负责一个功能领域中的相应职责2) 开闭原则：要求一个软件实体对扩展开放，对修改关闭，即在不修改源代码的基础上扩展一个系统的行为3) 里氏代换原则：在软件中如果能够使用基类对象，那么一定能够使用其子类对象4) 依赖倒转原则：抽象不应该依赖于细节，细节应该

3、依赖于抽象；要针对接口编程，不要依赖于实现编程5) 接口隔离原则：客户端不应该依赖于那些它不需要的接口，即将一些大的接口细化成一些小的接口供客户端使用6) 合成复用原则：要求复用时尽量使用对象组合，而不是继承7) 迪米特法则：一个软件实体应当尽可能少的与其他实体发生相互作用。第二章 观察者模式1. 背景：某对象发生变化，需其他对象作出调整2. 两个角色：观察者和被观察者3. 步骤：注册通知撤销注册4. 设计类图： 5. 示例：Teacher.cs:class Teacher:Subject private string _phone; public string Phone get retur

4、n _phone; set _phone = value; notifyObserver(); private ArrayList stuList; public Teacher() stuList = new ArrayList() public void registerObserver(Observer o) stuList.Add(o); public void removeObserver(Observer o) stuList.Remove(o); public void notifyObserver() for (int i = 0; i stuList.Count; i+) (

5、Observer)stuListi).update(_phone); Student.cs:class Student:Observer private string _name; public string Name get return _name; set _name = value; private string _tPhone; public string TPhone get return _tPhone; set _tPhone = value; public Student(string name) this.Name = name; this.TPhone = ; publi

6、c void update(object o) this.TPhone = (string)o; public void show() Console.WriteLine(Name: + Name + nTeachers Phone: + TPhone); 第三章 适配器模式1. 环境：想使用一个已经存在的类，但它的接口不符合要求，此时用到适配器模式，将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。2. 适配器模式的四种角色：目标，被适配者，适配者，客户端3. 适配器模式分类：类的适配器模式（采用继承实现），对象适配器（采用对象组合实现）4.

7、 适配器模式实现步骤： 1) 类适配器： a) 确定目标接口 b) 确定被适配者 c) 创建适配器（继承自被适配者，实现目标接口） 2) 对象适配器 a) 确定目标接口b) 确定被适配者 c) 创建适配器（拥有被适配者的对象，实现目标接口）5. 示例： Target.cs:目标接口 interface Target void run(); void fly(); Deer.cs:被适配者 class Deer public void run() Console.WriteLine(我是一只五彩神鹿，带你游走四处); classAdapter:类适配器 class classAdapter :

8、Deer,Target public void fly() Console.WriteLine(哇啊哦，我可以飞了!); objectAdapter:对象适配器 class objectAdapter:Target private Deer deer; public objectAdapter(Deer d) this.deer = d; public void run() deer.run(); public void fly() Console.WriteLine(哇啊哦，我一样可以飞了!); Program.cs: static void Main(string args) Target

9、 flyDeer = new classAdapter(); Target flyDeer1 = new objectAdapter(new Deer(); flyDeer.run(); flyDeer.fly(); flyDeer1.run(); flyDeer1.fly();System.Console.Read(); 6. 类适配器和对象适配器哪个更好：1) 类适配器采用“多继承”的实现方式，带来了不良的高耦合2) 对象适配器采用“对象组合”的方式，更符合松耦合精神3) 类适配器无法面对多个被适配对象第四章 策略模式1. 环境：将每一个一系列的算法封装起来，而且使它们还可以相互替换，让算

10、法独立于使用它的客户而独立变化。 2. 类图：3. 三种角色：抽象策略类，具体策略类，环境类4. 实现步骤: 1) 定义抽象策略类 2) 实现具体策略类 3)定义环境类5. 示例： IStrategy.cs:抽象策略类interface IStrategy void fighting(); Bow.cs:具体策略类1 class Bow:IStrategy public void fighting() Console.WriteLine(向敌人放冷箭中); Knife.cs:具体策略类2 class Knife:IStrategy public void fighting() Console.

11、WriteLine(把敌人千刀万剐中-); Cannon.cs:具体策略类3class Cannon:IStrategy public void fighting() Console.WriteLine(加农炮轰击敌人中-); Context.cs：环境类class Context private IStrategy _strategy; public Context(IStrategy s) this._strategy = s; public void fighting() this._strategy.fighting(); Program.cs:class Program static

12、 void Main(string args) Context context; context = new Context(new Knife(); Console.WriteLine(选择武器为刀：); context.fighting(); Console.WriteLine(); context = new Context(new Bow(); Console.WriteLine(选择武器为弓-：); context.fighting(); Console.WriteLine(); context = new Context(new Cannon(); Console.WriteLin

13、e(选择武器为加农炮：); context.fighting(); Console.WriteLine(); Console.ReadLine(); 7. 策略模式的优点：1) 提供了对“开闭原则”的完美支持2) 提供了管理相关的算法族的办法3) 提供了可以替换继承关系的办法4) 可以避免使用多重条件选择语句8. 策略模式的缺点：1） 客户端必须知道所有的策略类，并自行决定使用哪一个策略类2） 策略模式将造成产生很多策略类9. 小结：1) 如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2) 一个系统需要动态地在几种算

14、法中选择一种。 3) 不希望客户端知道复杂的、与算法相关的数据结构，在具体策略类中封装算法和相关的数据结构，提高算法的保密性和安全性第五章 组合模式1. 环境：对于树形结构，当容器对象（如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻找也包含这个方法的成员对象并调用执行,（递归） .客户端希望一致地处理容器对象和叶子对象。 2. 组合模式:描述了如何将容器对象和叶子对象进行递归组合，使得用户在使用时无须对它们进行区分，可以一致地对待容器对象和叶子对象。 3. 类图：4. 三种角色：抽象组件类，叶子节点，组件集合类5. 实现步骤：1) 定义抽象组件接口 2) 实现叶子节点类，实现抽象组件类

15、的接口 3) 实现组件集合类，实现抽象组件类的接口 4) 定义环境类，将叶子节点和组件集合加入根组件集合 6 示例： Component.cs:抽象组件接口 public abstract class Component protected string name; public Component(string name) this.name = name; public abstract void Add(Component c); public abstract void Remove(Component c); public abstract void Diaplay(int dept

16、h); Doc.cs:实现叶子节点 public class Doc : Component public Doc(string name): base(name) public override void Add(Component c) Console.WriteLine(不能向叶子节点添加子节点); public override void Remove(Component c) Console.WriteLine(叶子节点没有子节点); public override void Diaplay(int depth) Console.WriteLine(new string(-, dep

17、th) + name); File.cs: 实现组件集合类： public class Files : Component List children = new List(); public Files(string name): base(name) public override void Add(Component c) this.children.Add(c); public override void Remove(Component c) this.children.Remove(c); public override void Diaplay(int depth) Consol

18、e.WriteLine(new String(-, depth) + name); foreach (Component component in children) component.Diaplay(depth + 2); Program.cs:模拟用户构建文件树 class Program static void Main(string args) Files rootFlies = new Files(根目录root); rootFlies.Add(new Doc(根目录下的文件A); rootFlies.Add(new Doc(根目录下的文件B); Files comp = new

19、Files(根目录下的文件夹FA); comp.Add(new Doc(文件夹FA中的文件FAA); comp.Add(new Doc(文件夹FA中的文件FAB); rootFlies.Add(comp); Files comp2 = new Files(文件夹FA中的文件夹FAX); comp2.Add(new Doc(文件夹FAX中的文件AXA); comp2.Add(new Doc(文件夹FAX中的文件AXB); comp.Add(comp2); rootFlies.Add(new Doc(根目录下的文件C); Doc leafD = new Doc(根目录下的文件D); rootFli

20、es.Add(leafD); rootFlies.Remove(leafD); rootFlies.Diaplay(1); Console.Read(); 执行结果： 7. 组合模式的优点：1) 组合模式以不遵守单一责任原则换取透明性，让Client将组合和叶节点一视同仁。 2）在实现组合模式时，有很多设计上的折衷。要根据需求平衡透明性和安全性。 3）有时候系统需要遍历一个树枝构件的子构件很多次， 这时候可以把遍历结果缓存4）组合模式的实现中，可以让子对象持有父对象的引用进行反向追溯。 8. 组合模式的缺点： 1） 使用组合模式后，控制树枝构件的类型不太容易。 2） 用继承的方法来增加新的行为

21、很困难9. 小结：组合模式使用环境 1) 表示对象的部分-整体层次结构 2) 用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象第六章 装饰模式1. 环境：动态的给一个对象添加一些功能，装饰模式用于动态的给一个对象添加一些额外的功能和职责2. 两种角色：油漆工，被修饰者3. 实现方式： 实现被装饰者类;定义被装饰者对象;使用被装饰者对象产生装饰者对象4. 设计类图： 5. 示例： Car.cs: 抽象汽车类 abstract class Car protected int cost; protected string description; public abstract

22、 int getCost(); public abstract string getDescription(); A1Car.cs: class A1Car:Car public A1Car() cost = 100000; description = Audi A1 Car; public override int getCost() return cost; public override string getDescription() return description; A4Car.cs:class A4Car:Car public A4Car() cost = 120000; de

23、scription = Audi A4 Car; public override int getCost() return cost; public override string getDescription() return description; A6Car.cs:class A6Car:Car public A6Car() cost = 160000; description = Audi A6 Car; public override int getCost() return cost; public override string getDescription() return

24、description; Decorator.cs:class Decorator:Car protected Car c; protected int decoratorcost; protected String decoratordescription; public void setCar(Car a) c = a; public override int getCost() return decoratorcost + c.getCost(); public override string getDescription() return c.getDescription() + de

25、coratordescription; Gps.cs:具体的装饰者Gpsclass Gps:Decorator public Gps() decoratorcost = 500; decoratordescription = with Gps Radar.cs：具体装饰者雷达class Radar:Decorator public Radar() decoratorcost = 1000; decoratordescription = with Radar; Program.cs:static void Main(string args) A1Car a = new A1Car(); Syst

26、em.Console.WriteLine(a.getDescription() + 价格： + a.getCost(); A4Car b = new A4Car(); System.Console.WriteLine(b.getDescription() + 价格： + b.getCost(); Decorator dec = new Gps(); dec.setCar(b); System.Console.WriteLine(dec.getDescription() + 价格： + dec.getCost(); System.Console.Read(); 执行结果：6. 扩展说明： 1)

27、装饰者与被装饰者具有相同的类型 2) 可以用多个装饰者装饰一个对象 3) 由于装饰者与被装饰者具有相同的类型，我们可以用装饰后的对象代替原来的对象。 4) 装饰者在委派它装饰的对象作某种处理时，可以添加上自己的行为（功能扩展）（在 委派之前或/和之后）。 5) 对象可以在任何时候被装饰，因此我们能在运行时动态的装饰对象。 6) 装饰模式解决的方案是利用子对象和委派第七章 状态模式1. 背景：某对象发生变化时，其所能做的操作也随之变化。状态模式解决的问题：允许对象在其内部状态改变的时候改变它的行为2. 角色：环境类，抽象状态类，具体状态类3. 实现步骤： 1) 定义状态类接口， 2) 实现Con

28、text类，具有状态的类，其中包含状态类接口的对象3) 当Context类执行某个接口的方法时，去调用真实状态类的实现方法 4) 当Context类修改状态时，修改Context类的真实状态对象 4. 具体实现： Room.cs: class Room protected State s; public string getState() return s.getState(); public void setState(State a) s = a; public void book() s.book(); s = new BookState(); public void checkin()

29、 s.checkin(); s = new CheckinState(); public void unbook() s.unbook(); s = new FreeState(); public void checkout() s.checkout(); s = new FreeState(); State.cs:abstract class State public abstract string getState(); public abstract void book(); public abstract void checkin(); public abstract void unbook(); public abstract void checkout(); FreeState.cs:class FreeState : State public override string getState() return 当前为空闲状态 public override void book() System.Console.WriteLine(当前为空闲状态，进行预定操作);