- 創建型：簡單工廠模式（並不是23種設計模式之一）、工廠方法、抽象工廠模式、單例模式、生成器模式和原型模式
- 結構型：適配器模式adapter、橋接模式bridge、組合器模式component、裝飾器模式decorator、門面模式、亨元模式flyweight和代理模式proxy
- 行爲型：命令模式command、解釋器模式、迭代器模式、中介者模式、備忘錄模式、觀察者模式、狀態模式state、策略模式、模板模式和訪問者模式
常用的幾種設計模式介紹
1、單例模式如果一個類始終只能創建一個實例，則這個類被稱爲單例類，這種模式就被稱爲單例模式。一般建議單例模式的方法命名爲：getInstance()，這個方法的返回類型肯定是單例類的類型了。getInstance方法可以有參數，這些參數可能是創建類實例所需要的參數，當然，大多數情況下是不需要的。實現單例模式的簡單例子：
public class Singleton {
public static void main(String[] args)
{
//創建Singleton對象不能通過構造器，只能通過getInstance方法
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
//將輸出true
System.out.println(s1 == s2);
}
//使用一個變量來緩存曾經創建的實例
private static Singleton instance;
//將構造器使用private修飾，隱藏該構造器
private Singleton(){
System.out.println("Singleton被構造！");
}
//提供一個靜態方法，用於返回Singleton實例
//該方法可以加入自定義的控制，保證只產生一個Singleton對象
public static Singleton getInstance()
{
//如果instance爲null，表明還不曾創建Singleton對象
//如果instance不爲null，則表明已經創建了Singleton對象，將不會執行該方法
if (instance == null)
{
//創建一個Singleton對象，並將其緩存起來
instance = new Singleton();
}
return instance;
}
}
簡單工廠模式的核心思想就是：有一個專門的類來負責創建實例的過程。 具體來說，把產品看着是一系列的類的集合，這些類是由某個抽象類或者接口派生出來的一個對象樹。而工廠類用來產生一個合適的對象來滿足客戶的要求。如果簡單工廠模式所涉及到的具體產品之間沒有共同的邏輯，那麼我們就可以使用接口來扮演抽象產品的角色；如果具體產品之間有功能的邏輯或，我們就必須把這些共同的東西提取出來，放在一個抽象類中，然後讓具體產品繼承抽象類。爲實現更好複用的目的，共同的東西總是應該抽象出來的。
/*
* 產品的抽象接口
*/
public interface Food {
/*
* 獲得相應的食物
*/
public void get();
}/*
* 麥香雞對抽象產品接口的實現
*/
public class McChicken implements Food{
/*
* 獲取一份麥香雞
*/
public void get(){
System.out.println("我要一份麥香雞");
}
}public class FoodFactory {
public static Food getFood(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
if(type.equalsIgnoreCase("mcchicken")) {
return McChicken.class.newInstance();
} else if(type.equalsIgnoreCase("chips")) {
return Chips.class.newInstance();
} else {
System.out.println("哎呀！找不到相應的實例化類啦！");
return null;
}
}
}/*
* 測試客戶端
*/
public class SimpleFactoryTest {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
//實例化各種食物
Food mcChicken = FoodFactory.getFood("McChicken");
Food chips = FoodFactory.getFood("Chips");
Food eggs = FoodFactory.getFood("Eggs");
//獲取食物
if(mcChicken!=null){
mcChicken.get();
}
if(chips!=null){
chips.get();
}
if(eggs!=null){
eggs.get();
}
}
}輸出的結果如下：
|
哎呀！找不到相應的實例化類啦！ 我要一份麥香雞 我要一份薯條 |
代理模式是一種應用非常廣泛的設計模式，當客戶端代碼需要調用某個對象時，客戶端實際上不關心是否準確得到該對象，它只要一個能提供該功能的對象即可，此時我們就可返回該對象的代理（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();
}
}調用時，先不創建：
|
Image image = new ImageProxy(null); |
Hibernate默認啓用延遲加載，當系統加載A實體時，A實體關聯的B實體並未被加載出來，A實體所關聯的B實體全部是代理對象——只有等到A實體真正需要訪問B實體時，系統纔會去數據庫裏抓取B實體所對應的記錄。
藉助於Java提供的Proxy和InvocationHandler，可以實現在運行時生成動態代理的功能，而動態代理對象就可以作爲目標對象使用，而且增強了目標對象的功能。如：
public interface Panther
{
//info方法聲明
public void info();
//run方法聲明
public void run();
}public class GunPanther implements Panther
{
//info方法實現，僅僅打印一個字符串
public void info()
{
System.out.println("我是一隻獵豹！");
}
//run方法實現，僅僅打印一個字符串
public void run()
{
System.out.println("我奔跑迅速");
}
}public class MyProxyFactory
{
//爲指定target生成動態代理對象
public static Object getProxy(Object target)
throws Exception
{
//創建一個MyInvokationHandler對象
MyInvokationHandler handler =
new MyInvokationHandler();
//爲MyInvokationHandler設置target對象
handler.setTarget(target);
//創建、並返回一個動態代理
return Proxy.newProxyInstance(target.getClass().getClassLoader()
, target.getClass().getInterfaces(), handler);
}
}public class MyInvokationHandler implements InvocationHandler
{
//需要被代理的對象
private Object target;
public void setTarget(Object target)
{
this.target = target;
}
//執行動態代理對象的所有方法時，都會被替換成執行如下的invoke方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Exception
{
TxUtil tx = new TxUtil();
//執行TxUtil對象中的beginTx。
tx.beginTx();
//以target作爲主調來執行method方法
Object result = method.invoke(target , args);
//執行TxUtil對象中的endTx。
tx.endTx();
return result;
}
}public class TxUtil
{
//第一個攔截器方法:模擬事務開始
public void beginTx()
{
System.out.println("=====模擬開始事務=====");
}
//第二個攔截器方法:模擬事務結束
public void endTx()
{
System.out.println("=====模擬結束事務=====");
}
}
public static void main(String[] args)
throws Exception
{
//創建一個原始的GunDog對象，作爲target
Panther target = new GunPanther();
//以指定的target來創建動態代理
Panther panther = (Panther)MyProxyFactory.getProxy(target);
//調用代理對象的info()和run()方法
panther.info();
panther.run();
}
觀察者模式結構中包括四種角色：
一、主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法。
二、觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法。
三、具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。
四：具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成爲它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。
觀察者模式定義了對象間的一對多依賴關係，讓一個或多個觀察者對象觀察一個主題對象。當主題對象的狀態發生變化時，系統能通知所有的依賴於此對象的觀察者對象，從而使得觀察者對象能夠自動更新。
在觀察者模式中，被觀察的對象常常也被稱爲目標或主題（Subject），依賴的對象被稱爲觀察者（Observer）。
Observer，觀察者接口：
觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法
public interface Observer {
void update(Observable o, Object arg);
}Observable，目標或主題：
主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法
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);
}
}
}Product被觀察類：
具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。
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);
}
}具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成爲它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。
NameObserver名稱觀察者：
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);
}
}
