工厂模式

最新推荐文章于 2024-09-19 09:28:37 发布

zhan19861022

最新推荐文章于 2024-09-19 09:28:37 发布

阅读量637

点赞数

分类专栏：设计模式、简单工厂、工厂方法、抽象工厂文章标签： class string 产品 interface 制造测试

本文链接：https://blog.csdn.net/zhan19861022/article/details/7455531

版权

设计模式、简单工厂、工厂方法、抽象工厂专栏收录该内容

1 篇文章 0 订阅

订阅专栏

工厂模式可分为：简单工厂、工厂方法、抽象工厂。

一、简单工厂

它也可看做工厂方法的一种，个人理解，简单工厂就是通过传递不同的参数给工厂能创建不同的产品，逻辑也很简单，这里举一个例子吧

话说某一天晓中了福利彩票特奖，一下子发达了，就投资开了家汽车厂，刚开始就引进了宝来、福克斯两款轿车的生产线，那这种情况就可以让我们的简单工厂出马咯

1、汽车接口

package factory;

public interface Car {
	String getCarInfo();
}

2、福克斯定义

package factory;

public class Focus implements Car {

	public String getCarInfo() {
		// TODO Auto-generated method stub
		return "FOCUS";
	}

}

3、奔驰定义

package factory;

public class Benz implements Car {

	public String getCarInfo() {
		// TODO Auto-generated method stub
		return "BENZ";
	}

}

4、晓的简单工厂

package factory;

public class CarFactory{

	
	public Car createCar(int type) {
		// TODO Auto-generated method stub
		if(type==1){
			return new Benz();
		}else{
			return new Focus();
		}
	}

}

5、客户端发命令造汽车的代码

package factory;

public class Client {
	public static void main(String[] argus){
		CarFactory factory = new CarFactory();
		//造奔驰
		Car benz = factory.createCar(1);
		System.out.println(benz.getCarInfo());
		//造福克斯
		Car focus = factory.createCar(2);
		System.out.println(focus.getCarInfo());
		
	}
}

好了，晓现在发现这生意赚头不少，决定新开一条BMW的生产线进来，这时问题来了，客户端Client是不需要改动了，只需要传递个bmw的参数即可，符合软件开发的开闭原则，而服务端不关要多一个BMW的实例，工厂内部代码还要修改，破坏了开放扩展，关闭修改这一原则。

再说白点，晓对于现状很不爽，难道每引进一条流水线就要修改老子工厂的原有代码（大忌，试想一下添加了新的生产线代码有误导致整个工厂瘫痪的场景)，而且这个工厂也会越来越大难以维护哦。这个时候就可以升级一下模式了，采用工厂方法模式

二、工厂方法模式

它的区别就是引入了抽象工厂父类的这一概念，这样晓就可以为每种汽车盖个工厂了，这样各干各的互不相干，你这条线坏了也不干我的事，有新品要做就搞个新的工厂即可。

package factory;
/**
 * 工厂抽象父类
 * @author Administrator
 *
 */
public abstract class AbstractFactory {
	public abstract AbstractProduct createProduct();
}

package factory;
/**
 * 抽象A类产品的父类
 * @author Administrator
 *
 */
public abstract class AbstractProduct {

	public abstract String getProductInfo();
	
}

package factory;

public class FactoryA extends AbstractFactory {

	@Override
	public AbstractProduct createProduct() {
		// TODO Auto-generated method stub
		return new ProductA();
	}

}

package factory;

public class FactoryB extends AbstractFactory{

	@Override
	public AbstractProduct createProduct() {
		// TODO Auto-generated method stub
		return new ProductB();
	}

}

package factory;

public class ProductA extends AbstractProduct {

	@Override
	public String getProductInfo() {
		// TODO Auto-generated method stub
		return "ProductA";
	}

}

package factory;

public class ProductB extends AbstractProduct {

	@Override
	public String getProductInfo() {
		// TODO Auto-generated method stub
		return "ProductB";
	}

}

package factory;
/**
 * 可运行的测试代码
 * 说明：通过传递不同的实际工厂，客户端制造了不同的产品
 * 思想：客户端通过具体的工厂创建不同的产品，而不需要去指定具体的产品
 * @author Administrator
 *
 */
public class Run {

	public static void main(String[] args){
		
		AbstractFactory factoryA = new FactoryA();
		System.out.println(factoryA.createProduct().getProductInfo());
		AbstractFactory factoryB = new FactoryB();
		System.out.println(factoryB.createProduct().getProductInfo());
		
	}
}

三、抽象工厂

晓现在有钱的蛋疼了，已经不能满足与造汽车这么低级的玩意，打算开始造飞机了，由于汽车跟飞机的本质区别，这时就引入了产品族的概念，需要抽象工厂模式的时刻到了。

这里懒得再写一遍，旧贴一下以前针对GOF23模式写的代码好了。。。。懒死了

package abstractFactory;
/**
 * 抽象工厂父类
 * @author Administrator
 *
 */
public abstract class AbstractFactory {
	
	public abstract AbstractProductA createProductA();
	
	public abstract AbstractProductB createProductB();
	
}

package abstractFactory;

public class Factory1 extends AbstractFactory {
	
	@Override
	public AbstractProductA createProductA(){
		return new ProductA1();
	}

	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB1();
	};
}

package abstractFactory;

public class Factory2 extends AbstractFactory {
	
	@Override
	public AbstractProductA createProductA(){
		return new ProductA2();
	}

	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	};
}

package abstractFactory;
/**
 * 抽象A类产品的父类
 * @author Administrator
 *
 */
public abstract class AbstractProductA {

	public abstract String getProductInfo();
	
}

package abstractFactory;
/**
 * 抽象B类产品的父类
 * @author Administrator
 *
 */
public abstract class AbstractProductB {

	public abstract String getProductInfo();
}

package abstractFactory;

public class ProductA1 extends AbstractProductA {

	@Override
	public String getProductInfo() {
		// TODO Auto-generated method stub
		return "ProductA1";
	}

}

package abstractFactory;

public class ProductA2 extends AbstractProductA {

	@Override
	public String getProductInfo() {
		// TODO Auto-generated method stub
		return "ProductA2";
	}

}

package abstractFactory;

public class ProductB1 extends AbstractProductB {

	@Override
	public String getProductInfo() {
		// TODO Auto-generated method stub
		return "ProductB1";
	}

}

package abstractFactory;

public class ProductB2 extends AbstractProductB {

	@Override
	public String getProductInfo() {
		// TODO Auto-generated method stub
		return "ProductB2";
	}

}

package abstractFactory;
/**
 * 可运行的测试代码
 * 说明：通过传递不同的实际工厂，客户端制造了不同系列的产品
 * 思想：客户端通过具体的工厂创建一系列具体的产品，而不需要去指定具体的产品
 * @author Administrator
 *
 */
public class Run {

	public static void main(String[] args){
		
		AbstractFactory factory1 = new Factory1();
		Client client1 = new Client(factory1);
		client1.printProductInfo();
		
		AbstractFactory factory2 = new Factory2();
		Client client2 = new Client(factory2);
		client2.printProductInfo();
	}
}