耦合是每个程序员都绕不开的话题,却也是最容易掉以轻心的存在。如何處理耦合,直接決定了我們代碼質量的上限。今天 Peak 君就和大家聊聊這門基本功,把 iOS 代碼中處理耦合的種種方式與其差異好好捋一遍。
耦合的話題可大可小,但道理是相通的。為方便討論,我們先抽象簡化,只考慮兩個類之間的耦合。
假設有個 Person 類需要喝水,按職責劃分,我們需要另一個 Cup 類來完成供水動作:
// Person.h @interface Person : NSObject - (void)drink; @end // Cup.h @interface Cup : NSObject - (id)provideWater; @end
很明顯,Person 和 Cup 要協作完成喝水,耦合無法避免。下面我們看看 Objective-C 裡都有哪些耦合方式,以及它們對後續代碼質量的影響。
直接在 .m 裡 import Cup.h,並臨時創建 Cup 對象來調用方法:
#import "Person.h"
#import "Cup.h"
@implementation Person
- (void)drink {
Cup *c = [Cup new];
id water = [c provideWater];
[self sip:water];
}
- (void)sip:(id)water {
// sip water
}
@end這大概是不少人會選的寫法:用到誰就 import 誰,調用完事,功能完成提測一氣呵成。初看沒毛病,但有個隱患——Person 與 Cup 的耦合被埋進了 Person.m 的方法實現裡,而 .m 往往是業務邏輯的重災區。當 Person.m 不斷膨脹,若換另一位同事維護,他無法從 Person.h 一眼看出這個類到底和誰有交互,翻遍 drink 的聲明也找不到線索,只能從頭到尾讀完整個文件,對團隊效率的傷害可想而知。
既然放在 .m 裡不夠清晰,那我們把耦合的部分提到 Property:
// Person.h
@interface Person : NSObject
@property (nonatomic, strong) Cup *cup;
- (void)drink;
@end
// Person.m
@implementation Person
- (void)drink {
id water = [self.cup provideWater];
[self sip:water];
}
- (void)sip:(id)water {
// sip water
}
@end這樣掃一眼 Person.h,就能明白它依賴了哪些類,比埋在 .m 裡清楚多了。
你有沒有想過,Objective-C 為什麼要有 .h 文件,而不像 Java、Swift 那樣一個文件即一個類?.h 的好壞是兩面的,它最大的意義在於把聲明與實現分離。閱讀一個 .h 時,它主要透露兩條信息:
所以 .h 才是代碼耦合的關鍵所在。當你猶豫某個 Property 要不要放進 .h 時,先問問自己:它是否真的必須暴露給外部?一旦暴露,就增加了依賴與耦合的概率。Review 代碼時,光看 .h 是否清晰,往往就能猜出設計者的水平。
把 Cup 作為 Person 的 Property 聲明,就表明兩者存在必要依賴,一目了然。但問題隨之而來:Cup 暴露出去後,外部可以隨意修改。當內部正在執行 drink,另一個線程把 cup 置空,業務流程就可能出岔子。
最直觀的做法是把 Cup 聲明為 readonly,同時提供一個對外 setter:
// Person.h @interface Person : NSObject @property (nonatomic, strong, readonly) Cup *cup; - (void)setPersonCup:(Cup *)cup; - (void)drink; @end
有人會問,這和上面有啥區別,不都是可讀可寫嗎?最大的區別是多了檢查與干預的入口。Debug 時我常需要查清某個 Property 到底被誰改了,在 setter 裡下斷點會方便很多;還能借助 Xcode 的 Caller 機制,看看哪些外部類調用了它,分析類間關聯很有幫助。
setter 也給了我們擴展的空間,比如加入多線程同步鎖,或者實現 Copy On Write:
// Person.m
- (void)setPersonCup:(Cup *)cup {
Cup *anotherCup = [cup copy];
_cup = anotherCup;
}這樣 Person 就不會和外部共享同一個 Cup,杜絕了「共用一個水杯」的衛生問題 ;)。總之,獨立的 setter 讓我們對代碼有更大的掌控力,也讓後續維護者省心,利己利人。
帶 setter 的 Property 雖好,但 setter 可以被任意外部類隨時調用,用著用著被別人改了總不踏實。要避免這種情況,可以用 init 注入——Objective-C 的 designated initializer 正是為此而生:
// Person.h @interface Person : NSObject - (instancetype)initWithCup:(Cup *)cup; - (void)drink; @end
去掉 Property,把 Cup 的設置收攏到 init 裡,Person 對外就只給一次設置機會,init 之後外部再無從修改。這是使用最多、也比較推薦的方式:只在對象誕生時建立關係,把可變性降到較低。它有缺點嗎?通過 init 杜絕了外部干擾,但一旦內部持有 cup,內部方法仍可能與 Cup 產生各種耦合:
// Person.m
@interface Person ()
@property (nonatomic, strong) Cup *myCup;
@end
@implementation Person
- (instancetype)initWithCup:(Cup *)cup {
self = [super init];
if (self) {
self.myCup = cup;
}
return self;
}
- (void)drinkWater {
id water = [self.myCup provideWater];
[self sip:water];
}
- (void)drinkMilk {
id milk = [self.myCup provideMilk];
[self sip:milk];
}
@end此時耦合的深淺,主要取決於 Cup.h 的設計是否清晰。若 Cup 頭文件結構合理,這其實算不上太糟。
用 Property 持有,耦合的風險會貫穿 Person 的整個生命週期,因為 Property 對 .m 是全局可見的。若換成 parameter 注入,就能把耦合限制在單個方法內部:
// Person.h
@interface Person : NSObject
- (void)drink:(Cup *)cup;
@end
// Person.m
- (void)drink:(Cup *)cup {
id water = [cup provideWater];
[self sip:water];
}好處在於:Person 和 Cup 的耦合只發生在 drink 內部,函數一結束,依賴關係隨之解除。從時間和空間跨度看,這比持有 Property 風險更小。但若 Person 裡有多處對 Cup 的依賴(drinkWater、drinkMilk、drinkCoffee……),那反而不如 Property 來得直觀方便。
單例的優劣已有大量文章探討,Peak 君只強調最常見的問題根源——狀態共享。把 Cup 做成單例:
// Person.m
- (void)drink {
id water = [[Cup sharedInstance] provideWater];
[self sip:water];
}這種耦合既和方式一一樣隱蔽,又最容易導致代碼降級。隨着版本迭代,很可能最終演化成一張所有對象都依賴同一狀態、且人人可讀寫的關聯圖:

