设计模式：工厂方法模式与抽象工厂模式

这两天抽空学习一下设计模式，刚开始遇到工厂模式，感觉工厂方法模式和抽象工厂模式的区别有点模糊，看了之前的面试资料也是有点区分不清，于是查阅一些网上的资料和博客，记录一下。

1，工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使得一个类的实例化延迟到了子类
工厂方法在简单工厂的基础上再包了一层工厂，所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定。（摘自别的博客，代码）

//定义上级工厂的接口
public interface IFractory {
    public Operation generateOper();
}
//为每一个类创建工厂
/**
 * 工厂方法  为每个对象生成一个工厂类
 */
public class AddOperationFactory implements IFractory{

    @Override
    public Operation generateOper() {
        return new AddOperation();
    }
}
public class SubOperationFactory implements IFractory {
    @Override
    public Operation generateOper() {
        return new SubOperation();
    }
}
public class MulOperationFactory implements IFractory {
    @Override
    public Operation generateOper() {
        return new MulOperation();
    }
}
public class DivOperationFactory implements IFractory {
    @Override
    public Operation generateOper() {
        return new DivOperation();
    }
}
//客户端代码
IFractory fractory = new AddOperationFactory();
Operation operation = fractory.generateOper();
operation.getResult(firstNum,secondNum);

---------------------
作者：最伤离别 
来源：CSDN 
原文：https://blog.csdn.net/xiaoddt/article/details/74937952?utm_source=copy 
版权声明：本文为博主原创文章，转载请附上博文链接！

工厂方法把类的实例化推迟到其子类，由客户端代码决定选择对应工厂类进行实例化。将判断问题移到客户端，但是如果工厂方法模式遇到需要更改产品线，只需要更改一个工厂实例化对象即可，非常方便。

2.抽象工厂模式：提供一个创建一系列相关相互依赖对象的接口，而无需指定他们具体的类。抽象工厂为不同产品族的对象创建提供接口。
使用场景：系统需要在不同产品族进行切换

/**
 * @Description 抽象工厂模式：最原始工厂
 * @Author xg
 * @Date 2018/10/11 10:02
 */
public interface IFactory {

	public KeyBoard createKeyBoard();

	public Mouse createMouse();

}

/**
 * @Description 键盘
 * @Author xg
 * @Date 2018/10/11 10:04
 */
public interface KeyBoard {

	public void getMessage();
}

/**
 * @Description 鼠标
 * @Author xg
 * @Date 2018/10/11 10:06
 */
public interface Mouse {

	public void getMessage();
}

/**
 * @Description 罗技产品
 * @Author xg
 * @Date 2018/10/11 10:08
 */
public class LGKeyBoard implements KeyBoard{
	@Override
	public void getMessage() {
		System.out.println("罗技键盘");
	}
}
/**
 * @Description 罗技产品
 * @Author xg
 * @Date 2018/10/11 10:09
 */
public class LGMouse implements Mouse {
	@Override
	public void getMessage() {
		System.out.println("罗技鼠标");
	}
}

/**
 * @Description 雷蛇产品
 * @Author xg
 * @Date 2018/10/11 10:10
 */
public class LSKeyBoard implements KeyBoard {
	@Override
	public void getMessage() {
		System.out.println("雷蛇键盘");
	}
}
/**
 * @Description 雷蛇产品
 * @Author xg
 * @Date 2018/10/11 10:12
 */
public class LSMouse implements Mouse {
	@Override
	public void getMessage() {
		System.out.println("雷蛇鼠标");
	}
}

/**
 * @Description 罗技工厂 不同产品组使用同一个工厂
 * @Author xg
 * @Date 2018/10/11 10:12
 */
public class LGFactory implements IFactory {
	@Override
	public KeyBoard createKeyBoard() {
		return new LGKeyBoard();
	}

	@Override
	public Mouse createMouse() {
		return new LGMouse();
	}
}

/**
 * @Description 雷蛇工厂
 * @Author xg
 * @Date 2018/10/11 10:13
 */
public class LSFactory implements IFactory {
	@Override
	public KeyBoard createKeyBoard() {
		return new LSKeyBoard();
	}

	@Override
	public Mouse createMouse() {
		return new LSMouse();
	}
}

package factory_demo;

import factory_demo.product.KeyBoard;
import factory_demo.product.Mouse;

/**
 * @Description 抽象工厂模式测试 客户端代码
 * @Author xg
 * @Date 2018/10/11 10:16
 */
public class FactoryTest {

	public static void main(String[] args) {

		IFactory lgFactory = new LGFactory();
		KeyBoard lgKeyBoard = lgFactory.createKeyBoard();
		lgKeyBoard.getMessage();
		Mouse lgMouse = lgFactory.createMouse();
		lgMouse.getMessage();

		IFactory lsFactory = new LSFactory();
		KeyBoard lsKeyBoard = lsFactory.createKeyBoard();
		lsKeyBoard.getMessage();
		Mouse lsMouse = lsFactory.createMouse();
		lsMouse.getMessage();
	}

}

好处：①便于交换产品系列，具体工厂在代码中一般只出现一次。这就使得改变应用的具体工厂很容易。
②能让具体的创建对象实例和客户端分离，客户端是通过他们的抽象接口操作实例
缺点：不太易于拓展，如果需要自增功能，或者自增产品，则需要至少修改三个类，而且实例化的代码是写死在程序中的，这样无法避免违背开放-关闭原则。
对于上述问题，可以通过配置文件，结合反射的方式来解决。

自己理解还不是很到位，文字总结也是依照别人理解，只能对代码有所意会，先记录下来供以后补充和学习。

设计模式：工厂方法模式与抽象工厂模式

猜你喜欢