一, 基本定义
/*
* 简单工厂设计模式:
* 文字描述理解:
* 简单工厂模式属于类的创建型模式, 又叫做静态工厂方法模式.
* 通过专门定义一个类来负责创建其它类的实例, 被创建的实例通常
* 都具有共同的父类.
* */
二, 首先创建 Apple,Banana 实体类
- public class Apple {
- public void eat(){
- System.out.println("吃苹果");
- }
- }
- public class Banana {
- public void eat(){
- System.out.println("吃香蕉");
- }
- }
编写测试类:
- public class MainClass {
- public static void main(String[] args) {
- // 实例 Apple
- Apple apple = new Apple();
- // 实例 Banana
- Banana banana = new Banana();
- apple.eat();
- banana.eat();
- // 可以发现 Apple,Banana 可以共同抽象出一个接口 eat
- }
- }
在运行中, 我们发现 Apple,Banana 类都有共同的方法. 那么我们就可以抽象出来一个接口来实现. 修改代码如下:
- public interface Fruit {
- void eat();
- }
- public class Apple implements Fruit {
- @Override
- public void eat() {
- System.out.println("吃苹果");
- }
- }
- public class Banana implements Fruit{
- @Override
- public void eat() {
- System.out.println("吃香蕉");
- }
- }
- public class MainClass {
- public static void main(String[] args) {
- /*
- // 实例 Apple
- Apple apple = new Apple();
- // 实例 Banana
- Banana banana = new Banana();
- apple.eat();
- banana.eat();
- **/
- // 可以发现 Apple,Banana 可以共同抽象出一个接口 eat, 多态实例化
- Fruit apple = new Apple();
- Fruit banana = new Banana();
- apple.eat();
- banana.eat();
- // 按照定义: 通过专门定义一个类来负责创建其他类的实例, 那么我们就需要创建 FruitFactory 实例, 具体代码如下.
- }
- }
创建 FruitFactory 工厂类:
- public class FruitFactory {
- /*
- * 获得 Apple 类的实例
- * */
- public Fruit getApple(){
- return new Apple();
- }
- /*
- * 获得 Banana 类的实例
- * */
- public Fruit getBanana(){
- return new Banana();
- }
- }
MainClass 测试类;
- public class MainClass {
- public static void main(String[] args) {
- /*
- // 实例 Apple
- Apple apple = new Apple();
- // 实例 Banana
- Banana banana = new Banana();
- apple.eat();
- banana.eat();
- **/
- // 可以发现 Apple,Banana 可以共同抽象出一个接口 eat, 多态实例化
- // Fruit apple = new Apple();
- // Fruit banana = new Banana();
- // apple.eat();
- // banana.eat();
- // 按照定义: 通过专门定义一个类来负责创建其他类的实例 FruitFactory
- Fruit apple = new FruitFactory().getApple();
- Fruit banana = new FruitFactory().getBanana();
- apple.eat();
- banana.eat();
- }
- }
那么我们有没有具体什么需要改进的地方? FruitFactory 表明静态方法. 这样就不用再新建实例化了.
- public class FruitFactory {
- /*
- * 获得 Apple 类的实例
- * */
- public static Fruit getApple(){
- return new Apple();
- }
- /*
- * 获得 Banana 类的实例
- * */
- public static Fruit getBanana(){
- return new Banana();
- }
- }
- // 直接类名调用即可.
- Fruit apple = FruitFactory.getApple();
- Fruit banana = FruitFactory.getBanana();
- apple.eat();
- banana.eat();
三, 模式中包含的角色和职责
1. 工厂 (Creator) 角色简单工厂模式的核心, 它负责实现创建所有实例的内部逻辑. 工厂类可以被外界直接调用, 创建所需的产品对象.
比如: 我们本次创建的 FruitFactory
2. 抽象 (Product) 角色, 简单工厂模式所创建的所有对象的父类, 它负责描述所有实例所共有的公共接口.
3. 具体产品 (Concrete Product) 角色简单工厂模式所创建的具体实例对象
FruitFactory 我们需要抽象一个具体方法, get 所有的对象实例化.
- public class FruitFactory {
- // /*
- //* 获得 Apple 类的实例
- //* */
- // public static Fruit getApple(){
- // return new Apple();
- // }
- //
- // /*
- //* 获得 Banana 类的实例
- //* */
- // public static Fruit getBanana(){
- // return new Banana();
- // }
- //get 所有的对象
- public static Fruit getFruit(String name) throws IllegalAccessException, InstantiationException {
- if (name.equalsIgnoreCase("apple")){
- return Apple.class.newInstance();
- }else if (name.equalsIgnoreCase("banana")){
- return Banana.class.newInstance();
- }else {
- return null;
- }
- }
- }
- // 测试类
- Fruit apple = FruitFactory.getFruit("apple");
- Fruit banana = FruitFactory.getFruit("banana");
- apple.eat();
- banana.eat();
FruitFactory 里面的 get 实例, 我们可以继续优化.
- public class FruitFactory {
- // /*
- //* 获得 Apple 类的实例
- //* */
- // public static Fruit getApple(){
- // return new Apple();
- // }
- //
- // /*
- //* 获得 Banana 类的实例
- //* */
- // public static Fruit getBanana(){
- // return new Banana();
- // }
- //get 所有的对象
- public static Fruit getFruit(String name) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
- // if (name.equalsIgnoreCase("apple")){
- // return Apple.class.newInstance();
- // }else if (name.equalsIgnoreCase("banana")){
- // return Banana.class.newInstance();
- // }else {
- // return null;
- // }
- Class<?> aClass = Class.forName(name);
- return (Fruit) aClass.newInstance();
- }
- }
注意: 测试类测试传入的 String 类型;
- Fruit apple = FruitFactory.getFruit("Apple");
- Fruit banana = FruitFactory.getFruit("Banana");
- apple.eat();
- banana.eat();
- Class<?> aClass = Class.forName(name);
这部分代码的调用, 比之前相比比较灵活了.
在这个模式中, 工厂类是整个模式的关键所在. 它包含必要的判断
逻辑, 能够根据外界给定的信息, 决定究竟应该创建哪个具体类的
对象. 用户在使用时可以直接根据工厂类去创建所需的实例, 而无
需了解这些对象是如何创建以及如何组织的. 有利于整个软件体系
结构的优化.
不难发现, 简单工厂模式的缺点也正体现在其工厂类上, 由于工厂类集中
了所有实例的创建逻辑, 所以 "高内聚" 方面做的并不好. 另外, 当系统中的
具体产品类不断增多时, 可能会出现要求工厂类也要做相应的修改, 扩展
性并不很好. 在具体调用比较麻烦.
一般推荐第二种比较好.
那么, 这种模式具体会在哪些方面应用比较多.
比如: 在 JDBC 不同数据库实现方面.
来源: https://www.cnblogs.com/hardy-test/p/10582109.html