java面向對象分析（深入理解面向對象）

2023-04-16 03:58:05

早期的程式語言如：C、Basic、Pascal等都是結構化程式語言。結構化程序設計的核心思想就是程序的開發採用自上而下的設計（稱為瀑布模式）。對於大型的應用來說，採用函數和庫的方式來對代碼進行管理。而C 、java、C#、Ruby等都是面向對象的程式語言，將現實世界採用類、對象的概念進行建模。

結構化程序設計方法主張按功能來分析系統需求，其主要原則可概括為自頂向下、逐步求精、模塊化等。

結構化程序設計首先採用結構化分析（Structured Analysis，SA）方法對系統進行需求分析，然後使用結構化設計（Structured Design，SD）方法對系統進行概要設計、詳細設計、最後採用結構化編程（Structured Program，SP）方法來實現系統。使用這種 SA、SD、SP的方式可以較好的保證軟體系統的開發進度和質量。

結構化程序使用三種基本控制結構構造程序，即：

結構化程序設計主要強調的是程序的易讀性。

詳細描述處理過程常用三種工具：圖形、表格和語言。

結構化程序設計曾被稱為軟體發展中的第三個裡程碑，要點是：

基本思想是使用類、對象、繼承、封裝、消息等基本概念來進行程序設計。最小的程序單元是類，這些類可以生成系統中的多個對象，而這些對象則直接映像成客觀世界的各種事務。採用面向對象方式開發的軟體系統邏輯上的組成結構如：

面向對象的軟體系統由多個類組成。類還會提供操作這些狀態數據的方法，為這些行為提供相應的實現。

[修飾符] class 類名{ 零到多個構造器定義.. 零到多個Field… 零到多個方法…}

一個實際的例子：

public class Person{ public String name; public int age; public void say(String content){ System.out.println(content); }}Person p; //p變量，放在棧內存裡p=new Person; //Person對象放在堆內存裡

類也是一種引用數據類型，因此程序中定義的Person類型的變量實際上是一個引用，它被存放在棧內存裡，指向實際的Person對象，而真正的Person對象則存放在堆(heap)內存中。Java程序不允許直接訪問堆內存中的對象，只能通過該對象的引用操作該對象。不管是數組還是對象，都只能通過引用來訪問它們。

堆內存裡的對象可以有多個引用，即多個引用變量指向同一個對象。如接上面的程序：

Person p2=p;

如果堆內存裡的對象沒有任何變量指向該對象，那程序將無法再訪問該對象，這個對象就變成了垃圾，Java的垃圾回收機制將回收該對象，釋放該對象所佔的內存區。因此，如果希望通知垃圾回收機制回收某個對象，只需切斷該對象的所有引用變量和它之間的關係即可，也就是把這些引用變量賦值為null。

final類似C#裡的sealed關鍵字，用於表示它修飾的類、方法和變量不可改變

final修飾的成員變量必須由程式設計師顯示地指定初始值類 Field：在靜態初始化塊中或聲明該Field時指定初始值實例Field：必須在非靜態初始化塊、聲明Field或構造函數中指定初始值

final修飾基本類型變量，變量的值不能改變但修飾引用類型變量，只保證這個引用類型變量所引用的地址不會改變，即一直引用同一個對象，但這個對象可以發生改變。

對一個final變量來說，不管它是類Field、實例Field，還是局部變量，只要該變量滿足3個條件，這個final變量就不再是一個變量，而是相當於一個直接量

public class test{ public static void main(String[] args) { final int a=5; System.out.println(a); }}

上面所示變量a其實不存在，在編譯時就轉換成System.out.println(5);

Java使用常量池來管理用過的字符串直接量，如String a=「java」;如果再定義String b=「java」;這時a==b 是true。

final修飾的方法不可被重寫。如果不希望子類重寫父類的某個方法，就可以使用final修飾該方法 。Object類的getClass就是一個final方法。

final修飾的類不可以有子類。如：java.lang.Math

創建實例後，該實例的Field是不可改變的。Java的8個包裝類和java.lang.String都是不可在。

Java的Integer類，使用了緩存策略。在使用new構造對象時，返回全新的integer對象。如果使用valueOf創建Integer對象，則在創建該對象的同時，會緩存該方法創建的對象Integer只緩存-128到127之間的Integer對象，超過範圍的對象不會緩存。

如果程序經常使用某個不可變類的實例，則可以把該實例保存進緩存，減少系統開銷。

