创建型设计模式-抽象工厂模型

参考

应用最广泛的模式-工厂方法模式

一.抽象工厂方法模式介绍

抽象工厂模式，是创建型设计模式之一。抽象工厂模式起源与以前对不同操作系统的图形化解决方案。

二.抽象工厂方法模式的定义

为一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体类。

三.抽象工厂方法模式的使用场景

一个对象有相同的约束时可以使用抽象工厂模式。

四.示例

因为我现在的工作是有关铁路方面的，就拿这个举例。
有扳手，测量器两种工具可以使用，使用哪个不确定，但是两种工具都有连接，接收数据，断开连接三种方法，我们可以使用抽象工厂模式。

public abstract class ToolFactory {
    
    
    public abstract ToolConnection connection();

    public abstract ToolReceiveData receiveData();

    public abstract ToolDisconnect disconnect();
}

public interface ToolConnection {
    
    
    void connection(String url);
}

public interface ToolReceiveData {
    
    
    void receiveData();
}

public interface  ToolDisconnect {
    
    
    void disconnect();
}

public class WrenchToolConnection implements ToolConnection {
    
    
    @Override
    public void connection(String url) {
    
    
        Log.d("=====", "连接扳手");
    }
}

public class WrenchToolReceiveData implements ToolReceiveData {
    
    
    @Override
    public void receiveData() {
    
    
        Log.d("=====", "接收扳手数据");
    }
}

public class WrenchToolDisconnect implements ToolDisconnect {
    
    
    @Override
    public void disconnect() {
    
    
        Log.d("=====", "断开扳手");
    }
}

public class MeasureToolConnection implements ToolConnection {
    
    
    @Override
    public void connection(String url) {
    
    
        Log.d("=====", "连接测量器");
    }
}

public class MeasureToolReceiveData implements ToolReceiveData {
    
    
    @Override
    public void receiveData() {
    
    
        Log.d("=====", "接收测量器数据");
    }
}

public class MeasureToolDisconnect implements ToolDisconnect {
    
    
    @Override
    public void disconnect() {
    
    
        Log.d("=====", "断开测量器");
    }
}

public class ChooseToolFactory extends ToolFactory {
    
    

    public static String wrench = "wrench";
    public static String measure = "measure";
    private String type;

    public ChooseToolFactory(String type) {
    
    
        this.type = type;
    }

    @Override
    public ToolConnection connection() {
    
    
        if (type.equals(wrench)) {
    
    
            return new WrenchToolConnection();
        } else if (type.equals(measure)) {
    
    
            return new MeasureToolConnection();
        }
        return null;
    }

    @Override
    public ToolReceiveData receiveData() {
    
    
        if (type.equals(wrench)) {
    
    
            return new WrenchToolReceiveData();
        } else if (type.equals(measure)) {
    
    
            return new WrenchToolReceiveData();
        }
        return null;
    }

    @Override
    public ToolDisconnect disconnect() {
    
    
        if (type.equals(wrench)) {
    
    
            return new WrenchToolDisconnect();
        } else if (type.equals(measure)) {
    
    
            return new MeasureToolDisconnect();
        }
        return null;
    }
}

 ChooseToolFactory chooseToolFactory = new ChooseToolFactory(ChooseToolFactory.wrench);
 chooseToolFactory.connection().connection("");
 chooseToolFactory.receiveData().receiveData();
 chooseToolFactory.disconnect().disconnect();

五.总结

优点：
分离接口实现，客户端使用抽象工厂来创建需要的对象，而客户端根本不知道具体实现是谁，客户端只是面向产品的接口编程而已，使其从具体的产品中解耦，同时基于接口与实现的分离，是抽象该工厂方法模式在切换产品时更加灵活，容易。

缺点：
类文件的爆炸性增加。
不容易扩展新的产品类。