简单工厂模式/静态工厂方法
简单工厂模式（Simple Factory Pattern）又叫做静态工厂方法模式（Static Factory Method Pattern），并不属于 GoF 的23种设计模式之一，是学习其他工厂模式的的基础。
- Factory：创建产品，返回抽象产品类
- Product：抽象产品类，公有属性和方法
- Concrete Product：具体产品角色，继承了抽象产品角色，需要实现抽象方法。
【例】硬币：铜币、金币
/*** 简单工厂模式* 创建对象和使用分离* 客户端不需要关心如何创建对象，只需要知道创建对象对应的参数* -违背了开闭原则* -一个类创建了太多对象，职责很重，出了故障系统崩溃* 1.直接new* 2.通过配置文件获取目标对象名，更加灵活*/
public class Client {public static void main(String[] args) {CoinFactory coinFactory = new CoinFactory();Coin copper = coinFactory.creatCoin("copper");System.out.println(copper.getCoin());//使用配置文件来进行灵活加载Properties properties = new Properties();try {//相对于类加载器的路径进行加载，根路径properties.load(CoinFactory.class.getClassLoader().getResourceAsStream("conf.properties"));//这里配置文件默认string，文件中不要加“”String coinName = (String)properties.get("sfp");Coin copper2 = coinFactory.creatCoin(coinName);System.out.println(copper2.getCoin());} catch (IOException e) {throw new RuntimeException(e);}}
}
//抽象产品
public interface Coin {String getCoin();
}
//工厂
public class CoinFactory {public Coin creatCoin(String coin){if (coin.equals("copper")){return new CopperCoin();}else if(coin.equals("gold")){return new GoldCoin();}else {return null;}}
}
//具体产品
public class CopperCoin implements Coin{@Overridepublic String getCoin() {return "I am a copper coin.";}
}
优点：
- 对象创建和使用分离
- 客户端只需要知道创建参数即可，不需要知道类名
- 引入配置文件一定程度上提高了灵活性
缺点：
- 工厂类职责过重，停摆影响大
- 增加系统复杂度和理解难度
- 添加新产品还是需要修改工厂类逻辑，违反开闭原则
- 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构
适用场景：
- 工厂类负责创建的对象比较少
- 客户端只知道传入工厂类的参数，对于如何创建对象并不关心。
工厂方法模式
工厂方法模式也被称为虚拟构造器模式（Virtual Constructor Pattern）或多态工厂模式（Polymorphic Factory Pattern）。
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。
- Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。
- ConcreteProduct（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。
- Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口
- ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。
【例】武器：精灵武器、兽人族武器
/*** 工厂方法模式：定义一个用于创建对象的接口即工厂，实例创建推迟到子类实现**/
public class Client {public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {//读取配置文件Properties properties = new Properties();properties.load(Client.class.getClassLoader().getResourceAsStream("conf.properties"));String factoryName = properties.getProperty("fmp");//反射加载类，多态性BlackSmith blacksmith = (BlackSmith) Class.forName(factoryName).newInstance();Weapon weapon = blacksmith.createWeapon();weapon.showWeapon();}
}
//抽象产品
public abstract class Weapon {public abstract void showWeapon();
}
//抽象工厂
public abstract class BlackSmith {public abstract Weapon createWeapon();
}
//子类创建实例
public class ElfBlackSmith extends BlackSmith {@Overridepublic Weapon createWeapon() {System.out.println("精灵族武器+1");return new ElfWeapon();}
}
public class OrcBlackSmith extends BlackSmith {@Overridepublic Weapon createWeapon() {System.out.println("兽人族武器+1");return new OrcWeapon();}
}优点：
- 无需关心创建细节
- 多态性设计的工厂和产品，让工厂自行决定如何创建对象，封装细节
- 符合开闭原则，无需修改，只需要添加新的工厂和产品。
缺点：
- 更多的类，额外开销
- 更抽象，且在实现时可能需要用到配置文件、反射等技术，增加了系统的实现难度。
适用环境：
- 客户端不知道它所需要的对象的类
- 抽象工厂类通过其子类来指定创建哪个对象，利用面向对象的多态性和里氏代换原则，系统更容易扩展。
抽象工厂模式
工厂方法模式一个工厂只能生产一个产品，会产生大量类。将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是抽象工厂模式（Abstract Factory Pattern）的基本思想。
- AbstractFactory（抽象工厂）：它声明了一组用于创建一组产品的方法，每一个方法对应一种产品。
- ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
- AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
- ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。
【例】精灵和兽人王国生产器：城堡、军队、国王
王国工厂（抽象类）：定义了一组用于创建产品的方法，需要军队、国王、城堡
精灵工厂（具体工厂）：创建精灵军队、城堡、国王
兽人工厂（具体工厂）：创建兽人军队、城堡、国王
城堡、军队、国王（抽象类）：声明方法
public class Client {public static void main(String[] args) throws Exception {//加载配置ResourceBundle conf = ResourceBundle.getBundle("conf");String className = conf.getString("afp");//创建工厂KingdomFactory factory = (KingdomFactory) Class.forName(className).newInstance();//创建王国System.out.println("建造了一座" + factory.creatCastle().getDescription());System.out.println("推选了一位" + factory.createKing().getDescription());System.out.println("组建了一支" + factory.createArmy().getDescription());}
}
//抽象产品
public interface King {String getDescription();
}
public interface Army {String getDescription();
}
public interface Castle {String getDescription();
}
//具体工厂（创建一组相关产品）
public class ElfKingdomFactory implements KingdomFactory {@Overridepublic Castle creatCastle() {return new ElfCastle();}@Overridepublic King createKing() {return new ElfKing();}@Overridepublic Army createArmy() {return new ElfArmy();}
}
//抽象工厂（定义一组创建方法）
public interface KingdomFactory {Castle creatCastle();King createKing();Army createArmy();
}优点：
- 封装性：将具体产品的创建封装在工厂类中，客户端无需了解具体产品的创建细节。
- 易于扩展：可以添加新的产品族，客户端代码无需修改。
- 一致性：保证创建的产品对象都是同一产品族的，从而保持产品的一致性。
缺点：
- 复杂性：增加了代码的复杂性，尤其是在产品族较多时，会导致类的数量急剧增加。
- 扩展性：添加新的产品类型时，需要修改抽象工厂接口，违反了开闭原则。
适用环境：
- 系统中有多于一个的产品族，而每次只使用其中某一产品族
- 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束，如同一操作系统下的按钮和文本框，按钮与文本框之间没有直接关系，但它们都是属于某一操作系统的，此时具有一个共同的约束条件：操作系统的类型。
- 产品类型稳定，设计完成之后，不会向系统中增加新的产品类或者删除已有的产品类。
jdk 源码分析
JDK 中的 Calendar 类使用到了简单工厂模式
这个getInstance()方法实际上是一个工厂方法，它通过调用createCalendar方法，创建了一个合适的Calendar实例。
jdk中的iterator同样也使用到了工厂方法进行创建
