大话设计模式-----(一)简单工厂模式 策略模式 二者比较
写一个计算器把，之前写法都是放在一起。界面显示和逻辑代码放在一起很不好，
不灵活，耦合度高，要解耦。那么就分开代码两个类。
这样写就算如此还是有问题。没有扩展性。如果要增加运算符那就要更改逻辑代码
很麻烦。
可以把所有可能变化的东西比较提取出他们都有的东西，作为一个类，让其每个运算符
进行继承，每个在重写其父类。就是进行不同的操作运算。
返回创建一个相当于工厂，在一个工厂里判断，有什么需求，对应的创建对应的运算符
子类。而且利于多态，实例化的每个子类都可以用父类来定义。并且因为是重写父类定义的
方法。直接就是定义的父类调用父类的方法。而不是每个不同的运算符的实例化子类去调用自己的额
方法。很美。这么写代码
提取出来的父类
//所有运算符的父类
class jishuan {
private double numberA;
private double numberB;
public double getNumberA() {
return numberA;
}
public void setNumberA(double numberA) {
this.numberA = numberA;
}
public double getNumberB() {
return numberB;
}
public void setNumberB(double numberB) {
this.numberB = numberB;
}
public double result(){
double result=0;
return result;
}
}各个运算符继承父类
//加法
class add extends jishuan{
public double result(){
double result=0;
result = getNumberA()+getNumberB();
return result;
}
}
//减法
class sub extends jishuan{
public double result(){
double result=0;
result = getNumberA()-getNumberB();
return result;
}
}
//乘法mult
class mult extends jishuan{
public double result(){
double result=0;
result = getNumberA()*getNumberB();
return result;
}
}
工厂
//工厂类factory
class factory{
//创建一个静态方法来判断创建实例化运算符
public static jishuan Createjishuan(String yunsuan){
jishuan js=null;
switch(yunsuan){
case "+":
js = new add();
break;
case "-":
js = new sub();
break;
case "*":
js= new mult();
break;
}
return js;
}
}使用这个工厂
public class client {
public static void main(String[] args) {
jishuan jsclient = factory.Createjishuan("+");
jsclient.setNumberA(1);
jsclient.setNumberB(2);
System.out.println(jsclient.result());
}
}遇到了一些问题。。。。
jdk 1.6不支持switch 的传入String。
在eclipse中更改 eclipse和项目的jdk为1.7即可。
http://blog.csdn.net/jiuyueguang/article/details/9350753
http://blog.csdn.net/emoven/article/details/43233917
最最重要的是
子类继承父类后父类的私有属性子类也是继承了的！，但是不能直接使用，可以直接get属性来获取！！！
策略模式就是用来封装算法的，选择所用具体实现的职责由客户端对象承担，并转交给策略模式的Context对象
策略模式的有点事简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试
饺子父类
abstract class jiaozi{
private String xianString;
public String getXianString() {
return xianString;
}
public void setXianString(String xianString) {
this.xianString = xianString;
}
public abstract void zuojiaozi();
}各种馅的饺子
//牛肉馅
class niurou extends jiaozi{
@Override
public void zuojiaozi() {
System.out.println(niurou.this.getXianString());
}
}
//韭菜馅
class jiucai extends jiaozi{
@Override
public void zuojiaozi() {
System.out.println(jiucai.this.getXianString());
}
}
//酸菜馅
class suancai extends jiaozi{
@Override
public void zuojiaozi() {
System.out.println(suancai.this.getXianString());
}
}策略类
//配置策略类
class Context{
jiaozi jz;
public Context(jiaozi jz){
this.jz = jz;
}
public void ContextInterface() {
jz.zuojiaozi();
}
}客户类
public class client {
public static void main(String[] args){
jiaozi jz = null;
String typeString = "牛肉";
switch(typeString){
case "牛肉":
jz = new niurou();
jz.setXianString("牛肉");
break;
case "韭菜":
jz = new jiucai();
jz.setXianString("韭菜");
break;
case "酸菜":
jz = new suancai();
jz.setXianString("酸菜");
break;
}
//客户选择什么馅后将这个馅传递给策略类
Context context ;
context = new Context(jz);
context.ContextInterface();
}
}恩，策略模式就是 有一个策略对象，进行配置。里面封装的是算法。
策略模式把原来工厂模式的工厂类传入的条件参数换成了子类。然后在其策略方法中调用这些子类继承父类重写父类的方法，来实现算法。在客户端中判断是什么打折条件。
策略模式
客户自己想吃什么饺子就买什么馅。然后给策略类。策略类根据饺子的规定做法做饺子。再给客户饺子
应用场景：优惠系统、工资计算系统等
工厂模式
客户想吃饺子。我想吃韭菜馅的饺子。然后告诉工厂。工厂给你做好给你。
应用场景：多数据库选择，类库文件加载等。
可以二者结合使用。写成一个策略类。在策略类传入条件，策略类判断使用什么馅的饺子。这使用工厂模式。然后调用做出饺子方法。恩，就是把客户判断条件放在了策略类中。减轻客户的负担。
新手学习设计模式可能理解的不对，若有错误望指出。谢谢。
参考
http://blog.csdn.net/fwj380891124/article/details/7552305
https://zhidao.baidu.com/question/1606721221938966387.html
http://www.cnblogs.com/langtianya/archive/2013/03/08/2950934.html
http://blog.csdn.net/tengzhaorong/article/details/6827093