程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 講授Java設計形式編程中的建造者形式與原型形式

講授Java設計形式編程中的建造者形式與原型形式

編輯:關於JAVA

講授Java設計形式編程中的建造者形式與原型形式。本站提示廣大學習愛好者:(講授Java設計形式編程中的建造者形式與原型形式)文章只能為提供參考,不一定能成為您想要的結果。以下是講授Java設計形式編程中的建造者形式與原型形式正文


建造者形式
界說
又叫生成器形式,它可以將龐雜對象的建造進程籠統出來(籠統種別),使這個籠統進程的分歧完成辦法可以結構出分歧表示(屬性)的對象。

當創立龐雜對象的算法應當自力於該對象的構成部門時,並且結構進程必需許可被結構的對象有分歧的表現時。我們可以斟酌應用建造者形式。

完成

 

1. Builder為創立一個Product對象的各個部件指定籠統接口。平日包括創立產物和前往產物的籠統辦法,也能夠是詳細辦法,把創立進程放到ConcreteBuilder類中。
2. ConcreteBuilder 完成Builder的接口以結構和拆卸該產物的各個部件。
3. Director擔任挪用恰當的建造者來組建產物,導演類普通不與產物類產生依附關系,與導演類直接交互的是建造者類。
4. Product表現被結構的龐雜對象。ConcreateBuilder創立該產物的外部表現並界說它的拆卸進程。

/** "Product" */ 
 class Pizza { 
  private String dough = ""; 
  private String sauce = ""; 
  private String topping = ""; 
  
  public void setDough (String dough)   { this.dough = dough; } 
  public void setSauce (String sauce)   { this.sauce = sauce; } 
  public void setTopping (String topping) { this.topping = topping; } 
 } 
  
  
 ''/** "Abstract Builder" */'' 
 abstract class PizzaBuilder { 
  protected Pizza pizza; 
  
  public Pizza getPizza() { return pizza; } 
  public void createNewPizzaProduct() { pizza = new Pizza(); } 
  
  public abstract void buildDough(); 
  public abstract void buildSauce(); 
  public abstract void buildTopping(); 
 } 
  
 /** "ConcreteBuilder" */ 
 class HawaiianPizzaBuilder extends PizzaBuilder { 
  public void buildDough()  { pizza.setDough("cross"); } 
  public void buildSauce()  { pizza.setSauce("mild"); } 
  public void buildTopping() { pizza.setTopping("ham+pineapple"); } 
 } 
  
 /** "ConcreteBuilder" */ 
 class SpicyPizzaBuilder extends PizzaBuilder { 
  public void buildDough()  { pizza.setDough("pan baked"); } 
  public void buildSauce()  { pizza.setSauce("hot"); } 
  public void buildTopping() { pizza.setTopping("pepperoni+salami"); } 
 } 
  
  
 ''/** "Director" */'' 
 class Waiter { 
  private PizzaBuilder pizzaBuilder; 
  
  public void setPizzaBuilder (PizzaBuilder pb) { pizzaBuilder = pb; } 
  public Pizza getPizza() { return pizzaBuilder.getPizza(); } 
  
  public void constructPizza() { 
   pizzaBuilder.createNewPizzaProduct(); 
   pizzaBuilder.buildDough(); 
   pizzaBuilder.buildSauce(); 
   pizzaBuilder.buildTopping(); 
  } 
 } 
  
 /** A customer ordering a pizza. */ 
 class BuilderExample { 
  public static void main(String[] args) { 
   Waiter waiter = new Waiter(); 
   PizzaBuilder hawaiian_pizzabuilder = new HawaiianPizzaBuilder(); 
   PizzaBuilder spicy_pizzabuilder = new SpicyPizzaBuilder(); 
  
   waiter.setPizzaBuilder ( hawaiian_pizzabuilder ); 
   waiter.constructPizza(); 
  
   Pizza pizza = waiter.getPizza(); 
  } 
 } 

客戶創立Director對象,並用它所想要的Builder對象停止設置裝備擺設。Director獲得客戶的要求創立產物,最初獲得產物。

長處
1. 可以對結構對象的進程停止精致的掌握,以發生分歧的產物對象。
2. 便於擴大,有新的產物時,只需增長新的ConcreteBuilder 便可以完成。

相干形式
籠統工場形式與生成器類似,由於它也能夠創立龐雜對象。重要的差別是生成器形式側重於一步步結構一個龐雜對象。而籠統工場形式側重於多個系列的產物對象(簡略的或是龐雜的)。
生成器在最初的一步前往產物,而關於籠統工場來講,產物是立刻前往的。

 


原型形式
界說
原型形式是創立型形式的一種,其特色在於經由過程“復制”一個曾經存在的實例來前往新的實例,而不是新建實例。被復制的實例就是我們所稱的“原型”,這個原型是可定制的。
原型形式多用於創立龐雜的或許耗時的實例,由於這類情形下,復制一個曾經存在的實例使法式運轉更高效;或許創立值相等,只是定名紛歧樣的同類數據。

