简单工厂模式小结

简单工厂模式预备知识
1.OO原则：
OCP原则（Open-Close-Principle开闭原则）：一个软件的实体应当对扩展开放，对修改关闭。（对于一个已有的软件，如果需要扩展，应当在不需修改已有代码的基础上进行。）


2.简单工厂模式：
（1）专门定义一个类来创建其他类的实例，被创建的实例通常都有公共的父类。
（2）简单工厂模式又称为静态工厂方法，属于类的创建型模式，通常他根据自变量的不同返回不同类的实例。
（3）实质：由一个工厂类根据传入的变量，动态的决定创建出哪一个产品类的实例。

工厂角色：它负责实现所有实例内部逻辑，工厂类可以被外界直接调用，创建所需产品对象

抽象产品角色：是简单工厂所创建的所有对象的父类，描述所有实例的共有的特性

具体产品角色:简单工厂的创建目标，所有创建的对象都是这个角色的所有具体类的实例。

下面是一个简单的例子：

package factory;
public interface IFruit 
{
	void plant();
	void grow();
	void harvest();
}

定义水果接口，抽象出水果的共有方法(抽象产品角色)

package factory;

public class Apple implements IFruit
{
	private int appleAge;
	public void plant()
	{
		System.out.println("apple has been planted");
	}

	public void grow() 
	{
		System.out.println("apple is growing");
	}
	
	public void harvest() 
	{
		System.out.println("apple has been harvesed");	
	}
	
	public void setTreeAge(int age)
	{
		this.appleAge = age;
	}
	
	public int getTreeAge()
	{
		return this.appleAge;
	}
}

定义苹果类，继承水果接口，并全部实现水果内部的方法(具体产品角色)

package factory;

public class Grape implements IFruit
{
	boolean seedless = false;
	public void plant() 
	{
		System.out.println("Grape has been planted");
	}

	public void grow() 
	{
		System.out.println("Grape is growing");		
	}
	public void harvest() 
	{
		System.out.println("Grape has been harvested");
	}
	
	public void setSeedless(boolean bb)
	{
		this.seedless = bb;
	}
	
	public boolean getSeedless()
	{
		return this.seedless;
	}
}

葡萄类，同苹果。

package factory;
/**
 * 
 * @author ustcqi
 *由一个工厂类根据传入的参数，动态的决定创建哪一个产品类的实例
 *工厂类是整个模式的关键，包含了必要的逻辑判断，根据外界给定的信息，
 *决定究竟创建哪个具体类的对象。
 *通过使用工厂类，外界可以从直接创建具体产品对象的局面摆脱出来
 *仅仅负责消费对象就可以了，而不必关心这些对象是如何创建和如何组织的。
 *有利于软件体系结构的优化
 */
public class Factory 
{
	public IFruit factory(String s)
	{
		if(s.equals("Apple"))
			return new Apple();
		else if(s.equals("Grape"))
			return new Grape();
		else
			System.out.println("Don't exist this fruit");
		return null;
	}
}

定义工厂类，用于生产水果。

import java.util.*;
import java.io.*;

import factory.Factory;
import factory.IFruit;

public class FactoryPattern 
{
	public static void main(String []args)
	{
		Factory ft = new Factory();
		IFruit apple = ft.factory("Apple");
		apple.grow();
		IFruit grape = ft.factory("Grape");
		grape.plant();
		IFruit ff = ft.factory("dfdf");
	}
}

最后的MAIN执行类

下面是计算器的简单工厂实现

抽象角色产品(操作类)

package pactory;

public class Operation 
{
	private double firNum;
	private double secNum;
	
	public void setFirNum(double a)
	{
		firNum = a;
	}
	
	public double getFirNum()
	{
		return this.firNum;
	}
	
	public void setSecNum(double b)
	{
		secNum = b;
	}
	
	public double getSecNum()
	{
		return secNum;
	}
	
	public double getResult()
	{
		return 0.0;
	}
}

具体产品角色(具体操作)

package pactory;

public class Addition extends Operation
{
	public double getResult()
	{
		return this.getFirNum() + this.getSecNum();
	}
}

减法操作：

package pactory;

public class Subtractor extends Operation
{
	public double getResult()
	{
		return this.getFirNum() - this.getSecNum();
	}
}

简单工厂类(生产产品角色类)

package pactory;

public class SimpleFactory 
{
	private Operation opr ;
	public Operation factoryOperate(String s)
	{
		if(s.equalsIgnoreCase("addition"))
			return new Addition();
		else if(s.equalsIgnoreCase("subtractor"))
			return new Subtractor();
		else
			return null;
	}
}

MAIN执行类

package pactory;

public class Main {
	public static void main(String[] args) 
	{
		SimpleFactory factory = new SimpleFactory();
		Operation opr = factory.factoryOperate("addition");
		opr.setFirNum(12.0);
		opr.setSecNum(23.9);
		double ret = opr.getResult();
		System.out.println(ret);
	}
}

最后一句话总结：简单工厂模式的实质：由一个工厂类根据传入的变量，动态的决定创建出哪一个产品类的实例。