文章目錄

• 設計原則
• • 1 單一職責原則
  • 2 開閉原則
  • 3 Liskov 替換原則
  • 4 依賴倒置原則
  • 5 接口隔離原則
  • 6 迪米特法則
• 設計模式：創建型模式
• • 1 工廠模式
  • 2 抽象工廠模式
  • 3 單例模式
• 設計模式：行為型模式
• • 1 觀察者模式
  • 2 模板模式
  • 3 備忘錄模式
• 設計模式：結構型模式
• • 1 代理模式
  • 2 裝飾器模式
  • 3 適配器模式

設計原則

六大設計原則詳解

1 單一職責原則

• 一個類只專注于做一件事

2 開閉原則

• 開閉原則是 OOP 中最基礎的設計原則
• 對拓展開放，對修改關閉，盡可能在不改變原有代碼的情況下進行拓展
• 要實現開閉原則，首先實現面向接口編程（依賴倒置原則）

3 Liskov 替換原則

• 子類必須能夠替換它們的基類型
• “父類能做的事，子類必須能做，要做到相等或更好”

4 依賴倒置原則

• 核心思想是面向接口編程，依賴于抽象而不依賴于具體
• 寫代碼時用到具體類時，不與具體類交互，而與具體類的上層接口交互
• 使用接口或者抽象類的目的是制定好規范和契約，而不去涉及任何具體的操作，把展現細節的任務交給他們的實現類完成

5 接口隔離原則

• 使用多個隔離的接口，比使用單個臃腫龐大接口要好（盡量細化接口，接口中的方法盡量少）
• 如果接口過于臃腫，只要接口中出現的方法，不管對依賴于它的類有沒有用處，實現類中都必須去實現這些方法

6 迪米特法則

• 一個實體應當盡量少的與其他實體之間發生相互作用，使得系統功能模塊相對獨立

---

設計模式：創建型模式

1 工廠模式

• 主要解決接口選擇的問題：將同一類對象的創建過程，轉移到一個工廠類實現
• 在創建對象時不會對客戶端暴露創建邏輯，并且是通過使用一個共同的接口來指向新創建的對象
  

// 1.創建接口 public interface Shape {void draw(); }// 2.創建接口的實現類 public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Inside Rectangle::draw() method.");} }public class Square implements Shape {@Overridepublic void draw() {System.out.println("Inside Square::draw() method.");} }// 3.創建工廠 public class ShapeFactory {public Shape getShape(String shapeType){if(shapeType == null){return null;} if(shapeType.equalsIgnoreCase("CIRCLE")){return new Circle();} else if(shapeType.equalsIgnoreCase("RECTANGLE")){return new Rectangle();} else if(shapeType.equalsIgnoreCase("SQUARE")){return new Square();}return null;} } public class FactoryPatternDemo {public static void main(String[] args) {ShapeFactory shapeFactory = new ShapeFactory();//獲取 Circle 的對象，并調用它的 draw 方法Shape shape1 = shapeFactory.getShape("CIRCLE");//調用 Circle 的 draw 方法shape1.draw();//...} }

---

2 抽象工廠模式

• 生產工廠的工廠，將屬于同一類型的工廠聚合在一起
• 從工廠生產器中獲取的工廠，也用共用的接口指向同一對象
  

// 1.創建形狀和顏色的接口，及其實現類（略）// 2.設置形狀和顏色的抽象工廠 public abstract class AbstractFactory {public abstract Color getColor(String color);public abstract Shape getShape(String shape); }// 3.繼承抽象工廠，實現各自對應的方法 public class ShapeFactory extends AbstractFactory {@Overridepublic Shape getShape(String shapeType){if(shapeType == null){return null;}if(shapeType.equalsIgnoreCase("CIRCLE")){return new Circle();} else if(shapeType.equalsIgnoreCase("RECTANGLE")){return new Rectangle();} else if(shapeType.equalsIgnoreCase("SQUARE")){return new Square();}return null;}@Overridepublic Color getColor(String color) {return null;} }public class ColorFactory extends AbstractFactory {@Overridepublic Shape getShape(String shapeType){return null;}@Overridepublic Color getColor(String color) {if(color == null){return null;} if(color.equalsIgnoreCase("RED")){return new Red();} else if(color.equalsIgnoreCase("GREEN")){return new Green();} else if(color.equalsIgnoreCase("BLUE")){return new Blue();}return null;} }// 4.工廠生產器——工廠的工廠 public class FactoryProducer {public static AbstractFactory getFactory(String choice){if(choice.equalsIgnoreCase("SHAPE")){return new ShapeFactory();} else if(choice.equalsIgnoreCase("COLOR")){return new ColorFactory();}return null;} } public class AbstractFactoryPatternDemo {public static void main(String[] args) {//獲取形狀工廠AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");//獲取形狀為 Circle 的對象Shape shape1 = shapeFactory.getShape("CIRCLE");//調用 Circle 的 draw 方法shape1.draw();//獲取顏色工廠AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");//獲取顏色為 Red 的對象Color color1 = colorFactory.getColor("RED");//調用 Red 的 fill 方法color1.fill();} }

