设计模式之工厂模式

Abstract Factory抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

 1 public interface Sender {  
 2     public void Send();  
 3 }  
 4 两个实现类：
 5 public class MailSender implements Sender {  
 6     @Override  
 7     public void Send() {  
 8         System.out.println(“this is mailsender!”);  
 9     }  
10 }  
11 public class SmsSender implements Sender {  
12     @Override  
13     public void Send() {  
14         System.out.println(“this is sms sender!”);  
15     }  
16 }  
17 public interface Provider {  
18     public Sender produce();  
19 }  
20 两个工厂类：
21 public class SendMailFactory implements Provider {  
22     @Override  
23     public Sender produce(){  
24         return new MailSender();  
25     }  
26 }  
27 public class SendSmsFactory implements Provider{  
28     @Override  
29     public Sender produce() {  
30         return new SmsSender();  
31     }  
32 }  
33 测试类：public class Test {  
34     public static void main(String[] args) {  
35         Provider provider = new SendMailFactory();  
36         Sender sender = provider.produce();  
37         sender.Send();  
38     }  
39 } 

普通工厂：

功能描述：

发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。

1. Factory Method工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。

1 package factory;

7 public interface Product {
8     //声明类所需继承的共同接口，也可以是抽象类
9 }

产品类A

 1 package factory;
 7 public class ProductA implements Product {
 8     public ProductA() {
 9         System.out.println("ProductA");
10     }
11 }

产品类B

 1 package factory;
 7 public class ProductB implements Product {
 8     public ProductB() {
 9         System.out.println("ProductB");
10     }
11 }

工厂类

 1 package factory;
 7 public class Factory {
 8     //可以在工厂类中添加任何你所需要的逻辑
 9     public static Product create(String str)
10     {
11         //生成ProductA
12         if(str.equalsIgnoreCase("ProductA"))
13         {
14             return new ProductA();
15         }
16         else
17             //生成ProductB
18             if(str.equalsIgnoreCase("ProductB"))
19             {
20                 return new ProductB();
21             }
22         return null;
23     }
24 
25 }

客户端

 1 package factory;
 7 public class Client {
 8     public static void main(String[] args) {
 9         //调用Factory的静态方法生成所要的类
10         Factory.create("productA");
11         Factory.create("ProductB");
12     }
13 }

控制台输出结果：