在Java語言中，除了8個基本數據類型值，一切都是對象。對於8個基本的數據類型，Java也提供了包裝類：

基本數據類型包裝類byteByteshortShortintIntegerlongLongcharCharacterfloatFloatdoubleDoublebooleanBoolean

對象是Java程序的核心，所以Java裡的對象具有唯一性，每個對象都有一個標識來引用它，如果某個對象失去了標識，這個對象將變成垃圾。Java語言不允許直接訪問對象，而是通過對對象的引用來操作對象。

使用示例：

Float f1=new Float("4.56");Booean blObj = new Boolean(b1);

java.lang.NumberFormatException異常。

int i = integerObject.intValue;

Java類包含5種成員：

類Field（static修飾）屬於整個類，當系統第一次準備使用該類時，系統會為該類Field分配內存空間。類Field開始生效，直到該類被卸載，所佔內存才會被垃圾回收機制回收。類Field生存範圍幾乎等同於該類的生存範圍。當類的初始化完成後，類Field也被初始化完成。

類Field既可通過類訪問，也可通過類的對象來訪問。通過類的對象來訪問類Field時，實際上訪問的不是該類所擁有的Field。而C#其實不允許通過對象訪問類Field。

三個部分有機組成，其中OOA和OOD的結構需要使用一種方式來描述並記錄，目前業界統一採用UML（統一建模語言）來描述並記錄OOA和OOD的結果。

UML的2.0 一共包括13種類型的圖形。使用這13種圖形中的某些就可以很好地描述並記錄軟體分析、設計的摘要。通常而言，我們沒有必要為軟體系統繪製13種UML圖形，常用的UML圖形有用例圖、類圖、組件圖、部署圖、順序圖、活動圖和狀態圖。

將對象的實現細節隱藏起來，然後通過一些公用方法來暴露該對象的功能

面向對象實現軟體復用的重要手段，當子類繼承父類後，子類作為一種特殊的父類，將直接獲得父類的屬性和方法

子類對象可以直接賦給父類變量，但運行時依然表現出子類的行為特徵，這意味著同一個類型的對象在執行同一個方法時，可能表現出多種行為特徵

忽略一個主題中與當前目標無關的那些方法，以便更充分地注意與當前目標有關的方面。抽象並不打算了解全部問題，而只是考慮部分問題。例如，考慮考察Person對象時，我們不可能在程序中把Person的所有細節都定義出來，通常只能定義Person的部分數據、部分行為特徵—而這些數據、行為特徵是軟體系統所關心的部分

抽象類是從多個類中抽象出來的模板，如果將這種抽象進行是更徹底，則可以提煉出一種更加特殊的抽象類——接口。接口層不能包含應運，接口裡所有方法都是抽象方法。

[修飾會] interface 接口中 extends 父接口1,父接口2...{ 常量定義; 抽象方法定義;}

示例：

package lee;public interface Output{ int MAC_CACHE_LINE=50; void out; void getData(String msg);}

接口完全支持多繼承，一個接口可以有多個直接父接口。多個父接口排在extends後，用,隔開。

接口不能用於創建實例，但接口中以用於聲明引用類型爆裂。當使用接口為聲明引用類型變量地，這個引用類型盤龍乃至其實現類的對象。除此之外，接口的主要用途不是被實現類實現。

示例：

