今天实际用代码走了一遍工厂方法模式，抽象工厂模式的思想和玩法，略有些心得，记录一下。

1.工厂方法模式

工厂方法模式（英语：Factory method pattern）是一种实现了“工厂”概念的面向对象设计模式。就像其他创建型模式一样，它也是处理在不指定对象具体类型的情况下创建对象的问题。工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。”（来自维基百科）
代码如下：
公共接口

public interface Sender {
 public void send();
}

邮件实现类

public class MailSender implements Sender{
 @Override
 public void send() {
  System.out.println("邮件发送短信");
 }
}

短信实现类

public class SmsSender implements Sender{
 @Override
 public void send() {
  // TODO Auto-generated method stub
  System.out.println("调用发送短信的方法");
 }
}

构建工厂类

public class SendFactory {

 public Sender produce(String type){
  if("sms".equals(type)){
   return new SmsSender();
  }else if("mail".equals(type)){
   return new MailSender();
  }else{
   System.out.println("请输入正确的类型");
   return null;
  }
 }
 
 //改进的工厂模式，不依赖于传参
 public Sender produceSms(){
  return new SmsSender();
 }

 public Sender produceMail(){
  return new MailSender();
 }
 
 
 //静态工厂模式、
 public static Sender produceSms2 (){
  return new SmsSender();
 }
 
 public static Sender produceMail2(){
  return new MailSender();
 }
 
}```
测试类

public class SenderFactoryTest {

public static void main(String[] args){
SendFactory sendFactory = new SendFactory();
//Sender send = sendFactory.produce("mail");
//send.send();
Sender send = sendFactory.produceMail();
send.send();

//调用静态方法
Sender send2 = SendFactory.produceMail2();
send2.send();
}
}

关于工厂模式总结：当我们需要大量创建某一类产品时，并且具有共同的接口，可以通过工厂模式进行创建。
# 2抽象工厂模式
**抽象工厂模式**（英语：**Abstract factory pattern**）是一种软件开发[设计模式](https://zh.wikipedia.org/wiki/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F_(%E8%AE%A1%E7%AE%97%E6%9C%BA))。抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的[工厂](https://zh.wikipedia.org/wiki/%E5%B7%A5%E5%8E%82%E6%96%B9%E6%B3%95)封装起来。在正常使用中，客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为[接口](https://zh.wikipedia.org/w/index.php?title=%E6%8E%A5%E5%8F%A3_(%E8%B5%84%E8%AE%AF%E7%A7%91%E6%8A%80)&action=edit&redlink=1)来创建这一主题的具体对象。客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，因为客户端程序仅使用这些对象的通用接口。抽象工厂模式将一组对象的实现细节与他们的一般使用分离开来。

代码实现：

public interface Sender {
public void send();
}

两个实现类

public class MailSender implements Sender{
@Override
public void send() {
// TODO Auto-generated method stub
System.out.println(" mail send ");
}
}

public class SmsSender implements Sender{

@Override
public void send() {
// TODO Auto-generated method stub
System.out.println("sms send");
}

}

再提供一个接口

public interface Provider {

public Sender produce();
}

两个工厂类

public class MailSenderFactory implements Provider {

@Override
public Sender produce() {
// TODO Auto-generated method stub
return new MailSender();
}

}

public class SmsSenderFactory implements Provider {

@Override
public Sender produce() {
// TODO Auto-generated method stub
return new SmsSender();
}

}

测试

public class Test {

public static void main(String [] args){
Provider provider = new SmsSenderFactory();
Sender send = provider.produce();
send.send();

Provider pro = new MailSenderFactory();
pro.produce().send();
}
}

这个模式的好处是，如果你现在想增加一个新功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，无需去改动原有的代码。这样做的目的是拓展性较好！