完成

1. Client - 創立一個新的對象,然後經由過程clone獲得別的一個對象。
2. Prototype - 界說一個clone本身的籠統辦法。
3. ConcretePrototype - 完成clone辦法。

public interface Prototype { 
  public abstract Object clone ( ); 
} 
 
  
 
public class ConcretePrototype implements Prototype { 
  public Object clone() { 
    return super.clone(); 
  } 
} 
 
public class Client { 
 
  public static void main( String arg[] )  
  { 
    ConcretePrototype obj1= new ConcretePrototype (); 
    ConcretePrototype obj2 = ConcretePrototype)obj1.clone(); 
  } 
 
} 

實例
1. 游戲中許多元素都是反復的,我們可使用原型形式復制雷同的元素。
2. 制造數據圖表時,第一次我們須要從數據庫讀取數據保留到對象中,當須要制造雷同數據的其他圖表時,應用原型形式可以免從新讀取數據庫。

相干成績和完成
1. 假如須要創立的原型數量不固定,可以創立一個原型治理器,在復制原型對象之前,客戶端先在原型治理器中檢查
能否存在知足前提的原型對象,假如有,則直接應用,假如沒有,克隆一個,這類稱作掛號情勢的原型形式。
2. 復制有兩種:深復制和淺復制。淺復制時,復制對象和原型對象同享對象一切的外部變量,兩個對象具有一樣的內存空間和性命周期。對原型對象的修正同時也修正了它的復成品,反之亦然。

java中只需完成Cloneable接口便可以挪用Object類的clone辦法完成淺復制:

public class ShallowClone implements Cloneable { 
  int age; 
  Person person; 
   
  public void setAge(int age){ 
    this.age = age; 
  } 
   
  public void setPerson(String name){ 
    person = new Person(name); 
  } 
   
  public Object clone() throws CloneNotSupportedException{ 
    // 默許java完成的是淺復制 
    return super.clone(); 
  } 
} 
 
public class Person { 
  String name; 
  public Person(String name){ 
    this.name = name; 
  } 
} 
 
public class Test { 
  public static void main(String[] args) throws CloneNotSupportedException { 
    ShallowClone oldShallowClone = new ShallowClone(); 
    oldShallowClone.setAge(20); 
    oldShallowClone.setPerson("eric"); 
    System.out.println("oldname: " + oldShallowClone.person.name + " age: " + oldShallowClone.age); 
     
    ShallowClone newShallowClone = (ShallowClone)oldShallowClone.clone(); 
    System.out.println("newname: " + newShallowClone.person.name + " age: " + newShallowClone.age); 
     
    oldShallowClone.age = 30; 
    oldShallowClone.person.name = "frank"; 
    System.out.println("newname: " + newShallowClone.person.name + " age: " + newShallowClone.age); 
  } 
} 

輸入:

oldname: eric age: 20
newname: eric age: 20
newname: frank age: 20

可見淺復制復制的是對象的援用,當轉變對象的值時,復制後的對象也會轉變,而java的根本類型是復制的值。

上面我們完成深復制:

public class DeepClone { 
  int age; 
  Person person; 
   
  public void setAge(int age){ 
    this.age = age; 
  } 
   
  public void setPerson(String name){ 
    person = new Person(name); 
  } 
   
  public DeepClone(DeepClone deepClone){ 
    this.age = deepClone.age; 
    this.person = new Person(deepClone.person.name); 
  } 
   
  public DeepClone() {} 
 
  public Object clone() throws CloneNotSupportedException{ 
    return new DeepClone(this); 
  } 
} 
 
public class Test { 
  public static void main(String[] args) throws CloneNotSupportedException { 
    DeepClone oldDeepClone = new DeepClone(); 
    oldDeepClone.setAge(20); 
    oldDeepClone.setPerson("eric"); 
    System.out.println("oldname: " + oldDeepClone.person.name + " age: " + oldDeepClone.age); 
     
    DeepClone newDeepClone = (DeepClone)oldDeepClone.clone(); 
    System.out.println("newname: " + newDeepClone.person.name + " age: " + newDeepClone.age); 
     
    oldDeepClone.age = 30; 
    oldDeepClone.person.name = "frank"; 
    System.out.println("newname: " + newDeepClone.person.name + " age: " + newDeepClone.age); 
  } 
} 

輸入:

oldname: eric age: 20
newname: eric age: 20
newname: eric age: 20

下面的復制辦法中,我們從新創立了一個對象,而且從新創立了援用,完成了深度復制。

長處
1. 復制比new機能更好。
2. 簡化或許隱蔽創立對象的細節,直接復制。

 

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved