设计模式之三：对象创建模式(工厂模式)-CSDN博客

通过对象创建模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。

典型的模式：

Factory Method 工厂方法模式

Abstract Factory 抽象工厂模式

Prototype 　原型模式

Builder　　构建器

一，、Factory Method

1，出现原因

在软件系统中，经常面临创建对象的工作。由于需求的变化，需要创建的对象的具体类型经常变化。

如何解决？

绕过常规的对象创建方法（new），提供一种封装机制来避免客户程序和这种具体对象创建工作的紧耦合。

2，依赖倒置原则

应该依赖抽象，而不应该依赖细节。

二，案例解析

比如现在有一个文件分隔的需求，点击按钮可把文件分隔若干份。

1，文件分隔类，并在其中定义文件分隔的方法

/**
 * 文件分隔类
 */
public class FileSpliter {
public void split(String filePath,int number){
        System.out.println("分隔文件的方法");
    }

}

2，点击按钮会进行文件分隔，所以调用文件分隔类的分隔方法

public class MainForm {

    public void buttonClick(){
        //文件路径
        String filePath = "d:/yaming/video";
        //文件分隔的个数
        int number = 3;

        /**注意：
         * 一个对象的类型应该声明为抽象类或接口，而不应该声明为具体的类。如果这里是具体的类，那么这一块在以后就不能支持变化
         */
        FileSpliter spliter = new FileSpliter();

        spliter.split(filePath,number);

    }
}

3，缺点

一个对象的类型应该声明为抽象类或接口，而不应该声明为具体的类。如果这里是具体的类，那么这一块在以后就不能支持变化

三，重构代码

1，思路

面向接口编程思想，定义文件分隔接口，然后具体的文件分隔类实现该接口。

我们这里定义两种具体的文件分隔类。图片分隔类用来分隔图片，文档分隔类用来分隔文档

2，代码

/**
 * 文件分隔接口,
 */
public interface ISpliter {
    void split();
}

/**
 * 图片分隔类
 */
public class PictureSpliter implements ISpliter{  
    
    @Override
    public void split(String filePath,int number){
        System.out.println("分隔图片的方法");
    }

}

/**
 * 文本分隔类
 */
public class TxtSpliter implements ISpliter{

    @Override
    public void split(String filePath,int number){
        System.out.println("分隔文本的方法");
    }

}

public class MainForm {

    public void buttonClick(){
        //文件路径
        String filePath = "d/yaming/video";
        //文件分隔的个数
        int number = 3;

        /**注意：
         * 这里我们抽象出来一个文件分隔接口，然后不同类型的文件分隔类实现这个接口，就可以实现对应类型的文件分隔了。
         * 但是，我们还是依赖具体的文件分隔类：PictureSpliter。（这里就是细节依赖了，我们需要的是抽象依赖。等号前面的已经是抽象的了，等号后面还没有满足。）
         * MainForm在编译的时候，还是依赖PictureSpliter了。这里是编译时依赖。
         */
        ISpliter spliter = new PictureSpliter();

        spliter.split(filePath,number);
        
    }
}

3，问题：

这里我们抽象出来一个文件分隔接口，然后不同类型的文件分隔类实现这个接口，就可以实现对应类型的文件分隔了。
但是，我们还是依赖具体的文件分隔类：PictureSpliter。（这里就是细节依赖了，我们需要的是抽象依赖。等号前面的已经是抽象的了，等号后面还没有满足。）
MainForm在编译的时候，还是依赖PictureSpliter了。这里是编译时依赖。

四，继续重构

1，思路

这里我们使用一个工厂，它可以创建ISpliter的子类对象，MainForm中就不需要依赖具体的 PictureSpliter类了。

2，代码

/**
 * 文件分隔接口,
 */
public interface ISpliter {
    
    void split(String filePath,int number);
}

/**
 * 图片分隔类
 */
public class PictureSpliter implements ISpliter {

    @Override
    public void split(String filePath,int number){
        System.out.println("分隔图片的方法");
    }
}

/**
 * 文本分隔类
 */
public class TxtSpliter implements ISpliter {

    @Override
    public void split(String filePath,int number){
        System.out.println("分隔文本的方法");
    }

}

