面試題整理--Java設計模式--建立型模式
概況
總體來說設計模式分為三大類:
(1)建立型模式,共五種:工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
(2)結構型模式,共七種:介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
(3)行為型模式,共十一種:策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式。
建立型模式
建立型模式,共五種:工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
工廠方法模式
工廠方法模式分為三種:普通工廠模式、多個工廠方法模式和靜態工廠方法模式。
1、普通工廠模式
普通工廠模式就是建立一個工廠類,對實現了同一介面的一些類進行例項的建立。
package com.mode.create;
public interface MyInterface {
public void print();
}
package com.mode.create;
public class MyClassOne implements MyInterface {
@Override
public void print() {
System.out.println("MyClassOne");
}
}
package com.mode.create;
public class MyClassTwo implements MyInterface {
@Override
public void print() {
System.out.println("MyClassTwo");
}
}
package com.mode.create;
public class MyFactory {
public MyInterface produce(String type) {
if ("One".equals(type)) {
return new MyClassOne();
} else if ("Two".equals(type)) {
return new MyClassTwo();
} else {
System.out.println("沒有要找的型別");
return null;
}
}
}
package com.mode.create;
public class FactoryTest {
public static void main(String[] args){
MyFactory factory = new MyFactory();
MyInterface myi = factory.produce("One");
myi.print();
}
}
FactoryTest的執行結果我想應該很明顯了。
再回頭來理解這句話:普通工廠模式就是建立一個工廠類,對實現了同一介面的一些類進行例項的建立。
2、多個工廠方法模式
多個工廠方法模式,是對普通工廠方法模式的改進,多個工廠方法模式就是提供多個工廠方法,分別建立物件。
直接看程式碼吧,我們修改MyFactory和FactoryTest如下:
package com.mode.create;
public class MyFactory {
public MyInterface produceOne() {
return new MyClassOne();
}
public MyInterface produceTwo() {
return new MyClassTwo();
}
}
package com.mode.create;
public class FactoryTest {
public static void main(String[] args){
MyFactory factory = new MyFactory();
MyInterface myi = factory.produceOne();
myi.print();
}
}
執行結果也是十分明顯了。
再回頭來理解這句話:多個工廠方法模式,是對普通工廠方法模式的改進,多個工廠方法模式就是提供多個工廠方法,分別建立物件。
3、靜態工廠方法模式
靜態工廠方法模式,將上面的多個工廠方法模式裡的方法置為靜態的,不需要建立例項,直接呼叫即可。
直接看程式碼吧,我們修改MyFactory和FactoryTest如下:
package com.mode.create;
public class MyFactory {
public static MyInterface produceOne() {
return new MyClassOne();
}
public static MyInterface produceTwo() {
return new MyClassTwo();
}
}
package com.mode.create;
public class FactoryTest {
public static void main(String[] args){
MyInterface myi = MyFactory.produceOne();
myi.print();
}
}
執行結果依舊很明顯。
再回顧:靜態工廠方法模式,將上面的多個工廠方法模式裡的方法置為靜態的,不需要建立例項,直接呼叫即可。
抽象工廠模式
工廠方法模式有一個問題就是,類的建立依賴工廠類,也就是說,如果想要拓展程式,必須對工廠類進行修改,這違背了閉包原則。
為解決這個問題,我們來看看抽象工廠模式:建立多個工廠類,這樣一旦需要增加新的功能,直接增加新的工廠類就可以了,不需要修改之前的程式碼。
這樣就符合閉包原則了。
下面來看看程式碼:
MyInterface、MyClassOne、MyClassTwo不變。
新增如下介面和類:
package com.mode.create;
public interface Provider {
public MyInterface produce();
}
package com.mode.create;
public class MyFactoryOne implements Provider {
@Override
public MyInterface produce() {
return new MyClassOne();
}
}
package com.mode.create;
public class MyFactoryTwo implements Provider {
@Override
public MyInterface produce() {
return new MyClassTwo();
}
}
修改測試類FactoryTest如下:
package com.mode.create;
public class FactoryTest {
public static void main(String[] args){
Provider provider = new MyFactoryOne();
MyInterface myi = provider.produce();
myi.print();
}
}
執行結果依舊顯然。
再回顧:抽象工廠模式就是建立多個工廠類,這樣一旦需要增加新的功能,直接增加新的工廠類就可以了,不需要修改之前的程式碼。
單例模式
單例模式,不需要過多的解釋。
直接看程式碼吧:
package test;
public class MyObject {
private static MyObject myObject;
private MyObject() {
}
public static MyObject getInstance() {
if (myObject != null) {
} else {
myObject = new MyObject();
}
return myObject;
}
}
4、建造者模式
建造者模式:是將一個複雜的物件的構建與它的表示分離,使得同樣的構建過程可以建立不同的表示。
字面看來非常抽象,實際上它也十分抽象!!!!
建造者模式通常包括下面幾個角色:
(1) Builder:給出一個抽象介面,以規範產品物件的各個組成成分的建造。這個介面規定要實現複雜物件的哪些部分的建立,並不涉及具體的物件部件的建立。
(2) ConcreteBuilder:實現Builder介面,針對不同的商業邏輯,具體化複雜物件的各部分的建立。 在建造過程完成後,提供產品的例項。
(3)Director:呼叫具體建造者來建立複雜物件的各個部分,在指導者中不涉及具體產品的資訊,只負責保證物件各部分完整建立或按某種順序建立。
(4)Product:要建立的複雜物件。
在遊戲開發中建造小人是經常的事了,要求是:小人必須包括頭,身體和腳。
下面我們看看如下程式碼:
Product(要建立的複雜物件。):
package com.mode.create;
public class Person {
private String head;
private String body;
private String foot;
public String getHead() {
return head;
}
public void setHead(String head) {
this.head = head;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
}
Builder(給出一個抽象介面,以規範產品物件的各個組成成分的建造。這個介面規定要實現複雜物件的哪些部分的建立,並不涉及具體的物件部件的建立。):
package com.mode.create;
public interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
}
ConcreteBuilder(實現Builder介面,針對不同的商業邏輯,具體化複雜物件的各部分的建立。 在建造過程完成後,提供產品的例項。):
package com.mode.create;
public class ManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Person();
}
public void buildBody() {
person.setBody("建造男人的身體");
}
public void buildFoot() {
person.setFoot("建造男人的腳");
}
public void buildHead() {
person.setHead("建造男人的頭");
}
public Person buildPerson() {
return person;
}
}
Director(呼叫具體建造者來建立複雜物件的各個部分,在指導者中不涉及具體產品的資訊,只負責保證物件各部分完整建立或按某種順序建立。):
package com.mode.create;
public class PersonDirector {
public Person constructPerson(PersonBuilder pb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}
測試類:
package com.mode.create;
public class Test {
public static void main(String[] args) {
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new ManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}
執行結果:
回顧:建造者模式:是將一個複雜的物件的構建與它的表示分離,使得同樣的構建過程可以建立不同的表示。
5、原型模式
該模式的思想就是將一個物件作為原型,對其進行復制、克隆,產生一個和原物件類似的新物件。
說道複製物件,我將結合物件的淺複製和深複製來說一下,首先需要了解物件深、淺複製的概念:
淺複製:將一個物件複製後,基本資料型別的變數都會重新建立,而引用型別,指向的還是原物件所指向的。
深複製:將一個物件複製後,不論是基本資料型別還有引用型別,都是重新建立的。簡單來說,就是深複製進行了完全徹底的複製,而淺複製不徹底。
寫一個深淺複製的例子:
package com.mode.create;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Prototype implements Cloneable, Serializable {
private static final long serialVersionUID = 1L;
private int base;
private Integer obj;
/* 淺複製 */
public Object clone() throws CloneNotSupportedException {
// 因為Cloneable介面是個空介面,你可以任意定義實現類的方法名
// 如cloneA或者cloneB,因為此處的重點是super.clone()這句話
// super.clone()呼叫的是Object的clone()方法
// 而在Object類中,clone()是native(本地方法)的
Prototype proto = (Prototype) super.clone();
return proto;
}
/* 深複製 */
public Object deepClone() throws IOException, ClassNotFoundException {
/* 寫入當前物件的二進位制流 */
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
/* 讀出二進位制流產生的新物件 */
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
public int getBase() {
return base;
}
public void setBase(int base) {
this.base = base;
}
public Integer getObj() {
return obj;
}
public void setObj(Integer obj) {
this.obj = obj;
}
}
測試類:
package com.mode.create;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws CloneNotSupportedException,
ClassNotFoundException, IOException {
Prototype prototype = new Prototype();
prototype.setBase(1);
prototype.setObj(new Integer(2));
/* 淺複製 */
Prototype prototype1 = (Prototype) prototype.clone();
/* 深複製 */
Prototype prototype2 = (Prototype) prototype.deepClone();
System.out.println(prototype1.getObj()==prototype1.getObj());
System.out.println(prototype1.getObj()==prototype2.getObj());
}
}
轉載 http://blog.csdn.net/u013142781
相關推薦
面試題整理--Java設計模式--建立型模式
概況 總體來說設計模式分為三大類: (1)建立型模式,共五種:工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 (2)結構型模式,共七種:介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。 (3)行為型模式,共十一種:策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈
java設計模式(建立型模式)之建造者模式
1.建造模式的本質 1.實現了物件元件的單獨構造和裝配這個模式的構建過程複雜情況下使用. 2.實現了構建和裝配的解耦,不同構建起,相同的裝配,可以做出不同的物件.相同的構建起,不同裝配順序也可以出現不同的物件,試下了構建演算法/裝配演算法的解耦.實現了
java設計模式(建立型模式)之原型模式prototype
原型模式: 通過產生一個物件需要非常複雜的資料準備或訪問許可權.則可以使用原型模式 java中的克隆技術,以某個物件為原型,複製出新的物件, 優勢:效率高(直接克隆,避免了重複執行構造過程) 克隆類似於new,但是不同於new.new建
java設計模式——建立型模式專題(二)策略模式
策略模式:說白了,就是將一組演算法封裝起來,使他們可以互換。 package 策略模式; public class StrategePattern { /** * 抽象策略角色 * @author zouxiang * */ public sta
設計模式-建立型模式-單例
單例模式保證一個類只有一個物件,並且提供一個訪問該例項的全域性訪問點。 1.單例模式例項一(餓漢式) public class Singleton { private static Singleton sin = new Singleton(); /// 直接初始化一個例項物件
設計模式-建立型模式-單例模式
設計模式-建立型模式-單例模式 建立型模式 建立型模式隱藏類的例項和建立細節,通過隱藏物件如何建立組合在一起達到整個系統獨立。 單例模式 確保同一時刻只有一個例項被訪問。 Ensure a class has only one instance, and provide a global point
設計模式-建立型模式-工廠模式(工廠三兄弟)
設計模式-建立型模式-工廠模式(工廠三兄弟) 工廠模式分為簡單工廠,工廠方法,抽象工廠。 簡單工廠模式 一個介面,三個具體類,一個工廠,通過選擇,生產出對應的物件。 package demo2; public class Circle implements Shape{ public Circ
設計模式-建立型模式-工廠模式(工廠三兄弟) TypeScript
設計模式-建立型模式-工廠模式(工廠三兄弟) TypeScript 簡單工廠模式 定義一個介面,三個具體類。然後書寫如下,通過選擇,生產出相應的物件 // 定義Shape介面 interface Shape { draw():void; } // 下面為產品類 // 產品 Circle cla
設計模式-建立型模式-建造者模式
設計模式-建立型模式-建造者模式 建造者模式即生成器模式,將一個複雜的構建與它的表示分離,使得同樣的構建過程可以建立不同的表示。 程式碼如下 // 產品類 public class Product{ public void doSomething(){ // 業務處理 }
設計模式--建立型模式--抽象工廠
//Creational Patterns--abstract factory //建立型模式--抽象工廠 //----------------------------------------------------------------- class Tank { pu
設計模式--建立型模式--工廠方法
//----------------------------------------------------------------- //Creational Patterns--factory method //建立型模式--工廠方法 //----------------
設計模式--建立型模式--建造者模式
//Creational Patterns--builder //建立型模式--建造者模式 //1.Builder 抽象建造者 //2.ConcreteBuilder 具體建造者 //3.Director 指揮者 //4.Product 產品 //產品
設計模式--建立型模式--原型模式
//Creational Patterns--Prototype Pattern //建立型模式--原型模式 //Prototype(抽象原型):定義了克隆自身的介面。 //ConcretePrototype(具體原型):被複制的物件,需要實現 Prototype 定義的介
23種設計模式----工廠方法模式----建立型模式
工廠方法模式或者說是簡單工廠方法。 ps:學會模板方法再學習工廠方法更簡單,或者說工廠方法模式是在模板方法的基礎上進行設計的。 1.什麼是工廠方法模式 將例項的生成交給子類(出自《圖解設計模式》) 這句話怎麼理解? 我自己的理解就是把建立和實現分離。 使用工廠
設計模式-建立型模式-工廠模式,抽象工廠模式
簡單工廠模式 簡單工廠模式不是 23 種裡的一種,簡而言之,就是有一個專門生產某個產品的類。 它只算工廠模式的一個特殊實現。簡單工廠模式在實際中的應用相對於其他2個工廠模式用的還是相對少得多,因為它只適應很多簡單的情況。 簡單工廠例項 1)建立Shape介面 publ
看透設計模式-建立型模式
總結下自己關於設計模式的一些思考。(我終於看穿了愛情,不過就是一圈圈圈圈菸圈圈圈圈 用來解悶消遣。。) 設計模式是對一些 常用的類的行為規範的一個最佳實踐的提取。 設計模式不是架構模式,設計模式關注的是程式碼的可讀性,拓展性。而架構關注的是 效能、穩定性、可用性 開閉原則,並不是說,我們
設計模式 建立型模式
設計模式主要分為建立性模式、行為模式、結構模式。 建立類模式包括單例模式、工廠模式、建造者模式、原型模式 單例模式 單例模式的核心就是一個類只有一個物件,java簡單實現如下。 package mode.create; /** * 單例設計模式 */ public cl
java語言實現建立型模式—簡單工廠模式
一、描述 簡單工廠模式又名靜態工廠方法模式,是所有工廠模式中最簡單的一個,它定義一個具體的工廠類來負責建立所有類的物件並初始化建立的物件,它主要由3部分組成:工廠類、抽象類、實現抽象類的具體類,然後通過客戶端呼叫工廠類建立相應的物件。 注意:簡單工廠模式不屬於GoF總結的2
[設計模式]建立型模式
定義 建立型模式抽象了例項化的過程。它將系統與它的物件建立、結合、表示的方式分離。 建立型模式都會將關於該系統使用哪些具體的類的資訊封裝起來。 在軟體工程中,建立型模式是處理物件建立的設計模式,試圖根據實際情況使用合適的方式建立物件。 基本的物件建立方式可能會導致設計上的問題,或增
軟體設計模式-建立型模式(二)
生成器模式: 生成器模式將一個複雜物件的構建與他的表示分離,使得同樣的構建過程可以建立不同的表示。 設計類圖: 組成部分: (1)Builder:建立Product物件的抽象介面 (2) Concrete Builde