到那時,到處打補丁修 Bug,按下葫蘆浮起瓢。這類場景很常見,比如在單例裡持有用戶信息,登出後忘了清理,就會冒出莫名其妙的 bug;而單例一旦散落項目各處,逐一排查更是頭疼。
繼承是一種強耦合關係,網上關於 inheritance 與 composition 優劣的討論已不鮮見。繼承確實能在初期快速建立清晰的對象模型,重用與多態也很誘人;問題在於這種強耦合在理解上容易產生分歧——什麼對象該被確立為父子關係?哪些子類行為該上提到父類?多層繼承時這些問題會更複雜。所以 Peak 君建議盡量少用繼承來描述對象,除非是毫無爭議、一目了然的父子關係。
用 runtime 處理耦合是 Objective-C 的獨門絕活,耦合度低到幾乎「感覺不到」:
// Person.m
- (void)drink:(id)obj {
id water = nil;
SEL sel = NSSelectorFromString(@"provideWater");
if ([obj respondsToSelector:sel]) {
water = [obj performSelector:sel];
}
if (water) {
[self sip:water];
}
}既不用 import Cup 頭文件,也不必知道 Cup 支持哪些方法。但問題恰恰在於耦合太低,讓開發者感知不到類與類之間的關係。哪天有人把 provideWater 改成 getWater,drink 若沒同步,編譯期不會報錯,runtime 也不會崩潰,可業務流程卻悄悄斷了。這也是為什麼我們不推薦用 runtime 的黑魔法去做業務,它更適合無副作用的場景,比如用 AOP 打日誌。
這並非獨立的耦合方式,而是可以與上述任意方式結合、進一步降低耦合的手段,也是複雜類關係設計中首推的做法:
@protocol LiquidContainer (NSObject)(此處圓括號替換尖括號) - (id)provideWater; - (id)provideCoffee; @end // Person.h @interface Person : NSObject - (void)drink:(id(LiquidContainer))container;(此處圓括號替換尖括號) @end
無論 Property 持有還是 parameter 注入,都能用 protocol 來降低依賴。protocol 只規定方法聲明,不限定由哪個具體類實現,為後期維護留出了更大的空間與可能性。
以上是常見的兩兩耦合方式。從中我們能感知到:不同方式導致的耦合深淺,本質上就是「互相調用函數、訪問狀態的頻次」。理解這一點,有助於我們量化兩個對象的耦合度,並在更複雜場景中分析一個模塊甚至一種架構的耦合程度。
比如 A、B、C 三個類,可以拆成 AB、BC、AC 三組兩兩關係去分析,進而感知 ABC 作為整體的耦合度。顯然,相連式(只需分析 AB 和 BC)比全連接式看起來更健康。在我們挑選設計模式重構代碼時,也可以依此類推,選擇耦合度最低、最貼合業務的方案。
原則是:類與類之間調用的方法、依賴的狀態越少越好。在 Objective-C 這門語言下,寫出分類清晰、接口簡潔的頭文件尤為重要。
前面的分析重在量化和感知耦合深淺,但並非每次方法調用都有風險,有些耦合可以稱之為良性。
把代碼高度抽象,無非兩類:Data 與 Action。Class 中的 Property 是 Data,函數則是 Action。真正讓代碼變危險的是狀態變化,也就是改動 Data。如果一個函數是純函數——既不依賴外部狀態,也不修改外部狀態——那麼無論被調用多少次都是安全的。若 Person 和 Cup 互相調用的都是純函數,兩者的耦合便可視為良性,不會導致狀態維護混亂,只是會讓重構變得更費力,畢竟耦合越深,改動面越大。
所以做設計時,應盡量讓元素間的耦合趨於良性,這就牽涉到狀態維護。下面兩種設計方式值得對比:

圖中紅圈代表每個類或功能單元持有的狀態。按上方方式,各單位各自處理狀態變化,若狀態間還互相依賴,耦合越深,開發調試與重構就越難,代碼也降級越厲害。若按下方方式,把狀態變化集中到一起處理,維護起來就輕鬆許多——這也正是很多 App 引入 model layer 的原因:把 App 狀態(各類 model)的變化獨立成一個層,上層業務只作為它的展現與交互外殼。這套思路,大到整個 App 架構,小到一個功能模塊,都能借鑑。
本文梳理了常見的耦合方式,重在分析不同寫法對最終耦合的影響。值得一提的是,這些方式並無絕對優劣,不同業務場景下選擇各異:有的確實需要持有 Property,有的則更適合單例。關鍵在於我們能看清每種方式對後期維護的影響。文中部分內容偏抽象,多為個人感悟與總結,或有不妥之處,歡迎讀者批判性地吸收,但願能為大家日常寫代碼、處理耦合帶來一點幫助。