/**
 * 创建ISpliter的工厂
 */
public class SpliterFactory {

    public ISpliter createSpliter(){
        return new PictureSpliter();
    }
}

public class MainForm {

    public void buttonClick(){
        //文件路径
        String filePath = "d/yaming/video";
        //文件分隔的个数
        int number = 3;

        SpliterFactory factory = null;

        /**注意：
         * 这里我们使用一个工厂，它可以创建ISpliter的子类对象，MainForm中就不需要依赖具体的PictureSpliter类了。
         * 但是，因为在编译时，MainForm需要依赖SpliterFactory，而SpliterFactory在编译时需要依赖PictureSpliter。
         * 所以，我们还是没解决掉编译时依赖的问题
         *
         */
        ISpliter spliter = factory.createSpliter();

        spliter.split(filePath,number);
        
    }
}

3，问题

这里我们使用一个工厂，它可以创建ISpliter的子类对象，MainForm中就不需要依赖具体的PictureSpliter类了。
但是，因为在编译时，MainForm需要依赖SpliterFactory，而SpliterFactory在编译时需要依赖PictureSpliter。
所以，我们还是没解决掉编译时依赖的问题

五，继续重构

1，思路

我们把工厂抽象一下，使用接口的方式。

2，代码

/**
 * 文件分隔接口,
 */
public interface ISpliter {
    void split(String filePath,int number);
}

/**
 * 图片分隔方法
 */
public class PictureSpliter implements ISpliter {

    @Override
    public void split(String filePath,int number){
        System.out.println("分隔图片的方法");
    }

}

/**
 * 文本分隔方法
 */
public class TxtSpliter implements ISpliter {
    
    @Override
    public void split(String filePath,int number){
        System.out.println("分隔文本的方法");
    }

}

/**
 * 创建ISpliter的工厂接口，
 * 接口的好处是，我们只定义方法，不具体实现
 */
public interface SpliterFactory {

    ISpliter createSpliter();
}

//给具体的类创建对应的工厂类
public class PictureSpliterFactory implements SpliterFactory {
    
    @Override
    public ISpliter createSpliter() {
        return new PictureSpliter();
    }
}

public class TxtSpliterFactory implements SpliterFactory{
    
    @Override
    public ISpliter createSpliter() {
        return new TxtSpliter();
    }
}

public class MainForm {

    /**
     * 3,注意：这里不可以写具体的工厂。必须要写抽象的。那么在哪里指定具体的工厂类呢？
     * 我们可以通过传参的方式，让外界传具体的工厂类。
     * 比如外界传的是PictureSpliterFactory,那么factory.createSpliter();就会创建PictureSpliter类。这里就体现了多态的思想。
     */
    SpliterFactory factory = null;//工厂

    public MainForm(SpliterFactory factory){
        this.factory = factory;
    }

    public void buttonClick(){
        //文件路径
        String filePath = "d/yaming/video";
        //文件分隔的个数
        int number = 3;

        /**注意：
         * 1,这里我们使用的工厂是一个接口，它可以创建ISpliter。ISpliter是一个接口,我们在工厂这个接口没有去具体指定实例化哪个文件分隔类。
         *   这样,虽然MainForm依赖SpliterFactory,但是SpliterFactory不依赖具体的实现类,编译时就没有细节依赖了。
         *
         * 2,具体要创建那种文件分隔类呢？我们肯定是要确定的，不然没法实例化对象啊。这个事情可以未来再去做。
         *   思路：我们有一系列的具体类，那我们就创建一系列的对应的工厂。即每一个类都有一个对应的工厂。
         *
         */
        ISpliter spliter = factory.createSpliter();

        spliter.split(filePath,number);

        /**
         * 4,未来 PictureSpliter类在其他地方还是要创建的,这个时候是不是又产生依赖了？
         *   确实是产生依赖了,但是MainForm中是没有对具体类产生依赖的。MainForm中SpliterFactory和ISpliter都是抽象的。没有依赖具体类。
         *   所以并没有把依赖这个事情给消灭掉（其实也不可能消灭掉），而是把依赖赶到了某一个局部的地方。
         */
        
    }
}