java 工厂模式实现_Java三种实现工厂模式的方法

学习工厂模式的时候就曾思考过这么写的好处，再手动敲了代码后发现自己更糊涂了，后来搜索例子和各种文案才有点概念，特此记录一下个人的理解

工厂模式的好处：

1.减少了重复代码

2.让创建对象于使用方法分离，代码解耦

3.利于后期的维护，事实上你创建的工厂的作用就是给你提供你需要的对象，不用在代码中 一个个new Class，后期如果需要换对象不用在调用的地方去改，修改工厂类中实例化对象的方法就可以，

这些都是个人理解，有什么不对留言指正，下面是实现工厂模式的三种方法

一，简单工厂模式

1.创建一个接口或者抽象方法

1 /**2 * 被创建者的公共接口3 * @author lql294 *5 */

6 public interfaceSender {7 //公有方法

8 public voidSend();9 }

2.创建两个实现类

1 public classMailSend implements Sender{2

3 @Override4 public voidSend() {5 //TODO Auto-generated method stub6 //实现接口方法

7 System.out.println("MailSender");8 }9

10 }

public classSmsSend implements Sender{

@Overridepublic voidSend() {//TODO Auto-generated method stub//实现接口方法

System.out.println("SmsSend");

}

}

3.创建一个工厂类

1 /**2 * 工厂类3 * @author lql294 *5 */

6 public classSenderFactory {7 publicSender produce(String Type){8 if("mail".equals(Type)){9 return newMailSend();10 }else if("sms".equals(Type)){11 return newSmsSend();12 }else{13 System.out.println("请输入正确的类型！");14 return null;15 }16 }17 }

最后实例化工厂类调用工厂类的produce方法，参数是想要返回被创建者对象的类型

二，工厂方法模式

1.创建被创建者接口

1 /**2 * 被创建者接口3 * @author lql294 *5 */

6 public interfacePrudactInterface {7 //定义公共方法

8 public voidproduction();9 }

2.创建工厂接口

1 /**2 * 定义工厂类接口3 * @author lql294 *5 */

6 public interfaceFactoryInterface {7 //创建对象方法

8 publicPrudactInterface found();9 }

3.实现被创建者接口

1 /**2 * 产品实体类3 * @author lql294 *5 */

6 public classPrudactPojo implements PrudactInterface{7

8 @Override9 public voidproduction() {10 //TODO Auto-generated method stub11 //定义生成什么产品

12 System.out.println("生产芒果饮料。。。。。");13 }14

15 }

1 /**2 * 定义产品实体类3 * @author lql294 *5 */

6 public classPrudactPojo_2 implements PrudactInterface{7

8 @Override9 public voidproduction() {10 //TODO Auto-generated method stub

11 System.out.println("生成苹果饮料。。。。。。。");12 }13

14 }

4.实现工厂接口

1 /**2 * 定义PrudactPojo工厂实体类3 * @author lql294 *5 */

6 public classFactoryPojo implements FactoryInterface{7

8 @Override9 publicPrudactInterface found() {10 //TODO Auto-generated method stub11 //实现创建对象方法，

12 PrudactInterface prudactPojo = newPrudactPojo();13 returnprudactPojo;14 }15

16 }

1 public classFactoryPojo_2 implements FactoryInterface {2

3 @Override4 publicPrudactInterface found() {5 //TODO Auto-generated method stub

6 PrudactInterface prudactPojo_2 = newPrudactPojo_2();7 returnprudactPojo_2;8 }9

10 }

这两种的方法的实现都相对较简单，简单工厂模式就是一个大工厂，里面根据分支条件来判断你需要的各种对象，这种并不灵活，所有的创建对象的方法都在一个工厂类里面，工厂方法就是将工厂细分，一个工厂只生产创建一个对象，后期对于代码更好的维护，

三，抽象工厂模式

1.创建接口

1 /**2 *公共接口3 *4 */

5 public interfaceShape {6 voiddraw();7 }

2.实现接口

1 /**2 *接口实体类3 */

4 public classRectangle implements Shape {5

6 @Override7 public voiddraw() {8 System.out.println("Inside Rectangle::draw() method.");9 }10 }

1 /**2 *接口实体类3 *4 */

5 public classSquare implements Shape {6

7 @Override8 public voiddraw() {9 System.out.println("Inside Square::draw() method.");10 }11 }

3.创建扩展接口

1 /**2 *扩展接口，颜色3 */

4 public interfaceColor {5 voidfill();6 }

4.实现扩展接口

1 public classRed implements Color {2

3 @Override4 public voidfill() {5 System.out.println("Inside Red::fill() method.");6 }7 }

1 public classGreen implements Color {2

3 @Override4 public voidfill() {5 System.out.println("Inside Green::fill() method.");6 }7 }

5.创建工厂抽象类

1 /**2 *抽象工厂方法3 */

4 public abstract classAbstractFactory {5 public abstractColor getColor(String color);6 public abstractShape getShape(String shape) ;7 }

6.实现工厂抽象类

1 /**2 *实现工厂类，制定特定功能的工厂3 *4 */

5 public classShapeFactory extends AbstractFactory {6

7 @Override8 publicShape getShape(String shapeType){9 if(shapeType == null){10 return null;11 }12 if(shapeType.equalsIgnoreCase("CIRCLE")){13 return newCircle();14 } else if(shapeType.equalsIgnoreCase("RECTANGLE")){15 return newRectangle();16 } else if(shapeType.equalsIgnoreCase("SQUARE")){17 return newSquare();18 }19 return null;20 }21

22 @Override23 publicColor getColor(String color) {24 return null;25 }26 }

1 public classColorFactory extends AbstractFactory {2

3 @Override4 publicShape getShape(String shapeType){5 return null;6 }7

8 @Override9 publicColor getColor(String color) {10 if(color == null){11 return null;12 }13 if(color.equalsIgnoreCase("RED")){14 return newRed();15 } else if(color.equalsIgnoreCase("GREEN")){16 return newGreen();17 } else if(color.equalsIgnoreCase("BLUE")){18 return newBlue();19 }20 return null;21 }22 }

7.创建一个工厂创造器/生成器类

1 public classFactoryProducer {2 public staticAbstractFactory getFactory(String choice){3 if(choice.equalsIgnoreCase("SHAPE")){4 return newShapeFactory();5 } else if(choice.equalsIgnoreCase("COLOR")){6 return newColorFactory();7 }8 return null;9 }10 }

最后通过FactoryProducer对象调用getFactory方法，参数被创建者的类型

总结：工厂模式的使用就是将创建对象与对象的使用解耦，在各个地方用对应的工厂类创造所需要的对象，最后如有修改对工厂统一修改