设计模式--抽象工厂模式

设计模式–抽象工厂模式

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

优点

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

缺点

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

使用场景

 QQ 换皮肤，一整套一起换。
 生成不同操作系统的程序。
注意事项：产品族难扩展，产品等级易扩展。

代码实现

package design.patten.abstractFactory;
/** 
* 形状
* @author SHIMINGDA 
*/
public interface Shape {
    void draw();
}
package design.patten.abstractFactory;
/** 
* 圆形 
*/
public class Circle implements  Shape{
    @Override    public void draw() {
        System.out.println("圆形");    
}
}
package design.patten.abstractFactory;
public class Square implements  Shape{
    @Override    public void draw() {
        System.out.println("正方形");   
 }
}
package design.patten.abstractFactory;
/** * 形状工厂
 * @author SHIMINGDA 
**/
public class ShapeFactory  extends AbstractFactory {
    @Override   Color getColor(String color) {
        return null;    }

    @Override    Shape getShape(String shape) {
        if ("Circle".equalsIgnoreCase(shape)) {
            return new Circle();       }
        if ("Square".equalsIgnoreCase(shape)) {
            return new Square();       }
        return null;    }
}


package design.patten.abstractFactory;
/** 
* 颜色 
* @author SHIMINGDA 
*/
public interface Color {
    void fill();}
package design.patten.abstractFactory;
public class Blue implements Color {
    @Override    public void fill() {
        System.out.println("蓝色");   
 }
}
package design.patten.abstractFactory;
public class Green implements Color {
    @Override    public void fill() {
        System.out.println("绿色");  
  }
}
package design.patten.abstractFactory;
/**
 * 红色
 * @author SHIMINGDA 
*/
public class Red  implements  Color{
    @Override   public void fill() {
        System.out.println("红色"        
);  
  }
}
package design.patten.abstractFactory;
/** 
* 颜色工厂
* @author SHIMINGDA
*/
public class ColorFactory  extends AbstractFactory{

    @Override    Color getColor(String color) {
        if("red".equalsIgnoreCase(color)){
            return new Red();        }
        if("Green".equalsIgnoreCase(color)){
            return new Green();        }
        if("Blue".equalsIgnoreCase(color)){
            return new Blue();        }

        return null;    }

    @Override    Shape getShape(String shape) {
        return null;    }
}
package design.patten.abstractFactory;
/** 
* 抽象工厂
* @author SHIMINGDA 
*/
public abstract class AbstractFactory {

 abstract Color getColor(String color);   
 abstract Shape getShape(String shape);
}
package design.patten.abstractFactory;
/** 
* @author SHIMINGDA 
* 产生工厂
 */
public class ProductFactory {
private ProductFactory(){

}
public static AbstractFactory getFactory(String factory){
    if("shape".equalsIgnoreCase(factory)){
        return  new ShapeFactory();    }
    if ("color".equalsIgnoreCase(factory)){
        return new ColorFactory();   
 }
    return null;
}
}
package design.patten.abstractFactory;
/**
* 抽象工厂模式测试 
* @author SHIMINGDA 
*/
public class AbstractFactoryTest {

    public static void main(String[] args){
    AbstractFactory     abstractFactory;
    //----------------------------Shape-------------------------        abstractFactory=ProductFactory.getFactory("shape");  
      Shape circle= abstractFactory.getShape("CIRCLE"); 
   circle.draw();  
  Shape square=abstractFactory.getShape("square");   
 square.draw();
//----------------------------Color------------------        System.out.println("----------------------------Color------------------");    abstractFactory=ProductFactory.getFactory("color");  
  Color red=abstractFactory.getColor("red");  
  red.fill();   
 Color blue=abstractFactory.getColor("blue");   
 blue.fill();   
 Color green=abstractFactory.getColor("green");  
  green.fill();   
 }

}


设计模式--策略模式
策略模式
在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。
优点
1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。
缺点
 1、策略类会增多。 2、所有策略类都需要对外暴露。
使用场景
1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 
2、一个系统需要动态地在几种算法中选择一种。
3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。
代码实现
package design.patten.strategy;/*** 实现策略模式** @author SHIMINGDA*/public abstract class Strategy {
    public abstract void model();}
class StrategyA extends Strategy{

