工厂模式简述

时间 2019-11-11

标签工厂模式简述繁體版

原文原文链接

代码的优化离不开设计模式的使用，今天主要介绍一下工厂模式：java

工厂模式概念程序员

　　实例化对象，用工厂方法代替new操做设计模式

　工厂模式包括工厂方法模式、抽象工厂模式ide

什么状况用
有一组类似的对象要建立
编码时不能预见建立哪一些实例
考虑代码的拓展性
低耦合，一个对象的改变不影响以来他的对象优化

具体实例ui

模拟需求：须要生产宝马、奔驰、奥迪编码

原始的作法：存在BMW、AUDI个类，经过new的方式建立多个对象spa

public class BMW { .net

　　public BMW(){
　　　　System.out.println("这是-->BMW");
　　}
}

public class AUDI {
　　public AUDI(){
　　　　System.out.println("这是-->AUDI");
　　}
}

public class {
public static void main(String[] args) {
　　BMW bmw = new BMW();
　　AUDI audi = new AUDI();
}
}设计

客户须要知道怎么去建立一款车,客户和车就紧密耦合在一块儿了.为了下降耦合,就出现了工厂类,

把创造车的操做细节都放到了工厂里面去,客户直接使用工厂的建立工厂方法,传入想要的车型号就好了,而没必要去知道建立的细节.这就是工业革命了：

简单工厂模式

即咱们创建一个工厂类方法来制造新的对象

产品类：

public interface Car {
　　public void carBrand();
}

public class AUDI implements Car {
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->AUDI");
　　}
}

public class BMW implements Car{
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->BMW");
　　}
}

工厂类

public class CarFactory {
public Car creatCar(String carType){
　　switch (carType ) {
　　case "bmw":
　　　　return new BMW();
　　case "audi":
　　　　return new AUDI();

　　default:
　　break;
　　}
　　return null;
　　}
}

客户端

public class Test {
CarFactory factory = new CarFactory();

　　factory.creatCar("bmw");

　　 factory.creatCar("audi");
}

简单工厂模式又称静态工厂方法模式。重命名上就能够看出这个模式必定很简单。它存在的目的很简单：定义一个用于建立对象的接口。
      先来看看它的组成：
1) 工厂类角色：这是本模式的核心，含有必定的商业逻辑和判断逻辑，用来建立产品
         2) 抽象产品角色：它通常是具体产品继承的父类或者实现的接口。
         3) 具体产品角色：工厂类所建立的对象就是此角色的实例。在Java中由一个具体类实现。

下面咱们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户再也不知足现有的车种类的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就能够被客户使用了。因此对产品部分来讲，它是符合开闭原则的；可是工厂部分好像不太理想，由于每增长一种新型车，都要在工厂类中增长相应的建立业务逻辑（createCar(String carType)方法须要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，咱们称它为全能类或者上帝类。
       咱们举的例子是最简单的状况，而在实际应用中，极可能产品是一个多层次的树状结构。因为简单工厂模式中只有一个工厂类来对应这些产品，因此这可能会把咱们的上帝累坏了，也累坏了咱们这些程序员。
        因而工厂方法模式做为救世主出现了。工厂类定义成了接口,而每新增的车种类型,就增长该车种类型对应工厂类的实现,这样工厂的设计就能够扩展了,而没必要去修改原来的代码。
5、工厂方法模式
        工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它能够被子类继承。这样在简单工厂模式里集中在工厂方法上的压力能够由工厂方法模式里不一样的工厂子类来分担。
工厂方法模式组成：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以建立对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中通常有抽象类或者接口来实现。
4)具体产品角色：具体工厂角色所建立的对象就是此角色的实例。在java中由具体的类来实现。
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；并且这样使得结构变得灵活起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就能够被客户使用，而没必要去修改任何已有的代码。能够看出工厂角色的结构也是符合开闭原则的！

代码以下：

产品类：

public interface Car {
　　public void carBrand();
}

public class AUDI implements Car {
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->AUDI");
　　}
}

public class BMW implements Car{
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->BMW");
　　}
}

工厂类

public interface CarFactory {
　　public Car creatCar();

}

public class BMWFactory implements CarFactory {
　　@Override
　　public Car creatCar() {
　　　　return new BMW();
　　}

　}

public class AUDIFactory implements CarFactory{

　　@Override
　　public Car creatCar() {
　　　　return new AUDI();
　　}
　　}

客户端

public class Test {
public static void main(String[] args) {
　　BMWFactory bmwFactory = new BMWFactory();
　　Car bwm = bmwFactory.creatCar();
　　AUDIFactory audiFactory = new AUDIFactory();
　　　　Car audi = audiFactory.creatCar();
　　　　}
　　}

这里还可使用家java的反射技术实现工厂模式

产品类：

public interface Car {
　　public void carBrand();
}

public class AUDI implements Car {
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->AUDI");
　　}
}

public class BMW implements Car{
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->BMW");
　　}
}

工厂类

public class CarFactory {
public Car creatCar(String carType) throws IOException {
　　Car car = null;
　　　try {
　　　　PropertiesReader propertiesReader = new PropertiesReader();
　　　　Map<String, String> carClassMap = propertiesReader.getProperties();
　　　　String carClass = carClassMap.get(carType);
　　　　car = (Car) Class.forName(carClass).newInstance();
　　} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
　　}

　　　　return car;

}

//读取配置java类文件信息

public class PropertiesReader {
　　　　public Map<String,String> getProperties() throws IOException{
　　　　Properties props= new Properties();
　　　　Map<String,String> map = new HashMap<String,String>();

　　InputStream in = getClass().getResourceAsStream("type.properties");
　　　　props.load(in);

　　Map<String, String> map1 = new HashMap<String, String>((Map) props);
　　　　return map1;
　　　　}
}

//配置文件内容

bmw=com.hand.car.BMW
audi=com.hand.car.AUDI

客户端

public class Test {

public static void main(String[] args) throws IOException {
　　　　CarFactory carFactory = new CarFactory();
　　　　Car bmw = carFactory.creatCar("bmw");
　　　　bmw.carBrand();
　　　　}
　　}

工厂方法模式仿佛已经很完美的对对象的建立进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增加。当产品种类很是多时，会出现大量的与之对应的工厂对象，这不是咱们所但愿的。

参考http://blog.csdn.NET/hguisu/article/details/7505909

以上就是简单工厂模式。