設計模式概述
設計模式概述設計模式（Design pattern）是一套被反復使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。使用設計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。
1. 設計模式不是一種方法和技術，而是一種思想
2. 設計模式和具體的語言無關,學習設計模式就是要建立面向對象的思想，盡可能的面向接口編程，低耦合，高內聚，使設計的程序可復用。
3. 學習設計模式能夠促進對面向對象思想的理解，反---之亦然。它們相輔相成
設計模式的幾個要素
* 名字 必須有一個簡單，有意義的名字
* 問題 描述在何時使用模式
* 解決方案 描述設計的組成部分以及如何解決問題
* 效果 描述模式的效果以及優缺點
設計模式的分類
1. 創建型模式對象的創建
2. 結構型模式對象的組成（結構）
3. 行為型模式對象的行為
創建型模式
簡單工廠模式
抽象產品角色
package com.china.shanghai.wanson;
public abstract class Product {
public abstract void show();
}
具體產品角色
package com.china.shanghai.wanson;
public class ConcreteProduct1 extends Product {
@Override
public void show() {
System.out.println("產品1");
}
}
package com.china.shanghai.wanson;
public class ConcreteProduct2 extends Product {
@Override
public void show() {
System.out.println("產品2");
}
}
工廠角色
package com.china.shanghai.wanson;
/**
* 簡單工廠模式概述又叫靜態工廠方法模式，
* 它定義一個具體的工廠類負責創建-些類的實例
*/
public class SimpleFactory {
public SimpleFactory() {
}
public static ConcreteProduct1 CreateProduct1(){
return new ConcreteProduct1();
}
public static ConcreteProduct2 CreateProduct2(){
return new ConcreteProduct2();
}
public static Product createProduct(String type){
if("product1".equals(type)){
return new ConcreteProduct1();
}else if("product2".equals(type)){
return new ConcreteProduct2();
}else {
return null;
}
}
}
驅動測試/客戶端測試
package com.china.shanghai.wanson;
public class Driver {
public static void main(String[] args) {
/** 方法一
* 具體類調用
*/
ConcreteProduct1 concreteProduct1=new ConcreteProduct1();
concreteProduct1.show();
ConcreteProduct2 concreteProduct2=new ConcreteProduct2();
concreteProduct2.show();
System.out.println("**************************************\n");
/**方法2
* 工廠有了后，通過工廠創建
*/
ConcreteProduct1 concreteProduct11=SimpleFactory.CreateProduct1();
concreteProduct11.show();
ConcreteProduct2 concreteProduct21=SimpleFactory.CreateProduct2();
concreteProduct21.show();
System.out.println("**************************************\n");
/** 方法3
* 改進工廠后
*/
Product product=SimpleFactory.createProduct("product1");
product.show();
product=SimpleFactory.createProduct("product2");
product.show();
product=SimpleFactory.createProduct("product3");
if(product!=null){
product.show();
}else {
System.out.println("對不起," +
"我們不生產沒這個東西");
}
}
}
工廠方法模式
抽象產品
package com.china.wanson;
public abstract class Product {
public abstract void show();
}
具體產品
package com.china.wanson;
public class ConcreteProduct1 extends Product {
@Override
public void show() {
System.out.println("product1");
}
}
package com.china.wanson;
public class ConcreteProduct2 extends Product {
@Override
public void show() {
System.out.println("product2");
}
}
抽象工廠
package com.china.wanson;
public interface Factory {
public abstract Product createProduct();
}
具體工廠
package com.china.wanson;
public class ConcreteFactory1 implements Factory {
@Override
public Product createProduct() {
return new ConcreteProduct1();
}
}
package com.china.wanson;
public class ConcreteFactory2 implements Factory {
@Override
public Product createProduct() {
return new ConcreteProduct2();
}
}
驅動測試/客戶端測試
package com.china.wanson;
public class Driver {
public static void main(String[] args) {
Factory factory=new ConcreteFactory1();
Product product=factory.createProduct();
product.show();
factory=new ConcreteFactory2();
product=factory.createProduct();
product.show();
}
}
抽象工廠模式
詳細代碼實現
package com.factory;
import com.product.ComboBox.ComboBox;
import com.product.TextField.TextField;
import com.product.button.Button;
// 界面皮膚工廠接口 充當抽象工廠
public interface SkinFactory {
public Button createButton();
public TextField createTextField();
public ComboBox createComboBox();
}
package com.factory.impl;
import com.factory.SkinFactory;
import com.product.ComboBox.ComboBox;
import com.product.ComboBox.impl.SpringComboBox;
import com.product.TextField.TextField;
import com.product.TextField.impl.SpringTextField;
import com.product.button.Button;
import com.product.button.impl.SpringButton;
///Spring皮膚工廠 充當具體工廠
public class SpringSkinFactory implements SkinFactory {
public Button createButton() {
return new SpringButton();
}
public TextField createTextField() {
return new SpringTextField();
}
public ComboBox createComboBox() {
return new SpringComboBox();
}
}
package com.factory.impl;
import com.factory.SkinFactory;
import com.product.ComboBox.ComboBox;
import com.product.ComboBox.impl.SummerComboBox;
import com.product.TextField.TextField;
import com.product.TextField.impl.SummerTextField;
import com.product.button.Button;
import com.product.button.impl.SummerButton;
///Summer皮膚工廠 充當具體工廠
public class SummerSkinFactory implements SkinFactory {
public Button createButton() {
return new SummerButton();
}
public TextField createTextField() {
return new SummerTextField();
}
public ComboBox createComboBox() {
return new SummerComboBox();
}
}
**************************************************************************************************************
package com.product.button;
//按鈕接口 充當抽象角色
public interface Button {
public void display();
}
package com.product.button.impl;
import com.product.button.Button;
//Spring按鈕類 充當具體產品
public class SpringButton implements Button {
public void display() {
System.out.println("顯示綠色按鈕");
}
}
package com.product.button.impl;
import com.product.button.Button;
public class SummerButton implements Button {
public void display() {
System.out.println("顯示紅色按鈕");
}
}
**************************************************************************************
package com.product.ComboBox;
//組合框接口 充當抽象角色
public interface ComboBox {
public void display();
}
package com.product.ComboBox.impl;
import com.product.ComboBox.ComboBox;
public class SpringComboBox implements ComboBox {
public void display() {
System.out.println("顯示綠色邊框組合框");
}
}
package com.product.ComboBox.impl;
import com.product.ComboBox.ComboBox;
public class SummerComboBox implements ComboBox {
public void display() {
System.out.println("顯示紅色邊框組合框");
}
}
********************************************************************************************************
package com.product.TextField;
public interface TextField {
public void display();
}
package com.product.TextField.impl;
import com.product.TextField.TextField;
//Spring文本框 充當具體產品
public class SpringTextField implements TextField {
public void display() {
System.out.println("顯示綠色邊框文本框");
}
}
package com.product.TextField.impl;
import com.product.TextField.TextField;
//Summer文本框 充當具體產品
public class SummerTextField implements TextField {
public void display() {
System.out.println("顯示紅色邊框文本框");
}
}
*************************************************************************************************
import com.factory.SkinFactory;
import com.factory.impl.SpringSkinFactory;
import com.factory.impl.SummerSkinFactory;
import com.product.ComboBox.ComboBox;
import com.product.TextField.TextField;
import com.product.button.Button;
public class Test {
public static void main(String[] args) {
// 使用抽象層定義
SkinFactory skinFactory;
Button button;
TextField textField;
ComboBox comboBox;
skinFactory=new SpringSkinFactory();
button=skinFactory.createButton();
textField=skinFactory.createTextField();
comboBox=skinFactory.createComboBox();
button.display();
textField.display();
comboBox.display();
System.out.println("*********************************");
skinFactory=new SummerSkinFactory();
button=skinFactory.createButton();
textField=skinFactory.createTextField();
comboBox=skinFactory.createComboBox();
button.display();
textField.display();
comboBox.display();
}
}
抽象工廠
package com.factory;
import com.product.AbstractProductWoman;
import com.product.AbstractProductMan;
//定制抽象工廠類或者接口
public interface AbstractFactory {
public AbstractProductWoman createWoman();
public AbstractProductMan createMan();
}
具體工廠
package com.factory;
import com.product.AbstractProductWoman;
import com.product.ConcreteProducNorthtMan;
import com.product.ConcreteProductNorthWoman;
import com.product.AbstractProductMan;
//具體工廠類
public class ConcreteNorthFactory implements AbstractFactory {
public AbstractProductWoman createWoman() {
return new ConcreteProducNorthtMan();
}
public AbstractProductMan createMan() {
return new ConcreteProductNorthWoman();
}
}
package com.factory;
import com.product.AbstractProductWoman;
import com.product.ConcreteProductSouthMan;
import com.product.ConcreteProductSouthWoman;
import com.product.AbstractProductMan;
//具體工廠類
public class ConcreteSouthFactory implements AbstractFactory {
public AbstractProductWoman createWoman() {
return new ConcreteProductSouthMan();
}
public AbstractProductMan createMan() {
return new ConcreteProductSouthWoman();
}
}
抽象產品1
package com.product;
public interface AbstractProductMan {
public void manufactureMan();
}
抽象產品2
package com.product;
public interface AbstractProductWoman {
public void manufactureWoman();
}
具體產品1
package com.product;
public class ConcreteProducNorthtMan implements AbstractProductWoman {
public void manufactureWoman() {
System.out.println("北方男人");
}
}
package com.product;
public class ConcreteProductNorthWoman implements AbstractProductMan {
public void manufactureMan() {
System.out.println("北方女人");
}
}
具體產品2
package com.product;
public class ConcreteProductSouthMan implements AbstractProductWoman {
public void manufactureWoman() {
System.out.println("南方男人");
}
}
package com.product;
public class ConcreteProductSouthWoman implements AbstractProductMan {
public void manufactureMan() {
System.out.println("南方女人");
}
}
建造者模式
產品角色
package com.shanghai.wanson.designpattern;
/**
* 產品角色
*/
public class Product {
private String partA;
private String partB;
private String partC;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
public void setPartC(String partC) {
this.partC = partC;
}
public void show(){
/**
* 顯示產品的特性
*/
System.out.println("超微牌子");
}
}
抽象建造者
package com.shanghai.wanson.designpattern;
/**
* 抽象建造者
*/
abstract class Builder {
/**
* 創建產品對象
*/
protected Product product=new Product();
public abstract void builderPartA();
public abstract void builderPartB();
public abstract void builderPartC();
/**
* 返回產品對象
*/
public Product getResult(){
return product;
}
}
具體建造者
package com.shanghai.wanson.designpattern;
/**
* 具體建造者
*/
public class ConcreteBuilder extends Builder {
@Override
public void builderPartA() {
product.setPartA("建造partA");
}
@Override
public void builderPartB() {
product.setPartB("建造partB");
}
@Override
public void builderPartC() {
product.setPartC("建造partC");
}
}
指揮者
package com.shanghai.wanson.designpattern;
/**
* 指揮者
*/
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
/**
* 產品構建與組裝方法
*/
public Product construct(){
builder.builderPartA();
builder.builderPartB();
builder.builderPartC();
return builder.getResult();
}
}
驅動測試/客戶端測試
package com.shanghai.wanson.designpattern;
public class Driver {
public static void main(String[] args) {
Builder builder=new ConcreteBuilder();
Director director=new Director(builder);
Product product=director.construct();
product.show();
}
}
case:建造者模式小案例
package com.product;
//復合產品
public class Actor {
private String Type;//臉色類型
private String sex;//性別
private String face;//臉型
private String costume;//服裝
private String hairstyle;//發型
public String getType() {
return Type;
}
public void setType(String type) {
Type = type;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getFace() {
return face;
}
public void setFace(String face) {
this.face = face;
}
public String getCostume() {
return costume;
}
public void setCostume(String costume) {
this.costume = costume;
}
public String getHairstyle() {
return hairstyle;
}
public void setHairstyle(String hairstyle) {
this.hairstyle = hairstyle;
}
}
********************************************************************************************************************
package com.build;
import com.product.Actor;
//角色建造起 ：抽象建造者
public abstract class ActorBuilder {
protected Actor actor=new Actor();
public abstract void buildType();
public abstract void buildSex();
public abstract void buildFace();
public abstract void buildCostume();
public abstract void buildHairstyle();
public Actor createActor(){
return actor;
}
}
****************************************************************************************************************************
package com.build.impl;
import com.build.ActorBuilder;
//天使角色建造器:具體建造者
public class AngelBuilder extends ActorBuilder {
public void buildType() {
actor.setType("天使");
}
public void buildSex() {
actor.setSex("女");
}
public void buildFace() {
actor.setFace("漂亮");
}
public void buildCostume() {
actor.setCostume("白裙");
}
public void buildHairstyle() {
actor.setHairstyle("披肩長發");
}
}
******************************************************************************************************
package com.build.impl;
import com.build.ActorBuilder;
//魔鬼角色建造器:具體建造者
public class GhostBuilder extends ActorBuilder {
public void buildType() {
actor.setType("魔鬼");
}
public void buildSex() {
actor.setSex("妖");
}
public void buildFace() {
actor.setFace("丑陋");
}
public void buildCostume() {
actor.setCostume("黑衣");
}
public void buildHairstyle() {
actor.setHairstyle("光頭");
}
}
*******************************************************************************************************
package com.build.impl;
import com.build.ActorBuilder;
//英雄角色建造器:具體建造者
public class HeroBuilder extends ActorBuilder {
public void buildType() {
actor.setType("英雄");
}
public void buildSex() {
actor.setSex("男");
}
public void buildFace() {
actor.setFace("英俊");
}
public void buildCostume() {
actor.setCostume("盔甲");
}
public void buildHairstyle() {
actor.setHairstyle("飄逸");
}
}
**********************************************************************************************************
package com.director;
import com.build.ActorBuilder;
import com.product.Actor;
//指揮官角色 充當指揮者
public class DirectorController {
public Actor construct(ActorBuilder actorBuilder){
actorBuilder.buildType();
actorBuilder.buildSex();
actorBuilder.buildFace();
actorBuilder.buildCostume();
actorBuilder.buildHairstyle();
return actorBuilder.createActor();
}
}
*****************************************************************************************
package com.test;
import com.build.ActorBuilder;
import com.build.impl.AngelBuilder;
import com.build.impl.GhostBuilder;
import com.build.impl.HeroBuilder;
import com.director.DirectorController;
import com.product.Actor;
public class Driver {
public static void main(String[] args) {
DirectorController directorController=new DirectorController();
System.out.println("*********************天使**********************************");
ActorBuilder actorBuilder=new AngelBuilder();
Actor angle=directorController.construct(actorBuilder);
String type=angle.getType();
System.out.println(type+"的外觀:\t\t");
System.out.println("性別:\t"+angle.getSex());
System.out.println("面容:\t"+angle.getFace());
System.out.println("服裝:\t"+angle.getCostume());
System.out.println("發型:\t"+angle.getHairstyle());
System.out.println("*******************************************************");
System.out.println("**********************英雄*********************************");
ActorBuilder actorBuilder1=new HeroBuilder();
Actor hero=directorController.construct(actorBuilder1);
String type1=hero.getType();
System.out.println(type1+"的外觀:\t\t");
System.out.println("性別:\t"+hero.getSex());
System.out.println("面容:\t"+hero.getFace());
System.out.println("服裝:\t"+hero.getCostume());
System.out.println("發型:\t"+hero.getHairstyle());
System.out.println("*******************************************************");
System.out.println("**********************魔鬼*********************************");
ActorBuilder actorBuilder2=new GhostBuilder();
Actor ghost=directorController.construct(actorBuilder2);
String type2=ghost.getType();
System.out.println(type2+"的外觀:\t\t");
System.out.println("性別:\t"+ghost.getSex());
System.out.println("面容:\t"+ghost.getFace());
System.out.println("服裝:\t"+ghost.getCostume());
System.out.println("發型:\t"+ghost.getHairstyle());
System.out.println("*******************************************************");
}
}
原型模式
抽象原型類
package com.china.wanson;
public class Prototype implements Cloneable {
public Prototype clone(){
Prototype prototypeobject=null;
try {
prototypeobject=(Prototype)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return prototypeobject;
}
}
具體原型類
package com.china.wanson;
public class ConcretePrototype extends Prototype {
public void show(){
System.out.println("原型模式實現類");
}
}
驅動測試/客戶端測試
package com.china.wanson;
public class Driver {
public static void main(String[] args) throws CloneNotSupportedException {
ConcretePrototype cp=new ConcretePrototype();
for (int i = 0; i <10 ; i++) {
ConcretePrototype clonecp=(ConcretePrototype) cp.clone();
clonecp.show();
}
}
}
單例模式
單例模式驅動
package com.wanson.designpatten;
public class Singleton {
private static volatile Singleton instance=null; //單例對象
private Singleton(){ //私有構造函數
}
//靜態工廠方法
public static Singleton getInstance(){
if(instance==null){ //雙重檢測機制
synchronized (Singleton.class){ //同步鎖
if(instance==null){
instance=new Singleton(); //雙重檢測機制
}
}
}
return instance;
}
}
客戶端測試/驅動測試
package com.wanson.designpatten;
import java.util.Calendar;
public class Driver {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
System.out.println(instance);
Singleton secondInstance = Singleton.getInstance();
System.out.println(secondInstance);
Calendar calendar1=Calendar.getInstance();
System.out.println(calendar1);
Calendar calendar2=Calendar.getInstance();
System.out.println(calendar2);
}
}
單例模式案例
public class Singleton {
/**
* 雙重鎖校驗機制 *
*/
/*private static volatile Singleton instance=null;
private Singleton() {
System.out.println("產生一個學習委員");
}
public static synchronized Singleton getInstance() {
if (instance==null){
instance=new Singleton();
}else {
System.out.println("已經有一個學習委員，不能產生新的學習委員");
}
return instance;
}
public static void setInstance(Singleton instance) {
Singleton.instance = instance;
}
public void getName(){
System.out.println("我是學習委員:李遠遠");
}*/
/**
* 懶漢 線程不安全
*/
/*private static Singleton instance;
public Singleton() {
System.out.println("產生一個學習委員");
}
public static Singleton getInstance() {
if(instance==null){
instance=new Singleton();
}else {
System.out.println("已經有一個學習委員，不能產生新的學習委員");
}
return instance;
}
public void getName(){
System.out.println("我是學習委員:李遠遠");
}*/
/**
* 懶漢 線程安全
*/
/*private static Singleton instance;
public Singleton() {
System.out.println("產生一個學習委員");
}
public static synchronized Singleton getInstance() {
if(instance==null){
instance=new Singleton();
}else {
System.out.println("已經有一個學習委員，不能產生新的學習委員");
}
return instance;
}
public void getName(){
System.out.println("我是學習委員:李遠遠");
}*/
/**
* 餓漢
*/
/* private static Singleton instance=new Singleton();
public Singleton() {
System.out.println("產生一個學習委員");
}
public static Singleton getInstance() {
if(instance==null){
return instance;
}else {
System.out.println("已經有一個學習委員，不能產生新的學習委員");
return instance;
}
}
public void getName(){
System.out.println("我是學習委員:李遠遠");
}*/
/**
* 餓漢的 變異版
*/
/*private static Singleton instance=null;
static {
instance=new Singleton();
}
public static Singleton getInstance() {
if(instance==null){
return instance;
}else {
System.out.println("已經有一個學習委員，不能產生新的學習委員");
return instance;
}
}
public void getName(){
System.out.println("我是學習委員:李遠遠");
}*/
/**
* 內部靜態類
*/
private static class SingletonHolder{
private static final Singleton instance=new Singleton();
}
public Singleton() {
System.out.println("產生一個學習委員");
}
public static final Singleton getInstance() {
if(SingletonHolder.instance==null){
return SingletonHolder.instance;
}else {
System.out.println("已經有一個學習委員，不能產生新的學習委員");
return SingletonHolder.instance;
}
}
public void getName(){
System.out.println("我是學習委員:李遠遠");
}
}
public class Driver {
public static void main(String[] args) {
Singleton singleton=Singleton.getInstance();
singleton.getName();
System.out.println("*****************************");
Singleton singleton1=Singleton.getInstance();
singleton1.getName();
if(singleton==singleton1){
System.out.println("same");
}else {
System.out.println("not same");
}
}
}
結構型模式
適配器模式
橋接模式
組合模式
裝飾模式
外觀模式
外觀角色
package com.shanghai.wanson.designpattern;
/**
*外觀角色
*/
public class Facade {
private subSystem01 system01=new subSystem01();
private subSystem02 system02=new subSystem02();
private subSystem03 system03=new subSystem03();
public void method(){
system01.methon1();
system02.methon2();
system03.methon3();
}
}
子系統角色01
package com.shanghai.wanson.designpattern;
/**
* 子系統角色01
*/
public class subSystem01 {
public void methon1(){
System.out.println("子系統01方法被調用");
}
}
子系統角色02
package com.shanghai.wanson.designpattern;
/**
* 子系統角色02
*/
public class subSystem02 {
public void methon2(){
System.out.println("子系統02方法被調用");
}
}
子系統角色03
package com.shanghai.wanson.designpattern;
public class subSystem03 {
public void methon3(){
System.out.println("子系統03方法被調用");
}
}
客戶角色或者驅動測試
package com.shanghai.wanson.designpattern;
public class Driver {
public static void main(String[] args) {
Facade facade=new Facade();
facade.method();
}
}
外觀模式優/缺點與適用環境
外觀模式是一種使用頻率非常高的設計模式，它通過引入ー個外觀角色來簡化客戶端與子系統之間的交互，為復雜的子系統調用提供一個統一的入口，使子系統與客戶端的耦合度降低，且客戶端調用非常方便。
外觀模式並不給系統增加任何新功能，它僅僅是簡化調用接口。在幾乎所有的軟件中都能夠找到外觀模式的應用，
例如
絕大多數B/S系統都有一個首頁或者導航頁面，大部分C/S系統都提供了菜單或者工具欄，在這里首頁和導航頁面就訪問子系統，降低了系統的復雜程度。
所有涉及與多個業務對象交互的場景都可以考慮 是BS系統的外觀角色，而菜單和工具欄就是CS系統的外觀角色，通過它們用戶可以快使用外觀模式進行重構，
例如 Java EE中的 Session外觀模式。
外觀模式優點
外觀模式的優點主要如下
(1)它對客戶端屏蔽了子系統組件，減少了客戶端所需處理的對象數目，並使子系統使用起來更加容易。通過引入外觀模式，客戶端代碼將變得很簡單，與之關聯的對象也很少。
(2)它實現了子系統與客戶端之間的松耦合關系，這使得子系統的變化不會影響到調用它的客戶端，只需要調整外觀類即可
(3)一個子系統的修改對其他子系統沒有任何影響，而且子系統內部變化也不會影響到外觀對象。
外觀模式缺點
外觀模式的缺點主要如下:
(1)不能很好地限制客戶端直接使用子系統類，如果對客戶端訪問子系統類做太多限制則減少了可變性和靈活性。
(2)如果設計不當，增加新的子系統可能需要修改外觀類的源代碼，違背了開閉原則。
外觀模式適用環境
在以下情況下可以考慮使用外觀模式:
(1)當要為訪問一系列復雜的子系統提供一個簡單入口時可以使用外觀模式。
(2)客戶端程序與多個子系統之間存在很大的依賴性。引入外觀類可以將子系統與客戶端解耦，從而提高子系統的獨立性和可移植性。
(3)在層次化結構中可以使用外觀模式定義系統中每一層的入口，層與層之間不直接產生聯系，而通過外觀類建立聯系，降低層之間的耦合度。
享元模式
代理模式
package com.shanghai.subject;
//抽象主體角色
public abstract class AbstractSubject {
public abstract void buyTV();
}
package com.shanghai.proxy;
import com.shanghai.subject.AbstractSubject;
//代理主體角色
public class Proxy extends AbstractSubject {
RealProxy realProxyBuyer =new RealProxy();
public void preRequest(){
System.out.println("詢問客戶需求比如類型 尺寸 價位 等相關信息");
}
public void buyTV() {
preRequest();
realProxyBuyer.buyTV();
postRequest();
}
public void postRequest(){
System.out.println("負責把電視機送到客戶家里，然后進行安裝事宜");
}
}
package com.shanghai.proxy;
import com.shanghai.subject.AbstractSubject;
//真實代理角色
public class RealProxy extends AbstractSubject {
public void buyTV() {
System.out.println("\t\t\t\t我已經在商場買了一台電視機");
}
}
package com.shanghai.test;
import com.shanghai.proxy.Proxy;
import com.shanghai.subject.AbstractSubject;
public class Test {
public static void main(String[] args) {
AbstractSubject abstractSubject=
new Proxy();
abstractSubject.buyTV();
}
}
行為型模式
職責鏈模式
package com.wanson.request;
// 采購單類 充當請求類
public class PurchaseRequest {
private double amount;//采購金額
private int number;//采購單編號
private String purpose;//采購目的
public PurchaseRequest(double amount, Integer number, String purpose) {
this.amount = amount;
this.number = number;
this.purpose = purpose;
}
public Double getAmount() {
return amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public Integer getNumber() {
return number;
}
public void setNumber(Integer number) {
this.number = number;
}
public String getPurpose() {
return purpose;
}
public void setPurpose(String purpose) {
this.purpose = purpose;
}
}
********************************************************************************************************************************************************
package com.wanson.handle;
import com.wanson.request.PurchaseRequest;
//審批者類 充當抽象處理者
public abstract class Approver {
protected Approver successor;//定義后繼對象
protected String name;
public Approver(String name) {
this.name = name;
}
//設置后繼者
public void setSuccessor(Approver successor) {
this.successor = successor;
}
// 抽象請求處理方法
public abstract void processRequest(PurchaseRequest request);
}
******************************************************************************************************************************************************
package com.wanson.handle.impl;
import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
// 主任 充當具體處理者
public class Director extends Approver {
public Director(String name) {
super(name);
}
public void processRequest(PurchaseRequest request) {
if (request.getAmount()<50000){
System.out.println("主任"+this.name+"審批采購單:"+
request.getNumber()+",金額:"+
request.getAmount()+"元,采購目的:"+
request.getPurpose()+".");//處理請求
}else {
this.successor.processRequest(request);//轉發請求
}
}
}
********************************************************************************************************************************************************************************
package com.wanson.handle.impl;
import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
// 副董事長 充當具體處理者
public class VicePresident extends Approver {
public VicePresident(String name) {
super(name);
}
public void processRequest(PurchaseRequest request) {
if (request.getAmount() < 100000) {
System.out.println("副董事長" + this.name + "審批采購單:" +
request.getNumber() + ",金額:" +
request.getAmount() + "元,采購目的:" +
request.getPurpose() + ".");//處理請求
} else {
this.successor.processRequest(request);//轉發請求
}
}
}
********************************************************************************************************************************************************
package com.wanson.handle.impl;
import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
// 董事長 充當具體處理者
public class President extends Approver {
public President(String name) {
super(name);
}
public void processRequest(PurchaseRequest request) {
if (request.getAmount() < 500000) {
System.out.println("董事長" + this.name + "審批采購單:" +
request.getNumber() + ",金額:" +
request.getAmount() + "元,采購目的:" +
request.getPurpose() + ".");//處理請求
} else {
this.successor.processRequest(request);//轉發請求
}
}
}
*****************************************************************************************************************************************************************************************
package com.wanson.handle.impl;
import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
public class Congress extends Approver {
public Congress(String name) {
super(name);
}
public void processRequest(PurchaseRequest request) {
System.out.println("召開董事會審批采購單:" +
request.getNumber() + ",金額:" +
request.getAmount() + "元,采購目的:" +
request.getPurpose() + ".");//處理請求
}
}
***************************************************************************************************************************************************************************
package com.test;
import com.wanson.handle.*;
import com.wanson.handle.impl.Congress;
import com.wanson.handle.impl.Director;
import com.wanson.handle.impl.President;
import com.wanson.handle.impl.VicePresident;
import com.wanson.request.PurchaseRequest;
public class Test {
public static void main(String[] args) {
Approver
sunwukong=new Director("孫悟空"),
tangseng=new VicePresident("唐僧"),
pusa=new President("觀音菩薩"),
congress=new Congress("董事會");
// 創建責任鏈
sunwukong.setSuccessor(tangseng);
tangseng.setSuccessor(pusa);
pusa.setSuccessor(congress);
// 創建采購單
PurchaseRequest purchaseRequest1=new PurchaseRequest(3000,10001,"西游記");
sunwukong.processRequest(purchaseRequest1);
PurchaseRequest purchaseRequest2=new PurchaseRequest(60000,10002,"水滸傳");
sunwukong.processRequest(purchaseRequest2);
PurchaseRequest purchaseRequest3=new PurchaseRequest(160000,1003,"三國演義");
sunwukong.processRequest(purchaseRequest3);
PurchaseRequest purchaseRequest4=new PurchaseRequest(800000,1004,"The Plum in the Golden Vase");
sunwukong.processRequest(purchaseRequest4);
}
}
命令模式
解釋器模式
迭代器模式
抽象迭代器
package com.china.wanson;
public interface Iterator {
public boolean hasNext();
public Object next();
}
具體迭代器
package com.china.wanson;
public class ConcreteIterator implements Iterator {
private List list=null;
private int index;
public ConcreteIterator(List list) {
super();
this.list = list;
}
@Override
public boolean hasNext() {
if(index>=list.getSize()){
return false;
}else {
return true;
}
}
@Override
public Object next() {
Object object=list.get(index++);
return object;
}
}
抽象聚合類
package com.china.wanson;
public interface List {
public void add(Object object);
public Object get(int index);
public Iterator iterator();
public int getSize();
}
具體聚合類
package com.china.wanson;
public class ConcreteAggregate implements List {
private Object[]list;
private int size=0;
private int index=0;
public ConcreteAggregate() {
index=0;
size=0;
list=new Object[100];
}
@Override
public void add(Object object) {
list[index++]=object;
size++;
}
@Override
public Object get(int index) {
return list[index];
}
@Override
public Iterator iterator() {
return new ConcreteIterator(this);
}
@Override
public int getSize() {
return size;
}
}
驅動測試/測試客戶端
package com.china.wanson;
public class Driver {
public static void main(String[] args) {
List list=new ConcreteAggregate();
list.add("beijing");
list.add("shanghai");
list.add("shenzhen");
Iterator iterator=list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
中介者模式
備忘錄模式
觀察者模式
抽象觀察者
package com.shanghai.wanson.designpattern;
/**
* 抽象觀察者
*/
public interface Observer {
void response();//反應
}
抽象目標
package com.shanghai.wanson.designpattern;
import java.util.ArrayList;
import java.util.List;
/**
* 抽象目標
*/
abstract class Subject {
//定義一個觀察者集合 用於存儲 所有觀察者對象
protected List<Observer> observers=new ArrayList<Observer>();
//增加觀察者方法
public void add(Observer observer){
observers.add(observer);
}
//刪除觀察者方法
public void remove(Observer observer){
observers.remove(observer);
}
public abstract void notifyObserve();//通知觀察者方法
}
具體目標
package com.shanghai.wanson.designpattern;
/**
* 具體目標
*/
public class ConcreteSubject extends Subject {
@Override
public void notifyObserve() {
System.out.println("具體目標發生改變......");
System.out.println("---------------------");
for (Object object:observers){
((Observer)object).response();
}
}
}
具體觀察者1
package com.shanghai.wanson.designpattern;
/**
* 具體觀察者1
*/
public class ConcreteObserver1 implements Observer {
@Override
public void response() {
System.out.println("具體觀察者1做出反應！！");
}
}
具體觀察者2
package com.shanghai.wanson.designpattern;
/**
* 具體觀察者2
*/
public class ConcreteObserver2 implements Observer {
@Override
public void response() {
System.out.println("具體觀察者2做出反應！！");
}
}
測試客戶端
package com.shanghai.wanson.designpattern;
/**
* 觀察者設計模式
*/
public class ObserverPattern {
public static void main(String[] args) {
Subject subject=new ConcreteSubject();
Observer observer1=new ConcreteObserver1();
Observer observer2=new ConcreteObserver2();
subject.add(observer1);
subject.add(observer2);
subject.notifyObserve();
}
}
觀察者模式優/缺點與適用環境
觀察者模式是一種使用頻率非常高的設計模式，無論是移動應用、web應用或者桌面應用，觀察者模式幾乎無處不在，它為實現對象之間的聯動提供了一套完整的解決方案，
凡是涉及一對一或者一對多的對象交互場都可以使用觀察者模式。
觀察者模式廣泛應用於各種編程語言的GUI事件處理的實現，
在基於事件的XML解析技術(例如SAX2)
以及Web事件處理中也都使用了觀察者模式。
觀察者模式優點
觀察者模式優點觀察者模式的優息主要如下:
(1)可以實現表示層和數據邏輯層的分離，定義了穩定的消息更新傳遞機制，並抽象了更新接口，使得可以有各種各樣不同的表示層充當具體觀察者角色。
(2)在觀察目標和觀察者之間建立一個抽象的耦合。觀察目標只需要維持一個抽象觀察者的集合，無須了解其具體觀察者，由於觀察目標和觀察者沒有緊密地耦合在一起，因此它們可以屬於不同的抽象化層次
(3)支播通信，觀察目標會向所有已注冊的觀察者對象發送通知，簡化了一對多系統設計的難度
(4)符合開團原則，增加新的具體觀察者無須修改原有系統代碼，在具體觀察者與觀察目標之間不存在關聯關系的情況下增加新的觀察目標也很方便。
觀察者模式缺點
(1)如果一個觀察目標對象有很多直接和間接觀察者，將所有的觀察者都通知到會花很多時間。
(2)如果在觀察者和觀察目標之間存在循環依賴，觀察目標會觸發它們之間進行循環調用，可能導致系統崩
(3)觀察者模式沒有相應的機制讓觀察者知道所觀察的目標對象是怎么發生變化的而僅僅只是知道觀察目標發生了變化。
觀察者模式適用環境
在以下情況下可以考慮使用觀察者模式:
(1)ー個抽象模型有兩個方面 ,
其中一個方面依賴於另一個方面，將這兩個方面封裝在獨立的對象中使它們可以各自獨立地改變和復用
(2)一個對象的改變將導致一個或多個其他對象也發生改變，而並不知道具體有多少對象將發生改變，也不知道這些對象是誰。
(3)需要在系統中創建一個觸發鏈，A對象的行為將影響B對象，B對象的行為將影響C對象……，可以使用觀察者模式創建一種鏈式觸發機制。
狀態模式
抽象狀態類
package com.com.china.wanson.statepattern;
/**
* 抽象狀態類
*/
public abstract class State {
public abstract void Handle(Context context);
}
具體狀態類
package com.com.china.wanson.statepattern;
/**
* 具體狀態類1
*/
public class ConcreteState1 extends State {
@Override
public void Handle(Context context) {
System.out.println("當前狀態A:");
context.setState(new ConcreteState2());
}
}
package com.com.china.wanson.statepattern;
/**
* 具體狀態類2
*/
public class ConcreteState2 extends State {
@Override
public void Handle(Context context) {
System.out.println("當前狀態B");
context.setState(new ConcreteState1());
}
}
環境類或上下文類
package com.com.china.wanson.statepattern;
/**
* 環境類
*/
public class Context {
private State state;
//定義環境類的初始狀態
public Context() {
this.state = new ConcreteState1();
}
//讀取狀態
public State getState() {
return state;
}
//設置新的狀態
public void setState(State state) {
this.state = state;
}
//對請求做處理
public void Handle(){
state.Handle(this);
}
}
驅動測試/客戶端測試
package com.com.china.wanson.statepattern;
public class Driver {
public static void main(String[] args) {
Context context=new Context();
context.Handle();
context.Handle();
context.Handle();
context.Handle();
context.Handle();
}
}
策略模式
模板方法模式
訪問者模式
