GOF23之工厂模式Demo
2015-05-21 11:32
507 查看
java开发过程中经常使用到工厂模式,下面列出非工厂模式与三种工厂模式的Demo
1.非工厂模式
以Running Car为例
运行结果
Audi Running!
Byd Running!
2.简单工厂模式(实际中使用最多的工厂模式)
简而言之就是要什么我造什么,全部在一个工厂中实现,所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了,这违背了开闭原则。
运行结果:
Audi Running!
Byd Running!
简单工厂的另一种方式
运行结果:
Audi Running!
Byd Running!
3.工厂方法模式
定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。完全实现‘开-闭 原则’,实现了可扩展。其次更复杂的层次结构,可以应用于产品结果复杂的场合。
缺点:导致工厂过多。
以Running Car为例
运行结果
Audi Running!
Byd Running!
Benz Running!
4.抽象工厂模式
以生产汽车为例,生产汽车分为一般汽车和豪华汽车,组装汽车时使用不同的座椅、轮胎、引擎。座椅、轮胎、引擎全部抽象出来,生产汽车的工厂也抽象出来,由不同规格的座椅、轮胎、引擎来实现抽象的座椅、轮胎、引擎,由生产不同汽车的工厂来实现生产汽车。
引擎接口与实现类:
座椅接口与实现类:
轮胎接口与实现类:
生产汽车的工厂接口:
低端汽车工厂的实现类:
高端汽车工厂的实现类:
测试:
运行结果:
转速很快!
启动快!可以自动启停!
转速较慢!
启动慢!不能自动启停!
以上的Demo可以较为详细的解释了3种工厂模式。实际项目中,简单工厂的使用还是最多的。
1.非工厂模式
以Running Car为例
public interface Car { void run(); } public class Audi implements Car { @Override public void run() { System.out.println("Audi Running"); } } public class Byd implements Car { @Override public void run() { System.out.println("Byd Running!"); } } public class Client01 { //调用者 public static void main(String[] args) { Car c1 = new Audi(); Car c2 = new Byd(); c1.run(); c2.run(); } }
运行结果
Audi Running!
Byd Running!
2.简单工厂模式(实际中使用最多的工厂模式)
简而言之就是要什么我造什么,全部在一个工厂中实现,所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了,这违背了开闭原则。
public class CarFactory { public static Car createCar(String type){ if("奥迪".equals(type)){ return new Audi(); }else if("比亚迪".equals(type)){ return new Byd(); }else{ return null; } } } public class Client02 { //调用者 public static void main(String[] args) { Car c1 =CarFactory.createCar("奥迪"); Car c2 = CarFactory.createCar("比亚迪"); c1.run(); c2.run(); } }
运行结果:
Audi Running!
Byd Running!
简单工厂的另一种方式
public class CarFactory2 { public static Car createAudi(){ return new Audi(); } public static Car createByd(){ return new Byd(); } } public class Client02 { //调用者 public static void main(String[] args) { Car c1 = CarFactory2.createAudi(); Car c2 = CarFactory2.createByd(); c1.run(); c2.run(); } }
运行结果:
Audi Running!
Byd Running!
3.工厂方法模式
定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。完全实现‘开-闭 原则’,实现了可扩展。其次更复杂的层次结构,可以应用于产品结果复杂的场合。
缺点:导致工厂过多。
以Running Car为例
public interface Car { void run(); } public class Audi implements Car { @Override public void run() { System.out.println("Audi Running!"); } } public class Benz implements Car { @Override public void run() { System.out.println("Benz Running!"); } } public class Byd implements Car { @Override public void run() { System.out.println("Byd Running!"); } } public interface CarFactory { Car createCar(); } public class AudiFactory implements CarFactory { @Override public Car createCar() { return new Audi(); } } public class BenzFactory implements CarFactory { @Override public Car createCar() { return new Benz(); } } public class BydFactory implements CarFactory { @Override public Car createCar() { return new Byd(); } } public class Client { public static void main(String[] args) { Car c1 = new AudiFactory().createCar(); Car c2 = new BydFactory().createCar(); Car c3 = new BenzFactory().createCar(); c1.run(); c2.run(); c3.run(); } }
运行结果
Audi Running!
Byd Running!
Benz Running!
4.抽象工厂模式
以生产汽车为例,生产汽车分为一般汽车和豪华汽车,组装汽车时使用不同的座椅、轮胎、引擎。座椅、轮胎、引擎全部抽象出来,生产汽车的工厂也抽象出来,由不同规格的座椅、轮胎、引擎来实现抽象的座椅、轮胎、引擎,由生产不同汽车的工厂来实现生产汽车。
引擎接口与实现类:
public interface Engine { void run(); void start(); } class LuxuryEngine implements Engine{ @Override public void run() { System.out.println("转速很快!"); } @Override public void start() { System.out.println("启动快!可以自动启停!"); } } class LowEngine implements Engine{ @Override public void run() { System.out.println("转速较慢!"); } @Override public void start() { System.out.println("启动慢!不能自动启停"); } }
座椅接口与实现类:
public interface Seat { void massage(); } class LuxurySeat implements Seat { @Override public void massage() { System.out.println("自动按摩!"); } } class LowSeat implements Seat { @Override public void massage() { System.out.println("不能按摩!"); } }
轮胎接口与实现类:
public interface Tyre { void revolve(); } class LuxuryTyre implements Tyre { @Override public void revolve() { System.out.println("旋转磨损小!"); } } class LowTyre implements Tyre { @Override public void revolve() { System.out.println("旋转磨损快!"); } }
生产汽车的工厂接口:
public interface CarFactory { Engine createEngine(); Seat createSeat(); Tyre createTyre(); }
低端汽车工厂的实现类:
public class LowCarFactory implements CarFactory { @Override public Engine createEngine() { return new LowEngine(); } @Override public Seat createSeat() { return new LowSeat(); } @Override public Tyre createTyre() { return new LowTyre(); } }
高端汽车工厂的实现类:
public class LuxuryCarFactory implements CarFactory { @Override public Engine createEngine() { return new LuxuryEngine(); } @Override public Seat createSeat() { return new LuxurySeat(); } @Override public Tyre createTyre() { return new LuxuryTyre(); } }
测试:
public class Client { public static void main(String[] args) { CarFactory factory = new LuxuryCarFactory(); Engine e = factory.createEngine(); e.run(); e.start(); CarFactory factory2 = new LowCarFactory(); Engine e2 = factory2.createEngine(); e2.run(); e2.start(); } }
运行结果:
转速很快!
启动快!可以自动启停!
转速较慢!
启动慢!不能自动启停!
以上的Demo可以较为详细的解释了3种工厂模式。实际项目中,简单工厂的使用还是最多的。
相关文章推荐
- GOF23之单例模式Demo
- 【GOF23设计模式】工厂模式
- GOF23之组合模式Demo
- GOF23之桥接模式Demo
- GOF23之工厂模式理解
- 【GOF23设计模式】--工厂模式
- GOF23之外观模式Demo
- 【GOF23设计模式】_工厂模式JAVA229-231
- GOF23之建造者模式Demo
- GOF23之代理模式Demo
- GOF23设计模式之外观模式不使用外观模式的实现
- 【GOF23设计模式】享元模式
- GOF 23设计模式之 桥接模式
- go语言快速入门:简单工厂模式的实现(23)
- 设计模式 2/23 工厂模式(二)
- 【GOF23设计模式】_解释器模式_访问者模式_数学表达式动态解析库式JAVA247
- [GoF23] java中的Proxy模式(二)
- 设计模式GOF23——责任链模式
- 【GOF23设计模式】责任链模式
- (GOF23设计模式)_单例模式_双重检查锁式_静态内部类式_枚举式