文章目錄

• 設計模式
• • 1.七大原則
  • • 1.單一職責原則
    • 2.接口隔離原則
    • 3.依賴倒轉原則
    • • 代碼實現
      • • 有問題代碼
        • 實現依賴倒轉原則以后的代碼
    • 4.里氏替換原則
    • 5.開閉原則
    • 6.迪米特法原則
    • **7.合成復用原則**
  • 設計模式：
  • • 1.單例模式：
    • • 餓漢模式：
      • 懶漢模式（雙重if判斷）：
      • 懶漢模式靜態內部類：
      • 枚舉單例模式：
    • 2.策略模式（把相同行為的不同實現進行封裝）
    • 3. 享元模式（Flyweight pattern）
    • 4.代理模式
    • • 靜態代理
      • 動態代理(JDK代理)
      • cglib代理
    • 5.模板方法模式
    • 6.觀察者模式
    • 7.工廠模式
    • • 7.1代碼
      • 7.2抽象出來的三個抽象類
      • 7.3 把三個抽象類放到一個抽象類中封裝
      • 7.4 每個產品增加自己產品抽象類，繼承（extends）抽象父類
      • • 7.41現代世界的人
        • 7.42魔法世界的人
      • 7.43客戶端進行調用,修改MagicStickFactory這個產品就可以進行不同的調用

設計模式

1.七大原則

1.單一職責原則

（每個類或者每個方法只需要實現一個職責，不需要實現很多其他的功能。）在類中的方法足夠多需要在類的層面遵守單一職責原則

方法遵循單一職責代碼實現：

package com.example;public class SingleResponsibility {public static void main(String[] args) {Vehicle vehicle = new Vehicle();vehicle.runAir("飛機");vehicle.runRolad("車子");vehicle.runWater("游艇");} } class Vehicle{public void runRolad(String vehicle){System.out.println(vehicle + "在公路上面運行");}public void runWater(String vehicle){System.out.println(vehicle + "在水中上面運行");}public void runAir(String vehicle){System.out.println(vehicle + "在天上運行");} }

2.接口隔離原則

A通過接口B依賴于C（只要實現接口B的1，2，3方法）,D通過接口B依賴于F（只需要 實現接口B的1，4，5方法）,這樣A就得實現所有的B接口的方法，D就得實現所有的B接口方法，導致浪費，且相關性強，所以得遵循接口最小原則，把 方法1 放在一個接口Interface1， 方法 2，3放在一個接口Interface2 ,方法4，5放在一個接口Interface3.

3.依賴倒轉原則

高層模塊不應該依賴低層模塊，二者應該依賴其抽象（接口和抽象類）

抽象不應該依賴細節，細節（一般是java的實現類）應該依賴抽象

、依賴倒轉的中心思想是面向接口編程

設計理念：以抽象為基礎搭建的架構比以細節為基礎的架構要穩定的多。

java里面接口或者抽象類的目的是設計好規范（不去實現），實現一定是由那個實現類去操作。

繼承時遵循里氏替換原則

代碼實現

有問題代碼

package com.monkey.single.inversion;public class DependenceInversion {public static void main(String[] args) {Person person = new Person();person.receiveMessage(new Email());} }class Email{public String getInfo(){return "email,helloWorld";} }//1.這個只可以接收郵箱的消息，不可以接收其他的比如微信，支付寶，短信的消息。 //2.我們可以來創建一個接口IReceiver(),這樣Person類和接口IReceiver發生依賴 //因為Email,WeChat等等屬于接收的范圍，他們各自實現IReceiver接口就行，這樣就發生了依賴倒轉。class Person{ // 這里是對實現類進行了依賴public void receiveMessage(Email email){System.out.println(email.getInfo());}}

實現依賴倒轉原則以后的代碼