interface Product{ int getProduceTime;}public class Printer implements Out , Product{ private String[] printDate=new String[MAX_CACHE_LINE]; private int dataNum=0; public void out{ while(dataNum>0){ System.out.println("印表機列印" printDate); System.arraycopy(printDate,1,printDate,0,--dataNum); } } public void getData(String msg){ if(dataNum >= MAX_CACHE_LINE){ System.out.println("輸出隊列已滿，添加失敗"); }else { printData[dataNum ]=msg; } } public int getProducteTime{ return 45; } public static void main(String[] args){ Output o = new Printer; o.getData("輕量級Java EE企業應用實戰"); o.getData("瘋狂Java 講義"); o.out; o.getData("瘋狂Android講義"); o.getData("瘋狂Ajax講義"); o.out; Product p = new Printer; System.out.println(p.getProduceTime); //所有接口類型的引用變量都可直接賦給Object類型的變量 Object obj=p; }}

可以實現簡單工廠模式、命令模式等。

public class OuterClass{}

public class StaticInnerClassTest{ private int prop1=5; private static int prop2=9; static class StaticInnerClass{ private static int age; public void accessOuterProp{ System.out.println(prop1); System.out.println(prop2); } }}

定義在代碼中間

public class LocalInnerClass{ public static void main(String[] args){ class InnerBase{ int a; } class InnerSub extends InnerBase{ int b; } InnerSub is=new InnerSub; is.a=5; is.b=8; System.out.println(is.a "," is.b"); }}

interface Product{ public double getPrice; public String getName;}public class AnonymousTest{ public void test(Product p){ System.out.println("購買了一個" p.getName ",花掉了" p.getPrice); public static void main(String[] args){ AnonymousTest ta = new AnonymousTest; ta.test(new Product{ public double getPrice{ return 567.8; } public String getName{ return "AGP"; } }) } }}

閉包（Closure）是一種能被調用的對象，它保存創建它的作用域信息。Java7沒有顯式支持閉包，但可以把非靜態內部類當成面向對象領域的閉包。通過這種仿閉包的非靜態內部類，就可以很方便地實現回調功能。

interface Teachable{ void work;}public class Programmer{ private String name; public Programmer{} public Programmer(String name){ this.name=name; } //...getter & setter public void work{ System.out.println(name "doing..."); }}public class TeachableProgrammer extends Programmer implements Teachable{ public void work{ System.out.println(getName "doing ..."); }}

java8開始支持lambda表達式，可以看成一種閉包，允許把函數當成參數使用，是面向函數式編程的思想。lambda表達式語法：

(paramters) -> expression；

或

(paramters) -> {statements;} 展開如： (Type1 param1, Type2 param2, Type2 param2, ...) -> { statement1; statement2; statement3; ... return statementX; }

實例：

//匿名內部類寫法 new Thread(new Runnable { @Override public void run { System.out.println("內部類寫法"); } }).start;

改用lambda：

//lambda 寫法new Thread( -> System.out.println("lambda寫法")).start;

lambda表達式特徵

幾個示例：

//入參為空 TestDemo no_param = -> "hi, no param"; TestDemo no_param2 = -> { return "hi, no param"; }; System.out.println(no_param.hi); //單個參數 TestDemo2 param = name -> name; TestDemo2 param2 = name -> { return name;}; System.out.println(param.hei("hei, grils")); //多個參數 TestDemo3 multiple = (String hello, String name) -> hello " " name; //一條返回語句，可以省略大括號和return TestDemo3 multiple2 = (hello, name) -> hello name; //多條處理語句，需要大括號和return TestDemo3 multiple3 = (hello, name) -> { System.out.println("進入內部"); return hello name; }; System.out.println(multiple.greet("hello", "lambda"));

public class Season{ private final String name; private final String desc; public static final Season SPRING=new Season("春天",""); public static final Season SUMMBER=new Season("夏天",""); public static final Season FALL=new Season("秋天",""); ... public static Season getSeason(int seasonNum){ switch(seasonNum){ case 1: return SPRING; case 2: return SUMMBER; ... } } private Season(String name,String desc){ this.name=name; this.desc=desc; } public String getName{ return this.name; } public String getDesc { return this.desc; }}

使用

public class SeasonTest{ public SeasonTest(Season s) { System.out.println(s.getName); } public static void main(String[] args) { new SeasonTest(Season.FALL); }}

public enum SeasonEnum{ SPRING,SUMMBER,FALL,WINTER;｝

public class EnumTest{ public void judge(SeasonEnum s) { switch(s) { case SPRING: System.out.println("描述"); break; ... } } public static void main(String[] args) { for(SeasonEnum s:SeasonEnum.values){ System.out.println(s); } new EnumTest.judge(SeasonEnum.SPRING); }}

java.lang.Enum類提供了以下方法：

枚舉類也可以定義Field、方法。枚舉為的實例只能是枚舉值，不能隨意通過new創建枚舉類對象。

在setName裡可以對賦值進行驗證。

枚舉類也可以實現一個或多個接口。與普通類實現一個或多個接口完全一樣，枚舉類實現一個或多個接口時，也需要實現該接口所包含的方法。

this關鍵字總是指向調用該方法的對象。根據this出現位置的不同，this作為對象的默認引用有兩種情形：

有些時候this可以省略，編譯器會自動在引用內部方法時加上this.classname.方法名。Java允許使用對象來調用static修飾的Field方法，但應避免這樣使用，現代的IDE一般會給出報警。

Java的方法參數傳遞只有一種方式：值傳遞，這是因為Java沒有指針的概念。正如前面提到過的，Java的一個對象可以拆為兩部分：

當把一個對象作為參數時，傳遞的值是對象的引用地址，即棧裡的變量複製了，但指向的堆仍然沒有變。為了便於理解，往往可以認為Java傳遞複雜參數時（非8種基本類型）採用的是按引用傳值，但要注意面試時不能這樣講。

public class Varargs{ public static void test(int a,String... books) { for(String tmp : books) { System.out.println(tmp); } } public static void main(String[] args) { test(5,"參數2","參數3"); }}

如果需要在子類方法中調用父類被覆蓋的實例方法，則可使用super限定來調用父類被覆蓋的實例方法：

public void callOverrideMethod{ super.fly;}

Java引用變量有兩個類型：一個是編譯時類型，一個是運行時類型。如果編譯與運行時類型不一到處，就可能出現所謂的多態(Polymorphism)

instanceof運算符的前一個操作數通常是一個引用類型變量，後一個操作數通常是一個類（也可以是接口，可以把接口理解成一種特殊的類），它用於判斷前面的對象是否是後面的實例，或者其子類，實現類的實例。

初始化塊初始化塊是Java類裡可出現的第4種成員，一個類裡可以有多個初始化塊，相同類型的初始化塊之間有順序：前面定義的初始化塊先執行，後面定義的初始化後執行

public class Person{ { ; //先執行 } { ; //2 } public Person { ; //3 } public static void main(String[] args) { new Person; }}

初始化塊只在創建Java對象時隱匿執行，而且在構造函數之前執行。

在類初始化階段執行靜態初始化塊，因此比普通初始化塊先執行。靜態初始化塊會一直上溯到頂父類靜態初始化類先執行，最後才執行該類的靜態初始化塊。

JDK1.5後新增引入靜態成員：

import static java.lang.Math.*;

可以引入所有靜態Field和方法。

class Person{}Person p=new Person;//下面兩句效果是一樣的System.out.println(p);System.out.println(p.toString);

Java程序中測試兩個變量是否相等有兩種方式。

常量池（constant pool）專門用於管理在編譯期被確定並被保存在已編譯的.class文件中的一些數據。它包括了關於類、方法、接口中的常量，還包括字符串常量。

JVM常量池保證相同的字符串（在編譯期間可運算的值）直接量只有一個，不會產生多個副本。

使用new String創建的字符串對象是運行時創建出來的，它被保存在運行時內存區內（堆內存），不會放入常量池中。

要判斷兩個引用變量的值是否相等時，可以使用.equals判斷。equals方法也可以重寫。

從JDK1.5之後，提供了自動裝箱(Autoboxing)和自動拆箱(AutoUnboxing)功能。即：

Integer intObj=5;boolean b = (Boolean)boolObj;

Integer a=2;Integer b=2;a==b //trueInteger a=128;Integer b=128;a==b //false

其原因是-128~127之間的整數自動裝箱成一個Integer實例時，會放入一個名為cache的數組中緩存起來。不在這個範圍內的，系統總是重新創建一個Integer實例。

每個類只擔任一個職責，每個類應只有一個引起它變化的原因。一個類只負責一項職責，應該僅有一個引起它變化的原則

子類可以擴展父類的功能，但不能改變父類原有的功能

高層模塊不應該依賴低層模塊，二者都應該依賴其抽象；抽象不應該依賴細節；細節應該依賴抽象。即針對接口編程，不要針對實現編程依賴倒置原則的中心思想是面向接口編程，傳遞依賴關係有三種方式，以上的說的是是接口傳遞，另外還有兩種傳遞方式：構造方法傳遞和setter方法傳遞。

建立單一接口，不要建立龐大臃腫的接口，儘量細化接口，接口中的方法儘量少。也就是說，我們要為各個類建立專用的接口，而不要試圖去建立一個很龐大的接口供所有依賴它的類去調用。在程序設計中，依賴幾個專用的接口要比依賴一個綜合的接口更靈活。接口是設計時對外部設定的「契約」，通過分散定義多個接口，可以預防外來變更的擴散，提高系統的靈活性和可維護性。

開閉原則要求軟體有一個良好的基本結構，確保面對「變化」的時候，僅僅擴展而不是修改現有對象的組織框架就可以隨需而動。抽象化是關鍵，定義抽象類或接口，使其可以有很多的具體實現預見所有的需要，在任何情況下都不再修改上層商業邏輯。

抽象類的用法：

垃圾回收只負責回收堆內存中的對象，不會回收任何物理資源程序無法精確控制垃圾回收的運行垃圾回收前，會調用finalize方法，該方法可能使該對象重新復活，從而導致垃圾回收機製取消回收

測試：

public class GcTest { public static void main(String[] args){ for(int i=0;i<4;i ){ new GcTest; } } public void finalize { System.out.println("系統正在清理資源"); }}

可以看到finalize不會被調用。而如果：

public class GcTest { public static void main(String[] args){ for(int i=0;i<4;i ){ new GcTest; Runtime.getRuntime.gc; } } public void finalize { System.out.println("系統正在清理資源"); }}

則finalize會被調用。使用java -verbose:gc GcTest查看垃圾回收後的提示信息：

但上面語句只是建議垃圾回收，系統仍有可能不立即進行垃圾回收。

System和Runtime類提供了runFinalization方法，可以強制垃圾回收機制調用系統中可恢復對象的finalize方法

常用命令：

jar cf test.jar test //test是目錄

jar cvf test.jar test

jar cvfM test.jar test

jar cvfm test.jar manifest.mf test

jar tf test.jar

jar tvf test.jar

jar xf test.jar

jar xvf test.jar

jar uf test.jar Hello.class

jar uvf test.jar Hello.class

程序發布的方式：

java package.MainClass

或

start javaw package.MainClass

jar cvfe test.jar Test *.class

該命令把目錄下的*.class壓縮到test.jar，並指定使用Test類為程序入口。運行的方法：

java -jar test.jarjavaw test.jar

面向對象軟體開發需要經過OOA（面向對象分析）、OOD（面向對象設計）和OOP（面向對象編程）三個階段，OOA對目標系統進行分析，建立分析模型，並將之文檔化；OOD用面向對象的思想對OOA的結果進行細化，得出設計模型。OOA和OOD的分析、設計結果需要統一的符號來描述、交流並記錄，UML就是這種用於描述、記錄OOA和OOD結果的符號表示法。面向對象的分析與設計方法在20世紀80年代末至90年代出現了一個高潮，UML是這個高潮的產物。在些期間出現了三種具有代表性的表示方法。Booch是面向對象方法最早的倡導者之一，他提出了面向對象軟體工程的概念。Booch1993表示法比較適合於系統的設計和構造。Rumbaugh等人提出了面向對象的建模技術（OMT）方法，採用面向對象的概念，並引入了各種獨立於語言的表示符。這種方法用對象模型、動態模型、功能模型和用例模型共同完成對整個系統的建模，所定義的概念和符號可用於軟體開發的分析、設計和實現的全過程，軟體開發人員不必在開發過程的不同階段進行概念和符號的轉換。OMT-2特別適用於分析和描述以數據為中心的信息系統。Jacobson於1994年提出了OOSE方法，其最大特點是面向用例（Use-Case），並在用例的描述中引入了外部角色的概念。用例的概念是精確描述需求的重要武器，但用例貫穿於整個開發過程，包括對系統的測試和驗證。OOSE比較適合支持商業工程和需求分析。UML統一了Booch、Rumbaugh和Jacobson的表示方法，而且對其進行了進一步的發展，並最終統一為大眾所接受的標準建模語言。UML是一種定義良好、易於表達、功能強大且普遍適用的建模語言，它的作用域不限於支持面向對象的分析與設計，還支持從需求分析開始的軟體開發全過程。UML的大致發展過程如圖所示：

UML2.0一共包括13種正式圖形：

用例圖用於描述系統提供的系列功能，而每個用例則代表系統的一個功能模塊。用例圖的主要目的是幫助開發團隊以一種可視化的方式理解系統的需求功能，用例圖對系統的實現不作任何說明，僅僅是系統功能的描述。用例圖包括用例（以一個橢圓表示，用例的名稱放在橢圓的中心或橢圓下面）、角色（Actor，也就是與系統交互的其它實體，以一個人形符號表示）、角色和用例之間的關係（以簡單的線段來表示），以及系統內用例之間的關係。用例圖一般表示出用例的組織關係—要麼是整個系統的全部用例，要麼是完成具體的一組用例。下面是BBS系統的部分用例示意圖。

用例圖通常用於表達系統或者系統範疇的高級功能。用例圖主要在需求分析階段使用，用於描述系統實現的功能，方便與客戶交流，保證系統需求的無二性，用實例圖表示系統外觀，不要指望用例圖和系統的各個類之間有任何聯繫。不要把用例做得過多，過多的用例將導致難以閱讀，難以理解；儘可能多地使用文字說明。

類圖是最古老、功能最豐富、使用最廣泛的UML圖。類圖表示系統中應該包含哪些實體，各實體之間如何關聯；換句話說，它顯示了系統的靜態結構，類圖可用於表示邏輯類，邏輯類通常就是業務人員所談及的事物種類。類在類圖上使用包含三個部分的矩形來描述，最上面的部分顯示類的名稱，中間部分包含類的屬性，最下面的部分包含類的方法。類之間有三種基本關係：

關聯具有一定的方向性，如果僅能從一個類單方向地訪問另一個類，則被稱為單向關聯；如果兩個類可以互相訪問對象，則稱為雙向關聯。一個對象能訪問關聯對象的數目被稱為多重性。關聯使用一條實線表示，帶箭頭的實線表示單向關聯。關聯關係包括兩種特例：聚合和組合。它們都有部分和整體的關係，但通常認為組合比聚合更加嚴格。如：

圖中描述Teacher與Student之間的關聯關係：

泛化與繼承是同一個概念，都是指子類是一種特殊的父類，類與類之間的繼承關係是非常普遍的，繼承關係使用帶空心三角形的實線表示。從下圖可以看出，Student和Person類之間的繼承關係。

如果一個類的改動會導致另一個類的改動，則稱兩個類之間存在依賴。依賴關係使用帶箭頭的虛線表示，其中箭頭指向被依賴的實體。依賴的常見可能原因如下：

對於現代的大型應用程式而言，通常不只是單獨一個類或單獨一組類所能完成的，通常會由一個或多個可部署組件組成。對Java程序而言，可復用的組件通常打包成一個JAR、WAR等文件；對C/C 應用而言，通常是DLL動態連結庫文件。組件圖提供系統的物理視圖，它的用途是顯示系統中的軟體對其它軟體組件的依賴關係。組件圖可以在一個非常高的層次上顯示，僅顯示系統中粗粒度的組件，也可以在組件包層次上顯示。組件圖通常包含組件、接口和Port等圖元，UML使用帶插頭符號的矩形來表示組件，使用圓圈代表接口，使用位於組件邊界上的小矩形代表Port。組件的接口表示它能對外提供的服務規範，這個接口通常有兩種表現形式：

部署圖用於描述軟體系統如何部署到硬體環境中，它的用途是顯示軟體系統不同的組件將在何處物理運行，以及它們將如何彼此通信。

順序圖顯示具體用例（或者是用例的一部分）的詳細流程，並且顯示流程中不同對象之間的調用關係，同時還可以很詳細地顯示對不同對象的不同調用。順序圖描述了對象之間的交互（順序圖和通信圖都被稱為交互圖），重點在於描述消息及其時間順序。順序圖有兩個維度：垂直維度，以發生的時間順序顯示消息/調用的序列；水平維度，顯示消息被發送的對象實例。順序圖的頂部每個框表示每個類的實例（對象），框中的類實例名稱和類名稱之間用冒號或空格來分隔，例如myReportGenerator:ReportGenerator。如果某個類實例向另一個類實例發送一條消息，則繪製一條指向接收類實例的帶箭頭的連線，並把消息/方法的名稱放在連線上面。對於某些特別重要的消息，還可以繪製一條帶箭頭的指向發起類實例的虛線，將返回值標註在虛線上，繪製帶返回值的信息可以使得序列圖更易於閱讀。用戶登錄順序圖：

當繪製順序圖時，消息可以向兩個方向擴展，消息穿梭在順序圖中，通常應該把消息發送者與接收者相鄰擺放，儘量避免消息跨越多個對象。對象的激活期不是其存在的時間，而是它佔據CPU的執行時間，繪製順序圖時，激活期要精確。

活動圖和狀態機圖都被稱為演化圖。

上圖描繪了Hibernate 實體具有3個狀態：瞬態、持久化和脫管。繪製狀態機圖時應該保證對象只有一個初始狀態，可以有多個終結狀態。狀態要表示對象的關鍵快照，有重要的實際意義，無關緊要的狀態則無須考慮，繪製狀態機時事件和方法要明確。狀態機圖擅長表現單個對象的跨用例行為，對於多個對象的交互行為應該考慮採用順序圖，不要對系統的每個對象都畫狀態機圖，只對真正需要關心各個狀態的對象才繪製狀態機圖。

本文學習資源來自《瘋狂Java講義》。UML部分摘自一本書忘了名稱，如有侵權請告知，我將立刻予以刪除。