- 浏览: 348827 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
bsc2xp:
作者的文章不错,但是程序好像有错误:1、StreamFilte ...
Java6.0新特性之StAX--全面解析Java XML分析技术 -
bystander_:
写的真好啊, 牛
JAVA面试题解惑系列合集恢复下载 -
qdp150273:
想下载,怎么下载不了
《JAVA面试题解惑系列合集》PDF电子书下载 -
qdp150273:
不错啊,受益匪浅
《JAVA面试题解惑系列合集》PDF电子书下载 -
miroki:
感谢分享!
JAVA面试题解惑系列合集恢复下载
1.简单工厂(Simple Factory)部分
*针对接口编程可以隔离掉系统以后可能发生的一大堆改变。
*用静态方法定义的工厂被成为静态工厂,这样就不用使用创建对象的方法来实例化对象,使用方便。但是这样做的缺点是无法通过继承来改变创建方法的行为。
*简单工厂不是一种设计模式,但是它比较常用。
2.工厂方法(Factory Method)模式部分
----芝加哥风味匹萨店----
------------
----加州风味匹萨店----
------------
*工厂方法用来处理对象的创建,并将这样的行为封装在子类中。这样,客户程序中关于超类的代码就和子类对象的创建代码解耦(Decouple)了。
工厂方法的定义:abstract Product factoryMethod(String type);
*所有工厂模式都用来封装对象的创建。
*工厂方法模式(Factory Method Pattern)通过让子类来决定该创建的对象是什么,来达到将对象的创建过程封装的目的。
*在工厂方法模式中包括创建者(Creator)类和产品(Product)类两种类型的类。
----设计谜题解答----
------------
工厂(Factory Method Pattern)方法模式:定义了一个创建对象的接口,但是由子类来决定要实例化的类是哪一个。它让类把实例化推迟到了子类。
*创建者(Creator)类实现了所有操纵产品的方法,但是不实现工厂方法。
*工厂方法模式可以和策略(Strategy)模式结合起来,在运行时动态地更换工厂类,从而创建不同的产品对象,这是简单工厂所不具有的弹性。
*工厂方法模式可以让客户在实例化对象时,只依赖接口,而不依赖具体的实现类。这符合“针对接口编程,而不是针对实现编程”的软件设计原则。
*如果类A的改变会影响到类B,那么我们说类B“依赖于”类A。
软件设计原则:要依赖抽象,不要依赖具体类。这个原则又被称为“依赖倒置原则(Dependency Inversion Principle)”。
*依赖倒置原则说明不能让高层组件依赖于底层组件,而且它们都应该依赖于抽象。
*遵循依赖倒置原则的三个指导方针:
(1)变量不可以持有具体类的引用。这可以通过使用工厂避开。
(2)不要让类派生自具体类。否则就会依赖具体类,违反了“针对接口编程,而不是针对现实编程”的软件设计原则。
(3)不要覆盖基类中已实现的方法。出现这样的情况就说明基类设计的有问题。
3.抽象工厂(Abstract Factory)模式部分
抽象工厂模式:提供一个接口,用于创建相关或者依赖对象的家族,而不需要明确指定具体类。
*抽象工厂模式是工厂方法模式的演变。工厂方法模式中,创建者只生产一种类型的产品,而抽象工厂模式中,创建者生产一组不同类型的产品。
----ChicagoPizzaIngredientFactory代码----
------------
*抽象工厂(Abstract Factory)模式同时结合了工厂方法(Factory Method)模式和策略(Strategy)模式。
*工厂方法使用继承:把对象的创建委托(Delegate)给子类,让子类实现工厂方法创建对象。
*抽象工厂使用对象的组合:对象的创建被实现在工厂接口所暴露出来的方法中。
*所有工厂模式都通过减少应用程序和具体类之间的依赖来促进松耦合,即解耦(Decouple)。
4.简单工厂(Simple Factory)实例
5.静态工厂实例
在上例的基础上实现:
修改CarSalesShop的代码:
6.工厂方法(Factory Method)模式实例
在上例的基础上实现:
7.抽象工厂(Abstract Factory)模式实例
8.结合策略模式优化抽象工厂实例
修改CarSalesShop类如下:
这样修改后,就不再需要BeijingCarSalesShop和ShanghaiCarSalesShop这两个类。使用方法如下:
这样修改后,由于引入了策略模式,消除了两个两个子类,并且可以通过增加setPartsFactory()方法达到运行时改变零件生产工厂的目的。
--END--
*针对接口编程可以隔离掉系统以后可能发生的一大堆改变。
*用静态方法定义的工厂被成为静态工厂,这样就不用使用创建对象的方法来实例化对象,使用方便。但是这样做的缺点是无法通过继承来改变创建方法的行为。
*简单工厂不是一种设计模式,但是它比较常用。
2.工厂方法(Factory Method)模式部分
----芝加哥风味匹萨店----
public class ChicagoPizzaStore extends PizzaStore { Pizza createPizza(String item) { if ("cheese".equals(item)) { return ChicagoStyleCheesePizza(); } else if ("veggie".equals(item)) { return ChicagoStyleVeggiePizza(); } else if ("clam".equals(item)) { return ChicagoStyleClamPizza(); } else if ("pepperoni".equals(item)) { return ChicagoStylePepperoniPizza(); } else return null; } }
------------
----加州风味匹萨店----
public class CaliforniaPizzaStore extends PizzaStore { Pizza createPizza(String item) { if ("cheese".equals(item)) { return CaliforniaStyleCheesePizza(); } else if ("veggie".equals(item)) { return CaliforniaStyleVeggiePizza(); } else if ("clam".equals(item)) { return CaliforniaStyleClamPizza(); } else if ("pepperoni".equals(item)) { return CaliforniaStylePepperoniPizza(); } else return null; } }
------------
*工厂方法用来处理对象的创建,并将这样的行为封装在子类中。这样,客户程序中关于超类的代码就和子类对象的创建代码解耦(Decouple)了。
工厂方法的定义:abstract Product factoryMethod(String type);
*所有工厂模式都用来封装对象的创建。
*工厂方法模式(Factory Method Pattern)通过让子类来决定该创建的对象是什么,来达到将对象的创建过程封装的目的。
*在工厂方法模式中包括创建者(Creator)类和产品(Product)类两种类型的类。
----设计谜题解答----
引用
1、与NYPizzaStore和ChicagoPizzaStore平行的是CaliforniaPizzaStore类,继承自PizzaStore类。
2、与NYStyleCheesePizza和ChicagoStyleCheesePizza平行的是CaliforniaStyleCheesePizza、CaliforniaStylePepperoniPizza、CaliforniaStyleClamPizza、CaliforniaStyleVeggiePizza类,继承自Pizza类,被CaliforniaPizzaStore类所依赖。
2、与NYStyleCheesePizza和ChicagoStyleCheesePizza平行的是CaliforniaStyleCheesePizza、CaliforniaStylePepperoniPizza、CaliforniaStyleClamPizza、CaliforniaStyleVeggiePizza类,继承自Pizza类,被CaliforniaPizzaStore类所依赖。
------------
工厂(Factory Method Pattern)方法模式:定义了一个创建对象的接口,但是由子类来决定要实例化的类是哪一个。它让类把实例化推迟到了子类。
*创建者(Creator)类实现了所有操纵产品的方法,但是不实现工厂方法。
*工厂方法模式可以和策略(Strategy)模式结合起来,在运行时动态地更换工厂类,从而创建不同的产品对象,这是简单工厂所不具有的弹性。
*工厂方法模式可以让客户在实例化对象时,只依赖接口,而不依赖具体的实现类。这符合“针对接口编程,而不是针对实现编程”的软件设计原则。
*如果类A的改变会影响到类B,那么我们说类B“依赖于”类A。
软件设计原则:要依赖抽象,不要依赖具体类。这个原则又被称为“依赖倒置原则(Dependency Inversion Principle)”。
*依赖倒置原则说明不能让高层组件依赖于底层组件,而且它们都应该依赖于抽象。
*遵循依赖倒置原则的三个指导方针:
(1)变量不可以持有具体类的引用。这可以通过使用工厂避开。
(2)不要让类派生自具体类。否则就会依赖具体类,违反了“针对接口编程,而不是针对现实编程”的软件设计原则。
(3)不要覆盖基类中已实现的方法。出现这样的情况就说明基类设计的有问题。
3.抽象工厂(Abstract Factory)模式部分
抽象工厂模式:提供一个接口,用于创建相关或者依赖对象的家族,而不需要明确指定具体类。
*抽象工厂模式是工厂方法模式的演变。工厂方法模式中,创建者只生产一种类型的产品,而抽象工厂模式中,创建者生产一组不同类型的产品。
----ChicagoPizzaIngredientFactory代码----
public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory { public Dough createDough() { return new ThickCrustDough(); } public Sause createSause() { return new FlumTomatoSause(); } public Cheese createCheese() { return new Mozzarella(); } public Veggies[] createVeggies() { return new Beggies[] {new BlackOlives(), new Spinach(), new EggPlant()}; } public Pepperoni createPepperoni() { return new SlicedPepperoni(); } public Clam createClam() { return new FrozenClams(); } }
------------
*抽象工厂(Abstract Factory)模式同时结合了工厂方法(Factory Method)模式和策略(Strategy)模式。
*工厂方法使用继承:把对象的创建委托(Delegate)给子类,让子类实现工厂方法创建对象。
*抽象工厂使用对象的组合:对象的创建被实现在工厂接口所暴露出来的方法中。
*所有工厂模式都通过减少应用程序和具体类之间的依赖来促进松耦合,即解耦(Decouple)。
4.简单工厂(Simple Factory)实例
public abstract class Car { protected String name;// 名称 protected String engines;// 发动机 protected String wheels;// 车轮 protected String lamps;// 车灯 public void prepare() { System.out.println("Preparing " + name); System.out.println("Get engines ready..."); System.out.println("Get wheels ready..."); System.out.println("Get lamps ready..."); } // 组装 public void fabricate() { System.out.println("Adding engines."); System.out.println("Adding wheels."); System.out.println("Adding lamps."); } // 检测 public void detect() { System.out.println("Detect the car."); } public String getName() { return name; } } public class BmwX3Car extends Car { public BmwX3Car() { name = "BMW X3"; engines = "One Engine"; wheels = "Four Wheels"; lamps = "Two Lamps"; } } public class BmwX5Car extends Car { public BmwX5Car() { name = "BMW X5"; engines = "Two Engines"; wheels = "Four Wheels"; lamps = "Four Lamps"; } } public class BmwX7Car extends Car { public BmwX7Car() { name = "BMW X7"; engines = "Four Engine"; wheels = "Four Wheels and One Spare Tyre"; lamps = "Six Lamps"; } } public class SimpleCarFactory { // 简单工厂 public Car createCar(String type) { if ("bmwx3".equals(type)) { return new BmwX3Car(); } else if ("bmwx5".equals(type)) { return new BmwX5Car(); } else if ("bmwx7".equals(type)) { return new BmwX7Car(); } else return null; } } // 汽车销售店 public class CarSalesShop { public Car orderCar(String type) { SimpleCarFactory factory = new SimpleCarFactory(); Car car = factory.createCar(type); car.prepare(); car.fabricate(); car.detect(); System.out.println("A " + car.getName() + " car is ready."); return car; } }
5.静态工厂实例
在上例的基础上实现:
public class StaticCarFactory { // 静态工厂 public static Car createCar(String type) { if ("bmwx3".equals(type)) { return new BmwX3Car(); } else if ("bmwx5".equals(type)) { return new BmwX5Car(); } else if ("bmwx7".equals(type)) { return new BmwX7Car(); } else return null; } }
修改CarSalesShop的代码:
public class CarSalesShop { public Car orderCar(String type) { Car car = StaticCarFactory.createCar(type);// 与简单工厂的区别在这里 car.prepare(); car.fabricate(); car.detect(); System.out.println("A " + car.getName() + " car is ready."); return car; } }
6.工厂方法(Factory Method)模式实例
在上例的基础上实现:
public class BeijingBmwX3Car extends Car { public BeijingBmwX3Car() { name = "Beijing BMW X3"; engines = "One Engine"; wheels = "Four Wheels"; lamps = "Two Lamps"; } } public class BeijingBmwX5Car extends Car { public BeijingBmwX5Car() { name = "Beijing BMW X5"; engines = "Two Engines"; wheels = "Four Wheels"; lamps = "Four Lamps"; } } public class BeijingBmwX7Car extends Car { public BeijingBmwX7Car() { name = "Beijing BMW X7"; engines = "Four Engine"; wheels = "Four Wheels and One Spare Tyre"; lamps = "Six Lamps"; } } public class ShanghaiBmwX3Car extends Car { public ShanghaiBmwX3Car() { name = "Shanghai BMW X3"; engines = "One Engine"; wheels = "Four Wheels"; lamps = "Two Lamps"; } } public class ShanghaiBmwX5Car extends Car { public ShanghaiBmwX5Car() { name = "Shanghai BMW X5"; engines = "Two Engines"; wheels = "Four Wheels"; lamps = "Four Lamps"; } } public class ShanghaiBmwX7Car extends Car { public ShanghaiBmwX7Car() { name = "Shanghai BMW X7"; engines = "Four Engine"; wheels = "Four Wheels and One Spare Tyre"; lamps = "Six Lamps"; } } public abstract class CarSalesShop { public Car orderCar(String type) { Car car = createCar(type); car.prepare(); car.fabricate(); car.detect(); System.out.println("A " + car.getName() + " car is ready."); return car; } // 工厂方法接口 public abstract Car createCar(String type); } public class BeijingCarSalesShop extends CarSalesShop { @Override public Car createCar(String type) { if ("bmwx3".equals(type)) { return new BeijingBmwX3Car(); } else if ("bmwx5".equals(type)) { return new BeijingBmwX5Car(); } else if ("bmwx7".equals(type)) { return new BeijingBmwX7Car(); } else return null; } } public class ShanghaiCarSalesShop extends CarSalesShop { @Override public Car createCar(String type) { if ("bmwx3".equals(type)) { return new ShanghaiBmwX3Car(); } else if ("bmwx5".equals(type)) { return new ShanghaiBmwX5Car(); } else if ("bmwx7".equals(type)) { return new ShanghaiBmwX7Car(); } else return null; } }
7.抽象工厂(Abstract Factory)模式实例
// 发动机接口 public interface Engine { public int getHorsepower(); } public class BeijingEngine implements Engine { public int getHorsepower() { return 200; } } public class ShanghaiEngine implements Engine { public int getHorsepower() { return 230; } } // 车轮接口 public interface Wheel { public double getDiameter(); } public class BeijingWheel implements Wheel { public double getDiameter() { return 80; } } public class ShanghaiWheel implements Wheel { public double getDiameter() { return 95; } } // 车灯接口 public interface Lamp { public int getPower(); } public class BeijingLamp implements Lamp { public int getPower() { return 60; } } public class ShanghaiLamp implements Lamp { public int getPower() { return 80; } } // 汽车零件制造工厂 public interface PartsFactory { public Engine createEngine(); public Wheel createWheel(); public Lamp createLamp(); } public class BeijingPartsFactory implements PartsFactory { public Engine createEngine() { return new BeijingEngine(); } public Lamp createLamp() { return new BeijingLamp(); } public Wheel createWheel() { return new BeijingWheel(); } } public class ShanghaiPartsFactory implements PartsFactory { public Engine createEngine() { return new ShanghaiEngine(); } public Lamp createLamp() { return new ShanghaiLamp(); } public Wheel createWheel() { return new ShanghaiWheel(); } } public abstract class Car { protected String name;// 名称 protected Engine[] engines;// 发动机 protected Wheel[] wheels;// 车轮 protected Lamp[] lamps;// 车灯 public void prepare() { System.out.println("Preparing " + name); System.out.println("Get engines ready..."); System.out.println("Get wheels ready..."); System.out.println("Get lamps ready..."); } // 组装 public void fabricate() { System.out.println("Adding engines."); System.out.println("Adding wheels."); System.out.println("Adding lamps."); } // 检测 public void detect() { System.out.println("Detect the car."); } public String getName() { return name; } } public class BmwX3Car extends Car { private PartsFactory factory; public BmwX3Car(PartsFactory factory) { this.factory = factory; name = "BMW X3"; // 一个发动机 engines = new Engine[] { this.factory.createEngine() }; // 四个车轮 wheels = new Wheel[] { this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel() }; // 两个车灯 lamps = new Lamp[] { this.factory.createLamp(), this.factory.createLamp() }; } } public class BmwX5Car extends Car { private PartsFactory factory; public BmwX5Car(PartsFactory factory) { this.factory = factory; name = "BMW X5"; // 两个发动机 engines = new Engine[] { this.factory.createEngine(), this.factory.createEngine() }; // 四个车轮 wheels = new Wheel[] { this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel() }; // 四个车灯 lamps = new Lamp[] { this.factory.createLamp(), this.factory.createLamp(), this.factory.createLamp(), this.factory.createLamp() }; } } public class BmwX7Car extends Car { private PartsFactory factory; public BmwX7Car(PartsFactory factory) { this.factory = factory; name = "BMW X7"; // 四个发动机 engines = new Engine[] { this.factory.createEngine(), this.factory.createEngine(), this.factory.createEngine(), this.factory.createEngine() }; // 四个车轮和一个备用胎 wheels = new Wheel[] { this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel(), this.factory.createWheel() }; // 六个车灯 lamps = new Lamp[] { this.factory.createLamp(), this.factory.createLamp(), this.factory.createLamp(), this.factory.createLamp() }; } } public abstract class CarSalesShop { public Car orderCar(String type) { Car car = createCar(type); car.prepare(); car.fabricate(); car.detect(); System.out.println("A " + car.getName() + " car is ready."); return car; } // 工厂方法接口 public abstract Car createCar(String type); } public class BeijingCarSalesShop extends CarSalesShop { @Override public Car createCar(String type) { PartsFactory factory = new BeijingPartsFactory(); if ("bmwx3".equals(type)) { return new BmwX3Car(factory); } else if ("bmwx5".equals(type)) { return new BmwX5Car(factory); } else if ("bmwx7".equals(type)) { return new BmwX7Car(factory); } else return null; } } public class ShanghaiCarSalesShop extends CarSalesShop { @Override public Car createCar(String type) { PartsFactory factory = new ShanghaiPartsFactory(); if ("bmwx3".equals(type)) { return new BmwX3Car(factory); } else if ("bmwx5".equals(type)) { return new BmwX5Car(factory); } else if ("bmwx7".equals(type)) { return new BmwX7Car(factory); } else return null; } }
8.结合策略模式优化抽象工厂实例
修改CarSalesShop类如下:
public class CarSalesShop { private PartsFactory factory; public CarSalesShop(PartsFactory factory) { this.factory = factory; } public Car orderCar(String type) { Car car = createCar(type); car.prepare(); car.fabricate(); car.detect(); System.out.println("A " + car.getName() + " car is ready."); return car; } // 原有的工厂方法接口,现在实现了它 public Car createCar(String type) { if ("bmwx3".equals(type)) { return new BmwX3Car(factory); } else if ("bmwx5".equals(type)) { return new BmwX5Car(factory); } else if ("bmwx7".equals(type)) { return new BmwX7Car(factory); } else return null; } }
这样修改后,就不再需要BeijingCarSalesShop和ShanghaiCarSalesShop这两个类。使用方法如下:
public class Test { public static void main(String[] args) { PartsFactory factory = new BeijingPartsFactory(); CarSalesShop shop = new CarSalesShop(factory); shop.orderCar("bmwx7"); } }
这样修改后,由于引入了策略模式,消除了两个两个子类,并且可以通过增加setPartsFactory()方法达到运行时改变零件生产工厂的目的。
--END--
发表评论
-
Java6.0新特性之StAX--全面解析Java XML分析技术
2010-04-19 12:57 23811作者:臧圩人(zangweiren) 网址:http://za ... -
《Head First设计模式》阅读笔记.全书总结
2010-04-14 15:13 55141、模式(Pattern)定义 ... -
《Head First设计模式》阅读笔记.其他设计模式
2010-04-14 13:33 21981、附录A部分-剩下的模 ... -
《Head First设计模式》阅读笔记.第十三章
2010-04-13 14:40 19551、与设计模式相处 模式:是在某种情境下(Context), ... -
《Head First设计模式》阅读笔记.第十二章
2010-04-12 15:15 20341、复合(Complex)模式部分 *模式通常被一起使用,并 ... -
《Head First设计模式》阅读笔记.第十一章
2010-04-08 17:57 23751、代理(Proxy)模式部分 实现RMI(远程方法调用)的 ... -
《Head First设计模式》阅读笔记.第十章
2010-04-02 17:22 21941.状态(State)模式部分 *设计谜题 -------- ... -
《Head First设计模式》阅读笔记.第八章
2010-03-30 14:28 23521.模板方法(Template Metho ... -
《Head First设计模式》阅读笔记.第九章
2010-01-27 10:33 25441.迭代器(Iterator)模式 ... -
《Head First设计模式》阅读笔记.第七章-外观模式实例补充
2010-01-21 17:08 2055// 电源 public class Power { p ... -
《Head First设计模式》阅读笔记.第七章
2010-01-21 11:02 22291.适配器(Adapter)模式部分 *OO适配器和真实世界 ... -
《Head First设计模式》阅读笔记.第六章
2010-01-19 14:53 19281.命令(Command)模式部分 引用----连连看解答- ... -
《Head First设计模式》阅读笔记.第五章
2010-01-15 16:48 20381.单件(单态,Singleton)模式部分 *有些对象我们 ... -
《Head First设计模式》阅读笔记.第三章
2010-01-13 12:07 21161.装饰者(Decorator)模式部分 *利用组合(com ... -
《Head First设计模式》阅读笔记.第二章
2010-01-12 15:04 24481.观察者(Observer)模式部分 *观察者模式:定义了 ... -
《Head First设计模式》阅读笔记.第一章
2010-01-12 10:00 37971.策略模式部分 *面向对象(OO)的四个基本概念是:抽象、 ...
相关推荐
1.1 《Head First设计模式》阅读笔记.第一章 1.2 《Head First设计模式》阅读笔记.第二章 1.3 《Head First设计模式》阅读笔记.第三章 1.4 《Head First设计模式》阅读笔记.第四章 1.5 《Head First设计模式》...
Head.First 设计模式学习笔记.pdf Head.First 设计模式学习笔记.pdf
笔记_HeadFirst设计模式
HeadFirst设计模式学习笔记比较全面详细地讲解了13个设计模式,有利于大家更好的学习HeadFirst设计模式,希望亲们会喜欢~~~
Head First 设计模式学习笔记。更多内容请参见文章内容。
HeadFirst 设计模式学习笔记3--装饰模式 Demo http://blog.csdn.net/laszloyu/archive/2010/05/12/5582561.aspx
HeadFirst设计模式 读书 笔记
HeadFirst 设计模式学习笔记2--观察者模式 demo http://blog.csdn.net/laszloyu/archive/2010/05/12/5581769.aspx
http://blog.csdn.net/laszloyu/archive/2010/05/11/5579765.aspx 示例代码
Head First设计模式读书笔记-DesignPatterns
NULL 博文链接:https://zhangfy068.iteye.com/blog/1706132
著名的《Head First Design ...由于书本过长,整理出笔记帮助回想起设计模式。文件是docx格式,只能由OFFICE Word 2007之后的版本打开,内附Visio类图文件。本文由个人整理摘录,部分内容来自书本,仅供学习使用。
NULL 博文链接:https://chxiaowu.iteye.com/blog/1276845
NULL 博文链接:https://never-say-never.iteye.com/blog/851923
趣味的移动开发讲解讲解,类似个人笔记,非常容易懂的,有好多勾画图
headfirst 设计模式读书笔记 书很好,浅显易懂,例子生动,适合初学者
设计模式Head First学习笔记,以及使用java编写的设计模式源码,Java原生sdk实现23种设计模式
java原始中的设计模式 Gof设计模式 一个Android应用程序,该应用程序演示了以下来源的GoF设计模式的源代码: E.Freeman,E.Freeman,K.Sierra,B.Bates的书:copyright:O'Reilly 2004 布莱恩·汉森(Bryan Hansen),...