Java设计模式之三种工厂模式

Java工厂模式分为简单工厂模式、静态工厂模式、抽象工厂模式。现在我们来介绍下，这也是最近比较有时间，来整理之前看过和经常用到的几种设计模式。

简单工厂模式

设计模式当中，很多对象的设计来通过实现接口来创建，这样一个接口可以被多个类实现，而创建这些类的对象，返回接口类型，进而实现多态的设计理念。

简单工厂模式的基本实现是提供一个共同的接口类A，创建几个有共同行为的类来实现接口A，然后创建简单工厂，工厂提供一个接收参数的方法，这个参数用来判断工厂要生产什么样的类型对象。

public interface Push {

    public void pushActivity();
}
 

public class APush implements Push{

    @Override
    public void pushActivity() {
        System.out.println("a push....");
    }

}

public class BPush implements Push{

    @Override
    public void pushActivity() {
        System.out.println("b push....");
    }

}
 

public class PushFactory {

    public Push prduce(String type){
        
        if("a".equals(type)){
            return new APush();
        }else if("b".equals(type)){
            return new BPush();
        }else{
            return null;
        }
    }
}

 

public class FactoryTest {

    public static void main(String[] args) {
        
        PushFactory factory = new PushFactory();
        Push push = factory.prduce("a");
        push.pushActivity();
    }

}

输出：

a push....
===========================================

静态工厂方法

静态工厂方法，也是一样定义接口A，并创建几个实现接口A的类。创建静态工厂类，工厂里提供多个静态方法，每个静态方法提供对应对象的创建方法。这种静态工厂里的静态方法，对外是可知的。不然客户端不知道要调用哪个方法去生产所需的对象。

接口和实现类，都和上面的一样定义。这里我们看下静态工厂类的创建

public class StaticFactory {

    public static Push getAPush(){
        return new APush();
    }
    
    public static Push getBPush(){
        return new BPush();
    }
}

 

public class FactoryTest {

    public static void main(String[] args) {
        
        /*PushFactory factory = new PushFactory();
        Push push = factory.prduce("a");
        push.pushActivity();
        */
        Push push = StaticFactory.getAPush();
        push.pushActivity();
        
    }

}
输出

a push....
====================================

抽象工厂模式

工厂模式有个问题，如果要扩展新的类或者功能，就需要修改工厂类。这违反了闭包原则，所以从设计的角度来看，就不要去改动原来的代码。对扩展开放，对修改关闭。这里就用到了抽象工厂模式，每个实现类，都有对应的工厂来生产。

public class APush implements Push{

    @Override
    public void pushActivity() {
        System.out.println("a push....");
    }

}

public class BPush implements Push{

    @Override
    public void pushActivity() {
        System.out.println("b push....");
    }

}

 

public interface Produce {

    public Push produce();
}

 

public class AFactory implements Produce{

    @Override
    public Push produce() {
        return new APush();
    }
}

public class BFactory implements Produce{

    @Override
    public Push produce() {
        return new BPush();
    }
}

public class AbstractFactory {

    public static void main(String[] args){
        
        AFactory factory = new AFactory();
        Push aPush = factory.produce();
        BFactory bFactory = new BFactory();
        Push bPush = bFactory.produce();
        aPush.pushActivity();
        bPush.pushActivity();
    }
}

输出

a push....
b push....