package com.monkey.single.inversion;public class DependenceInversion {public static void main(String[] args) {Person person = new Person();person.receiveMessage(new Email());person.receiveMessage(new Wexin());} }interface Ireceiver{public String getInfo(); }class Email implements Ireceiver{public String getInfo(){return "email,helloWorld";} }class Wexin implements Ireceiver{public String getInfo(){return "wexin,helloWorld";}}//1.這個只可以接收郵箱的消息，不可以接收其他的比如微信，支付寶，短信的消息。 //2.我們可以來創建一個接口IReceiver(),這樣Person類和接口IReceiver發生依賴 //因為Email,WeChat等等屬于接收的范圍，他們各自實現IReceiver接口就行，這樣就發生了依賴倒轉。class Person{// 這里是對接口進行依賴，穩定性好public void receiveMessage(Ireceiver ireceiver){System.out.println(ireceiver.getInfo());}}

實現接口間依賴傳遞的三種方式：

通過接口傳遞實現依賴

通過構造方法依賴傳遞

通過setter方法依賴傳遞

代碼：

4.里氏替換原則

5.開閉原則

6.迪米特法原則

7.合成復用原則

經典面試題目？

在項目的實際開發中哪里使用了ocp原則？ （工廠模式中有用）

spring中應用了哪些設計模式，原型模式在哪里 用到？

什么是解釋器設計模式？畫出它的UML類圖，分析各個角色是什么？

spring框架中哪里使用到了解釋器設計模式？并做源碼級別分析

單例模式一共有幾種實現方式？用代碼實現，并說明各個的優點缺點。

單列設計模式有幾種實現方式？

餓漢式 兩種

懶漢式 三種

雙重檢查

靜態內部類

設計模式概念：（design pattern）是對在軟件設計普遍存在（反復出現）的各種問題，提出 的一種解決方案。

使用設計模式可以使用項目具有：可擴展性，維護性，可靠性（新增一個功能對原來的功能影響不大），可復用性，效率提高等等

設計模式：

1.單例模式：

餓漢模式：

package com.monkey.sigleton; /* * 餓漢模式： * 類加載就實例化，JVM保證線程安全 * 推薦使用 * 唯一缺點： 不管使用與與否，類加載就會完成實例化 * * */ public class HungryMode {private static final HungryMode Instance = new HungryMode();private HungryMode(){};public static HungryMode getInstance(){return Instance;}public static void main(String[] args) {HungryMode instance = HungryMode.getInstance();HungryMode instance1 = HungryMode.getInstance();System.out.println(instance == instance1);}}

懶漢模式（雙重if判斷）：

package com.monkey.sigleton;public class LazyModeImprove {private static LazyModeImprove Instance;private LazyModeImprove(){};private static LazyModeImprove getInstance(){if(Instance == null){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (LazyModeImprove.class){if(Instance == null){Instance = new LazyModeImprove();}}}return Instance;}public static void main(String[] args) {for (int i = 0; i < 1000; i++) {new Thread(()->System.out.println(Instance.getInstance())).start();}} }

懶漢模式靜態內部類：

package com.monkey.sigleton;public class LazyModeStaicInnerClass {private LazyModeStaicInnerClass(){};private static class SingletonInstance{private static final LazyModeStaicInnerClass Instance = new LazyModeStaicInnerClass();}public static LazyModeStaicInnerClass getInstance(){return SingletonInstance.Instance;}}

枚舉單例模式：

