講解Java設(shè)計模式編程中的建造者模式與原型模式
建造者模式
定義
又叫生成器模式，它可以將復(fù)雜對象的建造過程抽象出來（抽象類別），使這個抽象過程的不同實現(xiàn)方法可以構(gòu)造出不同表現(xiàn)（屬性）的對象。
當創(chuàng)建復(fù)雜對象的算法應(yīng)該獨立于該對象的組成部分時，而且構(gòu)造過程必須允許被構(gòu)造的對象有不同的表示時。我們可以考慮使用建造者模式。
實現(xiàn)
1. Builder為創(chuàng)建一個Product對象的各個部件指定抽象接口。通常包含創(chuàng)建產(chǎn)品和返回產(chǎn)品的抽象方法，也可以是具體方法，把創(chuàng)建過程放到ConcreteBuilder類中。
2. ConcreteBuilder 實現(xiàn)Builder的接口以構(gòu)造和裝配該產(chǎn)品的各個部件。
3. Director負責調(diào)用適當?shù)慕ㄔ煺邅斫M建產(chǎn)品，導(dǎo)演類一般不與產(chǎn)品類發(fā)生依賴關(guān)系，與導(dǎo)演類直接交互的是建造者類。
4. Product表示被構(gòu)造的復(fù)雜對象。ConcreateBuilder創(chuàng)建該產(chǎn)品的內(nèi)部表示并定義它的裝配過程。
/** "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();
}
}
客戶創(chuàng)建Director對象，并用它所想要的Builder對象進行配置。Director取得客戶的請求創(chuàng)建產(chǎn)品，最后取得產(chǎn)品。
優(yōu)點
1. 可以對構(gòu)造對象的過程進行精細的控制，以產(chǎn)生不同的產(chǎn)品對象。
2. 便于擴展，有新的產(chǎn)品時，只需增加新的ConcreteBuilder 就可以實現(xiàn)。
相關(guān)模式
抽象工廠模式與生成器相似，因為它也可以創(chuàng)建復(fù)雜對象。主要的區(qū)別是生成器模式著重于一步步構(gòu)造一個復(fù)雜對象。而抽象工廠模式著重于多個系列的產(chǎn)品對象（簡單的或是復(fù)雜的）。
生成器在最后的一步返回產(chǎn)品，而對于抽象工廠來說，產(chǎn)品是立即返回的。
原型模式
定義
原型模式是創(chuàng)建型模式的一種,其特點在于通過“復(fù)制”一個已經(jīng)存在的實例來返回新的實例,而不是新建實例。被復(fù)制的實例就是我們所稱的“原型”，這個原型是可定制的。
原型模式多用于創(chuàng)建復(fù)雜的或者耗時的實例，因為這種情況下，復(fù)制一個已經(jīng)存在的實例使程序運行更高效；或者創(chuàng)建值相等，只是命名不一樣的同類數(shù)據(jù)。
實現(xiàn)
1. Client - 創(chuàng)建一個新的對象，然后通過clone得到另外一個對象。
2. Prototype - 定義一個clone自己的抽象方法。
3. ConcretePrototype - 實現(xiàn)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. 游戲中很多元素都是重復(fù)的，我們可以使用原型模式復(fù)制相同的元素。
2. 制作數(shù)據(jù)圖表時，第一次我們需要從數(shù)據(jù)庫讀取數(shù)據(jù)保存到對象中，當需要制作相同數(shù)據(jù)的其他圖表時，使用原型模式可以避免重新讀取數(shù)據(jù)庫。
相關(guān)問題和實現(xiàn)
1. 如果需要創(chuàng)建的原型數(shù)目不固定，可以創(chuàng)建一個原型管理器，在復(fù)制原型對象之前，客戶端先在原型管理器中查看
是否存在滿足條件的原型對象，如果有，則直接使用，如果沒有，克隆一個，這種稱作登記形式的原型模式。
2. 復(fù)制有兩種：深復(fù)制和淺復(fù)制。淺復(fù)制時，復(fù)制對象和原型對象共享對象所有的內(nèi)部變量，兩個對象具有一樣的內(nèi)存空間和生命周期。對原型對象的修改同時也修改了它的復(fù)制品，反之亦然。
java中只要實現(xiàn)Cloneable接口就可以調(diào)用Object類的clone方法實現(xiàn)淺復(fù)制：
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實現(xiàn)的是淺復(fù)制
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
可見淺復(fù)制復(fù)制的是對象的引用，當改變對象的值時，復(fù)制后的對象也會改變，而java的基本類型是復(fù)制的值。
下面我們實現(xiàn)深復(fù)制：
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
上面的復(fù)制方法中，我們重新創(chuàng)建了一個對象，并且重新創(chuàng)建了引用，實現(xiàn)了深度復(fù)制。
優(yōu)點
1. 復(fù)制比new性能更好。
2. 簡化或者隱藏創(chuàng)建對象的細節(jié)，直接復(fù)制。
相關(guān)文章
這篇文章主要介紹了探討Java驗證碼制作(下篇)的相關(guān)資料,需要的朋友可以參考下2016-05-05
Java實現(xiàn)文件或文件夾的復(fù)制到指定目錄實例
本篇文章主要介紹了Java實現(xiàn)文件或文件夾的復(fù)制到指定目錄實例，具有一定的參考價值，感興趣的小伙伴們可以參考一下。2017-03-03
Java SpringBoot+vue+實戰(zhàn)項目詳解
這篇文章主要介紹了SpringBoot+VUE實現(xiàn)前后端分離的相關(guān)資料，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-09-09
設(shè)計模式之構(gòu)建(Builder)模式 建造房子實例分析
構(gòu)建模式主要用來針對復(fù)雜產(chǎn)品生產(chǎn)，分離部件構(gòu)建細節(jié)，以達到良好的伸縮性,考慮到設(shè)計模式來源于建筑學(xué),因此舉一個建造房子的例子,需要的朋友可以參考下2012-12-12
AsyncHttpClient ListenableFuture源碼流程解讀
這篇文章主要為大家介紹了AsyncHttpClient ListenableFuture源碼流程解讀，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-12-12
這篇文章主要介紹了Mybatis如何自動生成sql語句，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-12-12
Spring @Retryable注解輕松搞定循環(huán)重試功能
spring系列的spring-retry是另一個實用程序模塊，可以幫助我們以標準方式處理任何特定操作的重試。在spring-retry中，所有配置都是基于簡單注釋的。本文主要介紹了Spring@Retryable注解如何輕松搞定循環(huán)重試功能，有需要的朋友可以參考一下2023-04-04
這篇文章主要為大家介紹了Java?時間相減算法題解示例,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-12-12
在Java開發(fā)中，我們通常會將我們的項目打包成可執(zhí)行的Jar包，以便于在其他環(huán)境中部署和運行，本文將介紹如何使用IDEA集成開發(fā)環(huán)境將Java項目打包成可執(zhí)行的Jar包，感興趣的朋友一起看看吧2023-07-07
這篇文章主要介紹了java實現(xiàn)上傳圖片進行切割的方法,以完整實例形式分析了Java針對上傳圖片進行切割的技巧,非常具有實用價值,需要的朋友可以參考下2015-02-02