1.简单工厂模式 静态工厂方法模式。 通过专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。
模式中包含的角色及职责 1.工厂 负责创建所有实例的内部逻辑，工厂类可以被其他外界直接调用，创建所需的产品对象。 2.抽象角色 简单工厂模式所创建的所有对象的父类，它负责描述所有实例所有的公共接口 3.具体产品 简单工厂模式所创建的具体实例对象。
一个工厂生产所有实例产品
public class SimpleFactory { public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException { //接口引用--多态 // Fruit apple = new Apple(); // Fruit banana = new Banana(); // apple.get(); // banana.get(); //实例化--静态工厂 /* Fruit apple = FruitFactory.getApple(); Fruit banana = FruitFactory.getBanana(); apple.get(); banana.get();*/ Fruit apple = FruitFactory.getFruit("Apple"); Fruit banana = FruitFactory.getFruit("Banana"); apple.get(); banana.get(); } } class FruitFactory{ /** * 获得Apple的实例 */ /*public static Fruit getApple(){ return new Apple(); } public static Fruit getBanana(){ return new Banana(); }*/ public static Fruit getFruit(String type) throws IllegalAccessException, InstantiationException, ClassNotFoundException { if (type==null | type==""){ System.out.println("不能为空"); return null; }else if(type.equalsIgnoreCase("apple")){ return Apple.class.newInstance(); }else if(type.equalsIgnoreCase("banana")){ return Banana.class.newInstance(); }else { System.out.println("找不到相应的类"); return null; } //运行报错 // Class<?> fruit = Class.forName(type); // return (Fruit) fruit.newInstance(); } } interface Fruit{ void get(); } class Apple implements Fruit{ public void get(){ System.out.println("采集苹果"); } } class Banana implements Fruit{ public void get(){ System.out.println("采集香蕉"); } }2.工厂方式模式 多态工厂模式 定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。仅负责具体工厂子类必须实现的接口， 可以使系统在不修改工厂角色的情况下引进新的产品。
模式中包含的角色及职责 1.抽象工厂角色 工厂方法的核心，任何工厂类必须实现这个接口 2.具体工厂 抽象工厂的实现，负责实例化产品对象。 3.抽象角色 工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口 4.具体产品角色 工厂方法模式所创建的具体实例对象
各个工厂生产各自对应的实例
package cn.hozi.design_pattern.Factory; /** * 工厂方式模式 */ public class FactoryMethod { public static void main(String[] args) { Factory appleFactory = new AppleFactory(); Factory bananaFactory = new BananaFactory(); Fruit apple = appleFactory.getFruit(); Fruit banana = bananaFactory.getFruit(); apple.get(); banana.get(); } } interface Factory{ public Fruit getFruit(); } class AppleFactory implements Factory{ @Override public Fruit getFruit() { return new Apple(); } } class BananaFactory implements Factory{ @Override public Fruit getFruit() { return new Banana(); } } class PearFactory implements Factory{ @Override public Fruit getFruit() { return new Pear(); } } class Pear implements Fruit{ @Override public void get(){ System.out.println("采集梨子"); } }抽象工厂模式： 抽象工厂模式可以向客户端提供一个接口，使得客户端在不比指定产品的具体类型的情况下，能够创建多个产品族的对象。 每个方法都被声明成抽象，而子类的方法覆盖这些方法来创建某些对象。 模式中包含的角色及职责 1.抽象工厂（FruitFactory） 包含对多个产品结构的声明，任何工厂类都必须实现这个接口 2.具体工厂(NorthFruitFactory,SouthFruitFactory) 负责实例化某个产品族中的产品对象 3.抽象角色 负责描述所有实例共有的公共接口（Apple,Banana） 4.具体产品 抽象模式下所创建的具体实例对象（NorthApple,SouthApple）
总结：抽象工厂中方法对应产品结构，具体工厂对应产品族(及一个产品类型(南方的)的工厂生产对应类型的实例（都是南方的）)
/** * 抽象工厂 * 一族对应一种类型的工厂 */ public class AbstractFactory { public static void main(String[] args) { FruitFactory2 northFruitFactory = new NorthFruitFactory(); Fruit apple = northFruitFactory.getApple(); apple.get(); Fruit banana = northFruitFactory.getBanana(); banana.get(); FruitFactory2 wenShiFruitFactory = new WenShiFruitFactory(); Fruit wenShiApple = wenShiFruitFactory.getApple(); Fruit wenShiBanana = wenShiFruitFactory.getBanana(); wenShiApple.get(); wenShiBanana.get(); } } abstract class Apple2 implements Fruit{ public abstract void get(); } abstract class Banana2 implements Fruit{ public abstract void get(); } class NorthApple extends Apple2{ @Override public void get() { System.out.println("采集北方苹果"); } } class SouthApple extends Apple2{ @Override public void get() { System.out.println("采集南方苹果"); } } class NorthBanana extends Banana2{ @Override public void get() { System.out.println("采集北方香蕉"); } } class SouthBanana extends Banana2{ @Override public void get() { System.out.println("采集南方香蕉"); } } class WenShiApple extends Apple2{ @Override public void get() { System.out.println("采集温室苹果"); } } class WenShiBanana extends Banana2{ @Override public void get() { System.out.println("采集温室香蕉"); } } interface FruitFactory2{ public Fruit getApple(); public Fruit getBanana(); } class NorthFruitFactory implements FruitFactory2{ @Override public Fruit getApple() { return new NorthApple(); } @Override public Fruit getBanana() { return new NorthBanana(); } } class SouthFruitFactory implements FruitFactory2{ @Override public Fruit getApple() { return new SouthApple(); } @Override public Fruit getBanana() { return new SouthBanana(); } } class WenShiFruitFactory implements FruitFactory2{ @Override public Fruit getApple() { return new WenShiApple(); } @Override public Fruit getBanana() { return new WenShiBanana(); } }工厂方法和抽象工厂的区别： 1.工厂方法使用的是类，抽象工厂使用的是对象。 2.抽象工厂提供一个用来创建一个产品家族的抽象类型，这个类型的子类定义了产品被生产的方法（把一群相关的产品集合起来） 3.抽象工厂如果新加入产品就需要改变接口