package com.monkey.sigleton;public enum EnumMode{ // 1. 可以防止反序列化，也是線程安全的INSTANCE;public void hellowWord(){System.out.println("hello Word");}public static void main(String[] args) {INSTANCE.hellowWord();}}

2.策略模式（把相同行為的不同實現進行封裝）

package com.monkey.strategy.improve;public abstract class Duck {FlyBehavior flyBehavior;public Duck() {}public abstract void display();//顯示鴨子信息public void setFlyBehavior(FlyBehavior flyBehavior) {this.flyBehavior = flyBehavior;}public void quack(){System.out.println("鴨子會嘎嘎叫");}public void swim(){System.out.println("鴨子會游戲");} // public void fly(){ // System.out.println("鴨子會飛行"); // } // improvepublic void fly(){if(flyBehavior !=null){flyBehavior.fly();}} } package com.monkey.strategy.improve;public interface FlyBehavior {void fly(); //子類具體實現 } package com.monkey.strategy.improve;public class GoodFlyBehavior implements FlyBehavior{@Overridepublic void fly() {System.out.println("飛翔技術高超");} } package com.monkey.strategy.improve;public class GoodFlyBehavior implements FlyBehavior{@Overridepublic void fly() {System.out.println("飛翔技術高超");} } package com.monkey.strategy.improve;public class PekingDuck extends Duck {PekingDuck(){flyBehavior = new BadFlyBehavior();}@Overridepublic void display() {System.out.println("我是北京鴨");} //北京鴨不能飛行，這里需要重寫方法/* @Overridepublic void fly() {System.out.println("北京鴨不能飛行");}*/ } package com.monkey.strategy.improve;public class ToyDuck extends Duck {ToyDuck(){flyBehavior = new BadFlyBehavior();}@Overridepublic void display() {System.out.println("我是玩具鴨");} // 需要重寫父類的所有方法public void quack(){System.out.println("玩具鴨子不會嘎嘎叫"); }public void swim(){System.out.println("玩具鴨子不會游戲");} // public void fly(){ // System.out.println("玩具鴨子不會飛行"); // } } package com.monkey.strategy.improve;public class WildDuck extends Duck {WildDuck(){flyBehavior = new GoodFlyBehavior();}@Overridepublic void display() {System.out.println("我是野鴨子");} }

3. 享元模式（Flyweight pattern）

場景應用：**數據庫連接池，緩沖池，Integer的底層源碼，String常量池等等。**可以解決重復對象內存浪費問題。

理解：需要的我們拿來使用，不需要的直接創建 new一個。

String str = "hello"; String s2 = new String("hello ");

**內部狀態：**對象共享出來的信息，且不隨享元對象的外部狀態改變而改變。

**外部狀態：**隨環境的改變而改變，不可共享的一個狀態。

public class IntegerCode {public static void main(String[] args) {Integer integer = Integer.valueOf(126);Integer integer1 = Integer.valueOf(126);System.out.println(integer == integer1);Integer integer2 = Integer.valueOf(128);Integer integer3 = Integer.valueOf(128);System.out.println(integer2 == integer3);} } //里面的Integer.valueOf()使用了享元模式，如果大小在[-128,127]之間使用同一個數組里面的數據，否則重新創建一個Integer類型對象，減少了內存的消耗。

4.代理模式

為一個對象提供一個替身，以控制這個對象的訪問。即 通過代理對象訪問目標對象。

被代理的對象可以是 遠程對象，創建開銷大的對象，或需要安全控制的對象。

主要有：動態代理（也叫jdk代理），靜態代理，cglib代理（可以在內存動態的創建對象，不需要實現接口，屬于動態代理）。

在有些情況下，我們不可以直接訪問目標對象，需要通過另外一個對象進行代理訪問。

靜態代理

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-owrRldFi-1659411175436)(C:\Users\24473\AppData\Roaming\Typora\typora-user-images\image-20220706230151861.png)]

動態代理(JDK代理)

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-ludHQFDo-1659411175438)(C:\Users\24473\AppData\Roaming\Typora\typora-user-images\image-20220709173609450.png)]

圖片上面是復用反射機制

可以看到代理對象不用實現目標接口

其實是通過 java的反射機制實現，然后通過代理對象進行調用ITeacherDao方法。

