设计模式初体验

看了下设计模式，谈谈自个的看法，和总结.望能指正其中理解不足之处:
理解并使用设计模式,能够培养我们良好的面向对象编程习惯,同时在实际应用中,可以如鱼得水,享受游刃有余的乐趣.
初学模式，看完之后总结以下几种：
一.行为模式
1.访问者(visitor)
针对对象群中的一些操作，在不改变对象结构的情况下，可以对对象进行操作.
比如有人类为抽象类，有欧洲人，亚洲人都继承自人类，现在要跟据不同的人进行打印他们的速度.
人类:
public abstract class Human implements Visiable{
private String name;//姓名
protected abstract void move();//移动
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
欧洲人:
public class EuropHuman extends Human {

public EuropHuman(){

}
public EuropHuman(String name){
this.setName(name);
}

@Override
protected void move() {
System.out.println("EuropHuman run number2");
}

public void accept(Visitor visitor) {
visitor.printMove(this);
}

public Human fetchName(Visitor visitor, String name) {
return visitor.getHuman(this, name);
}
}
亚洲人:
public class AsianHuman extends Human {

public AsianHuman(){

}

public AsianHuman(String name){
this.setName(name);
}

@Override
protected void move() {
System.out.println("AsianHuman run number1");
}

public void accept(Visitor visitor) {
visitor.printMove(this);
}

public Human fetchName(Visitor visitor, String name) {
return visitor.getHuman(this, name);
}
}
访问接口:
public interface Visitor {
public void accessHuman(List humanList);
public void printMove(Human human);
public Human printHuman(List humanList,String name);
public Human getHuman(Human human,String name);
}
定义可访问接口:
public interface Visiable {
public void accept(Visitor visitor);

public Human fetchName(Visitor visitor,String name);
}
访问接口具体实现类:
public class MyVisitor implements Visitor {

public void accessHuman(List humanList) {
for(Iterator iter = humanList.iterator();iter.hasNext();){
Human human = (Human)iter.next();
human.accept(this);
}
}

public void printMove(Human human) {
human.move();
}

public Human printHuman(List humanList, String name) {
Human curHuman = null;
for(Iterator iter=humanList.iterator();iter.hasNext();){
Human human = (Human)iter.next();
curHuman = getHuman(human,name);
if(curHuman != null){
break;
}
}
return curHuman;
}

public Human getHuman(Human human, String name) {
Human curHuman = null;
if(name.equals(human.getName())){
curHuman = human;
}
return curHuman;
}

}
测试:
public class TestVisitor {

/**
* @param args
*/
public static void main(String[] args) {
Human eHuman = new EuropHuman("jak");
Human aHuman = new AsianHuman("jim");
List l = new ArrayList();
l.add(eHuman);
l.add(aHuman);
Visitor v = new MyVisitor();
v.accessHuman(l);
Human h = v.printHuman(l, "h");
System.out.println(h);
}

}
总结:访问者模式总要是要定义访问接口以及被访问接口，并且具体的类必须实现被访问接口才能进行访问模式的操作，访问模式可以在不改变类的基本结构下进行对各个类的操作。
但是这样类就要依赖于接口，而且如果要增加一个新的操作时，要同时增加访问接口与被访问接口以及类的接口实现。上例中EuropHuman和AsianHuman都实现了被访问接口accept，
访问接口定义了具体的访问方式方法accessHuman,并实现了具体的访问方式printMove().这样如果新增一个查找姓名的方法，那么就要在访问接口新增一个具体的访问方法printHuman
并且要增加具体的访问方式getHuman，而且增加被访问接口方法fetchName，且每个类要实现该接口方法，比较烦锁。但是类的结构确实没有改变。

2.策略模式(strategy)

策略模式主要是把一些方法进行抽象，具体的实现方法由各个扩展类实现。可以在一些算法上进行这种操作.
比如有一台计算器，有不同的算法，根据不同的算法实现的结果也不一样:
计算器抽象类:
public abstract class Computer {
public abstract Float compute(Float a,Float b);
}
加法实现类:
public class Computer1 extends Computer {

@Override
public Float compute(Float a, Float b) {

return a+b;
}

}
减法实现类:
public class Computer2 extends Computer {

@Override
public Float compute(Float a, Float b) {

return a-b;
}

}
类的封装
public class ComputerFatory {
public static final Computer computer1= new Computer1();
public static final Computer computer2= new Computer2();
}
测试:
public class TestComputer {

/**
* @param args
*/
public static void main(String[] args) {
Float a = new Float(2);
Float b = new Float(3);
Float c = ComputerFatory.computer1.compute(a, b);
System.out.println(c);
c = ComputerFatory.computer2.compute(a, b);
System.out.println(c);
}

}
总结:策略模式总要是把一些类的共同特征进行抽象，获取时可以根据具的体实现进行调用。

3.observer(观察者)
观察者模式主要是对模型的某种变化，做出反应（主要是更新）。在java api中就有实现该模式的接口Java.util.Observer
比如:有一产品，如果该产品在设置产品名称和价格时，观察都能作出及时反应。
产品变化观察者:(要实现observer接口):
public class NameObserver implements Observer {

public void update(Observable arg0, Object arg1) {
if(arg1 instanceof String){
System.out.println("product name is change to " + arg1);
}else if(arg1 instanceof Float){
System.out.println("product price is change to " + arg1);
}
}
}
产品(要继承可观察类):
public class Product extends Observable {
private String name;
private Float price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
this.setChanged();
this.notifyObservers(name);
}
public Float getPrice() {
return price;
}
public void setPrice(Float price) {
this.price = price;
this.setChanged();
this.notifyObservers(price);
}

}
测式:
public class TestObserer {

/**
* @param args
*/
public static void main(String[] args) {
Product product = new Product();
NameObserver no = new NameObserver();
product.addObserver(no);
product.setName("jack");
product.setPrice(new Float(212));
}

}
总结:对于被观察者发生的变化，观察者能做出及时的反馈，这个对于 MVC设计时，模型的变化能及时通知视图相应的调整，这个许可以借鉴.

