设计模式代码(大话设计模式)2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。 3) 具体产品角色：工厂类所

简单工厂模式: 1抽象产品类,N具体产品类; 1工厂类; 1客户端.

工厂模式: 1抽象产品类,N具体产品类; 1工厂接口类,N具体产品工厂类; 1客户端.

简单工厂模式

工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

//抽象产品类
public abstract  class operation {
    private double numberA =0;
    private double numberB =0;
    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 abstract  double getResult();
}
//两个具体产品类
public class Add extends operation {
    public double getResult(){
        double result = getNumberA()+getNumberB();
        return  result;
    }
}
public class Mul extends operation {
    public double getResult(){
        return getNumberA()*getNumberB();
    }
}

//构建工厂类
public class OperationFactory {
    public static operation createOperate(String operta){
      switch (operta){
          case "+": return new Add();
          case "*": return new Mul();
      }
        return null;
    }
}

//客户端的使用
public class Client {
   public static void main(String[] args){
       operation op = OperationFactory.createOperate("+");
       op.setNumberA(12);
       op.setNumberB(10);
       System.out.println(op.getResult());
   }
}

工厂方法

　　简单工厂模式存在的问题：　去除了客户端与具体产品之间的依赖, 但同样地违背了开放-封闭原则.(就要要添加一个减法,需要加一个类同时修改工厂类)

工厂模式解决了上述方法,定义了用于创建对象的接口,让之类决定实例化类.(实例化是在具体之类中).实际上就是抽象处工厂类,创建具体产品各自的工厂.在使用是,new具体产品自己的工厂就可以.代码如下:

//抽象产品类	
public abstract  class operate {
    private double numA =0;
    private double numB =0;
  get,set省略
    public abstract  double getResult();
}
//具体产品类
public class Add extends operate {
    public double getResult(){
        return  getNumA()+getNumB();
    }
}
public class Mul extends operate {
    public double getResult(){
        return  getNumA()*getNumB();
    }
}

//工厂接口类
public interface operateFacory {
    public operate  createOperate();

}
//具体产品工厂类
public class addFactory implements operateFacory {
    public operate  createOperate(){
        return  new Add();
    }
}
public class MulFactory implements operateFacory {
    public operate createOperate(){
        return  new Mul();
    }
}

//客户端类
public class Cilent {
    public static void main(String[] args){
        //operateFacory of = new AddFactory();
        operateFacory of = new MulFactory();
        operate  op = of.createOperate();
        op.setNumA(3);
        op.setNumB(10);
        System.out.println(op.getResult());
    }
}

抽象工厂方法

　　抽象工厂可以使得产品和具体工厂分离,不会出现在客户diamagnetic中.比如,员工和部门的增删改查,只知道员工和部门,但是不知道具体实现过程. DataAccess类 : 在这个类中选择实例化的接口. 如new SqlServerUser() IUser接口, 具体实现SqlServerUser类,AcessUSer类 IDepartment 接口,具体实现SQLServerDepartment类, AccessDepartment类

调用 User user = new User(); Iuser iu =DataAccess.CreateUser(); iu.Insert(user); IDepatment id =DataAccess.CreateDepartment(); id.Insert(dept); id.GetDepartment(1);

代理模式

为其他对象提供一个代理以控制对这个对象的访问客户端,实例化代理代理: 实例化被代理者,在代理中调用其方法,代理只是实例化和调用被代理类: 写方法(实际上的操作)

策略模式

定义策略类(抽象类,或接口): 多个具体策略类上下文类:构造方法(接受策略对象),上下文家口,根据策略对象,调用具体算法. 客户端,实例化上下文类(传入具体策略对象),调用上下文接口

模板模式

　　不变行为搬移到超类,去除之类中的重复代码

一个模板方法(相同的方法提取到父类中,一些不同的方法作为抽象方法) 子类具体实现上述模板方法.

原型模式

在一个方法中,定义复制方法,之后只new 一次,再往后,定义对象是第一个new拷贝过来的(注意深拷贝和浅拷贝)

单例模式

保证一个类仅有一个实例,并提供一个访问它的全局访问点. 1.singleton类, 构造方法,private(拒绝外界利用new创造实例的可能) 2.static GetInstance()方法,获取全局访问点. 该方法中, 实例不存在,new;存在,返回已有的. 注意多线程时候的单例,要双重锁定(实例化为创建时,再进行加锁处理.)

编写过程中的问题,

1.静态成员方法才可以被类直接调用.

2.''为char型,""为String型