代理對象=增強內容+原對象。 其實就是spring中的aop我們想在當前的業務邏輯下添加一些其他的處理，比如日志、校驗等等，就不得不侵入原有的業務代碼，尤其是在重重繼承關系復雜的類中，需要增加一些內容，并不清楚會不會影響到其他功能，所以使用代理來實現需要增加的內容 package com.monkey.proxy.dynamic;public interface IteacherDao {void teach();//String sayProxyStart(String proxyName); } package com.monkey.proxy.dynamic;import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;public class ProxyFactory {private Object target; //代理的目標對象// 有參樹構造器，對target 進行初始化public ProxyFactory(Object target) {this.target = target;}//給目標對象通過 JDK的API 生成代理對象的方法public Object getProxyInstace(){ // ClassLoader loader 類加載器 // 2. Class<?> interface // 3. InvocationHandler //return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("jdk動態代理開始");Object object = method.invoke(target, args);return object;}});} } package com.monkey.proxy.dynamic;import com.monkey.proxy.ITeacherDao;public class Teacher implements IteacherDao {@Overridepublic void teach() {System.out.println("老師正在授課中。。。。。。。。。。");}@Overridepublic String sayProxyStart(String proxyName) {return proxyName;}} package com.monkey.proxy.dynamic;public class Client {public static void main(String[] args) {Teacher target = new Teacher();// 需要強制類型轉換為ITeacherDao才可以調用到 接口里面的方法IteacherDao proxyInstace = (IteacherDao)new ProxyFactory(target).getProxyInstace();System.out.println("proxyInstace"+proxyInstace); // 調用代理對象的方法proxyInstace.teach();String hello_proxy = proxyInstace.sayProxyStart("hello Proxy");System.out.println(hello_proxy);} }

cglib代理

靜態代理類和jdk代理都需要我們的目標對象實現一個接口，但是有些時候我們希望這個目標對象沒有實現接口,可以使用目標對象的子類實現代理，這就是cglib代理。

cglib是一個強大的，高性能的代碼生成包，它可以在運行期擴展java類實現java接口，（SpringAop中有使用，實現方法攔截。）

在Aop編程中如何選用代理模式：

目標對象需要實現接口，使用jdk代理（動態代理）

目標對象不需要實現接口，用cglib代理。

cglib底層是使用字節碼處理框架ASM，轉換字節碼，并生成新的類。

ProxyFactory(代理對象需要 implements MethodInterceptor) MethodInterceptor是框架待的一個接口方法攔截，里面重寫了 interceptor方法

5.模板方法模式

在一個抽象類中公開定義了一個執行它的方法模板，它的子類可以進行重寫（關鍵的步驟）方法來實現，但調用將以抽象類中定義的方式進行。

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-ISCrvslB-1659411189861)(C:\Users\24473\AppData\Roaming\Typora\typora-user-images\image-20220714230054147.png)]

重點

模板方法是用final修飾的不可以進行重寫

里面調用了常用的其他制作方法，可以進行重寫關鍵的方法。

關鍵的方法是不用寫相關的實現的。

基本流程實現的相同，需要寫上相關的實現。

代碼實現：

package com.monkey.template;public abstract class SoyaMilk { // 制作豆漿模板final void make(){select();if(customerAddCondiments()){addCondiments();}soak();beat();}//選材料void select(){System.out.println("第一步，選擇好新鮮的黃豆");}//添加不同的配料，抽象方法，子類具體實現abstract void addCondiments();boolean customerAddCondiments(){return true;}//浸泡void soak(){System.out.println("第三步，黃豆進行浸泡");}void beat(){System.out.println("第四步，黃豆打碎");} } package com.monkey.template;public class RedBeanSoyaMilck extends SoyaMilk{@Overridevoid addCondiments() {System.out.println("加入上好的紅豆豆漿");} } package com.monkey.template;public class PureSoyaMilk extends SoyaMilk{@Overridevoid addCondiments() {//純的豆漿不用添加}@Overrideboolean customerAddCondiments() {//因為是純的豆漿不用添加任何其他的東西return false;} } package com.monkey.template;public class PeanutSoyaMilk extends SoyaMilk{@Overridevoid addCondiments() {System.out.println("加入上好的花生豆漿");} } package com.monkey.template;public class Client {public static void main(String[] args) {System.out.println("紅豆豆漿開始制作");SoyaMilk soyaMilk = new RedBeanSoyaMilck();soyaMilk.make();System.out.println("花生豆漿開始制作");SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();peanutSoyaMilk.make();System.out.println("純豆漿開始制作");SoyaMilk pureSoyaMilk = new PureSoyaMilk();pureSoyaMilk.make();} }

6.觀察者模式

又叫發布-訂閱模式，模型視圖模式， 從屬模式， 源-監聽模式。

概念：**定義了一對多的依賴關系，讓多個觀察者同時監聽某個主題對象。**主題對象在狀態上發生變化，會同時通知所有觀察者對象，使他們同時更新自己。

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-sIalrkBc-1659411203154)(C:\Users\24473\AppData\Roaming\Typora\typora-user-images\image-20220722222223344.png)]

