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

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

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

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的结构。所以符合闭合原则。