二.结构模式

1.facade(外观模式)
这种模式应该是比较经常使用的模式，也讲我们正在使用这种模式，但并没有感觉到在使用。这种模式，主要是定义各个不变的部分提取出来定义一个接口为组件提供
一致的界面操作。
例如：有一个数据库操作类，定义接口DAO,并定义其具体实现类DAOImpl，在定义服务类时也可定义接口BMO及其实现类BMOImpl，并在实现类中定义DAO,示例如下:
DAO接口:
public interface ProductDAO {
public List queryProduct();
}
DAOImpl实现类:
public class ProductDAOImpl implements ProductDAO {

public List queryProduct() {
//do some db query;
List list = new ArrayList();
return list;
}

}

BMO接口:
public interface ProductBMO {
public List queryProduct();
}
BMOImpl实现类:
public class ProductBMOImpl implements ProductBMO {
private ProductDAO productDAO;

public List queryProduct() {
return productDAO.queryProduct();
}
public ProductDAO getProductDAO() {
return productDAO;
}
public void setProductDAO(ProductDAO productDAO) {
this.productDAO = productDAO;
}

}
测实类:
public class TestFacade {



public static void main(String[] args){
ProductDAO DAO = new ProductDAOImpl();
ProductBMOImpl bmo = new ProductBMOImpl();
bmo.setProductDAO(DAO);
List list = bmo.queryProduct();
System.out.println(list==null);
}
}

总结：对于这种操作最好可以结合spring注入操作，这样可以使代码看起来更流畅。

2.proxy(代理模式)
代理模式，就是在访问操作真正的类时，有经过一个限制的类，比如访问数据操作时，可能要涉及到权限等操作，这时可以使用代理模式。代理就是在源地址和目标地址中间有个中间
的操作。
比如:有一个设置姓名的数据操作，在设置姓名时要限制操作，如果有设置的操作权限才可进行操作.
数据库操作接口:
public interface Form {
public void setName(String name)throws Exception;
}
数据库操作类:
public class DBForm implements Form {

public void setName(String name) {
System.out.println("here is set the name" + name + " on database");
}

}
操作类的代理类:
public class FromProxy implements Form {
private Form dbForm;
private Permission permistion;
private Authorization authorization;

public FromProxy(Form dbForm,Permission permission,Authorization authorization){
this.dbForm = dbForm;
this.permistion = permission;
this.authorization = authorization;
}

public void setName(String name) throws Exception{
if(permistion.checkManagerPermission(authorization)){
dbForm.setName(name);
}else{
throw new Exception("没有足够权限!!!");
}
}

}
权限控制类:
public class Permission {
public static final int SYS_MANAGER = 1;
public static final int SYS_OPERATER = 2;
public static final int SYS_GUEST = 3;

public boolean checkManagerPermission(Authorization authorizatinon){
if(authorizatinon.getOperationId() == SYS_MANAGER){
return true;
}
return false;
}
}
权限设置类:
public class Authorization {
private int operationId;

public int getOperationId() {
return operationId;
}

public void setOperationId(int operationId) {
this.operationId = operationId;
}
}
测试:
public class TestProxy {

public static void main(String[] args){
Authorization author = new Authorization();
author.setOperationId(1);
Form dbForm = new DBForm();
Permission permission = new Permission();
FromProxy formProxy = new FromProxy(dbForm,permission,author);
try {
formProxy.setName("jim");
} catch (Exception e) {
e.printStackTrace();
}
}
}