    @Override    public void model() {
        System.out.println("实现A模型");   }
}
class StrategyB extends Strategy{

    @Override   public void model() {
        System.out.println("实现B模型");    }
}
class StrategyC extends Strategy{

    @Override   public void model() {
        System.out.println("实现C模型");   }
}
package design.patten.strategy;/** * 策略调配上下文 * * @author SHIMINGDA */public class Context {
    Strategy strategy;    public Context(Strategy strategy) {
        this.strategy = strategy;    }
    public void readModle(){
        strategy.model();    }
}
package design.patten.strategy;/** * 策略模型测试类 * @author SHIMINGDA */public class StrategyTest {
    public static void  main(String[] args){
        Context context;     
   context=new Context(new StrategyA());     
   context.readModle();       
 context=new Context(new StrategyB());    
context.readModle();       
 context=new Context(new StrategyC());      
  context.readModle();   }
}


设计模式--工厂模式
工厂模式提供创建对象的机制，但是不将原型暴露在外，而是通过统一接口，通过不同字符定义不同对象，指定给出新的对象。
主要形式
通过继承实现
优点
创建对象知道名称就可以了
扩展性能高，增加新的类型，在工厂类中实现就可以
不关心实例类型，只关心调用接口
下面是一个工厂模式实现的小例子：
package design.patten.factory.dome;

/**
 * 计算器
 *
 * @author SHIMINGDA
 */
public class Operation {
    private Double param_A;
    private Double Param_B;

    public Double getParam_A() {
        return param_A;
    }

    public void setParam_A(Double param_A) {
        this.param_A = param_A;
    }

    public Double getParam_B() {
        return Param_B;
    }

    public void setParam_B(Double param_B) {
        Param_B = param_B;
    }

    public Double getResult() throws Exception {
        return 0.0;
    }
}

class Add extends Operation {
    @Override
    public Double getResult() {
        return getParam_A() + getParam_B();
    }
}

class Sub extends Operation {
    @Override
    public Double getResult() {
        return getParam_A() - getParam_B();
    }
}

class Mul extends Operation {
    @Override
    public Double getResult() {
        return getParam_A() * getParam_B();
    }
}

class Div extends Operation {
    @Override
    public Double getResult() throws Exception {
        if (getParam_B() == 0.0) {
            throw new Exception("除数不能为0");
        }
        return (getParam_A() / getParam_B());
    }
}
package design.patten.factory.dome;


/**
 * 计算器工厂模式
 * @author SHIMINGDA
 */
public class OperationFactory {
 public static Operation createOperation(String sign){
     Operation operation=null;
     switch (sign){
         case "+":
             operation=new Add();
             break;
         case "/":
             operation=new Div();
             break;
         case "*":
             operation=new Mul();
             break;
         case "-":
             operation=new Sub();
             break;
     }
     return operation;
 }
}

package design.patten;

import design.patten.factory.dome.Operation;
import design.patten.factory.dome.OperationFactory;
import org.junit.Test;

/**
 * 测试类
 *
 * @author SHIMINGDA
 */
public class FactoryTest {

    Operation operation;

    @Test
    public void AddTest() throws Exception {
        operation = OperationFactory.createOperation("+");
        operation.setParam_A(10.0);
        operation.setParam_B(5.0);
        System.out.println("加法测试结果：="+operation.getResult());
    }

    @Test
    public void DivTest() throws Exception {
        operation=OperationFactory.createOperation("-");
        operation.setParam_A(10.0);
        operation.setParam_B(5.0);
        System.out.println("减法测试结果="+operation.getResult());
    }
    @Test
    public void Mul() throws Exception {
        operation = OperationFactory.createOperation("*");
        operation.setParam_A(10.0);
        operation.setParam_B(5.0);
        System.out.println("乘法测试结果=" + operation.getResult());
    }
    @Test
    public void SubTest() throws Exception {
        operation = OperationFactory.createOperation("/");
        operation.setParam_A(10.0);
        operation.setParam_B(5.0);
        System.out.println("除法测试结果=" + operation.getResult());
    }
    @Test
    public void SubExceptionTest() throws Exception {
        operation = OperationFactory.createOperation("/");
        operation.setParam_A(10.0);
        operation.setParam_B(0.0);
        System.out.println("除法异常测试结果=" + operation.getResult());
    }
}