---

3 單例模式

• 一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建

• 可以直接訪問，不需要實例化該類的對象

• 最常用的 DCL (double-checked locking) 實現：
  構造方法使用 private 修飾，保證該類只有自己能實例化自己
  使用 volatile 修飾屬性，指示 JVM，變量是共享且不穩定的，每次使用它都到主存中進行讀取，并禁止指令重排

public class Singleton { private volatile static Singleton singleton; private Singleton (){} public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) {if (singleton == null) {singleton = new Singleton(); } } } return singleton; } }

---

設計模式：行為型模式

1 觀察者模式

• 定義對象間的一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴于它的對象都得到通知并被自動更新

// 1.被觀察者類 public class Subject {private List<Observer> observers = new ArrayList<Observer>(); // 用List存放所有觀察者private int state;public int getState() {return state;}public void setState(int state) {this.state = state;notifyAllObservers();}public void attach(Observer observer){ // 添加觀察者observers.add(observer); }public void notifyAllObservers(){ // 通知觀察者，自己的狀態變化for (Observer observer : observers) {observer.update();}} }// 2.觀察者抽象類及其實現 public abstract class Observer {protected Subject subject;public abstract void update(); }public class BinaryObserver extends Observer{public BinaryObserver(Subject subject){this.subject = subject;this.subject.attach(this); // 調用被觀察者的attch方法，將自己注冊為它的觀察者}@Overridepublic void update() {System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); } } ...... public class ObserverPatternDemo {public static void main(String[] args) {Subject subject = new Subject();new HexaObserver(subject);new OctalObserver(subject);new BinaryObserver(subject);System.out.println("First state change: 15"); subject.setState(15);System.out.println("Second state change: 10"); subject.setState(10);} }

---

2 模板模式

• 一個抽象類公開定義了執行它的方法的方式/模板。它的子類可以按需要重寫方法實現，但調用將以抽象類中定義的方式進行
• 模板方法被聲明為 final，因為執行它的流程是固定的

// 1.模板類 public abstract class Game {abstract void initialize();abstract void startPlay();abstract void endPlay();// 模板方法，它規定了其他方法的執行流程是固定的public final void play(){//初始化游戲initialize();//開始游戲startPlay();//結束游戲endPlay();} }// 2.模板類的不同實現 public class Football extends Game {@Overridevoid endPlay() {System.out.println("Football Game Finished!");}@Overridevoid initialize() {System.out.println("Football Game Initialized! Start playing.");}@Overridevoid startPlay() {System.out.println("Football Game Started. Enjoy the game!");} }public class Cricket extends Game {@Overridevoid endPlay() {System.out.println("Cricket Game Finished!");}@Overridevoid initialize() {System.out.println("Cricket Game Initialized! Start playing.");}@Overridevoid startPlay() {System.out.println("Cricket Game Started. Enjoy the game!");} } public class TemplatePatternDemo {public static void main(String[] args) {// 不同的實現使用相同的模板Game game = new Cricket();game.play();game = new Football();game.play(); } }

3 備忘錄模式

• 在不破壞封裝性的前提下，捕獲一個對象的內部狀態，并在該對象之外保存這個狀態
• 備忘錄模式使用三個類 Memento、Originator 和 CareTaker
  Memento 包含了要被恢復的對象的狀態，相當于每一個存檔；
  Originator 創建并在 Memento 對象中存儲狀態，是要被存儲的對象；
  Caretaker 對象負責從 Memento 中恢復對象的狀態，相當于存檔的集合

// 1.Memento 類，包含了要被恢復的對象的狀態 public class Memento {private String state;public Memento(String state){this.state = state;}public String getState(){return state;} }// 2.Originator 類，要被記錄的類 public class Originator {private String state;public void setState(String state){this.state = state;}public String getState(){return state;}public Memento saveStateToMemento(){return new Memento(state);}public void getStateFromMemento(Memento Memento){state = Memento.getState();} }// 3.CareTaker 類，負責從 Memento 中恢復對象的狀態 public class CareTaker {private List<Memento> mementoList = new ArrayList<Memento>();public void add(Memento state){mementoList.add(state);}public Memento get(int index){return mementoList.get(index);} } public class MementoPatternDemo {public static void main(String[] args) {Originator originator = new Originator();CareTaker careTaker = new CareTaker();originator.setState("State #1");originator.setState("State #2");careTaker.add(originator.saveStateToMemento());originator.setState("State #3");careTaker.add(originator.saveStateToMemento());originator.setState("State #4");System.out.println("Current State: " + originator.getState()); originator.getStateFromMemento(careTaker.get(0));System.out.println("First saved State: " + originator.getState());originator.getStateFromMemento(careTaker.get(1));System.out.println("Second saved State: " + originator.getState());} }Current State: State #4 First saved State: State #2 Second saved State: State #3

---

設計模式：結構型模式

1 代理模式

