一、UML：關係的表示
繼承關係：空心三角形+實線（三角形指向被繼承類）
接口實現：空心三角形+虛線 （三角形指向被實現接口）
關聯關係：實線箭頭表示（指向的類是被關聯的類）
public class Penguin implents Brids{
private Climate climate;
}依賴關係：虛線箭頭表示（指向的類是被依賴的類）
public class Animal {
public Metabolism（Oxgyen oxgyen,Water water）{
.......
}
}聚合關係：空心菱形+實線
public class YanQun {
public DaYans[] DaYan ;
}合成（組合）關係：實心菱形+實線
在Brid類初始化時同時實例化Wing，它們之間同時生成。
public class Brid {
public Wing wing;
public Brid(){
wing = new Wing();
}
}
二、簡單工廠模式
簡單工廠模式的核心是解決對象的創建問題。
下面通過畫各種簡單的圖形示例代碼來加深對簡單工廠模式的理解：
圖形接口：
public interface Shape {
void draw();
}實現圖形接口的各種形狀，比如圓形，方向等等…
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle draw() method.");
}
}public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square draw() method.");
}
}定義並實現一個圖形工廠類：
public class ShapeFactory {
//使用 getShape 方法獲取形狀類型的對象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}接下來我們看看如何使用工廠模式的：
/**
* 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。
* 在工廠模式中，我們在創建對象時不會對客戶端暴露創建邏輯，並且是通過使用一個共同的接口來指向新創建的對象。
*/
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//獲取 Circle 的對象，並調用它的 draw 方法
Shape shape1 = shapeFactory.getShape("CIRCLE");
//調用 Circle 的 draw 方法
shape1.draw();
//獲取 Square 的對象，並調用它的 draw 方法
Shape shape3 = shapeFactory.getShape("SQUARE");
//調用 Square 的 draw 方法
shape3.draw();
}
}三、策略模式
- 策略模式是一種定義一系列算法的方法，從概念上來看，所有者些算法完成的都是相同的工作，只是實現不同，它可以以相同的方式調用所有的算法，減少了各種算法類與使用算法類之間的耦合。
- 策略模式的Strategy類層次爲Context定義了一系列的可供重用的算法或行爲。繼承有助於析取出這些算法中的公共功能。
- 簡化了單元測試，因爲每個算法都有自己的類，可以通過自己的接口單獨測試。
【未完待續】
四、設計模式原則
職責單一原則
開放-封閉原則
依賴倒轉原則
里氏代換原則
五、裝飾模式（Decorator）
動態的給一個對象添加一些額外的職責，就增加功能而言，裝飾模式（Decorator）比生產子類更靈活。
Component定義的一個對象接口，可以給這個對象動態的添加職責。
ConcreteComponent定義了一個具體的對象，也可以給這個對象動態的添加職責。
Decorator裝飾抽象類，從Component繼承，來擴展Component的功能，但是對於Component而言，無需知道Decorator的存在。
ConcreteDecoratorA和ConcreteDecoratorB就是具體的裝飾對象，給Component添加職責。
（注意：如果只有一個ConcreteComponent類而沒有抽象的Component類，那麼Decorator類可是ConcreteComponent的一個子類。同樣道理，如果只有一個ConcreteDecortator類，那麼就沒必要建立一個單獨的Decorator類，而可以把Decorator和ConcreteDecorator的責任合併成一個類。）
下面我們用人搭配衣服來實現一個裝飾模式的示例：
1、首先定義Component 類，這裏我們的Person類既是Component也是ConcreteComponent類
//Person類相當於裝飾模式中的ConcreteComponent
public class Person {
public Person(){}
private String name ;
public Person(String personName){
name = personName;
}
public void show(){
System.out.println("裝扮的 ："+name);
}
}2、定義裝飾類，也是Decorator類
//服飾類 相當於裝飾模式的Decorator類
public class Finery extends Person {
protected Person component;
/*核心代碼部分*/
public void Decorator(Person personComponent){
component = personComponent;
}
public void show(){
if(component != null)
{
component.show();
}
}
}
3、具體的職責實現，比如穿T恤A和穿T恤B（都穿T恤雖然不恰當，但是意思是穿不同的衣服即可）
public class TShirtsA extends Finery {
public void show(){
System.out.println("T恤A");
super.show();
}
}
public class TShirtsB extends Finery {
public void show(){
System.out.println("T恤B");
super.show();
}
}
4、接下來便是裝飾模式的使用
public class DecoratorPatternDemo {
public static void main(String args[]){
Person person = new Person("BXL");
TShirtsA tA = new TShirtsA();
TShirtsB tB = new TShirtsB();
tA.Decorator(person);
tB.Decorator(tA);
tB.show();
}
}
六、單例模式
這種模式涉及到一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建。
這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。
首先我們需要創建一個單例對象：
public class SingleObject {
//創建 SingleObject 的一個對象
private static SingleObject instance = new SingleObject();
//讓構造函數爲 private，這樣該類就不會被實例化
private SingleObject(){}
//獲取唯一可用的對象
public static SingleObject getInstance(){
return instance;
}
public void showMessage(){
System.out.println("Hello World!");
}
}接下來如何使用單例對象：
public static void main(String[] args) {
//不合法的構造函數
//編譯時錯誤：構造函數 SingleObject() 是不可見的
//SingleObject object = new SingleObject();
//獲取唯一可用的對象
SingleObject object = SingleObject.getInstance();
//顯示消息
object.showMessage();
}