java设计模式之一（工厂设计模式）

我们首先要清楚，设计模式是干什么用的，简单的说：解决一些在开发过程中面临的一般问题的解决方案，它是由众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

 

废话不多说，我们来看第一个设计模式：工厂设计模式。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

（简单工厂）

一个例子，我现在想买一辆宝马，我只需要下单付款，然后等着工厂把车给我送来，至于他们是怎么生产车我不管。放到代码中就是这样：

​//这就工厂
public interface Bwm{
   void car();
}

//实现接口
public class Rectangle implements Bwm{
 
   @Override
   public void car() {
      System.out.println("崭新出厂--别摸我--");
   }
}

​//我来买车了
Bwm b = new Rectangle;
//车车到手
b.car();

如果想买其他型号，那就让工厂去实现，我们就负责花钱。

（工厂方法模式）

我去买辆豪华版泥头车，工厂就去生产最新型号的车车，最后我拿到手。

 代码实现

//接口
public interface Shape {
   void draw();
}
//实现接口
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("--泥头车--");
   }
}
//实现接口
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("--卡丁车--");
   }
}
//工厂选择
public class Factory1 {
    public test gettest (String sic ){
        if (sic==null){
            return null;
        }
        switch (sic){
            case "30":
                return new Rectangle ();
            case "40":
                return new Square ();
            default:
                System.out.println("结束");
                break;
        }
        return null;
    }
}

非常简单。

（抽象工厂）

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。（就是工厂不仅生产格力的一系列产品，还生产海尔的一系列产品，那我们一次就只能选择是生产格力系列还是海尔系列）

//生产海尔系列产品的工厂
public interface haier{
   void draw();
}
public class Rectangle implements haier{
 
   @Override
   public void draw() {
      System.out.println("空调");
   }
}
public class Square1 implements haier{
 
   @Override
   public void draw() {
      System.out.println("冰箱");
   }
}
//生产格力系列产品的工厂
public interface geli{
   void draw();
}
public class Rectangle1 implements geli{
 
   @Override
   public void draw() {
      System.out.println("空调");
   }
}
public class Square implements geli{
 
   @Override
   public void draw() {
      System.out.println("冰箱");
   }
}
//创建抽象类方便获取那种系列的工厂
public abstract class AbstractFactory {
   public abstract Color gethaier(String haier);
   public abstract Shape getgeli(String geli);
}
//扩展抽象类基于给定的信息生成实体类的对象。
public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape gethaier(String haier){
      if(haier== null){
         return null;
      }        
      if(haier.equalsIgnoreCase("空调")){
         return new Rectangle();
      } else if(haier.equalsIgnoreCase("冰箱")){
         return new Square ();
      } 
      return null;
   }
   
   @Override
   public Color getgeli(String geli) {
      return null;
   }
}
//
public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getgeli(String geli){
      if(haier== null){
         return null;
      }        
      if(geli.equalsIgnoreCase("空调")){
         return new Rectangle1();
      } else if(geli.equalsIgnoreCase("冰箱")){
         return new Square1 ();
      } 
      return null;
   }
   
   @Override
   public Color gethaier(String haier) {
      return null;
   }
}
创建一个工厂创造器/生成器类，通过传递品牌来获取工厂
public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("海尔")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("格力")){
         return new ColorFactory();
      }
      return null;
   }
}

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

以上就是个人的一点见解，如有不对，欢迎指出