生活随笔
收集整理的這篇文章主要介紹了
后端学习 - 设计模式与设计原则
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
文章目錄 設計原則 1 單一職責原則 2 開閉原則 3 Liskov 替換原則 4 依賴倒置原則 5 接口隔離原則 6 迪米特法則 設計模式：創建型模式 設計模式：行為型模式 設計模式：結構型模式
設計原則
六大設計原則詳解
1 單一職責原則
2 開閉原則
開閉原則是 OOP 中最基礎的設計原則 對拓展開放，對修改關閉，盡可能在不改變原有代碼的情況下進行拓展 要實現開閉原則，首先實現面向接口編程（依賴倒置原則） 3 Liskov 替換原則
子類必須能夠替換它們的基類型 “父類能做的事，子類必須能做，要做到相等或更好” 4 依賴倒置原則
核心思想是面向接口編程，依賴于抽象而不依賴于具體 寫代碼時用到具體類時，不與具體類交互，而與具體類的上層接口交互 使用接口或者抽象類的目的是制定好規范和契約，而不去涉及任何具體的操作，把展現細節的任務交給他們的實現類完成 5 接口隔離原則
使用多個隔離的接口，比使用單個臃腫龐大接口要好（盡量細化接口，接口中的方法盡量少） 如果接口過于臃腫，只要接口中出現的方法，不管對依賴于它的類有沒有用處，實現類中都必須去實現這些方法 6 迪米特法則
一個實體應當盡量少的與其他實體之間發生相互作用，使得系統功能模塊相對獨立 設計模式：創建型模式
1 工廠模式
主要解決接口選擇的問題：將同一類對象的創建過程，轉移到一個工廠類實現 在創建對象時不會對客戶端暴露創建邏輯，并且是通過使用一個共同的接口來指向新創建的對象 public interface Shape { void draw ( ) ;
}
public class Rectangle implements Shape { @Override public void draw ( ) { System . out
. println ( "Inside Rectangle::draw() method." ) ; }
} public class Square implements Shape { @Override public void draw ( ) { System . out
. println ( "Inside Square::draw() method." ) ; }
}
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 ( ) ; Shape shape1
= shapeFactory
. getShape ( "CIRCLE" ) ; shape1
. draw ( ) ; }
}
2 抽象工廠模式
生產工廠的工廠，將屬于同一類型的工廠聚合在一起 從工廠生產器中獲取的工廠，也用共用的接口指向同一對象 public abstract class AbstractFactory { public abstract Color getColor ( String color
) ; public abstract Shape getShape ( String shape
) ;
}
public class ShapeFactory extends AbstractFactory { @Override 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 ; } @Override public Color getColor ( String color
) { return null ; }
} public class ColorFactory extends AbstractFactory { @Override public Shape getShape ( String shapeType
) { return null ; } @Override public 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 ; }
}
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" ) ; Shape shape1
= shapeFactory
. getShape ( "CIRCLE" ) ; shape1
. draw ( ) ; AbstractFactory colorFactory
= FactoryProducer . getFactory ( "COLOR" ) ; Color color1
= colorFactory
. getColor ( "RED" ) ; color1
. fill ( ) ; }
}
3 單例模式
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 觀察者模式
定義對象間的一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴于它的對象都得到通知并被自動更新 public class Subject { private List < Observer > observers
= new ArrayList < Observer > ( ) ; 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 ( ) ; } }
}
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 ) ; } @Override public 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，因為執行它的流程是固定的 public abstract class Game { abstract void initialize ( ) ; abstract void startPlay ( ) ; abstract void endPlay ( ) ; public final void play ( ) { initialize ( ) ; startPlay ( ) ; endPlay ( ) ; }
}
public class Football extends Game { @Override void endPlay ( ) { System . out
. println ( "Football Game Finished!" ) ; } @Override void initialize ( ) { System . out
. println ( "Football Game Initialized! Start playing." ) ; } @Override void startPlay ( ) { System . out
. println ( "Football Game Started. Enjoy the game!" ) ; }
} public class Cricket extends Game { @Override void endPlay ( ) { System . out
. println ( "Cricket Game Finished!" ) ; } @Override void initialize ( ) { System . out
. println ( "Cricket Game Initialized! Start playing." ) ; } @Override void 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 public class Memento { private String state
; public Memento ( String state
) { this . state
= state
; } public String getState ( ) { return state
; }
}
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 ( ) ; }
}
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 代理模式
直接訪問會給使用者或者系統結構帶來很多麻煩時，為其他對象提供一種代理以控制對這個對象的訪問 示例：圖像首次顯示時需要先加載，再次訪問不需要；通過代理自動化地完成這一過程
public interface Image { void display ( ) ;
} public class RealImage implements Image { private String fileName
; public RealImage ( String fileName
) { this . fileName
= fileName
; loadFromDisk ( fileName
) ; } @Override public void display ( ) { System . out
. println ( "Displaying " + fileName
) ; } private void loadFromDisk ( String fileName
) { System . out
. println ( "Loading " + fileName
) ; }
}
public class ProxyImage implements Image { private RealImage realImage
; private String fileName
; public ProxyImage ( String fileName
) { this . fileName
= fileName
; } @Override public 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 裝飾器模式
動態地給一個對象添加一些額外的職責，將其包裝成功能更強大的類，效果類似于繼承，作為繼承的一種替代方式 就增加功能來說，裝飾器模式相比生成子類更為靈活 public interface Shape { void draw ( ) ;
} public class Rectangle implements Shape { @Override public void draw ( ) { System . out
. println ( "Shape: Rectangle" ) ; }
}
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
) ; } @Override public 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 ( ) ) ; 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）是作為兩個不兼容的接口之間的橋梁，結合了兩個獨立接口的功能 public interface MediaPlayer { public void play ( String audioType
, String fileName
) ;
} public interface AdvancedMediaPlayer { public void playVlc ( String fileName
) ; public void playMp4 ( String fileName
) ;
}
public class VlcPlayer implements AdvancedMediaPlayer { @Override public void playVlc ( String fileName
) { System . out
. println ( "Playing vlc file. Name: " + fileName
) ; } @Override public void playMp4 ( String fileName
) { }
} public class Mp4Player implements AdvancedMediaPlayer { @Override public void playVlc ( String fileName
) { } @Override public void playMp4 ( String fileName
) { System . out
. println ( "Playing mp4 file. Name: " + fileName
) ; }
}
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 ( ) ; } } @Override public void play ( String audioType
, String fileName
) { if ( audioType
. equalsIgnoreCase ( "vlc" ) ) { advancedMusicPlayer
. playVlc ( fileName
) ; } else if ( audioType
. equalsIgnoreCase ( "mp4" ) ) { advancedMusicPlayer
. playMp4 ( fileName
) ; } }
}
public class AudioPlayer implements MediaPlayer { MediaAdapter mediaAdapter
; @Override public void play ( String audioType
, String fileName
) { if ( audioType
. equalsIgnoreCase ( "mp3" ) ) { System . out
. println ( "Playing mp3 file. Name: " + fileName
) ; } 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" ) ; }
}
總結
以上是生活随笔 為你收集整理的后端学习 - 设计模式与设计原则 的全部內容，希望文章能夠幫你解決所遇到的問題。
如果覺得生活随笔 網站內容還不錯，歡迎將生活随笔 推薦給好友。
