講解Java設計模式編程中的建造者模式與原型模式
建造者模式
定義
又叫生成器模式，它可以將復雜對象的建造過程抽象出來（抽象類別），使這個抽象過程的不同實現(xiàn)方法可以構造出不同表現(xiàn)（屬性）的對象。
當創(chuàng)建復雜對象的算法應該獨立于該對象的組成部分時，而且構造過程必須允許被構造的對象有不同的表示時。我們可以考慮使用建造者模式。
實現(xiàn)
1. Builder為創(chuàng)建一個Product對象的各個部件指定抽象接口。通常包含創(chuàng)建產(chǎn)品和返回產(chǎn)品的抽象方法，也可以是具體方法，把創(chuàng)建過程放到ConcreteBuilder類中。
2. ConcreteBuilder 實現(xiàn)Builder的接口以構造和裝配該產(chǎn)品的各個部件。
3. Director負責調(diào)用適當?shù)慕ㄔ煺邅斫M建產(chǎn)品，導演類一般不與產(chǎn)品類發(fā)生依賴關系，與導演類直接交互的是建造者類。
4. Product表示被構造的復雜對象。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. 可以對構造對象的過程進行精細的控制，以產(chǎn)生不同的產(chǎn)品對象。
2. 便于擴展，有新的產(chǎn)品時，只需增加新的ConcreteBuilder 就可以實現(xiàn)。
相關模式
抽象工廠模式與生成器相似，因為它也可以創(chuàng)建復雜對象。主要的區(qū)別是生成器模式著重于一步步構造一個復雜對象。而抽象工廠模式著重于多個系列的產(chǎn)品對象（簡單的或是復雜的）。
生成器在最后的一步返回產(chǎn)品，而對于抽象工廠來說，產(chǎn)品是立即返回的。
原型模式
定義
原型模式是創(chuàng)建型模式的一種,其特點在于通過“復制”一個已經(jīng)存在的實例來返回新的實例,而不是新建實例。被復制的實例就是我們所稱的“原型”，這個原型是可定制的。
原型模式多用于創(chuàng)建復雜的或者耗時的實例，因為這種情況下，復制一個已經(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. 游戲中很多元素都是重復的，我們可以使用原型模式復制相同的元素。
2. 制作數(shù)據(jù)圖表時，第一次我們需要從數(shù)據(jù)庫讀取數(shù)據(jù)保存到對象中，當需要制作相同數(shù)據(jù)的其他圖表時，使用原型模式可以避免重新讀取數(shù)據(jù)庫。
相關問題和實現(xiàn)
1. 如果需要創(chuàng)建的原型數(shù)目不固定，可以創(chuàng)建一個原型管理器，在復制原型對象之前，客戶端先在原型管理器中查看
是否存在滿足條件的原型對象，如果有，則直接使用，如果沒有，克隆一個，這種稱作登記形式的原型模式。
2. 復制有兩種：深復制和淺復制。淺復制時，復制對象和原型對象共享對象所有的內(nèi)部變量，兩個對象具有一樣的內(nèi)存空間和生命周期。對原型對象的修改同時也修改了它的復制品，反之亦然。
java中只要實現(xiàn)Cloneable接口就可以調(diào)用Object類的clone方法實現(xiàn)淺復制：
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)的是淺復制
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的基本類型是復制的值。
下面我們實現(xiàn)深復制：
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
上面的復制方法中，我們重新創(chuàng)建了一個對象，并且重新創(chuàng)建了引用，實現(xiàn)了深度復制。
優(yōu)點
1. 復制比new性能更好。
2. 簡化或者隱藏創(chuàng)建對象的細節(jié)，直接復制。
相關文章
Java TreeMap升序|降序排列和按照value進行排序的案例
這篇文章主要介紹了Java TreeMap升序|降序排列和按照value進行排序的案例，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-10-10
SpringSecurity是通過過濾器鏈來完成的,接下來的驗證碼,可以嘗試創(chuàng)建一個過濾器放到Security的過濾器鏈中,在自定義的過濾器中比較驗證碼,本文通過實例代碼介紹SpringSecurity集成圖片驗證碼的詳細過程,感興趣的朋友一起看看吧2023-12-12
spring-boot報錯java: 程序包javax.servlet.http不存在
當springboot項目從2.7.x的升級到3.0.x的時候,會遇到一個問題java: 程序包javax.servlet.http不存在,下面就來具體介紹一下,感興趣的可以了解一下2024-08-08
Java封裝數(shù)組實現(xiàn)在數(shù)組中查詢元素和修改元素操作示例
這篇文章主要介紹了Java封裝數(shù)組實現(xiàn)在數(shù)組中查詢元素和修改元素操作,結合實例形式分析了java針對數(shù)組元素查詢、修改的封裝操作實現(xiàn)技巧,需要的朋友可以參考下2020-03-03
Scala實現(xiàn)冒泡排序、歸并排序和快速排序的示例代碼
這篇文章主要介紹了Scala實現(xiàn)冒泡排序、歸并排序和快速排序的示例代碼，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2019-06-06
SpringBoot框架對異常的處理提供了幾種很強大的方法,我們可以通過@ControllerAdvice和@ExceptionHandler注解實現(xiàn)全局異常的處理,下面就來介紹一下這兩種方法的實現(xiàn),感興趣的可以了解一下2024-08-08
Java class文件格式之特殊字符串_動力節(jié)點Java學院整理
特殊字符串出現(xiàn)在class文件中的常量池中，本著循序漸進和減少跨度的原則， 首先把class文件中的特殊字符串做一個詳細的介紹， 然后再回過頭來繼續(xù)講解常量池，對java class 文件格式相關知識感興趣的的朋友一起學習吧2017-06-06
java開發(fā)中使用IDEA活動模板快速增加注釋的方法
這篇文章主要介紹了java開發(fā)中使用IDEA活動模板快速增加注釋,本文通過圖文并茂的形式給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-12-12
項目的數(shù)據(jù)庫密碼、redis 密碼等明文展示在配置文件中會有潛在的風險,因此采用合適的安全防護措施是有必要的,下面小編就為大家介紹一下SpringBoot中配置文件加密的方法,希望對大家有所幫助2023-11-11
這篇文章主要介紹了java簡介及環(huán)境搭建，文章主要介紹Java的發(fā)展史及環(huán)境搭建，對正在學Java的你有一定的參考價值，需要的小伙伴可以參考一下2022-03-03