以上是直接通过代理类进行设置访问，其实可以把这个代理类提升到代理工厂，如果要访问这个操作类（不是操作方法）要先有权限操作.
可以增加如下:
操作类实现工厂:
public class FormFactory {
public static Form formProxy = new DBForm();

public static Form createInstance(){
return formProxy;
}
}
操作类工厂代理:
public class FormFactoryProxy {
private Permission permissionl;
private Authorization authorization;

public FormFactoryProxy(Permission permissionl,Authorization authorization){
this.permissionl = permissionl;
this.authorization = authorization;
}

public Form createInstance() throws Exception{
if(this.permissionl.checkManagerPermission(authorization)){
Form dbForm = FormFactory.createInstance();
return new FromProxy(dbForm,permissionl,authorization);
}else{
throw new Exception("没有足够权限!!!");
}
}
}
测试:
public class TestProxy {

public static void main(String[] args){
Authorization author = new Authorization();
author.setOperationId(1);
Form dbForm = new DBForm();
Permission permission = new Permission();
// FromProxy formProxy = new FromProxy(dbForm,permission,author);
// try {
// formProxy.setName("jim");
// } catch (Exception e) {
// e.printStackTrace();
// }


FormFactoryProxy formFactoryProx = new FormFactoryProxy(permission,author);
try {
formFactoryProx.createInstance().setName("jackson");
} catch (Exception e) {
e.printStackTrace();
}
}
}
总结:对于代理类在权限设置这块可以使用到。平时在限制操作时，指在操作间类型有防火墙操作时可使用代理模式.

三.创建模式

1.facotry 工厂模式
平时使用对象一般都是用new Object(),工厂模式就是在创建对象时可以直接从工厂中取出，而且工厂可以控制对象是singleton的还是非singleton的。
比如:有一接口实现类完成数据操作，这个类可以由工厂获取
接口:
public interface ClassDAO {
public void doIt();
}
接口实现类:
public class ClassDAOEUImpl implements ClassDAO {

public void doIt() {
System.out.println("do it in europon!!!");
}

}
工厂类:(这里用动态生成实例)

public class MyFactory {
private static final String CLASS_NAME = "com.lins.designMode.factory.ClassDAOEUImpl";

public static ClassDAO getClassDAO(){
//ClassDAO clazzDAO = new ClassDAOZHImpl();

Class<ClassDAO> clazz = null;
ClassDAO clazzDAO = null;
try {
clazz = (Class<ClassDAO>) Class.forName(CLASS_NAME);
clazzDAO = (ClassDAO) clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}

return clazzDAO;
}
}
测试类:
public class TestFacotry {

/**
* @param args
*/
public static void main(String[] args) {
ClassDAO classDAO = MyFactory.getClassDAO();
classDAO.doIt();
}

}
总结:工厂模式主要是从工厂中取出相应的实例，而不要随时随地的生成实例。

2.builder(建造者)
建造者模式，是在一个方法要完成比较多的工作时，可以把这些工作各个分开，可以定义一个接口来分工这些工作，然后定义一个组织者把这些工作进行整合，最终完成成品.
比如：要建造一部汽车，这个是要花费大量的工序，我们定义一个接口来完成这些工序，最后再定义一个组织者把这些工序整合起来，完成一个成品。
构建者接口:
public interface Builder {
public void buildWheel();//建造轮子
public void buildDirect();//建造方向盘
public void buildOutSide();//建壳子
public void buildOthers();//其它

public Car getCar();//取得结果
}
构建者实现类:
public class MyBuilder implements Builder {

public void buildDirect() {
System.out.println("buildDirect");
}

public void buildOthers() {
System.out.println("buildOthers");
}

public void buildOutSide() {

System.out.println("buildOutSide");
}

public void buildWheel() {
System.out.println("buildWheel");

}

public Car getCar() {
Car car = new Car();
return car;
}

}
汽车:
public class Car {
public Car(){
System.out.println("this is a car!!!");
}
}
组织者:
public class Director {
private Builder builder;

public void setBuilder(Builder builder) {
this.builder = builder;
}

public void constructor(){
this.builder.buildWheel();
this.builder.buildDirect();
this.builder.buildOutSide();
this.builder.buildOthers();
}
}
测试:
public class TestMyBuilder {

/**
* @param args
*/
public static void main(String[] args) {
Builder builder = new MyBuilder();
Director director = new Director();
director.setBuilder(builder);
director.constructor();
Car car = builder.getCar();
}

}
总结:在对一个方法中有许多复杂操作时，可以把各个操作分开以减少藕合度，可以使用构建者模式。
3.singleton单态
单态的意思是指，只实例化对象一次
有两种形式:
public class MySingleton {
private static ClassA clazzA = new ClassA();//第一种
private static ClassA classA = null;//第二种

public static ClassA getInstance(){//第一种
return clazzA;
}

public static ClassA getInstance2(){//第二种
if(classA == null){
classA = new ClassA();
}
return classA;
}
}
各人平时比较多用第二种。

总结：对于只要使用一次的实例，可以考虑用单态的，在spring中也有关于此类bean的实例 singleton="true" 或 scope="singleton".