改進觀察者好處：

觀察者模式設計后會心集合方式管理用戶（Observer），包括register,remove,notify.

這樣觀察者就是一個新的公告板，不需要修改核心類WeatherData,遵守ocp原則。

JDK源碼中有一個ObServable類實現了觀察者模式

在這里相當于 Subject這個接口，進行管理Observer

Observable，里面的addObserver,deleteObserve,notifyObserver分別對應Subject里面的相關的方法。

Observer作用等價于我們的Observer,里面也有update方法。

只是源碼是通過繼承實現的，Observable里面已經實現了相關的方法實現

public class Observable {private boolean changed = false;private Vector<Observer> obs;/** Construct an Observable with zero Observers. */public Observable() {obs = new Vector<>();}/*** Adds an observer to the set of observers for this object, provided* that it is not the same as some observer already in the set.* The order in which notifications will be delivered to multiple* observers is not specified. See the class comment.** @param o an observer to be added.* @throws NullPointerException if the parameter o is null.*/public synchronized void addObserver(Observer o) {if (o == null)throw new NullPointerException();if (!obs.contains(o)) {obs.addElement(o);}}/*** Deletes an observer from the set of observers of this object.* Passing <CODE>null</CODE> to this method will have no effect.* @param o the observer to be deleted.*/public synchronized void deleteObserver(Observer o) {obs.removeElement(o);}/*** If this object has changed, as indicated by the* <code>hasChanged</code> method, then notify all of its observers* and then call the <code>clearChanged</code> method to* indicate that this object has no longer changed.* <p>* Each observer has its <code>update</code> method called with two* arguments: this observable object and <code>null</code>. In other* words, this method is equivalent to:* <blockquote><tt>* notifyObservers(null)</tt></blockquote>** @see java.util.Observable#clearChanged()* @see java.util.Observable#hasChanged()* @see java.util.Observer#update(java.util.Observable, java.lang.Object)*/public void notifyObservers() {notifyObservers(null);}/*** If this object has changed, as indicated by the* <code>hasChanged</code> method, then notify all of its observers* and then call the <code>clearChanged</code> method to indicate* that this object has no longer changed.* <p>* Each observer has its <code>update</code> method called with two* arguments: this observable object and the <code>arg</code> argument.** @param arg any object.* @see java.util.Observable#clearChanged()* @see java.util.Observable#hasChanged()* @see java.util.Observer#update(java.util.Observable, java.lang.Object)*/public void notifyObservers(Object arg) {/** a temporary array buffer, used as a snapshot of the state of* current Observers.*/Object[] arrLocal;synchronized (this) {/* We don't want the Observer doing callbacks into* arbitrary code while holding its own Monitor.* The code where we extract each Observable from* the Vector and store the state of the Observer* needs synchronization, but notifying observers* does not (should not). The worst result of any* potential race-condition here is that:* 1) a newly-added Observer will miss a* notification in progress* 2) a recently unregistered Observer will be* wrongly notified when it doesn't care*/if (!changed)return;arrLocal = obs.toArray();clearChanged();}for (int i = arrLocal.length-1; i>=0; i--)((Observer)arrLocal[i]).update(this, arg);}/*** Clears the observer list so that this object no longer has any observers.*/public synchronized void deleteObservers() {obs.removeAllElements();}/*** Marks this <tt>Observable</tt> object as having been changed; the* <tt>hasChanged</tt> method will now return <tt>true</tt>.*/protected synchronized void setChanged() {changed = true;}/*** Indicates that this object has no longer changed, or that it has* already notified all of its observers of its most recent change,* so that the <tt>hasChanged</tt> method will now return <tt>false</tt>.* This method is called automatically by the* <code>notifyObservers</code> methods.** @see java.util.Observable#notifyObservers()* @see java.util.Observable#notifyObservers(java.lang.Object)*/protected synchronized void clearChanged() {changed = false;}/*** Tests if this object has changed.** @return <code>true</code> if and only if the <code>setChanged</code>* method has been called more recently than the* <code>clearChanged</code> method on this object;* <code>false</code> otherwise.* @see java.util.Observable#clearChanged()* @see java.util.Observable#setChanged()*/public synchronized boolean hasChanged() {return changed;}/*** Returns the number of observers of this <tt>Observable</tt> object.** @return the number of observers of this object.*/public synchronized int countObservers() {return obs.size();} } public interface Observer {/*** This method is called whenever the observed object is changed. An* application calls an <tt>Observable</tt> object's* <code>notifyObservers</code> method to have all the object's* observers notified of the change.** @param o the observable object.* @param arg an argument passed to the <code>notifyObservers</code>* method.*/void update(Observable o, Object arg); }