• 直接訪問會給使用者或者系統結構帶來很多麻煩時，為其他對象提供一種代理以控制對這個對象的訪問
• 示例：圖像首次顯示時需要先加載，再次訪問不需要；通過代理自動化地完成這一過程

// 1.創建接口及其實現類 public interface Image {void display(); }public class RealImage implements Image {private String fileName;public RealImage(String fileName){this.fileName = fileName;loadFromDisk(fileName);}@Overridepublic void display() {System.out.println("Displaying " + fileName);}private void loadFromDisk(String fileName){System.out.println("Loading " + fileName);} }// 2.創建代理 public class ProxyImage implements Image {private RealImage realImage;private String fileName;public ProxyImage(String fileName){this.fileName = fileName;}@Overridepublic void display() { // 代理的功能if(realImage == null){realImage = new RealImage(fileName);}realImage.display();} } public class ProxyPatternDemo {public static void main(String[] args) {Image image = new ProxyImage("test_10mb.jpg");// 圖像將從磁盤加載image.display(); // 圖像不需要從磁盤加載image.display(); } }

---

2 裝飾器模式

• 動態地給一個對象添加一些額外的職責，將其包裝成功能更強大的類，效果類似于繼承，作為繼承的一種替代方式
• 就增加功能來說，裝飾器模式相比生成子類更為靈活

// 1.創建形狀接口及其實現類 public interface Shape {void draw(); }public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Shape: Rectangle");} }// 2.抽象裝飾類及其實現 public abstract class ShapeDecorator implements Shape {protected Shape decoratedShape;public ShapeDecorator(Shape decoratedShape){this.decoratedShape = decoratedShape;}public void draw(){decoratedShape.draw();} }public class RedShapeDecorator extends ShapeDecorator {public RedShapeDecorator(Shape decoratedShape) {super(decoratedShape); }@Overridepublic void draw() {decoratedShape.draw(); setRedBorder(decoratedShape);}private void setRedBorder(Shape decoratedShape){System.out.println("Border Color: Red");} } public class DecoratorPatternDemo {public static void main(String[] args) {Shape circle = new Circle();ShapeDecorator redCircle = new RedShapeDecorator(new Circle());ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());//Shape redCircle = new RedShapeDecorator(new Circle());//Shape redRectangle = new RedShapeDecorator(new Rectangle());System.out.println("Circle with normal border");circle.draw();System.out.println("\nCircle of red border");redCircle.draw();System.out.println("\nRectangle of red border");redRectangle.draw();} }

---

3 適配器模式

• 適配器模式（Adapter Pattern）是作為兩個不兼容的接口之間的橋梁，結合了兩個獨立接口的功能

// 1.創建要捏合的兩個接口 public interface MediaPlayer {public void play(String audioType, String fileName); }public interface AdvancedMediaPlayer { public void playVlc(String fileName);public void playMp4(String fileName); }// 2.創建加強播放器的實現類 public class VlcPlayer implements AdvancedMediaPlayer{@Overridepublic void playVlc(String fileName) {System.out.println("Playing vlc file. Name: "+ fileName); }@Overridepublic void playMp4(String fileName) {//什么也不做} }public class Mp4Player implements AdvancedMediaPlayer{@Overridepublic void playVlc(String fileName) {//什么也不做}@Overridepublic void playMp4(String fileName) {System.out.println("Playing mp4 file. Name: "+ fileName); } }// 3.創建 實現加強播放器方法的 適配器類 public class MediaAdapter implements MediaPlayer {AdvancedMediaPlayer advancedMusicPlayer;public MediaAdapter(String audioType){if(audioType.equalsIgnoreCase("vlc") ){advancedMusicPlayer = new VlcPlayer(); } else if (audioType.equalsIgnoreCase("mp4")){advancedMusicPlayer = new Mp4Player();} }@Overridepublic void play(String audioType, String fileName) {if(audioType.equalsIgnoreCase("vlc")){advancedMusicPlayer.playVlc(fileName);}else if(audioType.equalsIgnoreCase("mp4")){advancedMusicPlayer.playMp4(fileName);}} }// 4.創建未增強的播放器，注入適配器 public class AudioPlayer implements MediaPlayer {MediaAdapter mediaAdapter; @Overridepublic void play(String audioType, String fileName) { //播放 mp3 音樂文件的內置支持if(audioType.equalsIgnoreCase("mp3")){System.out.println("Playing mp3 file. Name: "+ fileName); } //mediaAdapter 提供了播放其他文件格式的支持else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){mediaAdapter = new MediaAdapter(audioType);mediaAdapter.play(audioType, fileName);}else{System.out.println("Invalid media. "+audioType + " format not supported");}} } public class AdapterPatternDemo {public static void main(String[] args) {AudioPlayer audioPlayer = new AudioPlayer();audioPlayer.play("mp3", "beyond the horizon.mp3");audioPlayer.play("mp4", "alone.mp4");audioPlayer.play("vlc", "far far away.vlc");} }

總結

以上是生活随笔為你收集整理的后端学习 - 设计模式与设计原则的全部內容，希望文章能夠幫你解決所遇到的問題。

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