语源科技BlogJava-生活的理想是为了理想的生活

设计模式之单态模式(Singleton)

杨显华 — Tue, 18 Sep 2007 03:41:00 GMT

什么是单态模式,其实很简单,就是让一个对象只能生成一个实例.Singleton的目的就是控制对象的产生.Singleton一般应用在资源访问,数据库连接等只需(能)有一个实例的地方.单态模式的设计就是完成一个对象是否存在并且是否需要创建的问题:
实例:
/**
* yangxh_520@yahoo.com.cn
* @author mymy5
* 2007.09.18
*/
//设计模式的构造有好几种方式它们有各自的优缺点
(1)第一种形式,此种方法使用了static 需要放弃同步

package cn.yxh.shejimoshi.singleton;

public class MySingleton {
public void printTxt(){
System.out.println("单态模式1");
}
private static MySingleton _instance = new MySingleton(); //注意为private仅供内部调用
private MySingleton(){//构造对象
}
public static MySingleton getInstance(){
return _instance;
}

}
(2)第二种形式,使用同步关键字synchronized
使用synchronized 如果是多个线程,会消耗很大内存,并且有可能造成瓶颈

package cn.yxh.shejimoshi.singleton;

public class MySingleton2 {
private static MySingleton2 _instance;
public void printTxt(){
  System.out.println("单态模式2");
}
public static synchronized MySingleton2 getInstance(){
  if(_instance==null){
   _instance = new MySingleton2();
  }
  return _instance;
}
}
(3)使用比较多人用的Double-checked locking

package cn.yxh.shejimoshi.singleton;

public class MySingleton3 {
private static MySingleton3 _instance;
public void printTxt(){
  System.out.println("单态模式3");
}
public static MySingleton3 getInstance(){
  if(_instance==null){
   synchronized(MySingleton3.class){
    if(_instance==null){
     _instance = new MySingleton3();
    }

   }
  }
     return _instance;
}
}

杨显华 2007-09-18 11:41 发表评论

设计模式之原型模式(Prototype)

杨显华 — Tue, 18 Sep 2007 01:42:00 GMT

原型模式就是通过一个对象创建另一个对象,简单的理解就是复制一个对象,至于复制的细节不需要去了解
而Java使用Cloneable接口的Clone方法实现对象复制,所以要实现Cloneable接口
实例:
/**
* yangxh_520@yahoo.com.cn
* @author mymy5
* 2007.09.18
*/
(1)抽象类AbstractClassClone () 实现Cloneable接口

package cn.yxh.shejimoshi.Prototype;

public class AbstractClassClone implements Cloneable{
String spoonName;

public String getSpoonName() {
return spoonName;
}

public void setSpoonName(String spoonName) {
  this.spoonName = spoonName;
}
public Object clone() throws CloneNotSupportedException
{
  Object object = null;
  object = super.clone();
  //Cloneable object = new AbstractClassClone(); 生成clone对象的另外一种方法 return object
  return object;
}
}
(2)抽象类的实现AbstractClassCloneImpl

package cn.yxh.shejimoshi.Prototype;

public class AbstractClassCloneImpl extends AbstractClassClone {
public AbstractClassCloneImpl(){
this.setSpoonName("工厂模式--原型(prototype)");
}
}
(3)工厂类FactoryForClone

package cn.yxh.shejimoshi.Prototype;

public class FactoryForClone {
public AbstractClassClone getInstance(){
return new AbstractClassCloneImpl();
}
}

(4)测试类Test

package cn.yxh.shejimoshi.Prototype;

public class Test {

public static void main(String[] args) throws CloneNotSupportedException {
  FactoryForClone factory = new FactoryForClone();
  AbstractClassClone test = factory.getInstance();
  AbstractClassCloneImpl test2 = (AbstractClassCloneImpl)test.clone();
  System.out.println(test2.spoonName);
  }
}

}

杨显华 2007-09-18 09:42 发表评论

设计模式之工厂模式(Factory)

杨显华 — Tue, 18 Sep 2007 01:21:00 GMT

工厂模式是在实际应用中采用的模式.所谓工厂模式,在形式上就是代替了我们平时所使用的New操作,把由New生成对象的操作交由工厂完成,这样做的最大好处是达到上层应用和下层具体实现解耦的目的.
实例:
/**
* yangxh_520@yahoo.com.cn
* @author mymy5
* 2007.09.18
*/
(1)抽象类AbstactClassTest

package cn.yxh.shejimoshi.factory;

public abstract class AbstactClassTest {
public void printSomething(){};//抽象方法,打印什么
}
(2)抽象类的实现类AbstactClassTestImpl

package cn.yxh.shejimoshi.factory;

public class AbstactClassTestImpl extends AbstactClassTest {
public void printSomething(){ //实现抽象类的抽象方法
System.out.println("工厂模式--抽象方法实现类打印!");
};

}
(3)抽象工厂InterfaceTest ,用来生成具体的工厂

package cn.yxh.shejimoshi.factory;

public interface InterfaceTest {
public AbstactClassTest instance(); //抽象方法
}

(4)工厂的具体实现类InterfaceTestImple

package cn.yxh.shejimoshi.factory;

public class InterfaceTestImple implements InterfaceTest {

public AbstactClassTest instance() { //抽象方法的实现,负责对象的生成
return new AbstactClassTestImpl();
}

}

(4)测试类Test

package cn.yxh.shejimoshi.factory;

public class Test {

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  InterfaceTest i = new InterfaceTestImple(); //生成工厂
  AbstactClassTest a= i.instance();                 //工厂生成对象
  a.printSomething();

  Class c = Class.forName("cn.yxh.shejimoshi.factory.AbstactClassTestImpl"); //生成对象的其他方法
  System.out.println(c.getName());
  AbstactClassTestImpl asd = (AbstactClassTestImpl)c.newInstance();                //使用class的newInstance来生成方法
  asd.printSomething();

}
}
先生成工厂,用工厂生成对象,用到的始终是对象的抽象类,当改写下层实现时不影响上层使用,

杨显华 2007-09-18 09:21 发表评论