简单工厂模式（simple factory）是类的创建模式，又叫静态工厂方法（static factory method）模式。
简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类。

有4个角色-->>
   工厂类角色：是具体产品类角色直接调用者。

抽象产品角色：接口或抽象类，负责具体产品角色的定义，及与客户端的交互。

具体产品角色：被工厂类创建的对象，也是客户端实际操作对象。

        客户端：调用工厂类产生实例，并调用实例的方法进行相应工作。

//抽象产品角色
public interface people{
　　public void say();
}

//具体产品角色
public class chinese implements people{
　　public void say(){
　　　　System.out.println("说中国话");
　　}
}

//具体产品角色
public class american implements people{
　　public void say(){
　　　　System.out.println("speak english");
　　}
}
//工厂类角色
public class peopleFactory{
　　//工厂方法
　　//注意 返回类型为抽象产品角色
　　public static people create(int type){
　　　　//判断逻辑，返回具体的产品角色给Client
　　　　if(type==1){
　　　　　　return new chinese();
　　　　}else if(type==2){
　　　　　　return new american();
　　　　}
　　}
}

public class test{
　　public static void main(String []args){
　　　　people p=peopleFactory.create(1);
　　　　p.say();
　　　　p=peopleFactory.create(2);
　　　　p.say();
　　}
}

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。

解决的问题：多了一个新对象，只需添加一套对应的工厂和产品就可以了，不需要修改原代码，或只需进行少量的修改。

具体：
实体工厂实现抽象工厂，实体产品实现抽象产品；
抽象工厂生产抽象产品，实体工厂生产实体产品；
实体工厂A生产实体产品A，实体工厂B生产实体产品B。

//抽象产品
public interface Icar{
　　public void docar();
}
//实体产品A
public class bwm implements Icar{
　　public void docar(){
　　　　System.out.println("我是宝马，别摸我");
　　}
}
//实体产品B
public class buick implements Icar{
　　public void docar(){
　　　　System.out.println("我是别克，很酷");
　　}
}

//抽象工厂
public interface Icarfactory{
　　public Icar createCar();
}
//实体工厂A
public class bmwFactory implements Icarfactory{
　　public Icar createCar(){
　　　　return new bwm();
　　}
}
//实体工厂B
public class buickFactory implements Icarfactory{
　　public Icar createCar(){
　　　　return new buick();
　　}
}

public class test{
　　public static void main(String []args){
　　　　Icarfactory factory=new bmwFactory();
　　　　Icar bwm= factory.createCar();
　　　　bwm.docar();

　　　　factory=new buickFactory();
　　　　Icar buick= factory.createCar();
　　　　buick.docar();

　　}
}

抽象工厂模式（Abstract Factory Pattern）是工厂方法模式的进一步抽象，为创建一组相关或相互依赖的对象提供一个借口，无需指定它们的具体类。

抽象工厂模式通常是用于创一族产品，并且这族产品分不同的等级；不同的具体工厂类生产不同等级的一族产品。

抽象工厂模式也有四种角色：抽象工厂、具体工厂、抽象产品和具体产品.

抽象工厂：AbstractFactory接口

//抽象工厂，定义了生产族产品的方法；
public interface AbstractFactory {
　　public ProductA factoryA();
　　public ProductB factoryB();
}

抽象产品：ProductA接口

//抽象产品A定义了产品的公共方法，产品A和B属于一个产品族
public interface ProductA {
　　public void method1();
　　public void method2();
}

抽象产品：ProductB接口

//抽象产品B定义了产品的公共方法，产品A和B属于一个产品族
public interface ProductB {
　　public void method1();
　　public void method2();
}

具体工厂（生产等级为2的族产品）：ConcreteFactory1类

//ConcreateFactory1是用来生产等级为1的产品A，B；
public class ConcreateFactory1 implements AbstractFactory {

//生产等级为1的产品A
@Override
public ProductA factoryA() {
　　// TODO Auto-generated method stub
　　return new ConcreateProductA1();
}


//生产等级为1的产品B
@Override
public ProductB factoryB() {
　　// TODO Auto-generated method stub
　　return new ConcreateProductB1();
}

}

具体工厂（生产等级为1的族产品）：ConcreteFactory2类

public class ConcreateFactory2 implements AbstractFactory {

　　//生产等级为2的产品A
　　@Override
　　public ProductA factoryA() {
　　　　// TODO Auto-generated method stub
　　　　return new ConcreateProductA2();
　　}

　　//生产等级为2的产品B
　　@Override
　　public ProductB factoryB() {
　　　　// TODO Auto-generated method stub
　　　　return new ConcreateProductB2();
　　}
}

具体产品（等级为1的A产品）：ConcreteProductA1类

//等级为1的具体产品A
public class ConcreateProductA1 implements ProductA {

　　@Override
　　public void method1() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为1的产品A的method1()");
　　}

　　@Override
　　public void method2() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为1的产品A的method2()");
　　}
}

具体产品（等级为2的A产品）：ConcreteProductA2类

//等级为2的具体产品A
public class ConcreateProductA2 implements ProductA {

　　@Override
　　public void method1() {
　　// TODO Auto-generated method stub
　　　　System.out.println("等级为2的产品A的method1()");
　　}

　　@Override
　　public void method2() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为2的产品A的method2()");
　　}
}

具体产品（等级为1的B产品）：ConcreteProductB1类

//等级为1的产品B
public class ConcreateProductB1 implements ProductB{

　　@Override
　　public void method1() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为1的产品B的method1()");
　　}

　　@Override
　　public void method2() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为1的产品B的method2()");
　　}
}

具体产品（等级为2的B产品）：ConcreteProductB2类

//等级为2的产品B
public class ConcreateProductB2 implements ProductB {

　　@Override
　　public void method1() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为2的产品B的method1()");
　　}

　　@Override
　　public void method2() {
　　　　// TODO Auto-generated method stub
　　　　System.out.println("等级为2的产品B的method2()");
　　}
}

运行结果：
　　等级为1的产品A的method1()
　　等级为1的产品A的method2()
　　等级为1的产品B的method1()
　　等级为1的产品B的method2()
　　等级为2的产品A的method1()
　　等级为2的产品A的method2()
　　等级为2的产品B的method1()
　　等级为2的产品B的method2()