HeadFirst设计模式

第一章策略模式

模式：是在某些情境下，针对某些问题的某种解决方案。

OO基础：抽象；封装；多态；继承

作业：设计抽象类Shape，派生类Rectangle，T riangle；建立对象时可以指定形状的长和宽（构造方法），可以显示形状，显示面积。

类图：

程序设计：

public class Test {

public static void main(String[] args) {

shape shape1,shape2;

shape1 = new Rectangle(10,20); //实例化

shape1.Display();//调用方法

shape1.showArea(); } }

定义：

定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

设计原则：

原则1：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

原则2（封装可变性）：逻辑相关，物理封装。

原则2（多态性（动态改变））：针对接口编程，而不是针对实现编程。

原则3：多用组合，少用继承。

继承的缺点：（继承class——extends）

破坏封装；父类实现改变，子类受牵连；继承静态，不能动态改变。

组合优点：（接口interface ——implements）

不破坏封装；动态；依靠接口。

组合缺点：

增加数量。

作业：图书销售问题：

有的书不打折

有的书实行每本一元的折扣

有的书提供打折促销，如9折，8折等

有的书提供买够多少返多少促销，如买100返40等

设计程序，根据数量单价计算图书金额。画出类图。

类图：

程序设计：

public static void main(String[] args) {

book skl=new book(new count(100.0,1));// 不打折的

skl.display();

book sk2=new book(new discount1(100.0,1,1));//每本书退一元的

sk2.display();

book sk3=new book(new discountn(100.0,8,1));//打八折的

sk3.display();

book sk4=new book(new returnn(100.0,100,40,1));//满一百送四十

sk4.display(); }

第二章观察者模式

定义：定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

设计原则：

原则1：为了交互对象之间的松耦合设计而努力。

原则2：找出程序中会变化的方面，然后将其和固定不变的方面相分离。

作业：设有一股票，其价格在一定范围内波动，股民需要三种报告：股票的当前价格；股票价格的统计分析报告（最低价、最高价、均价）；股票价格趋势预测。请运用观察者模式，编写上述股票行情程序（模拟估价10次变动）。要求画出相应的类图，提供java源程序。类图：

程序设计：

public static void main(String[] args) {

StockData stockData = new StockData();

CurrentStock currentPrice = new CurrentStock(stockData);

Analysis analysis = new Analysis(stockData);

Forecast forecast = new Forecast(stockData);

stockData.getPrice(30.00);

stockData.getPrice(29.00);

stockData.getPrice(20.00); }

第三章装饰者模式

定义：动态地将责任附加到对象上。想要扩展功能，装饰者提供了比继承更有弹性的替代方案。

设计原则：

类应该对扩展开放，对修改关闭。

作业：汽车店销售宝来（10万），速腾（13万），迈腾（18万），每种车可选装真皮座椅（2000元），天窗（3000元）疝气大灯（4000），编写程序计算加装选配件的车价。

类图：

程序设计：

