- 工厂模式是一种创建型模式。。。其中创建型模式包括:单例,工厂,建造者,原型四种
- /* 为什么要工厂方法:
- 1.因为我想控制产生交通工具的生产过程
- 2.工厂模式符合OCP原则,也就是开闭原则,
- 3。抽象工厂还有个最大优点,高内聚,低耦合,内聚都高到new的地方都转移到了一个类中来维护
- 工厂的共性是: 能生产多种产品,所以要具体产品类和抽象产品类,当然有一个具体工厂哈
- 工厂模式分为三种:
- 简单工厂模式(有些人又把简单工厂模式看成是工厂方法模式的一种特例),
- 工厂方法模式,
- 抽象工厂模式。
- */
- -------------------------没有工厂的时候-------------------------------------------------
- //当你控制了他的生产过程之后,像这样的代码就可以解耦了
- UserDao userDao = new UserDaoImpl(); //这个代码是依赖于UserDaoImpl的实现的,如果想要换个类,那么这个地方时需要改动的,也就是说用到的地方要改,被用到的地方也要改。。
- ---------------------------工厂来了-----------------------------------------------
- 简单工厂模式:优点:工厂类中包含了必要的逻辑判断(switch或者if/else),根据客户端的选择条件动态实例化相关的类,对客户端来说,去除了与具体产品的依赖。。。问题:因为需求变更后,我们需要修改原有的工厂类(至少要加case条件吧),这样违背了开放-封闭原则。
- 还有优点,他们转移了new,使得更换对象不需要大幅度修改。。。
- 它具有三个角色: 抽象产品角色,具体产品角色, 工厂类角色(new 的管理者)
- 一个工厂生产一种类别的产品。。。。。。。。
- 暴发户只要在车里面说一句:"开车"就可以了
- //抽象产品角色
- public interface Car{
- public void drive();
- }
- 具体产品角色
- public class Benz implements Car{
- public void drive(){
- System.out.println("Driving Benz");
- }
- }
- public class BMW implements Car{
- public void drive(){
- System.out.println("Driving BMW");
- }
- }
- //工厂类角色
- public class Driver{
- public static Car driverCar(String s){
- if(s.equals("Benz"))return new Benz();
- if(s.equals("BMW"))return new BMW();
- }
- }
- //例子二
- public class SimplePizzaFactory{
- public Pizza createPizza(String type){
- Pizza p = null; //抽象产品类
- if(type.equals("cheese")){
- p = new CheesePizza();//具体产品类
- }else if(type.equals("pepperoni")){
- p = new PepperoniPizza();
- }else if(type.equals("veggie")){
- p = new VeggiePizza();
- }
- return p;
- }
- }
- ---------------------------忧郁的分割线----------------------------------------------
- 下面是工厂方法:
- 工厂方法模式就是为了去除简单工厂中的if/else或者switch/case来做的,他定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
- 但是但是但是:工厂方法模式实现时,客户端需要决定实例化哪一个工厂,也就是说,工厂方法把简单工厂的内部逻辑判断已到了客户端代码来进行。。。。
- 我们想想他存在的意义,如果制造一辆汽车的过程只是一个new xxxCar();那么不要使用工厂,如果制造汽车的过程是 xxxxx;xxxxxx;xxxxx;.....; new xxxCar();xxxxx; 那么使用工厂方法模式,他可以使得知道汽车的这一系列的过程被封在起来,因为制造工厂的过程简单。。。
- 组成: 抽象工厂角色(工厂就开始抽象了哈),具体工厂角色,抽象产品角色,具体产品角色
- //抽象工厂角色
- public interface Driver{
- public Car driverCar();
- }
- //具体工厂角色
- public class BenzDriver implements Driver{
- public Car driverCar(){
- return new Benz();
- }
- }
- //具体工厂角色
- public class BMWDriver implements Driver{
- public Car driverCar(){
- return new BMW();
- }
- }
- ...产品类省略
- 使用:
- Driver driver = new BenzDriver();
- Car car = driver.driverCar();
- 对比简单工厂模式: Car car = Driver.driverCar("benz");
- -----------------抽象工厂---------------------------------------------------------
- /*
- 因为我们想让一个工厂生产不同的产品,
- 比如说我们想产生不同的交通工具,那么就要有不同的交通工具工厂的实现,每一个具体的工厂负责他对应的产品的控制
- */
- public abstract class Factory{
- public abstract Vihecle create();
- //这里使得所有工厂产生的产品有一个共性,他们还只能产生Vihecle的子类,或者让他们产生有Moveable接口的东西也可以
- }
- public class CarFactory extends Factory{
- public Vihecle create(){
- }
- }
- /**
- 如果一个工厂里面不是产生一个产品,而是产生一系列的产品
- */
- public class DefaultFactory{
- public void createCar(){}
- public void createAK47(){}
- public void createApple(){}
- }
- /*
- 如果要扩展的话,上面的写法不好。。。
- 所以创建一个他们的父亲工厂,其实实质和工厂方法是一样的,只不过多了几个工厂而已
- 嘿嘿。。。换皮肤的软件就是这么搞的
- */
- public abstract class Factory{
- public abstract void createVehicle();
- public abstract void createWeapon();
- public abstract void createFood(){};
- }
- /*
- 工厂和抽象工厂最大的区别:工厂利于扩展产品,但要扩展产品系列的话则会导致工厂泛滥,
- 抽象工厂利于产生产品系列,但对于扩展产品来说(比如要加一个Flower,则不但要改Factory而且要改所有Factory的子类)
- */
- -----------------配置文件与工厂的配合----------------------------------------------------------
- //下面是利用配置文件来指定类的工厂。。。。模拟Spring的Bean工厂
- //我们把要new 的东西放入配置文件中,这里配置文件里是这样 aakey=com.zhe.Car
- public class Test{
- public Car create(){
- Properties p = new Properties();
- p.load(Test.class.getClassLoader()
- .getResourceAsStream("com/zhe/a.properties"));
- String classString = p.getProperty("aakey");
- Object o = Class.forName(classString ).getInstance();
- //注意会调用空的构造函数
- Car car = (Car)o;
- car.run();
- }
- }
- //下面采用Spring自己的Bean工厂
- //这时的配置文件是:applicationContext.xml
- //里面 <bean id="aakey" value="com.zhe.Car" />哈哈,这就是所谓的Ioc依赖注入
- public class Test{
- public Car create(){
- BeanFactory f =
- new ClassPathXmlApplicationContext("applicationContext.xml");
- Object o = f.getBean("aaKey");
- Car car = (Car)o;
- car.run();
- }
- }
- //-----------------------------------------------------------------
- <<设计模式之禅>>-----抽象工厂
- 为什么要有抽象工厂? 所有设计模式都是为了使得代码重用,那么具体的工厂在生产过程中一定会有某些地方是一样的,那么就应该把他们提取出来,所以抽象工厂里面放的东西就是所有工厂的共性而已。。
- //这个接口规定了每个具体工厂的能力,规定了每个具体工厂要做什么事情
- public interface HumanFactory{
- public Human createYellowHuman();
- public Human createWhiteHuman();
- public Human createBlackHuman();
- }
- //下面是抽象工厂登场
- public abstract class AbstractHumanFactory implements HumanFactory{
- protected Human createHuman(HumanEnum human){ //定义了所有工厂制造人类的统一过程,他的目的其实就是为了减少代码量
- Human h = null;
- if(!human.getValue().equals("")){
- try{
- h = (Human)Class.forName(human.getValue()).newInstance();
- }catch(Exception e){
- }
- }
- return h;
- }
- }
- public class MaleHumanFactory extends AbstractHumanFactory{
- public Human createBlackHuman(){
- return super.createHuman(HumanEnum.BlackMaleHuman);
- }
- public Human createWhiteHuman(){
- return super.createHuman(HumanEnum.WhiteMaleHuman);
- }
- public Human createYellowHuman(){
- return super.createHuman(HumanEnum.YellowMaleHuman);
- }
- }
- 注意:我们把枚举看成是定义的static变量也可以,只不过他的好处是 不用判断输入参数是否为空,长度为0等边界条件
- public enum HumanEnum{
- YellowMaleHuman("com.zhe.yellowHuman.YellowMaleHuman");
- YellowFemaleHuman("com.zhe.yellowHuman.YellowFemaleHuman");
- WhiteMaleHuman("com.zhe.whiteHuman.WhitewMaleHuman");
- WhiteFemaleHuman("com.zhe.whiteHuman.WhiteFemaleHuman");
- private String value = "";
- private HumanEnum(String value){
- this.value = value;
- }
- public String getValue(){
- return this.value;
- }
- }
- 转自:http://z466459262.iteye.com/blog/709059
工厂模式2
最新推荐文章于 2024-08-29 17:15:49 发布