设计模式之_工厂系列

package com.learn.abstractfactory;/*** 现在我们假设这么一个东西,这个人不仅开着车,* 还拿着武器,比如说他拿着一把AK47,* 这个人不仅开着Car,手持AK47,* 这个人手上控制的产品非常多,* 他开着Car,手持AK47,嘴里叼着苹果* 一路哼着歌,奔着东北而去了* 这个人手里头控制着一系列产品* 如果我想控制这一系列产品的随时替换,* 我该怎么办?比如举个实际点的列子* 你家搞装修,现在还要卖整体厨房,* 油烟机也是他的,这个地板也是他的,* 热水器也是他的,微波炉也是他的,* 你能不能做到说把一系列产品替换掉的话就全给替换掉了* 这就好玩了,这件事情该怎么做呢* 其实根据我给大家的例子,* 我是不是有一个工厂一下子可以产生一系列产品* 这样我在Test里面所有的东西我都不去new他了* @author Leon.Sun**/
public class Test {public static void main(String[] args) {/*** 首先我new一个工厂出来* 如果我想把一系列产品全替换掉的话,* 我只要来一个新的工厂就可以了* 但是现在问题就来了* 我想把DefaultFactory换成MagicFactory* 我所有的产品都会跟着换过来* 下面的方法都要跟着改,太麻烦了* 我不想改下面的方法* 有人说起名字起成一样的,但是不能再语法上控制他* 如果我们想在语法上控制他,只能写特定的命名的方法* 我就要产生一个工厂的父类*/// DefaultFactory f = new DefaultFactory();/*** 我用父类引用指向子类对象* 因为MagicFactory是AbstractFactory的子类* 所以我可以这样去new* 我们在这里new的是MagicFactory* 如果我换成其他系列的产品,简单我只要换一个地方* 我把MagicFactory改成DefaultFactory* 你会发现你所有的一系列产品都会跟着变了* 而且还有一个好处,如果你对自己的东西不满意了* 一系列产品你都不满意,你添加你自己的系列产品* 交通工具从Vehicle继承* 武器从Weapon继承* 然后再产生自己的工厂* 你不必修改原来的代码* 换成自己的系列产品只需要改这么一个地方* 将来我把这个东西写在配置文件里* 你甚至源代码都不用变了* 只改配置文件就OK* 类似于这样的应用非常多* 我相信大家用过换皮肤的软件* 包括里面的按钮,什么菜单,对话框都整体的换过来了* 是不是很类似于抽象工程* 抽象工厂是生产了一系列产品,* 如果你想换掉一系列产品的时候,* 或者是想在一系列产品的情况下进行扩展,* 想产生新的系列产品* 以及想对这一系列产品的生产过程进行控制,* 用抽象工厂,* 抽象工厂和我们普通的工厂相比,* 他在哪方面具有长处,* 哪方面又是短处,* 我觉得最关键的一点,* 对于我们普通的工厂来说,* 我们是能够扩展产品的,* 对于普通的工厂来说,我们是可以对产品的维度上来扩展,* 我可以产生新的产品,* 可以产生新的产品的工厂,* 这两个东西我都可以产生,* 所以我可以在产品这方法进行扩展,* 如果我们普通工厂里面产生产品系列,* 你这个时候会不会很麻烦,* 你肯定会特别麻烦,* 因为你产生新的产品系列,* 你产生Apple,你就的产生AppleFactory,* 你产生MushRoom,你就的产生MushFactory,* 然后你就会发现工厂泛滥,* 最后你就会发现你的工厂类,会不断的泛滥,* 所以普通的方法工厂来说,最后会产生工厂泛滥这种问题,* 但是对于抽象工厂来说,他也有短处,* 我现在可以换产品系列,可以产生新的产品系列,* 可是我可以产生新的产品品种吗,比如说我现在想让这个人带着盔甲* 盔甲有具体的工厂让他去产生,这个时候就麻烦了,* 必须让AbstractFactory去动他的工厂,再加一个方法叫create盔甲* 然后我所有的子类原来实现过的得加上新的方法,有没有觉得很麻烦,* 所以这两个都有短处,简单工厂的短处在什么地方呢,产生产品系列的时候会很麻烦,* 工厂泛滥,而抽象工厂在产生产品系列品种的时候,你要改动的地方也太多,* 能不能把短处给他去掉,把长处给综合起来,既让他在产品系列有扩展,* 又能够在产品的品种方面唯一的确定,可以说天底下没有那么大的好事,* 很多很多事情那方面好了另一方面就不好,他最后是一个零和游戏,* 反正哪方面多了这方面就少了,没有特别特别好的解决方案,* 不过Spring本身提供了一种解决方案,Spring本身叫做bean工厂,* 为了测试Spring的Bean工厂,* 在Spring里面有一个工厂叫BeanFactory,他其实是由一些子类来实现的*/// MagicFactory m = new MagicFactory();// AbstractFactory f = new MagicFactory();AbstractFactory f = new DefaultFactory();/*** 要想用的时候把它new出来* * 现在我有一个客户类* * 然后所有的东西都有Factory来产生*/// Car c = new Car();// Car c = f.createCar();Vehicle v = f.createVehicle();// c.run();v.run();/*** 手持AK47* 让他去shoot*/// AK47 ak = new AK47();// AK47 ak = f.createAK47();// ak.shoot();/*** 他具体产生什么样的武器* 要根据他具体的工厂来决定* 只要你的工厂一旦替换掉之后* 我就可以把所有系列的产品全都替换过来*/Weapon w = f.createWeapon();w.shoot();/*** 我还可以让他去吃苹果* 然后打印他的名字*/// Apple a = new Apple();// Apple a = f.createApple();Food food = f.createFood();// a.printName();food.printName();}}

package com.learn.abstractfactory;/*** Car不去实现任何的接口了,也不管单例了* 这是我们最原始的状态* @author Leon.Sun**/
public class Car extends Vehicle {public void run() {System.out.println("冒着烟奔跑中car......");}}

package com.learn.abstractfactory;/*** 我们具体的子类,比如AK47* 应该是从Weapon继承* 这样我们的AK47的工厂createWeapon的方法去产生AK47了* @author Leon.Sun**/
public class AK47 extends Weapon {/*** AK47里面有一个方法*/public void shoot() {System.out.println("哒哒哒......");}
}

package com.learn.abstractfactory;public class Apple extends Food {/*** 拿到水果的名称* 简单起见就打印他的名字*/public void printName() {System.out.println("apple");}}

package com.learn.abstractfactory;/*** 由他来产生具体的东西,* 比如他可以产生一个Car,* 他可以产生一系列产品* 让这两个具体的Factory从AbstractFactory继承* @author Leon.Sun**/
public class DefaultFactory extends AbstractFactory {@Overridepublic Vehicle createVehicle() {return new Car();}@Overridepublic Weapon createWeapon() {return new AK47();}@Overridepublic Food createFood() {return new Apple();}//  public Car createCar() {
//      return new Car();
//  }/*** 他可以产生枪AK47*/
//  public AK47 createAK47() {
//      return new AK47();
//  }/*** 产生食品Apple*/
//  public Apple createApple() {
//      return new Apple();
//  }}

package com.learn.abstractfactory;/*** 魔法世界的工厂* 既然你是从AbstractFactory继承* 所以需要去是实现他的方法* 让他自己来帮我生成* @author Leon.Sun**/
public class MagicFactory extends AbstractFactory {@Overridepublic Vehicle createVehicle() {return new Broom();}@Overridepublic Weapon createWeapon() {return new MagicStick();}/*** 产生毒蘑菇*/@Overridepublic Food createFood() {return new MushRoom();}/*** 他产生的交通工具永远都是扫帚*/
//  public Broom createBroom() {
//      return new Broom();
//  }/*** 由他来产生武器* 魔法世界产生的武器应该叫魔法棒*/
//  public MagicStick createMagicStick() {
//      return new MagicStick();
//  }/*** 他还可以产生第三系列的产品* 魔法世界产生的食品蘑菇*/
//  public MushRoom createMushRoom() {
//      return new MushRoom();
//  }}

package com.learn.abstractfactory;/*** 一个简单的Broom* @author Leon.Sun**/
public class Broom extends Vehicle {public void run() {System.out.println("一路沙城暴飞奔......");}
}

package com.learn.abstractfactory;public class MagicStick extends Weapon {@Overridepublic void shoot() {/*** 他射出来的是一个大火球*/System.out.println("fire hu hu hu hu.......");}}

package com.learn.abstractfactory;/*** 他应该从Food继承* @author Leon.Sun**/
public class MushRoom extends Food {@Overridepublic void printName() {System.out.println("MushRoom.......");}}

package com.learn.abstractfactory;/*** 抽象工厂* 他当然有产生系列产品的方法* * 我们现在有一大堆的产品* 我们有一个Vehicle交通工具* Food食品,有一个Weapon武器* 然后在他们的下面有一个又一个的子类* 他们下面有子类去实现他* 现在我们一个工厂就能够产生一系列的产品* 这个工厂很好玩,一下子就能产生好多产品* 他可以产1系列的工厂* 当然我们还有2系列的工厂* 总而言之他可以产生V1,F2,W2* 其实他们两个是同一个父类* 像类似于这样一个内结构有什么样的好处呢* 好处就在于你想替换掉这一系列产品的时候* 你只需要把这一系列产品造出来,同时换掉这个工厂就可以了* 比如我想把1系列的产品替换成2系列的产品* 只需要替换产生工厂就可以了* 你没有必要所有的东西都自己取new一遍* * @author Leon.Sun**/
public abstract class AbstractFactory {/*** 因为我得根据的工厂产生具体的产品* 所以对于我们来说,这些产品我们也得统一起来* 当然我们也有这方面的经验了* 统一这些产品建父类就行了* 我就必须创建一个新的抽象的概念出来* 它是用来产生交通工具的* 有什么样的交通工具由他的子类来决定,* 所以增加了四个抽象概念* 第一个是AbstractFactory* 第二个是Vehicle* 第三个是Weapon* 第四个是Food* 这几个类都得创建出来* */public abstract Vehicle createVehicle();/*** 产生武器,至于你是魔法世界的武器还是大刀随便你*/public abstract Weapon createWeapon();/*** 还可以产生食品*/public abstract Food createFood();
}

package com.learn.abstractfactory;/*** 作为Vehicle来说* 现在就是面向抽象编程* 有什么好处,替换起来比较方便* 扩展起来比较容易* * @author Leon.Sun**/
public abstract class Vehicle {public abstract void run();
}

package com.learn.abstractfactory;/*** 首先class是abstract* @author Leon.Sun**/
public abstract class Weapon {/*** 首先有一个方法shoot* 怎么样去shoot由子类去决定*/public abstract void shoot();
}

package com.learn.abstractfactory;public abstract class Food {/*** 他怎么去print的,与我没关系* 由子类去决定*/public abstract void printName();
}

设计模式之_工厂系列_02相关推荐

设计模式之_工厂系列_01
package com.learn.factory;import java.util.ArrayList; import java.util.List;/*** 他现在new的是Car,* * 在这里 ...
设计模式之_工厂系列_03
package com.learn.spring;/*** 这个Factory模拟Spring,我把它改成interface* Spring的意思是这样的,当你拿到任何的具体的子类的时候,* * @a ...
设计模式之_动态代理_02
package com.learn.proxy;/*** JDK的那个类就叫Proxy* @author Leon.Sun**/ public class Proxy {/*** 这个方法就是用来产生 ...
设计模式练习_设计练习是邪恶的
设计模式练习 It was the final round of interviews. Or, so the candidate thought. 这是采访的最后一轮. 或者,所以候选人认为. Sh ...
java设计模式观察者模式_理解java设计模式之观察者模式
在生活实际中,我们经常会遇到关注一个事物数据变化的情况,例如生活中的温度记录仪,当温度变化时,我们观察它温度变化的曲线,温度记录日志等.对于这一类问题,很接近java设计模式里面的"观察者模 ...
设计模式之_动态代理_01
package com.learn.proxy;import java.util.Random;/*** 产生了坦克这么一个类* 坦克当然是可以移动的,实现了接口,实现了move方法* 我想知道一个方 ...
python 设计模式观察者_设计模式Python实现-观察者模式
观察者模式(发布-订阅模式 Publish Subscribe Pattern):定义了一种一对多的关系,让多个观察对象同时监听一个主题对象,当主题对象状态发生变化时会通知所有观察者,是它们能够自动更 ...
设计模式示例_责任链设计模式示例
设计模式示例本文是我们名为" Java设计模式 "的学院课程的一部分. 在本课程中,您将深入研究大量的设计模式,并了解如何在Java中实现和利用它们. 您将了解模式如此重要的原因 ...
设计模式示例_代理设计模式示例
设计模式示例本文是我们名为" Java设计模式 "的学院课程的一部分. 在本课程中,您将深入研究大量的设计模式,并了解如何在Java中实现和利用它们. 您将了解模式如此重要的原因 ...

设计模式之_工厂系列_02

设计模式之_工厂系列_02相关推荐

最新文章

热门文章