public static void main(String[] args) {

SellCar sellCar3=new MaiTeng();

sellCar3=new Chair(sellCar3);

sellCar3=new Light(sellCar3);

sellCar3=new Window(sellCar3);

System.out.println(sellCar3.getDescription()+

"$"+sellCar3.cost());//迈腾车带真皮坐椅和疝气大灯及天窗}

第四章工厂模式

简单工厂定义：

工厂方法模式：

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

抽象工厂模式：

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

设计原则：

依赖抽象，不要依赖具体类。

或：依赖倒置原则

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

作业：分别用简单工厂、工厂方法（工厂模式）和抽象工厂编写程序。

类图：

简单工厂：

工厂方法：

抽象工厂：

程序设计：

简单工厂：

public class Test {

public static void main(String[] args) {

DBTable dbTable;

dbTable=DBSimpleFactory.CreateTable("DEPT");

dbTable.Insert();

dbTable.Delete(); }

工厂方法：

public static void main(String[] args) {

DBFactoryMethod dbFactoryMethod;

dbFactoryMethod=new EMPFactory();

/*工厂建立后，可生产多个产品*/

DBTable dbTable;

dbTable=dbFactoryMethod.CreateTable();

dbTable.Insert();

dbTable.Delete(); }

抽象工厂：

public static void main(String[] args) {

EMPRecord empRecord=new EMPRecord();

DEPTRecord deptRecord=new DEPTRecord();

AbstractDBFactory dbFactory=new SQLServerFactory();

/*如果切换DB? */

/*工厂建立后，可生产多个产品*/

EMP emp=dbFactory.CreateEMP();

emp.Insert(empRecord);

empRecord=emp.GetEmp("王林");

DEPT dept=dbFactory.CreateDEPT();

dept.Insert(deptRecord);

deptRecord=dept.GetDept("计算机科学与技术学院"); }

第五章单件模式

定义：

确保一个类只有一个实例，并提供一个全局访问点。

设计原则：（无）

作业：（无）

类图：

程序设计：

第六章命令模式

定义：

将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

设计原则：（无）

作业：用命令模式编写一个计算器程序。

类图：

程序设计：

public static void main(String[] args) {

Total total=new Total();

Command add=new AddCommand(total);

Command minus=new MinusCommand(total);

Calculator calculator=new Calculator();

calculator.SetAdd(add);

calculator.SetMinus(minus);

calculator.AddButtonDown(100.0);

calculator.UndoButtonDown(); }

第七章适配器模式和门面（外观）模式

适配器模式定义：

讲一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

外观模式：

提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

设计原则：

最少知识原则：只和你的密友谈话。

适配器作业：请设计一个Kittie的具体类，并实现miao(),run(),sleep(),catchRat()等方法。再设计一个Puppie接口，要求有wao(), fetchBall(), run(), sleep()等方法。

设计一个适配器，将一只猫kittie伪装成小狗puppie。

编写一个测试主类，测试你的程序。

类图：

程序设计：

public static void main(String[] args) {

lDog dog=new lDog();

lCat cat=new lCat();

Puppie p=new Puppie(cat);

Kittie k=new Kittie(dog);

System.out.println("********Puppie***************");

p.wao();

p.run();

p.sleep();

p.fetchBall(); }

第八章模板方法模式

定义：

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

设计原则：（好莱坞原则）

别调用（打电话给）我们，我们会调用（打电话）你。

作业：（无）

类图：

程序设计：

第九章迭代器和组合模式

迭代器模式定义：

提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部的表示。

组合模式定义：

允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的

方式处理个别对象以及对象组合。

设计原则：

一个类应该只有一个引起变化的原因。（类应该只有一个改变的理由）

组合模式作业：计算机由显示器与主机组成

主机由主板与硬盘，主机箱组成

主板由CPU,内存，总线控制器组成

用组合模式实现计算机的结构，显示计算机组成

类图：（Accessory配件）

程序设计：

public static void main(String[] args) {

MenuComponent computer=new Menu("Computer","I am Ancestors");

MenuComponent Host=new Menu("Host","I am Computer's son");

MenuComponent Motherboard=new Menu("Motherboard","I am Host's son");

MenuComponent allMenus=new Menu("menus","all menus combined:");

allMenus.add(computer);

//加菜单项

computer.add(new MenuItem("Monitor","I am Computer's son"));

computer.add(Host);

Host.add(Motherboard);

Host.add(new MenuItem("Hard","I am Host's son "));

Host.add(new MenuItem("MainChassis","I am Host's son "));

Motherboard.add(new MenuItem("CPU","I am Motherboard's son"));

Motherboard.add(new MenuItem("Memory","I am Motherboard's son"));

Motherboard.add(new MenuItem("BusController","I am

Motherboard's son"));

AssemblyMan assemblyMan =new AssemblyMan(allMenus);

assemblyMan.printMenu(); } }

第十章状态模式

定义：

允许对象在内部状态改变时改变它行为，对象看起来好像修改了它的类。

设计原则：（无）

作业：交通信息号灯有红、黄、绿三种状态，可以按下按钮切换状态，每种状态允许通行不同，用状态模式实现。

类图：

程序设计：

public static void main(String[] args) {

State state=new RedState();

Button button=new Button(state);

button.request();

button.request();

button.request();

button.request(); }

第十一章代理模式

定义：

为另一个对象提供一个替身或占位符以控制对这个对象的访问。

设计原则：（无）

作业：图片类有Show()方法，设计一个程序，用代理显示图片，显示图片前先显示“请等待，正在加载。。。”

类图：

程序设计：

public static void main(String[] args) {

Icon icon=new PictureProxy();

icon.show(); }

第十二章复合模式（删）

第十三章桥接模式

使用桥接模式不只改变你的实现，也改变你的抽象。

作业：（课本程序）

类图：

程序设计：

public static void main(String[] args) {

RemoteControl remoteControl = new ConcreteRemote();

remoteControl.setChannel(new RCA());

remoteControl.on();

TV tv1=new RCA();

remoteControl.tuneChannel(tv1);

remoteControl.off(); }

模式目的：

策略：封装可互换的行为；并使用委托决定使用哪一个。

工厂方法：由子类决定实例化哪个具体类。

装饰者：不改变接口，但加入责任。

适配器：将一个接口转换成另一个接口。改变一个或多个类的接口。外观：让接口更简单。简化一群类的接口。

模板方法：子类决定如何实现算法中的步骤。

迭代器：提供一个方式来遍历集合，而无须暴露集合的实现。

组合：客户可以将对象的集合以及个别的对象一视同仁。