工厂模式

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

为了解耦还有后面的修改代码的过程中减少错误,所以用工厂来完成操作.

例子

我们平常都知道计算器吧,以计算器的加减乘除 来说明.

首先 我们定义一个抽象的操作类

里面定义了两个输入数 A B  定义了一个抽象的getResult() 方法  顾名思义 就是得到计算结果 给下层继承的类进行定制
public abstract class Operation {

	private double numberA;
	
	private double numberB;
	
	public abstract double getResult();
	
	//忽略set get
	
}

再定义加减乘除类 这些类都继承Operation抽象类

//加法操作类
public class OperatorAdd extends Operation{
	@Override
	public double getResult() {
		double result = this.getNumberA() + this.getNumberB();
		return result;
	}
}
//减法操作类
public class OperatorSub extends Operation{
	@Override
	public double getResult() {
		double result = this.getNumberA() - this.getNumberB();
		return result;
	}
}
//乘法操作类
public class OperatorMul extends Operation{
	@Override
	public double getResult() {
		double result = this.getNumberA() * this.getNumberB();
		return result;
	}
}

//除法操作类
public class OperatorDiv extends Operation {
	@Override
	public double getResult(){
		if (this.getNumberB() == 0){
			try {
				throw new Exception("除数为0");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		double result = this.getNumberA() / this.getNumberB();
		return result;
	}
}

好了 加减乘除的功能都写好 下面我们写一个计算的工厂类,要求的目标就是 传入一个运算符号 就返回所需要的计算类

public static Operation createOperate(String operate) {
		Operation oper = null;
		switch (operate) {
		case "+":
			oper = new OperatorAdd();
			break;
		case "-":
			oper = new OperatorSub();
			break;
		case "*":
			oper = new OperatorMul();
			break;
		case "/":
			oper = new OperatorDiv();
			break;
		}
		return oper;
}

用法:

Operation oper = OperationFactory.createOperate("+");
oper.setNumberA(1);
oper.setNumberB(2);
System.out.println(oper.getResult());

上述的就是我们所说的简单工厂的基础封装,简而言之 就是需要什么类型我们不需要再自己new xxxx() ,要什么 就从工厂里拿.

而对于的抽象工厂,可能会用的少一点,有兴趣可以自己网上看看.. 提供一个例子:

interface IProduct1 {  
    public void show();  
}  
interface IProduct2 {  
    public void show();  
}  
  
class Product1 implements IProduct1 {  
    public void show() {  
        System.out.println("这是1型产品");  
    }  
}  
class Product2 implements IProduct2 {  
    public void show() {  
        System.out.println("这是2型产品");  
    }  
}  
  
interface IFactory {  
    public IProduct1 createProduct1();  
    public IProduct2 createProduct2();  
}  
class Factory implements IFactory{  
    public IProduct1 createProduct1() {  
        return new Product1();  
    }  
    public IProduct2 createProduct2() {  
        return new Product2();  
    }  
}  
  
public class Client {  
    public static void main(String[] args){  
        IFactory factory = new Factory();  
        factory.createProduct1().show();  
        factory.createProduct2().show();  
    }  
}

策略模式

定义了一系列的算法,并将每一个算法封装起来,而且使它们可以相互替换。策略模式让算法独立于使用它的客户而独立变化.

首先 定义一个抽象的策略类

public abstract class Strategy {

	public abstract void algorithmIterface();//算法方法
}

再来定义一个环境类(Context)

public class Context {

	private Strategy strategy;
	public Context(Strategy strategy){
		this.strategy = strategy;
	}
	
	//上下文接口
	public void ContextInterface(){
		strategy.algorithmIterface();
	}
}

既然有了抽象的策略类,下面我们就可以继承并重写algorithmIterface()方法

public class ConcreteStrategyA extends Strategy {

	@Override
	public void AlgorithmIterface() {
		System.out.println("算法A");
	}

}
public class ConcreteStrategyB extends Strategy {
	@Override
	public void AlgorithmIterface() {
		System.out.println("算法B实现");
		
	}
}

用法:

public static void main(String[] args) {
		Context context = new Context(new ConcreteStrategyA());
		context.ContextInterface();
}
适用的地方

当存在以下情况时使用Strategy模式

1）许多相关的类仅仅是行为有异。 “策略”提供了一种用多个行为中的一个行为来配置一个类的方法。即一个系统需要动态地在几种算法中选择一种。

2）需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间 时间权衡的算法。当这些变体实现为一个算法的类层次时 ,可以使用策略模式。

3）算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

4） 一个类定义了多种行为 , 并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

总结

简单工厂模式也可以和策略模式结合起来用,有兴趣可以看看

总之,如果别人能快速理解你的代码，就是好代码。代码的可读性不是非得使用设计模式。