Java设计模式 -- 学习笔记

开始看设计模式了，javaeye 上的robbin 老大说,设计模式不是用来学的，而是用出来的，这点我赞同，今天看了下，发现以前自己有很多模式都用过了，现在做个总结，写了这个笔记：

设计模式解析：
1.工厂模式：对类实例化不要直接调用类，而要对接口，如：InterfaceA interface = new entityClass();
2.工厂方法：设计一个工厂来完成创建实例工作。如：
Factory a = new Factory("com.life.entityClass");
//工厂类：
Factory{
public static InterfaceType create(String url)
{
  Class c = Class.forName(url);
  InterfaceType type = (InterfaceType)c.newInstance();
  return type;
}
}
3.抽象工厂：一个类在实例化时要同里对他里面的类也进行实例化，此时可以把这一部分提取出来做为一个抽象工厂，如：
public abstract Facotory
{
abstract SampleInterface create(String url);
abstract SampleInterface2 create(String url);
}
//每个类生产出一套实例
public class SampleInterfaceA extends Factory
{
public SampleInterface create(String url)
{
  ....
  return SampleInterface;
}
public SampleInterface2 create(String url)
{
  ...
  return SampleInterface2;
}
}
//调用：Factory factory = new SampleInterfaceA(...);
4.prototype对象 (个人理解：对已有对象克隆)
//用在什么地方 ？＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
public class AbstractClass
{
//这个属性的作
private String childClassName;
public void setChildClassName(String childClassName){this.childClassName = childClassName;}
public String getChildClassName(){return this.childClassName;}
public Object clone()
{
  Object object = null;
  object = super.clone();
  return object;
}
}
//实现类
public class ChildClass extends abstractClass
{
public ChildClass()
{
  setChildClassName("childClass");
}
}
//具体调用:
AbstractClass ac = new ChildClass();
AbstractClass ac2 = ac.clone();
5.Build模式 : 一个对象是由多个部件组成，用Build模式可以实现表现和结构分离..（个人理解:把部件创建过和和实例化分离）
例：
public Interface BuildInterface
{
//创建头
void createHeader();
//创建身体
void createMain();
//创建脚
void createFooter();
//返回创建的实体
ProductInterface getResult();
}
//完成构建的类
public class EntityClass
{
private BuildInterface bi;
public EntityClass(BuildInterface buildInterface){this.bi = buildInterface;}
//所有的构建零部件在这里完成
public void create()
{
  bi.createHeader();
  bi.createMain();
  bi.createFooter();
}
}
public class EntityBuild implements BuildInterface
{
public void createHeader(){....} //实现创建头
public void createMain(){...} //实现创建身体
public void createFooter(){...} //实现创建脚
public ProductInterface getResult(){...} //返回实体
}
public Interface ProductInterface
{
....
}
//调用:
BuildInterface bi = new EntityBuild();
//这里可以把create方法也组织进一个类里,为什么还要分开写（这样好像就造成了代码冗余..每个类里都要写相同的方法）
EntityClass ec = new EntityClass(bi);
ec.create();
ProductInterface pi = bi.getResult();
6.singleton(单例模式)
//在应用程序中只能存在一个实例
例如：
public SingletonClass
{
private SingletonClass(){} //这个例子的妙处，不能用构造参数进行实例化
//只会被实例化一次
private static SingletonClass sc = new SingletonClass();
//得到实例
public static SingletonClass getInstance(){return sc;}
}
7.Facade ：为子系统提供一个统一的界面（个人理解：把相同的部分提取出来做成一个接口，子系统只需调用这个接口）
8.Proxy（代理模式） : 为其他对象提供一种代理以控制对这个对象的访问.(个人理解：不要直接操作对象，而是通过对另一对象的操作间接完成此操作)

注：有不对的地方请大家指出..
(未完。。。)