亚洲精品私拍国产福利在线,国产gv天堂亚洲国产gv刚刚碰,国外亚洲成AV人片在线观看

设计模式�Q�结构模式之Bridge

Sun — Mon, 04 Jun 2007 07:33:00 GMT

Bridge�Q�沟通着功能的类层次和实现的�c�d��?br>功能的类层次�Q�A实现了一些功�?要扩展A��q��承生成一个a �q�种��Z��新增功能而徏立的�c�d��ơ称为功能的�c�d��?br>实现的类层次�Q�抽象类AB ab�c�d��现AB�c?�q�里不是��Z��新增功能 �q�种�U�Cؓ实现的类层次
例如,一杯咖啡�ؓ�?有中杯和大杯之分,同时�q�有加奶不加奶之�? 如果用单�U�的�l�承,�q�四个具体实�?中杯大杯加奶不加�?之间有概念重�?因�ؓ有中杯加�?也有中杯不加�? 如果再在中杯�q�一层再实现两个�l�承,很显然�؜�?扩展性极�?那我们��用Bridge模式来实现它.
如何实现?
以上面提到的咖啡 ��Z��. 我们原来打算只设计一个接�?抽象�c?,使用Bridge模式�?我们需要将抽象和行为分开,加奶和不加奶属于行�ؓ,我们��它们抽象成一个专门的行�ؓ接口.
�E�序举例�Q?br>

先看看抽象部分的接口代码:

public abstract class Coffee
{
　　CoffeeImp coffeeImp;

　　public void setCoffeeImp() {
　　　　this.CoffeeImp = CoffeeImpSingleton.getTheCoffeImp();
　　}

　　public CoffeeImp getCoffeeImp() {return this.CoffeeImp;}

　　public abstract void pourCoffee();
}

其中CoffeeImp 是加不加奶的行�ؓ接口,看其代码如下:

public abstract class CoffeeImp
{
　　public abstract void pourCoffeeImp();
}

现在我们有了两个抽象�c?span lang=EN-US>,下面我们分别对其�q�行�l�承,实现concrete class:

//中杯
public class MediumCoffee extends Coffee
{
　　public MediumCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯�q�是大杯 ,重复2�ơ是中杯
　　　　for (int i = 0; i < 2; i++)
　　　　{

　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}

//大杯
public class SuperSizeCoffee extends Coffee
{
　　public SuperSizeCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯�q�是大杯 ,重复5�ơ是大杯
　　　　for (int i = 0; i < 5; i++)
　　　　{

　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}

上面分别是中杯和大杯的具体实�?span lang=EN-US>.下面再对行�ؓCoffeeImp�q�行�l�承:

//加奶
public class MilkCoffeeImp extends CoffeeImp
{
　　MilkCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　System.out.println("加了��味的牛�?);
　　}
}

//不加�?br>public class FragrantCoffeeImp extends CoffeeImp
{
　　FragrantCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　System.out.println("什么也没加,清香");
　　}
}

Bridge模式的基本框架我们已�l�搭好了,别忘记定义中�q�有一�?动态结�?我们现在可以喝到臛_��四种咖啡:
1.中杯加奶
2.中杯不加�?br>3.大杯加奶
4.大杯不加�?o:p>

看看是如何动态结合的,在��用之�?我们做个准备工作,设计一个单态类(Singleton)用来hold当前的CoffeeImp:

public class CoffeeImpSingleton
{
　　private static CoffeeImp coffeeImp;

　　public CoffeeImpSingleton(CoffeeImp coffeeImpIn)
　　 {this.coffeeImp = coffeeImpIn;}

　　public static CoffeeImp getTheCoffeeImp()
　　{
　　　　return coffeeImp;
　　}
}

看看中杯加奶和大杯加�?是怎么出来�?span lang=EN-US>:

//拿出牛奶
CoffeeImpSingleton coffeeImpSingleton = new CoffeeImpSingleton(new MilkCoffeeImp());

//中杯加奶
MediumCoffee mediumCoffee = new MediumCoffee();
mediumCoffee.pourCoffee();

//大杯加奶
SuperSizeCoffee superSizeCoffee = new SuperSizeCoffee();
superSizeCoffee.pourCoffee();

注意: Bridge模式的执行类如CoffeeImp和Coffee是一对一的关�p? 正确创徏CoffeeImp是该模式的关�?

Sun 2007-06-04 15:33 发表评论

设计模式�Q�结构模式之Decorator(�Ҏ��?

Sun — Mon, 04 Jun 2007 07:09:00 GMT

Decorator定义:
动态给一个对象添加一些额外的职责,��p��在墙上刷�Ҏ��.使用Decorator模式相比用生成子�c�L��式达到功能的扩充昑־�更�ؓ灉|��.

��Z��么��?span lang=EN-US>Decorator?
我们通常可以使用�l�承来实现功能的拓展,如果�q�些需要拓展的功能的种�c�d��J�多,那么势必生成很多子类,增加�pȝ��的复杂�?同时,使用�l�承实现功能拓展,我们必须可预见这些拓展功�?�q�些功能是编译时��q��定了,是静态的.

使用Decorator的理由是:�q�些功能需要由用户动态决定加入的方式和时�?Decorator提供�?��x��即用"的方�?在运行期间决定何时增加何�U�功�?

�E�序举例�Q?br>Display.java:
public abstract class Display {
public abstract int getColumns(); // 取得横向的字�?/p>

public abstract int getRows(); // 取得直向的行�?/p>

public abstract String getRowText(int row); // 取得�W�row个字�?/p>

public final void show() { // 打印所有內�?br>  for (int i = 0; i < getRows(); i++) {
   System.out.println(getRowText(i));
  }
}
}
Border .java:
public abstract class Border extends Display {
    protected Display display;          // 指装饰外框里面的「內宏V�?�?
    protected Border(Display display) { // 在��生对象实例时�Q�以参数指定「內宏V�?br>        this.display = display;
    }
}

StringDisplay .java:
public class StringDisplay extends Display {
private String string; // 打印的字�?

public StringDisplay(String string) { // 以参数指定打印的字串
this.string = string;
}

public int getColumns() { // 字数
return string.getBytes().length;
}

public int getRows() { // 行数�?
return 1;
}

public String getRowText(int row) { // 仅在row�?时才�q�回
  if (row == 0) {
   return string;
  } else {
   return null;
  }
}
}

SideBorder.java:
public class SideBorder extends Border {
private char borderChar; // 装饰字符

public SideBorder(Display display, char ch) { // 以构造子指定Display和装饰字�W?
super(display);
this.borderChar = ch;
}

public int getColumns() { // 字数要再加上內容两边的装饰字�W?br> return 1 + display.getColumns() + 1;
}

public int getRows() { // 行数同內容的行数
return display.getRows();
}

public String getRowText(int row) { // 指定该行的內容即为在內容之指定行的两�?br> // 加上装饰字符

return borderChar + display.getRowText(row) + borderChar;
}
}

UpDownBorder .java:
public class UpDownBorder extends Border {
private char borderChar; // 装饰字符

public UpDownBorder(Display display, char ch) { // 以构造子指定Display和装饰字�W?br> super(display);
this.borderChar = ch;
}

public int getColumns() { // 字数同內容的字数
return display.getColumns();
}

public int getRows() { // 行数要再加上內容上下的装饰字�W�的行数
return 1 + display.getRows() + 1;
}

public String getRowText(int row) { // 指定该行的內�?br>  if (row == 0 || row == getRows() - 1) {
   return makeLine(borderChar, getColumns());
  } else {
   return display.getRowText(row - 1);
  }
}

private String makeLine(char ch, int count) { // 以字�W�ch�Q�徏立重复count�ơ的�q�箋字串
  StringBuffer buf = new StringBuffer();
  for (int i = 0; i < count; i++) {
   buf.append(ch);
  }
  return buf.toString();
}
}

