工厂模式可以分为3类：简单工厂模式、工厂模式、抽象工厂模式
一：简单工厂模式（又叫静态工厂模式）
是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
现在围绕书中的一个运算实例来展开探索（用面向对象的思想来实现一个简单的加减运算）
先创建一个操作基类
/**
* @Author:
* @Description:封装
* 对numA、numB进行加减运算
* @Date: created in 2018/7/18
* @Modified By:
*/
public class Operation {
public double numA;
public double numB;
public double getNumA() {
return numA;
}
public void setNumA(double numA) {
this.numA = numA;
}
public double getNumB() {
return numB;
}
public void setNumB(double numB) {
this.numB = numB;
}
/**
* 操作数字返回结果
* @return
*/
public double result(){
return numA+numB;
}
}
然后再创建两个加减类继承上述基类重写result结果
/**
* @Author:
* @Description: 加
* @Date: created in 2018/7/18
* @Modified By:
*/
public class OperatorAdd extends Operation {
public double result(){
return numA+numB;
}
}
/**
* @Author:
* @Description: 减
* @Date: created in 2018/7/18
* @Modified By:
*/
public class OperatorSub extends Operation {
public double result(){
return numA-numB;
}
}
接下来我们可以根据不同运算方法创建不同类（通过静态工厂创建）
/**
* @Author:
* @Description:
* @Date: created in 2018/7/18
* @Modified By:
*/
public class OperationFactory {
public static Operation createOperation(String operation){
Operation oper = null;
switch (operation){
case "+":
oper = new OperatorAdd();
break;
case "-":
oper = new OperatorSub();
break;
}
return oper;
}
}
最后通过实例调用它
/**
* @Author:
* @Description:
* @Date: created in 2018/7/18
* @Modified By:
*/
public class MainTest {
public static void main(String[] args){
// Operation operation = OperationFactory.createOperation("+");
Operation operation = OperationFactory.createOperation("-");
operation.setNumA(5);
operation.setNumB(5);
System.out.println(operation.result());
}
}
简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。
这种简单工厂的写法是通过switch-case来判断对象创建过程的。在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足。
二：工厂方法
工厂方法在简单工厂的基础上再包了一层工厂，所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定。
定义父级工厂接口
/**
* @Author:
* @Description:用于创建操作对象
* @Date: created in 2018/7/18
* @Modified By:
*/
public interface IFactory {
Operation creOperation();
}
创建加法运算子工厂
/**
* @Author:
* @Description:
* @Date: created in 2018/7/18
* @Modified By:
*/
public class OperationAddFactory implements IFactory {
@Override
public Operation creOperation() {
return new OperatorAdd();
}
}
创建减法运算子工厂
/**
* @Author:
* @Description:
* @Date: created in 2018/7/18
* @Modified By:
*/
public class OperationSubFactory implements IFactory {
@Override
public Operation creOperation() {
return new OperatorSub();
}
}
main方法测试实例
/**
* @Author:
* @Description:
* @Date: created in 2018/7/18
* @Modified By:
*/
public class MainTest {
public static void main(String[] args){
// IFactory factory = new OperationAddFactory();
IFactory factory = new OperationSubFactory();
Operation operation = factory.creOperation();
operation.setNumA(5);
operation.setNumB(5);
System.out.println(operation.result());
}
}
工厂方法将类的实例化推迟到了其子类。所以使用工厂方法模式时，需要客户端决定实例化哪一个工厂类。
三：抽象工厂
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
实现
我们将创建 Animal 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 AnimalFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。
//创建animal、color接口
/** * @Author: * @Description: 动物 * @Date: created in 2018/7/19 * @Modified By: */ public interface Animal { void descript(); } /** * @Author: * @Description: 颜色 * @Date: created in 2018/7/19 * @Modified By: */ public interface Color { void fill(); }
//animal实现类
public class Dog implements Animal {
@Override
public void descript() {
System.out.println("I am dog");
}
}
public class Cat implements Animal {
@Override
public void descript() {
System.out.println("I am cat");
}
}
//color实现类
public class Red implements Color {
@Override
public void fill() {
System.out.println("I am red");
}
}
public class Green implements Color {
@Override
public void fill() {
System.out.println("I am green");
}
}
//为 Color 和 Animal对象创建抽象类来获取工厂。
public abstract class AbstractFactory {
public abstract Animal getAnimal(String animal);
public abstract Color getColor(String color);
}
//创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象
public class AnimalFactory extends AbstractFactory {
@Override
public Animal getAnimal(String animal) {
switch (animal){
case "cat":
return new Cat();
case "dog":
return new Dog();
}
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory {
@Override
public Animal getAnimal(String animal) {
return null;
}
@Override
public Color getColor(String color) {
switch (color){
case "red":
return new Red();
case "green":
return new Green();
}
return null;
}
}
//创建一个工厂生成器类，通过动物信息或颜色信息来获取工厂。
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("Animal")){
return new AnimalFactory();
}else if(choice.equalsIgnoreCase("Color")){
return new ColorFactory();
}
return null;
}
}
//main方法测试
public class MainTest {
public static void main(String[] args){
//获取动物工厂
AbstractFactory abstractFactory = FactoryProducer.getFactory("animal");
Animal animal = abstractFactory.getAnimal("cat");
Animal animal2 = abstractFactory.getAnimal("dog");
animal.descript();
animal2.descript();
//获取颜色工厂
AbstractFactory abstractFactory2 = FactoryProducer.getFactory("color");
Color color = abstractFactory2.getColor("red");
Color color2 = abstractFactory2.getColor("green");
color.fill();
color2.fill();
}
}
//输出结果
I am cat
I am dog
I am red
I am green