經常使用設計模式——總覽
1.單例模式
Java中單例模式定義：「一個類有且僅有一個實例，而且自行實例化向整個系統提供。」 java
目的：是使內存中保持1個對象。 算法
單例模式三種經常使用形式： 數據庫
第一種形式:懶漢式，也是經常使用的形式。 編程
public class SingletonClass{
private static SingletonClass instance=null;
public static SingletonClass getInstance()
{
if(instance==null)
{
instance=new SingletonClass();
}
return instance;
}
private SingletonClass(){
}
}
第二種形式:餓漢式 設計模式
//對第一行static的一些解釋
// java容許咱們在一個類裏面定義靜態類。好比內部類（nested class）。
//把nested class封閉起來的類叫外部類。
//在java中，咱們不能用static修飾頂級類（top level class）。
//只有內部類能夠爲static。
public static class Singleton{
//在本身內部定義本身的一個實例，只供內部調用
private static final Singleton instance = new Singleton();
private Singleton(){
//do something
}
//這裏提供了一個供外部訪問本class的靜態方法，能夠直接訪問
public static Singleton getInstance(){
return instance;
}
}
第三種形式: 雙重鎖的形式。 數組
public static class Singleton{
private static Singleton instance=null;
private Singleton(){
//do something
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(null==instance){
instance=new Singleton();
}
}
}
return instance;
}
}
2.簡單工廠模式
簡單工廠模式是由一個工廠對象決定建立出哪種產品類的實例。 編程語言
Output，接口 測試
public interface Output
{
//接口裏定義的屬性只能是常量
intMAX_CACHE_LINE = 50;
//接口裏定義的只能是public的抽象實例方法
void out();
void getData(String msg);
}
Printer，Output的一個實現 this
public class Printer implements Output
{
private String[] printData = new String[MAX_CACHE_LINE];
//用以記錄當前需打印的做業數
private int dataNum = 0;
public void out()
{
//只要還有做業，繼續打印
while(dataNum > 0)
{
System.out.println("打印機打印：" + printData[0]);
//把做業隊列總體前移一位，並將剩下的做業數減1
System.arraycopy(printData , 1, printData, 0, --dataNum);
}
}
public void getData(String msg)
{
if (dataNum >= MAX_CACHE_LINE)
{
System.out.println("輸出隊列已滿，添加失敗");
}
else
{
//把打印數據添加到隊列裏，已保存數據的數量加1。
printData[dataNum++] = msg;
}
}
}
BetterPrinter，Output的一個實現 spa
public class BetterPrinter implements Output
{
private String[] printData = new String[MAX_CACHE_LINE * 2];
//用以記錄當前需打印的做業數
private int dataNum = 0;
public void out()
{
//只要還有做業，繼續打印
while(dataNum > 0)
{
System.out.println("高速打印機正在打印：" + printData[0]);
//把做業隊列總體前移一位，並將剩下的做業數減1
System.arraycopy(printData , 1, printData, 0, --dataNum);
}
}
public void getData(String msg)
{
if (dataNum >= MAX_CACHE_LINE * 2)
{
System.out.println("輸出隊列已滿，添加失敗");
}
else
{
//把打印數據添加到隊列裏，已保存數據的數量加1。
printData[dataNum++] = msg;
}
}
}
OutputFactory，簡單工廠類
public class Output{
public Output getPrinterOutput(String type) {
if (type.equalsIgnoreCase("better")) {
return new BetterPrinter();
} else {
return new Printer();
}
}
}
public class Computer
{
private Output out;
public Computer(Output out)
{
this.out = out;
}
//定義一個模擬獲取字符串輸入的方法
public void keyIn(String msg)
{
out.getData(msg);
}
//定義一個模擬打印的方法
public void print()
{
out.out();
}
public static void main(String[] args)
{
//建立OutputFactory
OutputFactory of = new OutputFactory();
//將Output對象傳入，建立Computer對象
Computer c = new Computer(of.getPrinterOutput("normal"));
c.keyIn("建築永恆之道");
c.keyIn("建築模式語言");
c.print();
c = new Computer(of.getPrinterOutput("better"));
c.keyIn("建築永恆之道");
c.keyIn("建築模式語言");
c.print();
}
3.建造模式
該模式其實就是說，一個對象的組成可能有不少其餘的對象一塊兒組成的，好比說，一個對象的實現很是複雜，有不少的屬性，而這些屬性又是其餘對象的引用，可能這些對象的引用又包括不少的對象引用。封裝這些複雜性，就可使用建造模式。
4.門面模式
隨着系統的不斷改進和開發，它們會變得愈來愈複雜，系統會生成大量的類，這使得程序流程更難被理解。門面模式可爲這些類提供一個簡化的接口，從而簡化訪問這些類的複雜性。
門面模式（Facade）也被稱爲正面模式、外觀模式，這種模式用於將一組複雜的類包裝到一個簡單的外部接口中。
原來的方式
// 依次建立三個部門實例 Payment pay = new PaymentImpl(); Cook cook = new CookImpl(); Waiter waiter = new WaiterImpl(); // 依次調用三個部門實例的方法來實現用餐功能 String food = pay.pay(); food = cook.cook(food); waiter.serve(food);
門面模式
public class Facade {
// 定義被Facade封裝的三個部門
Payment pay;
Cook cook;
Waiter waiter;
// 構造器
public Facade() {
this.pay = new PaymentImpl();
this.cook = new CookImpl();
this.waiter = new WaiterImpl();
}
public void serveFood() {
// 依次調用三個部門的方法，封裝成一個serveFood()方法
String food = pay.pay();
food = cook.cook(food);
waiter.serve(food);
}
}
門面模式調用
Facade f = new Facade(); f.serveFood();
5.策略模式
策略模式用於封裝系列的算法，這些算法一般被封裝在一個被稱爲Context的類中，客戶端程序能夠自由選擇其中一種算法，或讓Context爲客戶端選擇一種最佳算法——使用策略模式的優點是爲了支持算法的自由切換。
public interface DiscountStrategy
{
//定義一個用於計算打折價的方法
double getDiscount(double originPrice);
}
public class OldDiscount implements DiscountStrategy {
// 重寫getDiscount()方法，提供舊書打折算法
public double getDiscount(double originPrice) {
System.out.println("使用舊書折扣...");
return originPrice * 0.7;
}
}
//實現DiscountStrategy接口，實現對VIP打折的算法
public class VipDiscount implements DiscountStrategy {
// 重寫getDiscount()方法，提供VIP打折算法
public double getDiscount(double originPrice) {
System.out.println("使用VIP折扣...");
return originPrice * 0.5;
}
}
public class DiscountContext
{
//組合一個DiscountStrategy對象
private DiscountStrategy strategy;
//構造器，傳入一個DiscountStrategy對象
public DiscountContext(DiscountStrategy strategy)
{
this.strategy = strategy;
}
//根據實際所使用的DiscountStrategy對象獲得折扣價
publicdouble getDiscountPrice(double price)
{
//若是strategy爲null，系統自動選擇OldDiscount類
if (strategy == null)
{
strategy = new OldDiscount();
}
return this.strategy.getDiscount(price);
}
//提供切換算法的方法
publicvoid setDiscount(DiscountStrategy strategy)
{
this.strategy = strategy;
}
}
public static void main(String[] args)
{
//客戶端沒有選擇打折策略類
DiscountContext dc = new DiscountContext(null);
double price1 = 79;
//使用默認的打折策略
System.out.println("79元的書默認打折後的價格是："
+ dc.getDiscountPrice(price1));
//客戶端選擇合適的VIP打折策略
dc.setDiscount(new VipDiscount());
double price2 = 89;
//使用VIP打折獲得打折價格
System.out.println("89元的書對VIP用戶的價格是："
+ dc.getDiscountPrice(price2));
}
6.觀察者模式
觀察者模式定義了對象間的一對多依賴關係，讓一個或多個觀察者對象觀察一個主題對象。當主題對象的狀態發生變化時，系統能通知全部的依賴於此對象的觀察者對象，從而使得觀察者對象可以自動更新。
觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法.
public interface Observer {
void update(Observable o, Object arg);
}
主題：主題是一個接口，該接口規定了具體主題須要實現的方法，好比添加、刪除觀察者以及通知觀察者更新數據的方法
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public abstract class Observable {
// 用一個List來保存該對象上全部綁定的事件監聽器
List<Observer> observers = new ArrayList<Observer>();
// 定義一個方法，用於從該主題上註冊觀察者
public void registObserver(Observer o) {
observers.add(o);
}
// 定義一個方法，用於從該主題中刪除觀察者
public void removeObserver(Observer o) {
observers.add(o);
// 通知該主題上註冊的全部觀察者
public void notifyObservers(Object value) {
// 遍歷註冊到該被觀察者上的全部觀察者
for (Iterator it = observers.iterator(); it.hasNext();) {
Observer o = (Observer) it.next();
// 顯式每一個觀察者的update方法
o.update(this, value);
}
}
}
具體主題：具體主題是一個實現主題接口的類，該類包含了會常常發生變化的數據。並且還有一個集合，該集合存放的是觀察者的引用。
public class Product extends Observable {
// 定義兩個屬性
private String name;
private double price;
// 無參數的構造器
public Product() {
}
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
// 當程序調用name的setter方法來修改Product的name屬性時
// 程序天然觸發該對象上註冊的全部觀察者
public void setName(String name) {
this.name = name;
notifyObservers(name);
}
public double getPrice() {
return price;
}
// 當程序調用price的setter方法來修改Product的price屬性時
// 程序天然觸發該對象上註冊的全部觀察者
public void setPrice(double price) {
this.price = price;
notifyObservers(price);
}
}
具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有能夠存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將本身的引用添加到具體主題的集合中，讓本身成爲它的觀察者，或者讓這個具體主題將本身從具體主題的集合中刪除，使本身不在時它的觀察者.
import javax.swing.JFrame;
import javax.swing.JLabel;
public class NameObserver implements Observer {
// 實現觀察者必須實現的update方法
public void update(Observable o, Object arg) {
if (arg instanceof String) {
// 產品名稱改變值在name中
String name = (String) arg;
// 啓動一個JFrame窗口來顯示被觀察對象的狀態改變
JFrame f = new JFrame("觀察者");
JLabel l = new JLabel("名稱改變爲：" + name);
f.add(l);
f.pack();
f.setVisible(true);
System.out.println("名稱觀察者:" + o + "物品名稱已經改變爲: " + name);
}
}
}
public class PriceObserver implements Observer {
// 實現觀察者必須實現的update方法
public void update(Observable o, Object arg) {
if (arg instanceof Double) {
System.out.println("價格觀察者:" + o + "物品價格已經改變爲: " + arg);
}
}
}
測試：
public class Test {
public static void main(String[] args) {
// 建立一個被觀察者對象
Product p = new Product("電視機", 176);
// 建立兩個觀察者對象
NameObserver no = new NameObserver();
PriceObserver po = new PriceObserver();
// 向被觀察對象上註冊兩個觀察者對象
p.registObserver(no);
p.registObserver(po);
// 程序調用setter方法來改變Product的name和price屬性
p.setName("書桌");
p.setPrice(345f);
}
}
7.代理模式
代理模式是一種應用很是普遍的設計模式，當客戶端代碼須要調用某個對象時，客戶端實際上不關心是否準確獲得該對象，它只要一個能提供該功能的對象便可，此時咱們就可返回該對象的代理（Proxy）。
代理就是一個Java對象表明另外一個Java對象來採起行動。如：
public class ImageProxy implements Image
{
//組合一個image實例，做爲被代理的對象
private Image image;
//使用抽象實體來初始化代理對象
public ImageProxy(Image image)
{
this.image = image;
}
/**
* 重寫Image接口的show()方法
* 該方法用於控制對被代理對象的訪問，
* 並根據須要負責建立和刪除被代理對象
*/
public void show()
{
//只有當真正須要調用image的show方法時才建立被代理對象
if (image == null)
{
image = new BigImage();
}
image.show();
}
}
如：Hibernate默認啓用延遲加載，當系統加載A實體時，A實體關聯的B實體並未被加載出來，A實體所關聯的B實體所有是代理對象——只有等到A實體真正須要訪問B實體時，系統纔會去數據庫裏抓取B實體所對應的記錄。
8.命令模式：
某個方法須要完成某一個功能，完成這個功能的大部分步驟已經肯定了，但可能有少許具體步驟沒法肯定，必須等到執行該方法時才能夠肯定。（在某些編程語言如Ruby、Perl裏，容許傳入一個代碼塊做爲參數。但Jara暫時還不支持代碼塊做爲參數）。
在Java中，傳入該方法的是一個對象，該對象一般是某個接口的匿名實現類的實例，該接口一般被稱爲命令接口，這種設計方式也被稱爲命令模式。
public interface Command
{
//接口裏定義的process方法用於封裝「處理行爲」
void process(int[] target);
}
public class ProcessArray
{
//定義一個each()方法，用於處理數組，
publicv oid each(int[] target , Command cmd)
{
cmd.process(target);
}
}
public class TestCommand
{
public static void main(String[] args)
{
ProcessArray pa = new ProcessArray();
int[] target = {3, -4, 6, 4};
//第一次處理數組，具體處理行爲取決於Command對象
pa.each(target , new Command()
{
//重寫process()方法，決定具體的處理行爲
public void process(int[] target)
{
for (int tmp : target )
{
System.out.println("迭代輸出目標數組的元素:" + tmp);
}
}
});
System.out.println("------------------");
//第二次處理數組，具體處理行爲取決於Command對象
pa.each(target , new Command()
{
//重寫process方法，決定具體的處理行爲
public void process(int[] target)
{
int sum = 0;
for (int tmp : target )
{
sum += tmp;
}
System.out.println("數組元素的總和是:" + sum);
}
});
}
}
9.橋接模式
因爲實際的須要，某個類具備兩個以上的維度變化，若是隻是使用繼承將沒法實現這種須要，或者使得設計變得至關臃腫。而橋接模式的作法是把變化部分抽象出來，使變化部分與主類分離開來，從而將多個的變化完全分離。最後提供一個管理類來組合不一樣維度上的變化，經過這種組合來知足業務的須要。
Peppery口味風格接口：
public interface Peppery
{
String style();
}
口味之一
public class PepperySytle implements Peppery
{
//實現"辣味"風格的方法
public String style()
{
return"辣味很重，很過癮...";
}
}
口味之二
public class PlainStyle implements Peppery
{
//實現"不辣"風格的方法
public String style()
{
return"味道清淡，很養胃...";
}
}
口味的橋樑
public abstract class AbstractNoodle
{
//組合一個Peppery變量，用於將該維度的變化獨立出來
protected Peppery style;
//每份Noodle必須組合一個Peppery對象
public AbstractNoodle(Peppery style)
{
this.style = style;
}
public abstract void eat();
}
材料之一，繼承口味
public class PorkyNoodle extends AbstractNoodle
{
public PorkyNoodle(Peppery style)
{
super(style);
}
//實現eat()抽象方法
public void eat()
{
System.out.println("這是一碗稍嫌油膩的豬肉麪條。"
+ super.style.style());
}
}
材料之二，繼承口味
public class BeefMoodle extends AbstractNoodle
{
public BeefMoodle(Peppery style)
{
super(style);
}
//實現eat()抽象方法
public void eat()
{
System.out.println("這是一碗美味的牛肉麪條。"
+ super.style.style());
}
}
主程序
public class Test
{
public static void main(String[] args)
{
//下面將獲得「辣味」的牛肉麪
AbstractNoodle noodle1 = new BeefMoodle(
new PepperySytle());
noodle1.eat();
//下面將獲得「不辣」的牛肉麪
AbstractNoodle noodle2 = new BeefMoodle(
new PlainStyle());
noodle2.eat();
//下面將獲得「辣味」的豬肉面
AbstractNoodle noodle3 = new PorkyNoodle(
new PepperySytle());
noodle3.eat();
//下面將獲得「不辣」的豬肉面
AbstractNoodle noodle4 = new PorkyNoodle(
new PlainStyle());
noodle4.eat();
}
}
相關文章
- 1. 【設計模式總結】對經常使用設計模式的一些思考
- 2. 經常使用設計模式
- 3. Python經常使用設計模式
- 4. Java經常使用的設計模式
- 5. 經常使用設計模式比較
- 6. java經常使用設計模式
- 7. .NET經常使用設計模式（一）
- 8. Android中經常使用設計模式
- 9. 幾種經常使用設計模式
- 10. 經常使用設計模式學習
- 更多相關文章...
- • Web 創建設計 - 網站建設指南
- • 瀏覽器 統計 - 瀏覽器信息
- • 委託模式
- • 使用Rxjava計算圓周率
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 【設計模式總結】對經常使用設計模式的一些思考
- 2. 經常使用設計模式
- 3. Python經常使用設計模式
- 4. Java經常使用的設計模式
- 5. 經常使用設計模式比較
- 6. java經常使用設計模式
- 7. .NET經常使用設計模式（一）
- 8. Android中經常使用設計模式
- 9. 幾種經常使用設計模式
- 10. 經常使用設計模式學習