7.工廠模式

這里講一下比較繞的 抽象工廠模式。
使用工廠模式可以使我們客戶端調用的時候變得簡單，只需要修改一個工廠模式封裝好的產品就行。
例子：

人開著car,拿著ak47,吃著Bread(面包) 對應三個類

魔法精靈 開著Broom(掃把)，拿著魔法棒，吃著MushRoom(蘑菇) 對應三個類
3. 人是一個產品，魔法精靈也是產品要求如何更加簡潔的增加其他的產品

可以把 形容詞使用接口， 名詞使用抽象類

7.1代碼

Ak47

public class AK47 extends Weapon {public void shoot(){System.out.println("shoot----");} }

Car

package com.monkey.factory.abstractfactory;import com.monkey.factory.Moveable;public class Car extends Vehicle {public void go(){System.out.println("car dididid........");} }

Bread

package com.monkey.factory.abstractfactory;public class Bread extends Food {public void eat(){System.out.println("eatBread......");} }

MagicStick

package com.monkey.factory.abstractfactory;public class MagicStick extends Weapon {public void shoot(){System.out.println("魔法棒----");} }

MushRoom

package com.monkey.factory.abstractfactory;public class MushRoom extends Food {public void eat(){System.out.println("mushroom-----");} }

Broom

package com.monkey.factory.abstractfactory;public class Broom extends Vehicle {public void go(){System.out.println("魔法世界的人開broom----");}}

7.2抽象出來的三個抽象類

package com.monkey.factory.abstractfactory;public abstract class Food {abstract void eat(); } package com.monkey.factory.abstractfactory;public abstract class Vehicle {abstract void go(); } package com.monkey.factory.abstractfactory;public abstract class Weapon {abstract void shoot();}

7.3 把三個抽象類放到一個抽象類中封裝

package com.monkey.factory.abstractfactory;public abstract class AbstractFactory {abstract Food createFood();abstract Vehicle createVehicle();abstract Weapon createWeapon(); }

7.4 每個產品增加自己產品抽象類，繼承（extends）抽象父類

7.41現代世界的人

package com.monkey.factory.abstractfactory;public class ModernFactory extends AbstractFactory{@OverrideFood createFood() {return new Bread();}@OverrideVehicle createVehicle() {return new Car();}@OverrideWeapon createWeapon() {return new AK47();} }

7.42魔法世界的人

package com.monkey.factory.abstractfactory;public class MagicStickFactory extends AbstractFactory {@OverrideFood createFood() {return new MushRoom();}@OverrideVehicle createVehicle() {return new Broom();}@OverrideWeapon createWeapon() {return new MagicStick();} }

7.43客戶端進行調用,修改MagicStickFactory這個產品就可以進行不同的調用

package com.monkey.factory.abstractfactory;import com.monkey.factory.Moveable; import com.monkey.factory.Plane;public class Main {public static void main(String[] args) { // new Car().go(); // // new Plane().go();AbstractFactory a = new MagicStickFactory();Food food = a.createFood();food.eat();Weapon weapon = a.createWeapon();weapon.shoot();Vehicle vehicle = a.createVehicle();vehicle.go();} }

總結

以上是生活随笔為你收集整理的java详细设计模式有代码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。