Main.java:
public class Main {
    public static void main(String[] args) {
        Display b1 = new StringDisplay("Hello, world.");
        Display b2 = new UpDownBorder(b1, '-');
        Display b3 = new SideBorder(b2, '*');
        b1.show();
        b2.show();
        b3.show();
        Display b4 =
                    new FullBorder(
                        new UpDownBorder(
                            new SideBorder(
                                new UpDownBorder(
                                    new SideBorder(
                                        new StringDisplay("您好�?),
                                        '*'
                                    ),
                                    '='
                                ),
                                '|'
                            ),
                            '/'
                        )
                    );
        b4.show();
    }
}

注意�Q�display�l�承�c�M��的getRowText�Ҏ��
�q�个�Ҏ��把所有的用法都��集成��C��?

Sun 2007-06-04 15:09 发表评论

设计模式�Q�结构模式之Composite(�l�合)

Sun — Mon, 04 Jun 2007 03:41:00 GMT

Composite定义:
��对象以树�Ş�l�构�l�织��h��,以达�?#8220;部分�Q�整�?#8221; 的层�ơ结构，使得客户端对单个对象和组合对象的使用��h��一致�?

使用Composite
首先定义一个接口或抽象�c�，�q�是设计模式通用方式了，其他设计模式�Ҏ��口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和��理Composite�l�合体的对象们（或称部�gComponent�Q?

下面的代码是以抽象类定义�Q�一般尽量用接口interface,

public abstract class Equipment
{
　　private String name;
　　//�|�络��h��
　　public abstract double netPrice();
　　//折扣��h��
　　public abstract double discountPrice();
　　//增加部�g�Ҏ��　　
　　public boolean add(Equipment equipment) { return false; }
　　//删除部�g�Ҏ��
　　public boolean remove(Equipment equipment) { return false; }
　　//注意�q�里�Q�这里就提供一�U�用于访问组合体�cȝ��部�g�Ҏ��?br>　　public Iterator iter() { return null; }
　　
　　public Equipment(final String name) { this.name=name; }
}

抽象�c?span>Equipment��是Component定义�Q�代表着�l�合体类的对象们,Equipment中定义几个共同的�Ҏ��?/span>

public class Disk extends Equipment
{
　　public Disk(String name) { super(name); }
　　//定义Disk�|�络��h��?
　　public double netPrice() { return 1.; }
　　//定义了disk折扣��h��?.5 �Ҏ��?br>　　public double discountPrice() { return .5; }
}

Disk是组合体内的一个对象，或称一个部�Ӟ��q�个部�g是个单独元素( Primitive)�?br>�q�有一�U�可能是�Q�一个部件也是一个组合体�Q�就是说�q�个部�g下面�q�有'儿子'�Q�这是树形结构中通常的情况，应该比较�Ҏ��理解。现在我们先要定义这个组合体�Q?/span>

abstract class CompositeEquipment extends Equipment
{
　　private int i=0;
　　//定义一个Vector 用来存放'儿子'
　　private Lsit equipment=new ArrayList();

　　public CompositeEquipment(String name) { super(name); }

　　public boolean add(Equipment equipment) {
　　　　 this.equipment.add(equipment);
　　　　 return true;
　　 }

　　public double netPrice()
　　{
　　　　double netPrice=0.;
　　　　Iterator iter=equipment.iterator();
　　　　for(iter.hasNext())
　　　　　　netPrice+=((Equipment)iter.next()).netPrice();
　　　　return netPrice;
　　}

　　public double discountPrice()
　　{
　　　　double discountPrice=0.;
　　　　Iterator iter=equipment.iterator();
　　　　for(iter.hasNext())
　　　　　　discountPrice+=((Equipment)iter.next()).discountPrice();
　　　　return discountPrice;
　　}
　　

　　//注意�q�里�Q�这里就提供用于讉K��自己�l�合体内的部件方法�?br>　　//上面dIsk 之所以没有，是因为Disk是个单独(Primitive)的元�?
　　public Iterator iter()
　　{
　　　　return equipment.iterator() ;
　　{
　　//重蝲Iterator�Ҏ��
　　 public boolean hasNext() { return i　　//重蝲Iterator�Ҏ��
　　 public Object next()
　　 {
　　　　if(hasNext())
　　　　　　 return equipment.elementAt(i++);
　　　　else
　　　　　 throw new NoSuchElementException();
　　 }
　　

}

上面CompositeEquipment�l�承了Equipment,同时��己里面的对象们提供了外部讉K��的方�?重蝲了Iterator,Iterator是Java的Collection的一个接口，是Iterator模式的实�?

我们再看�?span>CompositeEquipment的两个具体类:盘盒Chassis和箱子Cabinet�Q�箱子里面可以放很多东西�Q�如底板�Q�电源盒�Q�硬盘盒�{�；盘盒里面可以放一些小讑֤��Q�如��盘软驱�{�。无疑这两个都是属于�l�合体性质的�?/span>

public class Chassis extends CompositeEquipment
{
　　 public Chassis(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

public class Cabinet extends CompositeEquipment
{
　　 public Cabinet(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

��x��我们完成了整�?span>Composite模式的架构�?/span>

我们可以看看客户端调�?span>Composote代码:

Cabinet cabinet=new Cabinet("Tower");

Chassis chassis=new Chassis("PC Chassis");
//��PC Chassis装到Tower�?(��盘盒装到箱子里)
cabinet.add(chassis);
//��一�?0GB的硬盘装�?PC Chassis (��硬盘装到盘盒里)
chassis.add(new Disk("10 GB"));

//调用 netPrice()�Ҏ��;
System.out.println("netPrice="+cabinet.netPrice());
System.out.println("discountPrice="+cabinet.discountPrice());

上面调用的方�?span>netPrice()或discountPrice()�Q�实际上Composite使用Iterator遍历了整个树形结�?��L��同样包含�q�个�Ҏ��的对象�ƈ实现调用执行.

Composite是个很��y妙体现智慧的模式�Q�在实际应用中，如果��到树�Ş�l�构�Q�我们就可以��试是否可以使用�q�个模式�?/span>

Sun 2007-06-04 11:41 发表评论

设计模式�Q�结构模式之Proxy(代理)

Sun — Mon, 04 Jun 2007 02:57:00 GMT

Proxy是比较有用途的一�U�模�?而且变种较多,应用场合覆盖从小�l�构到整个系�l�的大结�?Proxy是代理的意�?我们也许有代理服务器�{�概�?代理概念可以解释�?在出发点到目的地之间有一道中间层,意�ؓ代理.

设计模式中定�?/strong>: 为其他对象提供一�U�代理以控制对这个对象的讉K��.要用再徏�?br>�E�序举例1�Q�权限访�?br>

public class ForumProxy implements Forum {

private ForumPermissions permissions;
private Forum forum;
this.authorization = authorization;

public ForumProxy(Forum forum, Authorization authorization,
ForumPermissions permissions)
{
this.forum = forum;
this.authorization = authorization;
this.permissions = permissions;
}

.....

public void setName(String name) throws UnauthorizedException,
ForumAlreadyExistsException
{
　　//只有是系�l�或论坛��理者才可以修改名称
　　if (permissions.isSystemOrForumAdmin()) {
　　　　forum.setName(name);
　　}
　　else {
　　　　throw new UnauthorizedException();
　　}
}

...

}

�?span lang=EN-US>DbForum才是接口Forum的真正实�?以修改论坛名�U�Cؓ�?

public class DbForum implements Forum, Cacheable {
...

public void setName(String name) throws ForumAlreadyExistsException {

　　....

　　this.name = name;
　　//�q�里真正��新名称保存到数据库�?
　　saveToDb();

　　....
}

...

}

凡是涉及到对论坛名称修改�q�一事�g,其他�E�序都首先得和ForumProxy打交�?由ForumProxy军_��是否有权限做某一样事�?ForumProxy是个名副其实�?�|�关","安全代理�pȝ��".
�E�序举例2�Q�用到才创徏
实际执行打印 ��Z��模仿长时间操�?在构建的时候�g�q?S
public class Printer implements Printable {
private String name;

public Printer() {
  heavyJob("正在产生Printer的对象实�?);
}

public Printer(String name) { // 构造子
  this.name = name;
  heavyJob("正在产生Printer的对象实�?" + name + ")");
}

public void setPrinterName(String name) { // 命名
  this.name = name;
}

public String getPrinterName() { // 取得名称
  return name;
}

public void print(String string) { // 输出名称
  System.out.println("=== " + name + " ===");
  System.out.println(string);
}

private void heavyJob(String msg) { // 较重的工作（假设�Q?br>  System.out.print(msg);
  for (int i = 0; i < 5; i++) {
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
   }
   System.out.print(".");
  }
  System.out.println("完成�?);
}
}
代理�c�：真正要打��C��才去调用生成printer�q�且参数赋��D��行打印操�?br>public class PrinterProxy implements Printable {
private String name; // 名称

private Printable real; // 「本人�?/span>

private String className; // 「本人」的�c�d��U?/span>

public PrinterProxy(String name, String className) { // 构造子
  this.name = name;
  this.className = className;
}

public synchronized void setPrinterName(String name) { // 命名
  if (real != null) {
   real.setPrinterName(name); //「本人」也要命�?br>  }
  this.name = name;
}

public String getPrinterName() { // 取得名称
  return name;
}

public void print(String string) { // 输出到画面上
  realize();
  real.print(string);
}

private synchronized void realize() { // 产生「本人�?br>  if (real == null) {
   try {
    real = (Printable) Class.forName("Proxy." + className)
      .newInstance();
    real.setPrinterName(name);
   } catch (ClassNotFoundException e) {
    System.err.println("找不到类 " + className + "�?);
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}
}
无论怎么调用setPrinterName�Ҏ��都不会��生real实例只有真正需要生成本人的时候才会生�?br>��试�Ҏ��Q?br>public class Main {
public static void main(String[] args) {
  Printable p = new PrinterProxy("Alice", "Printer");
  System.out.println("现在的名�U�是" + p.getPrinterName() + "�?);
  p.setPrinterName("Bob");
//不会生成Printer
  System.out.println("现在的名�U�是" + p.getPrinterName() + "�?);
//不会生成Printer
  p.print("Hello, world.");
//生成Printer
}
}

Sun 2007-06-04 10:57 发表评论

设计模式�Q�创建模式之Singleton(单�?

Sun — Wed, 30 May 2007 02:11:00 GMT
Singleton应该说是�q�x��用的最多的一�U�模式之一
Singleton模式主要作用是保证在Java应用�E�序中，一个类Class只有一个实例存在�?br>一般Singleton模式通常有几�U��Ş�?

public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自�׃��个实例，是不是很奇怪？
　　//注意�q�是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//�q�里提供了一个供外部讉K��本class的静态方法，可以直接讉K��　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
//当程序第一�ơ调用getInstance的时候初始化Singleton �c?同时初始化static字段产生唯一的对象实�?br>}

�W�二�U��Ş�?span>:

public class Singleton {

　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　//�q�个�Ҏ��比上面有所改进�Q�不用每�ơ都�q�行生成对象�Q�只是第一�ơ　　　　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance�Q�new Singleton();
　　return instance; 　　}

}

使用Singleton.getInstance()可以讉K��单态类�?/span>

上面�W�二中�Ş式是lazy initialization�Q�也��是说第一�ơ调用时初始Singleton�Q�以后就不用再生成了�?/span>

注意�?span>lazy initialization形式中的synchronized�Q�这个synchronized很重要，如果没有synchronized�Q�那么��用getInstance()是有可能得到多个Singleton实例�?/span>

一般认为第一�U��Ş式要更加安全些�?/p>

Sun 2007-05-30 10:11 发表评论

设计模式�Q�创建模式之Builder

Sun — Wed, 30 May 2007 01:54:00 GMT

Builder模式定义:
��一个复杂对象的构徏与它的表�C�分��?使得同样的构��E�可以创��Z��同的表示.

Builder模式是一步一步创��Z��个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容��可以构建它�?用户不知道内部的具体构徏�l�节.Builder模式是非常类似抽象工厂模�?�l�微的区别大概只有在反复使用中才能体会到.

��Z��构建复杂对象的�q�程和它�?strong>部�g解�?注意: 是解�?strong>�q�程�?strong>部�g.

因�ؓ一个复杂的对象,不但有很多大量组成部�?如汽�?有很多部�?车轮方向�?发动��有各�U�小零�g�{�等,部�g很多,但远不止�q�些,如何��这些部件装配成一辆汽�?�q�个装配�q�程也很复杂(需要很好的�l�装技�?,Builder模式��是��Z��部件和�l�装�q�程分开.

首先,需要一个接�?它定义如何创建复杂对象的各个部�g:

public interface Builder {

　　//创徏部�gA　　比如创徏汽�R车轮
　　void buildPartA();
　　//创徏部�gB 比如创徏汽�R方向�?br>　　void buildPartB();
　　//创徏部�gC 比如创徏汽�R发动�?br>　　void buildPartC();

　　//�q�回最后组装成品结�?(�q�回最后装配好的汽�?
　　//成品的组装过�E�不在这里进�?而是转移��C��面的Director�c�M��q�行.
　　//从而实��C��解�?strong>�q�程�?strong>部�g
　　Product getResult();

}

�?span lang=EN-US>Director构徏最后的复杂对象,而在上面Builder接口中封装的是如何创��Z��个个部�g(复杂对象是由�q�些部�g�l�成�?,也就是说Director的内�Ҏ��如何��部件最后组装成成品:

public class Director {

　　private Builder builder;

　　public Director( Builder builder ) {
　　　　this.builder = builder;
　　}
　　// ��部件partA partB partC最后组成复杂对�?br>　　//�q�里是将车轮方向盘和发动机组装成汽�R的过�E?br>　　public void construct() {
　　　　builder.buildPartA();
　　　　builder.buildPartB();
　　　　builder.buildPartC();

　　}

Builder的具体实现ConcreteBuilder:
通过具体完成接口Builder来构建或装配产品的部�?
定义�q�明��它所要创建的是什么具体东�?
提供一个可以重新获取��品的接口:

public class ConcreteBuilder implements Builder {

　　Part partA, partB, partC;
　　public void buildPartA() {
　　　　//�q�里是具体如何构建partA的代�?br>
　　};
　　public void buildPartB() {
　　　　//�q�里是具体如何构建partB的代�?br>　　};
　　 public void buildPartC() {
　　　　//�q�里是具体如何构建partB的代�?br>　　};
　　 public Product getResult() {
　　　　//�q�回最后组装成品结�?br>　　};

}

ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct();
Product product = builder.getResult();

builder�c�d��Q?br>

Sun 2007-05-30 09:54 发表评论

设计模式�Q�创建模式之Prototype(原型)

Sun — Tue, 29 May 2007 07:43:00 GMT

复制产生对象实例�Q?br>使用Prototype模式可以理解�?nbsp; 创造出一个和已有对象一��L��对象
ex)指着面包店橱�H�里的面包告诉老板我就要这�?虽然不知道名�?也不知道做法但是能买到和所指的相同的东�ѝ�?br>实例�Q?br>1、定义一个接�?实现Cloneable
public interface Product extends Cloneable {
    public abstract void use(String s);
    public abstract Product createClone();
}
2、声明一个manage�c�L��Ҏ��Product的createClone来进行复�?br>public class Manager {
       private Hashtable showcase = new Hashtable();
    public void register(String name, Product proto) {
        showcase.put(name, proto);
    }
    public Product create(String protoname) {
        Product p = (Product)showcase.get(protoname);
        return p.createClone();
    }
}
3、Product�cȝ��一个具体实�?br>public class UnderlinePen implements Product {
    private char ulchar;
    public UnderlinePen(char ulchar) {
        this.ulchar = ulchar;
    }
    public void use(String s) {
        int length = s.getBytes().length;
        System.out.println("\"" + s + "\"");
        System.out.print(" ");
        for (int i = 0; i < length; i++) {
            System.out.print(ulchar);
        }
        System.out.println("");
    }
    public Product createClone() {
        Product p = null;
        try {
            p = (Product)clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }
}
4、具体��?br>     // 预备阶段
        Manager manager = new Manager();
        UnderlinePen upen = new UnderlinePen('~');
        MessageBox mbox = new MessageBox('*');
        MessageBox sbox = new MessageBox('/');
        manager.register("strong message", upen);
        manager.register("warning box", mbox);
        manager.register("slash box", sbox);

        // 实现产生
        Product p1 = manager.create("strong message");
        p1.use("Hello, world.");
        Product p2 = manager.create("warning box");
        p2.use("Hello, world.");
        Product p3 = manager.create("slash box");
        p3.use("Hello, world.");
    }

也可以将product声明成抽象类实现Cloneable接口
�q�且实现createClone�Ҏ��
�q�样子类中就不用再声明creatClone�Ҏ��?��化了代码

clone�Ҏ��在Object中定�?因此所有类都会�l�承clone()�Ҏ��
Cloneable�q�个接口表示可用clone()�Ҏ��q�行复制
clone()�Ҏ��做的是浅拯�� 所做的操作是直接复制字�D�内�?�q�不��该字段对应的对象实例内�?假定有一个数�l?当��用clone�Ҏ��q�行拯��以后复制的结果，只是对应到该数组的参�?��x��向该数组的内存地址如果惛_��深拷�?必须重写clone�Ҏ�� 记得要加上super.clone()

Sun 2007-05-29 15:43 发表评论

设计模式�Q�创建对象之Factory

Sun — Tue, 29 May 2007 07:12:00 GMT

Factory有两�U�理解方式，个�h感觉不太一��P��不知道哪�U�理解方式比较正��?br>1、引入Factory Pattern的目的是��Z��装�cȝ��实例化操�?br>

public class Factory{

　　public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装蝲装入�c�R�?br>　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

那么在你的程序中,如果要实例化Sample�?��׃��?o:p>

Sample sampleA=Factory.creator(1);

�q�样,在整个就不涉及到Sample的具体子�c?辑ֈ��装效果,也就减少错误修改的机�?�q�个原理可以用很通俗的话来比�?��是具体事情做得��多,��容易范错误

2、Factory Pattern在父�c�规定对象的创徏�Ҏ��Q�但不深入到具体的类名，所有具体的实现都放在了子类�Q�大致可以分��Z�生对象实例的大纲(框架)和实际��生对象实例的�c�M��斚w��

实例�Q?br>
framework中的Factory是实现creat的抽象类
public final Product creat(String owner) {
  Product p = creadProduct(owner);
  registerProduct(p);
  return p;
}

public abstract Product creadProduct(String owner);
famework中的Product是仅实现use�Ҏ��的抽象类

具体的生成和使用�Ҏ��都用idcard中的�c�d��体实�?br> IDcardFactory�Q?br> IDcardFactory extends Factory
public synchronized Product creadProduct(String owner) {
IDcard ic = new IDcard(owner);
return ic;
}

IDcarrd�Q?br>class IDcard extends Product
IDcard(String owner) {
System.out.println("建立" + owner +"的卡");
this.owner = owner;
}
此处构造函��C��是public 只有通过同一个包中的factory才可以��生这个对象实�?/p>

public void use() {
  System.out.println("使用" + owner + "的卡");
}

具体使用�Q?br> public static void main(String[] args) {
  Factory fc = new IDcardFactory();
  Product p1 = fc.creat("card1");
  Product p2 = fc.creat("card2");
  Product p3 = fc.creat("card3");
  p1.use();
  p2.use();
  p3.use();
}
�q�样不必修改framework包中的内容就能够创徏��Z��同的产品和工�?/p>

Sun 2007-05-29 15:12 发表评论