简单工厂模式、工厂方法模式、抽象工厂模式这三种工厂模式的实例及其闭合原则。

这是本人学习多天后的个人总结。

主要是针对这三种方法对是否符合开闭原则的理解。

1.简单工厂模式

抽象一个产品对象

public interface Product {
<span style="white-space:pre"> </span>public void create();
}
之后三个产品实类

<pre name="code" class="java">public class Serverproduct implements Product{ public void create(){ System.out.println("使用server生产"); } }<span style="font-family: Arial, Helvetica, sans-serif;"> </span>

public class Mysqlproduct implements Product {
public void create() {
System.out.println("使用mysql生产");
}
}

public class Oracleproduct  implements Product{

public void create(){
System.out.println("使用Oracle生产");
}
}

核心类

public class Creator {
public static Product getproduct(String type) {
if (type.equalsIgnoreCase("server")) {
return new Serverproduct();
} else if (type.equalsIgnoreCase("mysql")) {
return new Mysqlproduct();
} else if (type.equalsIgnoreCase("oracle")) {
return new Oracleproduct();
} else {
System.out.println("哎呀！找不到相应的实例化类啦！");
return null;
}
}
}
客户端实现

public class Client {

public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
// TODO Auto-generated method stub
Product server = Factory.getproduct("server");
Product mysql =  Factory.getproduct("mysql");
Product oracle = Factory.getproduct("oracle");
server.create();
mysql.create();
oracle.create();
}
}

简单而言，如果添加一个产品Product时，就要在Creator添加一个If条件语句。这改变了Creator的结构，就不符合符合开闭原则。

2.工厂方法模式

产品抽象类

public interface Product {
public void create();
}
之后三个产品实类

public class Serverproduct implements Product{

public void create(){
System.out.println("使用server生产");
}
}<span style="font-family: Arial, Helvetica, sans-serif;">	  </span>

public class Mysqlproduct implements Product {
public void create() {
System.out.println("使用mysql生产");
}
}

public class Oracleproduct  implements Product{

public void create(){
System.out.println("使用Oracle生产");
}
}

抽象工厂类
public interface Factory {
public Product make();
}
实类三个工厂对应三个产品

public class Oraclefactory  implements Factory {
@Override
public Product make() {
// TODO Auto-generated method stub
return new Oracleproduct();
}
}

public class Mysqlfactory implements Factory {
@Override
public Product make() {
// TODO Auto-generated method stub
return new Mysqlproduct();
}
}

<pre name="code" class="java">public class Serverfactory  implements Factory {
@Override
public Product make() {
// TODO Auto-generated method stub
return new Serverproduct();
}
}

接口
public class Creator {
public static Factory getproduct(String type){
if(type.equalsIgnoreCase("server")) {
return new Serverfactory();
} else if(type.equalsIgnoreCase("mysql")) {
return new Mysqlfactory();
} else if(type.equalsIgnoreCase("oracle")) {
return new Oraclefactory();
} else {
System.out.println("哎呀！找不到相应的实例化类啦！");
return null;
}
}
}客户端
public class Client {
public static void main(String[] args) throws InstantiationException,
IllegalAccessException, ClassNotFoundException {
// TODO Auto-generated method stub
Factory server = Creator.getproduct("server");
Factory mysql = Creator.getproduct("mysql");
Factory oracle = Creator.getproduct("oracle");
Product p1 = server.make();
p1.create();
Product p2 = mysql.make();
p2.create();
Product p3 = oracle.make();
p3.create();
}
}每个工厂实现一个产品，如果增加一个新产品，则添加一产品实类，不一定要求实类化一个工厂。对已存的实类化工厂不用修改，所以对Creator类没有影响。

3.抽象工厂模式

抽象三个产品

public interface abstractmysql {
public void create();
}

<pre name="code" class="java">public interface abstractoracle {
public  void create();
}

public interface abstractserver {
public  void create();
}

实例化三个产品

public class Mysqlproduct implements abstractmysql{
public void create() {
System.out.println("使用mysql生产");
}
}

<pre name="code" class="java">public <span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;">class Oracleproduct  implements abstractoracle{	</span>

public void create(){ System.out.println("使用Oracle生产"); }}

public class Serverproduct implements abstractserver{
<span style="white-space:pre">	</span>
    public void create(){
        System.out.println("使用server生产");
    }
}

抽象工厂

interface Factory {
public Mysqlproduct createproduct1();
public Serverproduct createproduct2();
public Oracleproduct createproduct3();
}实类化工厂
public class Factoryall implements Factory
{
@Override
public Mysqlproduct createproduct1() {
// TODO Auto-generated method stub
return new Mysqlproduct();
}
@Override
public Serverproduct createproduct2() {
// TODO Auto-generated method stub
return new Serverproduct();
}
@Override
public Oracleproduct createproduct3() {
// TODO Auto-generated method stub
return new Oracleproduct();
}
}客户端
public class Client {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
// TODO Auto-generated method stub
Factory server =new Factoryall();
server.createproduct1().create();
Factory mysql =new Factoryall();
mysql.createproduct1().create();
Factory oracle =new Factoryall();
oracle.createproduct1().create();

}
}抽象模式可能是出现符合闭合原则，和不闭合原则。



如图所示，如果添加的产品独立创建一个工厂。这会改变Creator类的结构。所以不符合闭合原则。



如图所示，如果添加的产品只是加入到工厂中。这会改变指挥FactoryA，FactoryB类的结构。不改变Creator的结构。所以符合闭合原则。