设计模式—创建型模式之工厂模式
工厂模式（Factory Pattern）提供了一种创建对象的最佳方式。我们不必关心对象的创建细节，只需要根据不同情况获取不同产品即可。
简单工厂模式
比如我们有造车的工厂，来生产车，我们先定义一个抽象车产品：
//抽象车产品类
public abstract class AbstractCar {
String engine;
public abstract void run();
}
我们有两个具体的产品，货车和家用小汽车，都继承自抽象车：
//货车
public class Truck extends AbstractCar{
public Truck() {
this.engine = "货车引擎";
}
@Override
public void run() {
System.out.println(this.engine+"--->正在运行");
}
}
//家用小汽车
public class MiniCar extends AbstractCar{
public MiniCar() {
this.engine = "家用小汽车引擎";
}
@Override
public void run() {
System.out.println(this.engine + "----------》正在运行");
}
}
那我们的工厂可以如此定义：
public class MySimpleFactory {
/**
* 获取车
* @param type
* @return
*/
public AbstractCar newCar(String type){
if("truck".equals(type)){
return new Truck();
}else if("mini".equals(type)){
return new MiniCar();
}
return null;
}
}
一般简单工厂生产的产品优先。
测试类如下：
public class SimpleFactoryTest {
public static void main(String[] args) {
MySimpleFactory factory = new MySimpleFactory();
AbstractCar truck = factory.newCar("truck");
AbstractCar mini = factory.newCar("mini");
truck.run();
mini.run();
}
}
运行如下：
缺点
**违反了开闭原则，扩展不易。**如果有大量的产品，会有大量的if else。
工厂方法模式
因为简单工厂模式，会出现大量的if else，并不能满足打开扩展、关闭修改的原则，我们希望，如果有扩展，直接扩展一个类就好，不区改动创造类型的代码，这样工厂方法模式就出现了。我们可以把工厂再进行抽象，把我们的工厂提升一个层次。
抽象类或者接口，就会有多个实现；有多实现 就会有多功能。
抽象工厂如下:
public abstract class AbstarctCarFactory {
public abstract AbstractCar newCar();
}
我们的货车、小汽车，分别由不同的工厂来创建：
//货车工厂
public class TruckFactory extends AbstarctCarFactory {
@Override
public AbstractCar newCar() {
return new Truck();
}
}
//小汽车工厂
public class MiniCarFactory extends AbstarctCarFactory {
@Override
public AbstractCar newCar() {
return new MiniCar();
}
}
测试类如下:
public class FactoryMethodTest {
public static void main(String[] args) {
AbstarctCarFactory miniCarFactory = new MiniCarFactory();
AbstractCar miniCar = miniCarFactory.newCar();
miniCar.run();
TruckFactory truckFactory = new TruckFactory();
AbstractCar truck = truckFactory.newCar();
truck.run();
}
}
运行结果如下：
这样，如果我们有新的类型，可以直接继承这个抽象工厂即可。
缺点
系统复杂度增加，可创建的品类单一。
抽象工厂模式
我们先来区分两个概念：
- 产品等级：比如手机可以分为低配版手机、高配版手机；产品等级结构即产品的继承结构，如抽象类为手机，可以有拍照手机、游戏手机等等。
- 产品族：产品可以分为手机、汽车等，这是产品族。在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。
在车的产品基础上，我们又增加了新的产品，手机。
public abstract class AbstractPhone {
//手机类型
String type;
public abstract void run();
}
public class GamePhone extends AbstractPhone {
public GamePhone() {
this.type = "游戏手机";
}
@Override
public void run() {
System.out.println(this.type + "正在运行了...");
}
}
public class MyPhotoPhoneFactory implements MyAbstarctFactory{
@Override
public AbstractPhone newPhone() {
return new PhotoPhone();
}
}
如果我们想生产车和手机，我们可以定义抽象工厂：
public interface MyAbstarctFactory {
default AbstractCar newCar(){
return null;
}
default AbstractPhone newPhone(){
return null;
}
}
生产手机的工厂分别为：
public class MyGamePhoneFactory implements MyAbstarctFactory{
@Override
public AbstractPhone newPhone() {
return new GamePhone();
}
}
public class MyPhotoPhoneFactory implements MyAbstarctFactory{
@Override
public AbstractPhone newPhone() {
return new PhotoPhone();
}
}
生产车的工厂分别为：
public class MyMiniCarFactory implements MyAbstarctFactory{
@Override
public AbstractCar newCar() {
return new MiniCar();
}
}
public class MyTruckCarFactory implements MyAbstarctFactory{
@Override
public AbstractCar newCar() {
return new Truck();
}
}
测试类如下：
public class MyTest {
public static void main(String[] args) {
MyAbstarctFactory factory = new MyGamePhoneFactory();
AbstractPhone abstractPhone = factory.newPhone();
abstractPhone.run();
factory = new MyMiniCarFactory();
AbstractCar abstractCar = factory.newCar();
abstractCar.run();
}
}
运行如下:
可以看到，我们在扩展时，都是新增类，而不是修改原有的方法。
