工厂模式详解-优快云博客

1、工厂方法模式（Factory Method）

工厂模式分为三种：

1.1 普通工厂模式

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

代码如下：（代码实现发送邮件和发送消息）

首先，创建共同接口：

public interface Sender{
    public void send();
}

其次，创建实体类：

public class MailSender implements Sender{
    @Override
    public void send(){
        System.out.println("this is mailsender");
    }
}

public class SmsSender implements Sender{
    @Override
    public  void Send(){
        System.out.println("this is sms sender");
    }
}

最后，建工厂类：

public class SendFactory {
    public Sender produce(String type){
        if ("mail".equals(type)){
            return new MailSender();
        }else if ("sms".equals(type)){
            return new SmsSender();
        }
    }
}

测试：

public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produce("sms");
        sender.send();
    }

结果如下：

1.2 多个工厂方法模式

是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

public class SendFactory {
    public  Sender produceMail(){
        return new MailSender();
    }
    public Sender produceSms(){
        return new SmsSender();
    }

    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produceMail();
        sender.send();
    }
}

结果：

1.2 静态工厂方法模式

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class SendFactory {
    public static   Sender produceMail(){
        return new MailSender();
    }
    public static Sender produceSms(){
        return new SmsSender();
    }

    public static void main(String[] args) {
        Sender sender = SendFactory.produceMail();
        sender.send();
    }
}

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂模式创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确的创建对象。第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会用第三种——静态工厂模式。

2、抽象工厂模式（Abstract Factory）

工厂方法模式有一个问题是，类的创建依赖工厂类，也就是说，如果想要扩展程序，必须对工厂类进行修改。这就违背了开闭原则。所以，从设计角度考虑，存在一定问题，如何解决? 这就用到了抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

例子如下：

public interface Sender {
    public void Send();
}

两个实现类：

public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailSender!");
    }
}

public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender");
    }
}

工厂接口：

public interface Provider {
    public Sender produce();
}

两个工厂实现类：

public class SendMailFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

public class SendSmsFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

测试类：

  public static void main(String[] args){
         Provider provider = new SendMailFactory();
         Sender sender = provider.produce();
         sender.Send();
    }

这个模式的好处就是：如果现在想增加一个功能，只需要增加一个类去实现Sender接口，然后再一个实现工厂类去实现Provider接口。无需改动现成的代码。具备良好的扩展性。

通过单例模式的学习告诉我们：

1.单例模式实现起来简单，但是具体实现起来还是有一定难度的。

2.synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有时候并不是整个对象及整个过程都需要锁）

还有一种采用类的静态方法实现单例模式的效果。此处二者有什么不同呢？

首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态，因为接口中不允许有staic修饰的方法，所以即使实现了也是非静态的）

其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载。是因为有些类比较庞大，所以延迟加载有助于提升性能。单例可以被继承，他的方法可以被覆盖。但是静态类内部方法都是static，无法被覆写。