<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kash Yang on Medium]]></title>
        <description><![CDATA[Stories by Kash Yang on Medium]]></description>
        <link>https://medium.com/@kashkhyang?source=rss-31a102e43b96------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jxLmr2jyt-OkA4WPsSU9ag.jpeg</url>
            <title>Stories by Kash Yang on Medium</title>
            <link>https://medium.com/@kashkhyang?source=rss-31a102e43b96------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 16:01:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kashkhyang/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[用 Android Service 實作一個 Timer]]></title>
            <link>https://medium.com/@kashkhyang/%E7%94%A8android-service%E5%AF%A6%E4%BD%9C%E4%B8%80%E5%80%8Btimer-303388ffefd6?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/303388ffefd6</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[coroutine]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Mon, 23 Oct 2023 17:31:01 GMT</pubDate>
            <atom:updated>2023-10-24T03:22:17.625Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MHymgGkB5J5fESZg" /><figcaption>Photo by <a href="https://unsplash.com/@daria_shevtsova?utm_source=medium&amp;utm_medium=referral">Daria Shevtsova</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>延續前一章：<a href="https://medium.com/@kashkhyang/%E5%A6%82%E4%BD%95%E5%81%9A%E7%A8%8B%E5%BC%8F-%E8%A8%AD%E8%A8%88-4ded58ceb7de">如何做程式「設計」</a>，我們用開發一個 Timer 的程式來示範這個設計流程。</p><blockquote>這個範例中，某些架構或許並非需要，只是用來演示可能的過程。且開發者具備基本的 Android 知識，並非從 0 開始。</blockquote><h3>需求確認</h3><p>Timer 的需求如下：</p><ul><li>Timer 時間上限為 60 分鐘，下限為 1 分鐘，預設為 1 分鐘。</li><li>使用者可以按下增加/減少時間按鈕，調整 Timer 的時間，一次調整以 1 分鐘為單位。</li><li>使用者可以按下開始鍵，開始倒數。</li><li>使用者可以按下暫停鍵，暫停倒數。</li><li>使用者可以按下停止鍵，停止倒數。</li><li>使用者可以從通知列得知目前的剩餘時間。</li><li>若倒數尚未結束，使用者離開 APP 之後必須要能夠繼續倒數</li></ul><h3>技術選擇</h3><ul><li>背景執行：Service</li><li>Timer 主體：flow + delay</li><li>畫面處理： Compose UI</li><li>架構框架：MVI (<strong>M</strong>odel-<strong>V</strong>iew-<strong>I</strong>ntent)</li></ul><p>針對這些技術選擇，我們來稍微解釋一下：</p><h4>為什麼使用Service</h4><p>從官方<a href="https://developer.android.com/guide/components/services">文件</a>來看：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jm_4InAQrQwpGQfBB812iQ.png" /></figure><p>因為 Timer 需要能在使用者離開 APP 後能繼續倒數，所以我們需要一個能一直持續執行的角色，這時候Service肯定是首選。</p><blockquote>其他的選擇，像是WorkerManager, Thread, … 等等，都可以去查一下差異，會更了解哪些時機點該使用哪些元件。</blockquote><h4>為什麼使用flow + delay</h4><p>沒為什麼，因為想用。</p><p>用CountDownTimer 、Handler + postDelayed 也是可以。</p><h4>為什麼使用 Compose</h4><p>因為想畫的 UI 用Compose來堆積會比較快，所以選Compose</p><blockquote>寫了幾隻 Compose 範例之後，個人認為對比於傳統的xml來說，開發速度上真的快上滿多。</blockquote><h4>為什麼使用 MVI</h4><p>因為Compose UI 現在官方主推的就是MVI，就來試試看吧。</p><blockquote>至於 MVVM 與 MVI 的差別，本篇暫不討論</blockquote><h3>實作與重構循環</h3><p>確定使用哪些技術，開始實作之後，建議先畫個設計圖</p><p><strong>你可能第一版會畫出這樣的東西：</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/562/1*JEizMVS2goSIrha4RTs9Iw.png" /><figcaption>基本的Activity與Service溝通的架構</figcaption></figure><p>然後你突然想到，不是說好要用MVI嗎？那個ViewModel怎麼不見了？於是</p><p><strong>隔了一層 ViewModel 畫出了第二版：</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*xArBI4I_sFSCI6AMJDmqaw.png" /><figcaption>基本的MVVM / MVI架構</figcaption></figure><p>一邊查資料一邊實作的過程，被你看到了MVVM + Repository 的概念，你決定修改</p><p><strong>加上 Repo 有了第三版：</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qgq39VWZLY7yTHKQaIxwAw.png" /><figcaption>ViewModel與Repository架構</figcaption></figure><p>改到一半發現大家都在討論<a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">依賴反轉原則</a>，你又動搖了。看了一下教學，覺得也沒有難改到哪邊去，決定一次到位給他改下去</p><p><strong>加入抽象化的概念有了第四版：</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SbT43dQiP8-RgzUJ7N9ETg.png" /><figcaption>將ViewModel、Repository與Service的依賴關係抽象化</figcaption></figure><p>心想這樣肯定沒問題了吧，加緊腳步的開發吧！</p><p>正當你快完成的時候，PM 發來一個會議通知：「Timer 需求變更討論會議」。</p><p>抱者忐忑不安的心進到會議室之後，PM 試探性的問了一句：「你的 Timer 應該可以在任何地方使用吧？我們現在很多地方要用這個 Timer！」</p><p>你開始覺得不太妙，因為你的 Timer 其實就是 Service 本人，你想了一想</p><p><strong>把 Timer 獨立於 Service，畫出了第五版：</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jf2_836B8ZTPMz5ROXA0OQ.png" /><figcaption>Timer獨立於Service之外</figcaption></figure><p>短短的幾天你已經改了五版了，<strong>實作重構的循環</strong>已經經歷了五次了，回到我的這篇文章的出發點上：</p><blockquote>你怎麼知道要這樣寫？</blockquote><p>因為出發點不一樣，有經驗的人起步可能就是無經驗者的第四個循環、第五個循環，當然做得又快又好。</p><p>所以經驗的累積，就是體現在自己下一次的起步點往後面的循環移動，至於怎麼做，就看每個人的學習記憶方法了，期許各位都能成為被問這句話的人，也能把自己的經驗分享，讓大家都一起成長！</p><p>最後附上這次範例的程式碼</p><p><a href="https://github.com/kash-yang/ServiceTimer">GitHub - kash-yang/ServiceTimer: This is a Timer implemented with Service and Compose UI</a></p><p>範例程式中使用了startService() 跟 bindService()。常有人不確定什麼時候要使用哪一種。</p><p>這兩者的最大的差異在於有沒有需要持有 Service 的實體，如有需要就使用 bindService()，反之則使用 startService()。</p><p>生命週期的部分，用 bindService() 拉起來的 Service，只要沒有 Client 與 Service 維持 bond 的關係就會自動消滅。若是由 startService() 叫起的Service，則需要搭配 stopService()，才能將 Service 停止。</p><p>混用的生命週期則可以自己插 log 做個實驗，也能參考範例中的 Log ，TAG 為FlowTimerService</p><p>那故事到這邊就結束了嗎？</p><blockquote><strong>並沒有。</strong></blockquote><p>還記得我們提過的回饋檢討嗎？</p><p>科技進步得很快，會有新的框架不斷問世，改善現有的問題，到時候就會有第六版、第七版。</p><p>想法也改變的很快，客戶需求變更隨時來，第八、九、十版也很常見。</p><p>既然改變無可避免，我們能做的，就是寫出當每次改變來臨都可以簡單應對的 code。</p><p>能夠很快應對改變、能夠很改很少的 code 就達到目標，這就是資深工程師的精華所在，也是價值所在。</p><p>大家一起加油吧💪</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=303388ffefd6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[如何做程式「設計」]]></title>
            <link>https://medium.com/@kashkhyang/%E5%A6%82%E4%BD%95%E5%81%9A%E7%A8%8B%E5%BC%8F-%E8%A8%AD%E8%A8%88-4ded58ceb7de?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ded58ceb7de</guid>
            <category><![CDATA[beginner]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Sun, 22 Oct 2023 17:24:05 GMT</pubDate>
            <atom:updated>2024-03-04T03:39:27.180Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CDpy5QoXn1S2XqiM" /><figcaption>Photo by <a href="https://unsplash.com/@amayli?utm_source=medium&amp;utm_medium=referral">Amélie Mourichon</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>在學習寫程式的路上，設計出具備<em>易讀</em>、<em>好維護</em>、<em>有彈性</em>…（以下省略幾千字）的程式一直都是大家追求的目標，不管是看到別人的 code、自己不會寫去問人，或是被人問，應該很常聽到這句：</p><blockquote>你怎麼知道要這樣寫？</blockquote><p>對啊。你怎麼知道要這樣設計？你怎麼知道會遇到這樣的問題，能夠預留好某些彈性呢，甚至是防範於未然呢？</p><p>這句話問過的人都可能會得到這個好像有回答，但是好像沒什麼幫助的答案：</p><blockquote>這都是經驗。</blockquote><p>呃，我彷彿看到大學時期的我對這個回答感到無奈的臉。但好像就是這樣，寫多了自然就會知道。</p><p>但過去的我，一直沒有辦法被這個答案給說服。我不停在思考一件事情：</p><h3>難道就沒有更有邏輯性的回答嗎？</h3><p>現在的我，已經不會再問這種問題了。並不是我變得多會寫 code，而是我有我累積自己經驗的邏輯。</p><p>這篇文章的目的，就是希望能把我自己的邏輯記錄下來，幫助現在正在這條路上努力的人，也給過去的我一個交代。</p><p>這些經驗的累積，有一個很重要的概念，就是：<strong>循環、檢討、實際使用</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/459/1*ctAIcLoDog7nhfTgYG9vCQ.png" /></figure><blockquote>不要停止思考，不要妥協，不斷去追尋更好的做法，並且把每次學到的經驗，不僅僅回饋到下次的專案開發之中，同時也要回頭檢討過去的專案。</blockquote><h3>凡事由需求出發</h3><p>寫程式是目的性很強的一種工作，你得先知道往什麼方向去，要達到什麼目標，為了達成這個目標要做哪些事情。跟蓋房子一樣，不知道房子要蓋成什麼樣子，是沒有辦法動工的。</p><blockquote>開始寫 code 之前，確認需求一定是首要目標。</blockquote><h3>技術選擇靠實力</h3><p>確認完需求之後，要使用哪些技術來達成，這完全是實力的展現。跟你過去看過多少 code，寫過多少 code，累積了多少知識，有完全的正相關。不可能選擇一個自己不知道的技術，因為他一開始就不會在選項裡面。</p><p>選擇的過程也需要知道為什麼選這個，他應該直接跟需求有關，而不是為了比較新，或是炫技而使用。</p><p>那沒經驗怎麼辦？</p><p>查資料、看文件、問人，然後再 POC，這大概是你唯一的路。</p><blockquote>懂的下對的關鍵字、會整理資料、懂的怎麼問問題是現在大家都必備的能力。</blockquote><h3>實作與重構的循環</h3><p>確定技術選擇之後，會進入實作環節，但這重構又是怎麼一回事？</p><p>因為你會 Google、會看到別人的 code、會問 ChatGPT、會看 StackOverflow…，這些都會不斷影響你的想法，讓你在一邊開發的時候，一邊又想改寫法。</p><p>這都是正常的，只要技術能力跟得上，又有時程上的餘裕，直接改寫也不失是一個選擇。</p><p>實作以及重構的流程，會一直不斷的在開發的過程中上演，有經驗跟沒有經驗的開發者，就差在這個循環的次數（還有實作的速度😅）</p><blockquote>老話一句：先求有再求好，如果因為一直重構而沒辦法實作完成，反而本末倒置。建議至少先完成一版，再來思考重構。</blockquote><h3>回饋環節不能少</h3><p>當專案完成，程式碼寫完之後，好好檢討自己做得好，以及做得不好的地方，把這些事情統整記錄下來之後，找出原因，提出可行的解決方案，讓自己下次能夠做得更好，不要重蹈覆徹。</p><p>這環節不應放寬標準對待自己，更不能自我感覺良好，魔鬼就藏在細節裡。</p><blockquote>如果專案做完就算了，也沒有從中獲得什麼進步，那這專案對自己毫無幫助。一定能找出什麼讓自己成長。</blockquote><h3>練習機會別放過</h3><p>寫程式這條路上，學習得到的一切知識、技巧，有實作過跟僅僅是紙上談兵有顯著的差異，多練習多熟悉，之後才能抓準使用時機，所以說拿舊的專案來練習可以說是最好不過。</p><p>面對真實的自己很重要，了解過去自己有哪些不足之處，才有進步的機會。</p><blockquote>透過對過去的自己做 code review，能獲得最直接的成長。</blockquote><p>所以說，我認為「你怎麼知道要這樣寫？」的答案就在於<strong>實作重構的循環</strong>他之前已經走過了，並且檢討過了，也成為他的經驗之一，也因為已經內化成為知識了，所以沒辦法很明確的說出來是因為什麼事件，讓他有這種想法要寫成這樣。</p><p>那我們能做的是什麼？就是去搞清楚這樣寫是要解決什麼問題，為什麼能解決這個問題，並且把這次學會的融入自己的經驗，變成自己的東西，然後不斷的問自己：</p><h4>「如果是我的話，我會怎麼做？有沒有更好的寫法？」</h4><p>祝各位學習順利，實作重構的循環越來越少！</p><p>下一篇預計用一個 <a href="https://medium.com/@kashkhyang/%E7%94%A8android-service%E5%AF%A6%E4%BD%9C%E4%B8%80%E5%80%8Btimer-303388ffefd6">Timer</a> 的範例，來演示這個流程，一步一步改變實作。也順便回答學生的問題🤣</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ded58ceb7de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[動態改變Lottie動畫顏色 - Android Jetpack Compose]]></title>
            <link>https://medium.com/@kashkhyang/%E5%8B%95%E6%85%8B%E6%94%B9%E8%AE%8Alottie%E5%8B%95%E7%95%AB%E9%A1%8F%E8%89%B2-android-jetpack-compose-621be6582c2a?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/621be6582c2a</guid>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[lottie-animation]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Wed, 27 Sep 2023 17:44:13 GMT</pubDate>
            <atom:updated>2024-03-31T15:40:23.743Z</atom:updated>
            <content:encoded><![CDATA[<h3>動態改變 Lottie 動畫顏色 - Android Jetpack Compose</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oDiYjkZHVUCY8_fa" /><figcaption>Photo by <a href="https://unsplash.com/@jeremythomasphoto?utm_source=medium&amp;utm_medium=referral">Jeremy Thomas</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>數個月前為了 AppWorks School iOS 班學員，誕生了這一篇 <a href="https://medium.com/@kashkhyang/%E5%8B%95%E6%85%8B%E6%94%B9%E8%AE%8Alottie%E5%8B%95%E7%95%AB%E9%A1%8F%E8%89%B2-14a6f51cc815"><strong>動態改變 Lottie動畫顏色</strong></a>。現在一樣，只是對象換成 Android 班的學員，也可以說是一個不誤本業，現在來還債的概念吧 😂</p><p>其實很久很久以前做過這類的功能，既然要再做一次就來用新方法，用 Compose 實作吧</p><blockquote>功能定義，UI 設定，還有動畫的原始檔都與前篇一樣，這邊就不再提了</blockquote><h4>令人頭痛的地方</h4><p>Android 這邊沒有像 iOS 原生的UIColorPickerViewController 那樣方便的元件，可以用來挑選顏色。</p><p>查了一下 github，有滿多前輩們有做了類似的套件，但初步思考一下這玩意兒不應該太難，索性就動手做吧！</p><blockquote>果不其然出現了估計誤差，其實還滿搞剛的，最後也是抄了 Wiki 的數學公式，不過這又是另外一個故事了…</blockquote><h4>UI 設定</h4><h4>jetpack compose</h4><p>透過 Android Studio 的 New Project Setup Wizard，我們選擇Compose的Empty Activity ，這樣一些基本的元素就可以讓 Android Studio 幫忙 create 好，我們直接可以進入核心的部分</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*0uAzLZ2OnQUiDb4jyoUKDg.png" /></figure><h4>Dark mode</h4><pre>val color = when (isSystemInDarkTheme()) {<br>    true -&gt; Color.White<br>    else -&gt; Color.Red<br>}</pre><p><strong>動畫</strong></p><p>我們用lottie-compose : <a href="https://github.com/airbnb/lottie/blob/master/android-compose.md">https://github.com/airbnb/lottie/blob/master/android-compose.md</a></p><p>在Theme中把lottie的設定調整好，這邊要注意的是我們目標是要把顏色蓋在本來的動畫的相應的KeyPath上面，所以我們使用的是PorterDuffColorFilter，並且把Mode指定為SRC，表示只留下 source 的意思，不同的 Mode 有不同的效果，細節可以參考這邊: <a href="https://developer.android.com/reference/android/graphics/PorterDuff.Mode#alpha-compositing-modes"><strong>alpha-compositing-modes</strong></a></p><pre>val composition by rememberLottieComposition(<br>    LottieCompositionSpec.RawRes(R.raw.animation) //吸入raw中的animation.xml<br>)<br><br>val dynamicProperties = rememberLottieDynamicProperties(<br>    rememberLottieDynamicProperty(<br>        property = LottieProperty.COLOR_FILTER, <br>        value = PorterDuffColorFilter( //使用 PorterDuffColorFilter 把顏色蓋上去<br>                    currentColor.toArgb(), <br>                    PorterDuff.Mode.SRC //mode: 只留下source<br>                ),<br>        keyPath = arrayOf( //要作用的KeyPath<br>            &quot;**&quot;,<br>            &quot;Stroke 1&quot;<br>        )<br>    ),<br>)<br><br>...<br>...<br><br>LottieAnimation(<br>    modifier = Modifier<br>        .fillMaxWidth()<br>        .aspectRatio(1f, matchHeightConstraintsFirst = true),<br>    composition = composition, //吸入raw的參數(已在上方定義)<br>    iterations = LottieConstants.IterateForever, //loop<br>    dynamicProperties = dynamicProperties //拿來變色用的property(已在上方定義)<br>)</pre><p>有這三個元素之後，把color送進去dynamicProperties，就能夠達到換色的效果，但就像<a href="https://medium.com/@kashkhyang/%E5%8B%95%E6%85%8B%E6%94%B9%E8%AE%8Alottie%E5%8B%95%E7%95%AB%E9%A1%8F%E8%89%B2-14a6f51cc815#:~:text=%E5%8B%95%E6%85%8B%E6%94%B9%E8%AE%8A-,%E5%8B%95%E7%95%AB,-%E9%A1%8F%E8%89%B2">前篇</a>所說，我們依然要去找<strong>這個動畫有哪些 node，還有這些 node 的 keypath 分別又是什麼</strong></p><p><strong><em>BUT…</em></strong></p><p>Lottie 的工程師感覺滿任性的：<em>https://github.com/airbnb/lottie-android/issues/2080</em></p><blockquote>Your best bet is probably to use an AndroidView composable with an actual LottieAnimationView and then switch back once you know the KeyPath you need or just open up the animation in a sample project. <strong>As of now, I&#39;m not planning on porting that particular API.</strong></blockquote><p>他老兄不是很想 porting，然後還要我們用舊的方式去找，所以我又加了一段 code 來 log 出所有的 keypath，拿到之後就可以來換色囉</p><pre><br>AndroidView(<br>    modifier = modifier.fillMaxWidth(),<br>    factory = { lottieView }<br>) { view -&gt;<br>    // View&#39;s been inflated - add logic here if necessary<br>    with(view) {<br>        // 處理換色，概念與compose相同<br>        val applyColor: (keyPath: KeyPath, color: Int) -&gt; Unit = { keyPath, color -&gt;<br>            val filter = PorterDuffColorFilter(color, PorterDuff.Mode.SRC)<br>            this.addValueCallback(<br>                keyPath,<br>                LottieProperty.COLOR_FILTER,<br>                LottieValueCallback(filter)<br>            )<br>        }<br>        this.addLottieOnCompositionLoadedListener {<br>            resolveKeyPath(KeyPath(&quot;**&quot;)).forEach {<br>                //Log all the key paths<br>                Log.i(&quot;LottiePlayground&quot;, &quot;key path: $it&quot;)<br>            }<br>            applyColor(KeyPath(&quot;**&quot;, &quot;Stroke 1&quot;), selectedColor.toArgb())<br>        }<br>    }<br>}</pre><p>新舊的切換可以透過改變範例程式中的USE_OLD_LOTTIE來達到效果</p><pre>const val USE_OLD_LOTTIE = false<br>...<br>...<br>if (USE_OLD_LOTTIE) {<br>    OldWayAndroidLottieView(<br>        modifier = Modifier<br>            .fillMaxWidth()<br>            .aspectRatio(1f, matchHeightConstraintsFirst = true),<br>        selectedColor = currentColor<br>    )<br>} else {<br>    LottieAnimation(<br>        modifier = Modifier<br>            .fillMaxWidth()<br>            .aspectRatio(1f, matchHeightConstraintsFirst = true),<br>        composition = composition,<br>        iterations = LottieConstants.IterateForever,<br>        dynamicProperties = dynamicProperties<br>    )<br>}<br>...<br>...</pre><p>最後來看一下成果吧</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/1*hEIfEip84V_Cel2d5CqzMA.gif" /></figure><p>github: <a href="https://github.com/kash-yang/LottiePlayground-Android">https://github.com/kash-yang/LottiePlayground-Android</a></p><p>祝各位 Coding 愉快</p><p>關於色盤：目標是做成類似 mac 能看到的 color picker 這樣的東西…的超級陽春版，只有<strong>色盤</strong>跟<strong>透明度</strong>可選</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/336/1*vew9K5RyE-nS57vxvQjVbw.png" /></figure><p>最後做出來的成品長這樣</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/265/1*8yyK9r0L1WuCz536klPDCw.png" /></figure><p>我參考的是這幾篇 Wiki 跟 Medium，大家有興趣可以再去看看囉</p><ul><li><a href="https://en.wikipedia.org/wiki/HSL_and_HSV">HSL and HSV - Wikipedia</a></li><li><a href="https://en.wikipedia.org/wiki/Polar_coordinate_system">Polar coordinate system - Wikipedia</a></li><li><a href="https://medium.com/@bantic/hand-coding-a-color-wheel-with-canvas-78256c9d7d43">Hand-coding a color wheel with canvas</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=621be6582c2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[初探物件導向程式設計 OOP (四)]]></title>
            <link>https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E5%9B%9B-2d84d4077703?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d84d4077703</guid>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[abstraction]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Fri, 21 Jul 2023 10:14:50 GMT</pubDate>
            <atom:updated>2024-02-02T03:37:27.391Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7ErLV_P_QzBiwCsMuOVH-w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/de/@geerald?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Gerald Schömbs</a> on <a href="https://unsplash.com/images/animals/shark?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>前幾系列講了 OOP 的三個重要特性之後，本篇會從<strong>抽象化 (Abstraction) </strong>來討論<strong>多型</strong>的應用。</p><p><em>關於抽象化的定義及好處，可以參考</em><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%BA%8C-%E6%8A%BD%E8%B1%A1%E5%8C%96-4f018896bf7a"><em>這裡</em></a>。</p><p>在 Java 跟 Kotlin 中，抽象化有兩種方式，接下來透過幾個範例來看</p><ol><li>抽象類別：Abstract class</li><li>介面：Interface</li></ol><h4>抽象類別：Abstract class</h4><p>顧名思義，抽象類別本身也是一種類別class，所以他具備了所有類別的特色，包含建構子constructor、類別成員class member等等。那麼抽象類別跟一般類別的差別在哪裡呢？我們從一個簡單的Fish類別來看</p><pre>abstract class Fish(val name: String) {<br>    abstract val size: String<br><br>    fun sleep() {<br>        println(&quot;$name sleep&quot;)<br>    }<br><br>    open fun eat() {<br>        println(&quot;$name eat&quot;)<br>    }<br><br>    abstract fun swim()<br>}<br><br>fun main() {<br>    val fish = Fish(&quot;Alice&quot;) // 編譯錯誤<br>}</pre><p>有數個不同之處</p><ul><li>abstract 的修飾字，用來修飾哪個對象是抽象的，修飾類別還有類別成員</li><li>被abstract修飾的資料成員沒有賦值、方法成員則沒有實作</li><li>抽象類別沒辦法被實例化</li></ul><p><strong>抽象類別沒有辦法被實例化</strong>，可以是很直觀的理解，因為class沒有完成，這一份合約沒有寫完，沒有辦法拿來產生物件實體。</p><p>沒有完成的部分就是那些被abstract修飾的類別成員</p><blockquote>只有定義但沒有實作，所以實作會是什麼樣子？Fish這個類別是不知道的，這正是抽象的所在。</blockquote><p>那實作誰要來做呢？答案就是Fish的子類別，我們來創造一個Shark的class，以及Seahorse的class，來繼承Fish並且填入實作</p><pre>class Shark(name: String) : Fish(name) {<br><br>    // 替abstract 成員賦值<br>    override val size = &quot;Large&quot; <br><br>    override fun swim() {<br>        // 實作abstract method<br>        println(&quot;$name swim so fast&quot;)<br>    }<br>    <br>    override fun eat() {<br>        // 依然能覆寫本來的open method<br>        println(&quot;$name big bite&quot;)<br>    }<br>}<br><br>class Seahorse(name: String) : Fish(name) {<br>    // 替abstract 成員賦值<br>    override val size = &quot;tiny&quot;<br><br>    override fun swim() {<br>        // 實作abstract method<br>        println(&quot;$name swim so slow&quot;)<br>    }<br>}</pre><blockquote>生物小常識：海馬是魚類喔</blockquote><p>可以看到抽象的部分size、swim()，在兩個不同的子類別分別實作出不同的樣貌。<strong>如果在子類別中沒有實作父類別裡定義的抽象部分，則是會編譯失敗</strong>。</p><p>回到多型，今天假如說要舉辦魚類游泳比賽，你就可以利用多型的特性，來設計你的class</p><pre>//創建一個游泳比賽的類別，參賽者是所有魚<br>class SwimmingContest(val competitors: List&lt;Fish&gt;) {<br>     <br>    // 開始比賽<br>    fun start() {<br>        // 暫時忽略沒有同時開始游的問題<br>        competitors.forEach { it.swim() }<br>    }<br>}<br><br>fun main() {<br>    //多型的寫法，都是魚類，但實體不同<br>    val shark: Fish = Shark(&quot;Alice&quot;)<br>    val seahorse: Fish = Seahorse(&quot;Bob&quot;)<br><br>    SwimmingContest(<br>        listOf(shark, seahorse)<br>    ).start()<br>}</pre><p>這個比賽允許所有魚類參加，每一種魚都有自己獨特的泳姿與速度，比賽精彩，完美落幕。</p><p>不過，因為比賽太成功獲得了關注，開始有一些動物有些意見：</p><ul><li><strong>章魚 (Octopus)</strong>：為什麼我不能參加？我也在海裡生活，我也很會游泳！</li><li><strong>海豚 (Dolphin)</strong>：為什麼我不能參加？我跟魚長得很像，我也很會游泳！</li><li><strong>鱷魚 (Crocodile)</strong>：為什麼我不能參加？我名字裡有個魚！</li></ul><p>因為上述這些動物，都不是魚類，不能繼承Fish，當然沒辦法參加</p><blockquote>生物小常識：並不是名字有魚就是魚類，章魚是軟體動物，海豚是哺乳類，鱷魚是爬蟲類</blockquote><p>但身為比賽主辦方，覺得這些動物都很會游泳，如果能讓這些動物參加比賽，一定能增加精彩度，但他們又<strong>都不是魚類</strong>，該怎麼樣讓他們參加呢？</p><p>這時候我們就可以用 <strong>介面 (Interface)</strong>，來解決這個問題。</p><h4>介面：Interface</h4><p>介面也是一個我們用來達成抽象化的方法，抽象之處在於介面只需規範能做哪些事情，但並不需要知道這些事情是怎麼樣被完成的</p><p>是不是有點像剛剛的抽象類別？Fish只定義了能游泳，但不需要知道Shark、Seahorse是怎麼遊的。</p><p>引述良葛格的一句話：</p><blockquote>表面上看來，介面有點像是完全沒有任何方法被實作的抽象類別，但實際上兩者在語義與應用上是有差別的</blockquote><p>這句話寫得很好，乍看之下真的沒兩樣，那為什麼要設計 interface 呢？</p><ol><li>類別不能多重繼承，不能同時屬於魚類，又屬於爬蟲類。</li><li>介面不是類別，所以實作介面的類別，依然能擁有自己父類別的特性，而且可以實作多個介面，像鱷魚這樣可以會游泳，同時也會走路</li></ol><p>我們直接從範例來看，承續上面的難題，要怎麼讓這些不是魚類的動物，也能參加游泳比賽呢？</p><p>我們先定義一個Swimmer 介面，並且將剛剛的魚類別，修改一下</p><pre>// 定義介面<br>interface Swimmer {<br>    val size: String<br>    fun swim()<br>}<br><br>//定義父類別<br>open class Fish(val name: String) {<br>    <br>    fun sleep() {<br>        println(&quot;$name sleep&quot;)<br>    }<br><br>    open fun eat() {<br>        println(&quot;$name eat&quot;)<br>    }<br>}<br><br>//定義Shark 繼承Fish, 實作Swimable<br>class Shark(name: String): Fish(name), Swimmer {<br><br>    // 實作Swimable中定義的資料成員<br>    override val size = &quot;Large&quot; <br><br>    // 實作Swimable中定義的方法成員<br>    override fun swim() {<br>        println(&quot;$name swim so fast&quot;)<br>    }<br><br>    override fun eat() {<br>        println(&quot;$name big bite&quot;)<br>    }<br>}<br><br>class Seahorse(name: String): Fish(name), Swimmer {<br>    override val size = &quot;tiny&quot;<br><br>    override fun swim() {<br>        println(&quot;$name swim so slow&quot;)<br>    }<br>}</pre><p>接著我們馬上就能新增三個參賽者，並且修改參加游泳比賽的條件，從魚類，改為能游泳就能參加</p><pre>class Octopus: Swimmer { /* ... */}<br>class Dolphin: Swimmer { /* ... */}<br>class Crocodile: Swimmer { /* ... */}<br><br>//創建一個游泳比賽的類別，參賽者是所有會游泳的人<br>class SwimmingContest(val competitors: List&lt;Swimmer&gt;) {<br>     <br>    // 開始比賽<br>    fun start() {<br>        // 暫時忽略沒有同時開始游的問題<br>        competitors.forEach { it.swim() }<br>    }<br>}<br><br>fun main() {<br>    //多型的寫法，都是會游泳的動物，但實體不同<br>    val shark: Swimmer = Shark(&quot;Alice&quot;)<br>    val seahorse: Swimmer = Seahorse(&quot;Bob&quot;)<br>    val octopus: Swimmer = Octopus(&quot;Carol&quot;)<br>    val dolphin: Swimmer = Dolphin(&quot;Dave&quot;)<br>    val crocodile: Swimmer = Crocodile(&quot;Eve&quot;)<br><br>    SwimmingContest(<br>        listOf(shark, seahorse, octopus, dolphin, crocodile)<br>    ).start()<br>}</pre><p>如果之後舉辦跑步比賽，可以新增一個Runner interface，以Crocodile舉例，小修改後就可以馬上參加跑步比賽</p><pre>class Crocodile: Swimmer, Runner { /* ... */}</pre><p>如此一來彈性大增，且易於修改，這也呼應到了<a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">這個系列</a>的主題，應該依賴於抽象，而不應該依賴於實例。</p><p>希望各位都能藉由上面幾個範例了解抽象化帶來的好處，未來能多多使用，讓自己寫出更棒的程式碼</p><p>祝各位 Happy coding ~</p><p>抽象類別跟介面可以一起用嗎？可以的，介面如果沒有在基礎類別被實作的話，基礎類別就需要被宣告為abstract，因為尚有未完成部分</p><pre>abstract class Fish(val name: String): Swimmer { /* ... */}<br>class Shark(name: String): Fish(name) { /* ... */}<br>class Seahorse(name: String): Fish(name) { /* ... */}</pre><p>常常有人會問，怎麼知道什麼時候要用interface？什麼時候要用abstract class？從上述兩個例子來看，在抽象化的選擇上面，很顯然更具備彈性的是interface，而不是abstract class，因為抽象類別雖然能夠達到某一部分的抽象化，但最終依然是依賴這個類別的實體</p><p>而 interface 則完全自由，以上述的例子來說，甚至不是動物都可以參加，只要能跑就可以</p><p>介面可以理解為具備哪些能力、擁有哪些特質，OOO is like a XXX，這時候就可以選interface</p><pre>class Robot : runner { /* ... */ }<br>class Toy : runner { /* ... */ }<br>...</pre><blockquote>不知道怎麼選的時候，選 interface 至少立於不敗之地啦</blockquote><p>最後的最後不得不說一下，用 Java 來討論抽象化會清楚一點，因為 Java 在class 上面使用的修飾字是 extends，interface 則是使用implements。Kotlin 則都是使用: ，很容易讓初學者用詞不是很精準。</p><p>所以說雖然都是冒號，不過描述類別關係的時候要用<strong>繼承</strong>，描述介面的話則需要使用<strong>實作</strong>，才能算是合格的工程師喔！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d84d4077703" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[初探物件導向程式設計 OOP (三)]]></title>
            <link>https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E4%B8%89-4d8a43dc9b79?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d8a43dc9b79</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[inheritance]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Fri, 14 Jul 2023 06:30:05 GMT</pubDate>
            <atom:updated>2024-02-02T03:35:14.715Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YfeiqBSyWwmlA0NgGpgBIg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@rupixen?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">rupixen.com</a> on <a href="https://unsplash.com/images/animals/peacock?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>上一篇提到了三個 OOP 的特性：<strong>繼承</strong>、<strong>封裝</strong>、<strong>多型</strong></p><p>在聊了封裝的時候也提到了繼承，所以繼承到底是什麼呢？</p><p>我們來回到<a href="https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E4%B8%80-575f31fe9255">一開始</a>定義 class 的問題：</p><blockquote>不過這麼多物件要描述，我想到就累了，不是會寫到手很酸嗎？有沒有辦法省一些功？</blockquote><p>有的，就是<strong>繼承 (Inheritance)</strong>，接下來我們就來討論一下這個特性</p><h4>何謂繼承？</h4><p>從 Java <a href="https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html">官方</a>給的定義：</p><blockquote>classes can be derived from other classes, thereby inheriting fields and methods from those classes.</blockquote><p>他也解釋了繼承被設計出來的原因</p><blockquote>When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class</blockquote><p>繼承的概念可以理解為族譜，孩子某些部分來自父母，但每一個孩子都擁有它的獨特性。</p><p>也可以理解為擴充、延伸。基於原有物件的特性，加上獨特的部分，或是修改 (覆寫，override) 本來的特性。</p><p>我們透過例子來看一下，假設我們定義了一個鳥類 (Bird) 的 class，以及一個麻雀 (Sparrow) 的 class</p><pre>open class Bird(val name: String) {<br><br>    open val size = &quot;medium&quot;<br><br>    open fun walk(){ <br>        println(&quot;$name walking&quot;)<br>    }<br><br>    open fun fly(){<br>        println(&quot;$name flying&quot;)<br>    }<br><br>    fun eat() {<br>        println(&quot;$name pecking&quot;)<br>    }<br>}<br><br>class Sparrow(name: String) : Bird(name) {<br><br>    override val size = &quot;small&quot; // 覆寫變數<br><br>    override fun walk(){ <br>        println(&quot;$name hopping&quot;) // 麻雀都用跳的走路<br>    }<br><br>    override fun eat(){ // 編譯失敗，不能覆寫沒有開放(open)覆寫的method<br>        println(&quot;$name pecking small things&quot;)<br>    }<br>}<br><br>fun main() {<br>    val alice = Bird(&quot;Alice&quot;)<br>    alice.walk() // 印出 Alice walking<br>    alice.fly()  // 印出 Alice flying<br><br>    val bob = Sparrow(&quot;Bob&quot;)<br>    bob.walk() // 印出 Bob hopping<br>    bob.fly()  // 印出 Bob flying<br>}</pre><p>來做幾個名詞解釋，</p><ol><li>open修飾字表示開放，表示可被繼承，可被覆寫，跟他對應的則是final，不可變的意思（沒寫修飾字表示是 final）</li><li>繼承關係在 Kotlin 中使用 ： 連接兩個class來表示，class Sparrow(name: String) : Bird(name)</li><li><strong>被</strong>繼承的 class 我們可以稱他為：父類別(parent class)、超類別(super class)、基礎類別(base class)</li><li>繼承別的 class 我們可以稱他為：子類別(child class)、衍生類別(derived class)</li></ol><p>稍微綜合一下<a href="https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E4%BA%8C-c3379b3665c6">前篇</a>提到得可見度，子類別:</p><ul><li><strong>不能</strong>使用父類別中的private成員</li><li><strong>可以</strong>使用父類別中的 protected 、internal、public的所有成員</li><li><strong>只能</strong>覆寫 (override) open 又可見的成員</li></ul><p>如果不想完全 override 行為，而是延伸，可以使用super來呼叫父類別的 mothod，上述例子中我們改寫一下：</p><pre>...<br>override fun fly(){<br>    super.fly() // 呼叫父類別的fly method<br>    println(&quot;$name tired&quot;)<br>}<br>...<br><br>bob.fly()  // 印出 Bob flying Bob tired</pre><p>所以透過繼承關係，可以讓我們有辦法對一個物件進行延伸、擴充。不過除了能夠少寫一點程式碼之外，繼承關係這種擁有共通成員的作法，也能夠帶出另外一個 OOP 的特性，也就是<strong>多型</strong>。</p><h3>何謂多型？</h3><p>Java 的<a href="https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html">官方</a>提到：</p><blockquote>The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language. Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class.</blockquote><p>多型指就是的是使用同一個共通介面，來操作不同的物件實體的一種行為。</p><p>我們先從一個簡單的class例子看起，剛剛定義了Bird class，以及Sparrow class , 我們多定義一個Peacock class</p><pre>class Peacock(name: String) : Bird(name) {<br><br>    open val size = &quot;large&quot;<br><br>    override fun fly() {<br>        println(&quot;$name rarely fly&quot;)<br>    }<br><br>    fun flaunt() {<br>        println(&quot;$name flaunting its tail&quot;)<br>    }<br>}</pre><p>所以我們現在有一個父類別Bird，兩個子類別Sparrow、Peacock，當我們知道看下面的例子</p><pre>fun main() {<br>    // 編譯成功，定義三隻鳥<br>    val bird0: Brid = Bird(&quot;Alice&quot;)<br>    val bird1: Brid = Sparrow(&quot;Bob&quot;)<br>    val bird2: Brid = Peacock(&quot;Carol&quot;)<br><br>    bird0.fly() // 印出 Alice flying<br>    bird1.fly() // 印出 Bob flying Bob tired<br>    bird2.fly() // 印出 Carol rarely fly<br>    bird2.flaunt() // 編譯錯誤，只能存取到Brid定義的方法<br><br>    //嘗試強制轉型<br>    (bird2 as Peacock).flaunt() // 印出 Carol flaunting its tail<br>    (bird1 as Peacock).flaunt() // 執行錯誤 (runtime error)，轉型失敗<br>}</pre><p>注意上述的bird0、bird1、bird2的型別都為Bird，但指派的實作卻分別是Bird、Sparrow、Peacock，為什麼能夠編譯是因為他們都屬於Bird的子類別，都可被當作 Bird 做操作。但如果將這些 Bird 隨意型別轉換，是有可能產生錯誤的。</p><p>這些都是Bird 的變數，但實際上實體是不同的，這個概念就是多型。</p><p>那這特性有什麼好處？我們看一下這個鳥類訓練師的範例</p><pre>class BirdTrainer {<br><br>    // 訓練麻雀<br>    fun trainFly(sparrow: Sparrow) {<br>        sparrow.fly()<br>    }<br><br>    // 訓練孔雀<br>    fun trainFly(peacock: Peacock) {<br>        peacock.fly()<br>    }<br>}</pre><p>為了訓練麻雀跟孔雀飛行，需要創造出兩個 method 來執行訓練 <em>(註1)</em></p><p>不過用了多型的特性之後可以改寫為：</p><pre>class BirdTrainer {<br><br>    // 能夠訓練Bird，以及所有Bird的子類別<br>    fun trainFly(bird: Bird) {<br>        bird.fly()<br>    }<br>}<br><br>fun main() {<br>    <br>    val trainer = BirdTrainer()<br><br>    // 利用多型的特性，創造型別為Bird的list<br>    val birds = listOf(<br>        Bird(&quot;Alice&quot;),<br>        Sparrow(&quot;Bob&quot;),<br>        Peacock(&quot;Carol&quot;)<br>    )<br>    birds.forEach { <br>        trainer.trainFly(it)<br>    }<br>}</pre><p>好好利用繼承跟多型的特色，可以讓程式碼更精簡更好維護喔，希望大家都能動手玩一玩，試試看</p><p>祝大家 happy coding~</p><p><strong><em>註1</em></strong><em>：允許同名的 method 帶入不同參數的特性叫做</em><strong><em>多載 </em></strong><em>(</em><strong><em>overload</em></strong><em>)</em></p><p>什麼時候要使用繼承呢？繼承的初衷，是 is 的概念，麻雀是一種鳥、孔雀是一種鳥、企鵝是一種鳥，當有 OOO is a XXX 的時候，就可以考慮用繼承。</p><p>不過繼承的概念是好的，但一個東西總是會有正反兩面</p><p>實務使用上有好有壞，太多層的繼承其實反而造成程式碼難以維護。因為會不知道哪一層 override 了什麼，是哪一個子類別改變了行為等等。</p><blockquote>所以通常繼承關係最多不超過三層</blockquote><p>關於多型，其實他的核心並不在<strong>類別</strong>，他的目的在於<strong>降低依賴</strong>，所以他的精髓在於<strong>抽象化</strong>，細節可以參考這個系列文章： <a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875"><strong>何謂依賴</strong></a></p><p>下一篇，我們來用 <strong>介面 (interface) </strong>以及 <strong>抽象類別 (Abstract class) </strong>來討論抽象化在多型的應用實例！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d8a43dc9b79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[初探物件導向程式設計 OOP (二)]]></title>
            <link>https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E4%BA%8C-c3379b3665c6?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3379b3665c6</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[encapsulation]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[oop]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Thu, 13 Jul 2023 10:18:48 GMT</pubDate>
            <atom:updated>2024-02-02T03:32:38.713Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wFH7e_f29Gpo61mj-kUOKA.jpeg" /></figure><p>講完了什麼是類別class，以及什麼是物件之後，我們今天要來聊一下幾個物件導向的特性，他們分別是</p><blockquote>繼承、封裝、多型</blockquote><p>這三個特性是物件導向學習過程中必定要了解的，<strong>繼承</strong>跟<strong>多型</strong>通常會一起討論，要理解的觀念也比較多，<strong>封裝</strong>則是相對單純的概念，就讓我們由簡入深，探討一下這三個特性吧</p><h3>什麼是封裝？</h3><p>封裝 (Encapsulation)，指的就是</p><blockquote>定義類別 (class)，用以描述物件的特性，對物件資訊進行包裝的行為</blockquote><p>一樣我們用例子來說明，<a href="https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E4%B8%80-575f31fe9255">上一篇</a>我們定義了類別Person</p><pre>class Person constructor (<br>    var firstName: String,<br>    val lastName: String //姓<br>) { <br>    // Person的 class member 有五個，姓、名、身高、體重以及地址<br>    var height: Int = 0 //身高<br>    var weight: Int = 0 //體重<br>    var address: String? = null //地址<br><br>    // Person的 class method有二個<br>    fun eat() { /*...*/ } //吃<br>    fun sleep() { /*...*/ } //睡覺<br><br>} </pre><p>包含<em>姓名</em>、<em>身高</em>、<em>體重</em>，還有這個類別的物件可以具備的 <em>吃飯</em>、<em>睡覺</em> 的行為，我們將這些資訊<strong>封裝</strong>進去Person 裏面</p><blockquote>只要取得Person的實體，就能透過這個實體，取用被封裝在裡面的物件資訊</blockquote><p>當我們提到取用資訊的時候，必須介紹一個很重要的觀念，叫做：<strong>可見度 (Scope / Visibility)</strong>，物件導向程式語言會設計幾個修飾字 (modifiers)，來定義資訊的可見度，這個可見度決定了資料可以在哪邊被取用。</p><p><em>一般來說</em>可見度分為三個主要階層</p><ul><li><strong>private：</strong>不公開，只有定義的類別可見</li><li><strong>protected：</strong>部分公開，只有定義的類別以及其衍生類別可見 (<strong>繼承</strong>詳見之後的章節)</li><li><strong>public：</strong>完全公開，隨處可見</li></ul><p>Kotlin的可見度則是還有一個<strong>模組內</strong>的可見度</p><ul><li><strong>internal</strong>：<em>可以在同一個模組的任何地方被取用。</em></li></ul><p>四種 Kotlin 的可見度的限制由嚴格到寬鬆依序是</p><blockquote><em>private</em> <em>protected</em> <em>internal</em> <em>public</em></blockquote><p>不過，有些範例程式沒寫可見度的修飾字耶，也可以嗎？</p><blockquote>可以的，在 Kotlin 中沒寫可見度的話，系統預設是public</blockquote><p>我們先從一個簡單 Kotlin 程式開始看：</p><pre>// 沒寫可見度修飾字，表示為public，程式的任何地方都能new出Scope這個class的物件<br>open class Scope { <br>    private val privateInt = 0     // 只有Scope這個class內部可以取用<br>    protected val protectedInt = 1 // 只有Scope以及Scope的衍生class內部可以取用<br>    public val publicInt = 2       // 程式的任何地方都能取用<br>    <br>    private fun printScope() {<br>        println(privateInt)   // 印出 0<br>        println(protectedInt) // 印出 1<br>        println(publicInt)    // 印出 2<br>    }<br>}<br><br>// 定義一個MyScope的類別來繼承Scope<br>class MyScope : Scope() { <br>    // 定義一個printMyScope method<br>    fun printMyScope() {<br>        printScope() // 編譯失敗, MyScope不能取用Scope的private method<br>        privatePrintEverything() // 可以取用 MyScope 中的 private method<br>    }<br>    <br>    // 定義一個private 的 printMyScope method<br>    private fun privatePrintMyScope() {<br>        println(privateInt)   // 編譯失敗, MyScope不能取用Scope的private變數<br>        println(protectedInt) // 印出 1<br>        println(publicInt)    // 印出 2<br>    }<br>}<br><br>fun main() {<br>    val scope = MyScope()<br>    println(scope.privateInt)   // 編譯失敗<br>    println(scope.protectedInt) // 編譯失敗<br>    println(scope.publicInt)    // 印出 2<br>    scope.privatePrintMyScope() // 編譯失敗<br>    scope.printMyScope() // 印出 1, 2<br>}</pre><p>因為 Kotlin 更自由的 (相對於 Java ) 可以把成員宣告放在 top-level 的位置，上述四種可見度會在不同的位置有不同的效果，細節可以看這邊：<a href="https://kotlinlang.org/docs/visibility-modifiers.html#class-members">https://kotlinlang.org/docs/visibility-modifiers.html#class-members</a></p><p>可見度是一個很重要的觀念，在定義class的時候要切記：</p><blockquote>不要開放不應該開放的資訊</blockquote><p>因為你永遠不會知道這個class會被別的模組怎麼樣的使用。舉個例子，假設我們有一個電腦軟體，有固定的卸載流程，一定要照順序呼叫：</p><ol><li>暫停程式 stop()</li><li>儲存現有狀態 save()</li><li>反註冊系統 callback unregister()</li><li>清除記憶體 clear()</li><li>通知系統卸載 notify()</li></ol><p>試想如果這些 methods 都是public， 就無法確保呼叫的模組都有正確的照順序呼叫，所以你需要將這些 methods 隱藏在自己的程式內部，才能確保順序：</p><pre>public fun offload() {<br>    stop()<br>    save()<br>    unregister()<br>    clear()<br>    notify()<br>}<br><br>private fun stop() {}<br>private fun save() {}<br>private fun unregister() {}<br>private fun clear() {}<br>private fun notify() {}</pre><p>如此一來，你自己的程式就能完全掌控流程囉。</p><p>透過對可見度的控制，讓取得物件實體的程式只會取得被授權開放的資訊，讓封裝的特性更顯意義，而不是單純把資訊集中到某一個物件裡面而已。</p><p>在了解封裝以及可見度之後，我們下一篇就正式進入繼承與多型的探討囉</p><p>祝各位 happy coding~</p><p>實務面上設計可見度真的是很重要的喔，特別是當你要設計 library 給別人使用的時候，真的不確定該怎麼做的話就：</p><blockquote>都先宣告成private，然後後續真的需要再開放，會是最穩的做法！</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3379b3665c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[初探物件導向程式設計 OOP (一)]]></title>
            <link>https://medium.com/@kashkhyang/%E5%88%9D%E6%8E%A2%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-oop-%E4%B8%80-575f31fe9255?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/575f31fe9255</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[kotlin-beginners]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Thu, 06 Jul 2023 02:39:48 GMT</pubDate>
            <atom:updated>2024-02-02T03:30:15.215Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LRbpEDBiFDjJ2EVwPh0oIQ.jpeg" /></figure><p>最近接觸到很多零經驗的學員，從最基本的物件導向開始學起，過程中也是遇到一些問題，所以今天來跟大家聊一下怎麼學物件導向程式設計 (<strong>O</strong>bject <strong>O</strong>riented <strong>P</strong>rogramming)，也就是大家俗稱的 OOP</p><p>我們首先要先知道，寫程式的方式有很多種 (有興趣可以去查 <a href="https://en.wikipedia.org/wiki/Programming_paradigm">Programming Paradigm</a>)，而物件導向只是其中一種。藉由描述不同<strong>物件內還有物件之間</strong>的行為來讓人編寫程式的一種程式設計方式。</p><p>既然叫做物件導向，那我們肯定要先理解一件事：<strong>物件</strong></p><h4>什麼是物件？</h4><p>英文叫做 Object，雖然沒有什麼明確的定義，但我們可以暫時將這個概念對應到生活中的所有擁有實體的物體：桌子、椅子、毛小孩、車子…等等。</p><h4>什麼是物件導向？</h4><p>這是我自己對物件導向的理解：</p><blockquote><strong>物件導向就是嘗試將所有東西都描述成物件的一種思考邏輯。</strong></blockquote><p>包含那些存在但摸不到的東西，像是空氣、無線電波、極光。抑或是沒有實體、人類想像出來的東西，像是概念、思想等等這類抽象的東西。這些東西在物件導向的世界中，只要有<strong>規範</strong>可以描述，都可以<strong>成為</strong>一個物件。</p><p>注意我這邊的用詞，這邊想表達的是：</p><blockquote><strong>規範不等於物件本身，規範是一張紙，是一份合約，透過這張紙做出來的東西才是物件，才擁有實體</strong></blockquote><p>接下來我們會將這個想法從生活中帶回程式設計裡面，討論 OOP 中，怎麼利用規範來描述一個物件</p><p>在 OOP 中利用<strong>類別 (class)</strong>，來表示物件的規範，接下來我們都以 Kotlin 為主來說明，一個 class 基本上會包含這些元素</p><p><strong>1. 類別名稱 class name</strong></p><p>非常直覺，就是這個類別的名字</p><p><strong>2. 類別成員 class member</strong></p><p>分為兩種：</p><ul><li><strong>資料成員 (Field member)</strong>：說法不一，屬性 (property)、欄位 (field)、變數 (member data/variables)，這些說法都有，指的都是資料成員，表示類別中有哪些資料 (看例子會比較有感覺)</li><li><strong>方法成員 (Method member)</strong>：描述這個類別提供什麼功能可以操作使用</li></ul><p><strong>3. 類別建構子 class constructor</strong></p><p>敘述如何生成這個類別實例 (Instance) 的方法，以及生成實例的時候需要有哪些參數</p><p>了解了基本的 class 元素之後，我們現在來試著簡單設計一個人的 class，叫做 Person ，他可能會像這樣：</p><pre>// &quot;Person&quot; 就是class name<br>// constructor說明了生成Person需要輸入firstName, 以及lastName<br>class Person constructor (<br>    var firstName: String, //名<br>    val lastName: String //姓<br>) { <br>    // Person的 class member 有五個，姓、名、身高、體重以及地址<br>    var height: Int = 0 //身高<br>    var weight: Int = 0 //體重<br>    var address: String? = null //地址<br><br>    // Person的 class method有二個<br>    fun eat() { /*...*/ } //吃<br>    fun sleep() { /*...*/ } //睡覺<br><br>} </pre><p>看完這個 class 的 code 應該會針對 class member 有點疑問，為什麼是五個？不是只有三個嗎？</p><p>因為 Kotlin 幫你做了一些事情，讓工程師能少寫一點 code。這邊我們先借用 Java 的例子來看一下會清楚很多：</p><pre>class Person {<br>    <br>    // Person的 class member 有五個，姓、名、身高、體重以及地址<br>    public String lastName;  // 姓<br>    public String firstName; // 名<br>    public int height = 0;   // 身高<br>    public int weight = 0;   // 體重<br><br>    @Nullable<br>    public String address;   // 地址<br><br>    // constructor, 需要輸入姓、名做參數來生成物件實例<br>    public Person(String firstName, String lastName) {<br>        this.firstName = firstName;<br>        this.lastName = lastName;<br>    }<br>    <br>    // Person的 class method有二個<br>    public void eat() { /*...*/ }   // 吃<br>    public void sleep() { /*...*/ } // 睡覺<br>}</pre><p>各位現在可以看得出來，Kotlin 幫忙把生成實例的時候要帶入 constructor 的必要參數，放入你的 class member 裡囉。</p><p>有了這個物件的描述，我們就可以生成這個物件的 instance 了，在 OOP 中常常使用 new 這個字來形容這個實體化的行為，例如：我 <em>new 了一個 Person、new 一個 Person 的實體。</em></p><p>在 Kotlin 中生成一個實例很簡單，因為 Kotlin 會自動判斷型別 (是哪一個 class)，所以呼叫 constructor 並且帶入必要參數即可，Java 則是需要加上保留字 new 以及指定型別：</p><pre>// Kotlin<br>val kash = Person(&quot;Kash&quot;, &quot;Yang&quot;) // 自動判斷型別<br>val kash: Person = Person(&quot;Kash&quot;, &quot;Yang&quot;) // 表明Kash是一個Person<br><br>//Java<br>Person kash = new Person(&quot;Kash&quot;, &quot;Yang&quot;);</pre><p>擁有實體之後，程式就能透過這個物件的實體，呼叫這個類別所提供的 method，來實現某些行為：</p><pre>val kash = Person(&quot;Kash&quot;, &quot;Yang&quot;)<br>kash.eat() // Kash 吃飯<br>kash.sleep() //Kash 睡覺</pre><blockquote><strong>要注意每 new 一次實體出來，都會產生一個新的實例，雖然都是同樣的型別，但都是不同的個體</strong></blockquote><pre>var kashA = Person(&quot;Kash&quot;, &quot;Yang&quot;)  // 產生實體#1<br>kashA.eat() // kashA 吃飯<br><br>kashA = Person(&quot;Kash&quot;, &quot;Yang&quot;)      // 產生實體#2，並且把kashA指向的實體由#1改為#2<br>kashA.eat() // 一樣都是kashA 吃飯，但真正的實體已經由本來的 #1 變成 #2了<br><br>val kashB = Person(&quot;Kash&quot;, &quot;Yang&quot;)  // 產生實體#3</pre><p>每一個物件的操作都是獨立的，kashA.sleep() 只會讓 kashA 去睡覺，跟 kashB實例沒有關係。</p><blockquote><strong>通過很多個這樣的物件彼此之間的排列組合、互動，來達到目的的程式設計方法，就是 OOP</strong></blockquote><p>不過這麼多物件要描述，我想到就累了，不是會寫到手很酸嗎？有沒有辦法省一些功？</p><p>當然有囉，所以我們下一篇來聊一下，什麼是<strong>繼承 (inheritance)</strong></p><p>祝大家 happy coding ~</p><p>class 在 OOP 中是很基本的元素， 雖然在Kotlin中有很多變形，abstract class、inner class、data class、sealed class、enum class 或是typealias的應用等等，但不用擔心，他的邏輯都是一樣的，只是有不同的特性而已，掌握 clas s的基本概念，就能掌握這些變形的應用！</p><p>相信很多人會去問身邊的朋友，或是會去 google OOP 是什麼，很快會得到</p><blockquote><strong>繼承</strong>、<strong>封裝</strong>、<strong>多型</strong></blockquote><p>這三個 OOP 最常被提到的特色。</p><p>但說實話，我認為直接看這個這對初學者沒太大幫助，反而又多了三個名詞要解釋，然後越挖越深，不懂的越來越多。</p><p>所以先掌握基本盤，暸解定義，以及物件導向是什麼東西，再來看特色才有意義</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=575f31fe9255" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[什麼是依賴？ 什麼是依賴反轉原則？ (四)]]></title>
            <link>https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E5%9B%9B-714f2544228a?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/714f2544228a</guid>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[dependency-inversion]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Wed, 28 Jun 2023 08:44:00 GMT</pubDate>
            <atom:updated>2023-07-14T01:25:56.714Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ahv3tzAgOHy4k02Vv4oXQ.jpeg" /></figure><p>在學習程式設計的過程中，一定會常聽到</p><blockquote>不要設計高耦合的程式，要解耦，才好維護</blockquote><p>看完前面三篇聊到的<a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875"><strong>依賴</strong></a>、<a href="https://medium.com/%40kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%89-1dc81e9ded17"><strong>抽象化</strong></a>、<a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%89-1dc81e9ded17"><strong>依賴反轉原則</strong></a>這幾個觀念。應該對什麼是高耦合是什麼，解耦可以怎麼做有些基本的認識。</p><p>不過好維護又是什麼意思呢？除了前面提到的增加彈性，或是要改東西比較不會改太多地方，還有沒有別的呢？</p><p><strong>當然有囉！</strong>好維護其實表示了不容易出錯，或是不容易改錯，那要如何做到呢？靠的就是<strong>測試</strong>。</p><p>這一篇就是要來從軟體測試的角度切入，討論一下這些觀念在實務面上能帶來的好處</p><p>不過正如學習路上的各種觀念一樣，每一個都可以很深入的討論，一個可能又會帶出另外一個觀念。</p><p>測試也是一樣，有各種不同的測試，這篇不會每一個都討論，畢竟我們要的是討論依賴反轉原則的好處，所以我們把範圍限縮，只討論單元測試 (Unit Test) 的測試主體，這篇會全部都用Kotlin來寫，概念是不會被語言給限制的！</p><h4>什麼是單元測試</h4><p><a href="https://zh.wikipedia.org/zh-tw/%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95">Wiki</a>:</p><blockquote>是針對程式模組（軟體設計的最小單位）來進行正確性檢驗的測試工作。程式單元是應用的最小可測試部件。在程序化編程中，一個單元就是單個程式、函式、過程等；對於物件導向程式設計，最小單元就是方法，包括基礎類別（超類）、抽象類、或者衍生類別（子類）中的方法。</blockquote><p>簡而言之呢就是盡可能想辦法把你的程式切分成數個<strong>小單元</strong>（小模組），分別對這些小單元進行測試，確保他都有正確運作。</p><p>爾後透過這些小模組組合而成的大模組，出錯的機會就會低很多的一種測試概念，通常這些最小單位就會是一個class、一個method等等。</p><p>測試的過程是：透過操作這個模組，來比對預期結果和實際結果有沒有一致，一致表示通過 (Pass) 測試，反之則是沒通過 (Fail)。我們用一個簡單的例子來說明一下：</p><p><strong>假設你寫了一個calculator的class，提供大家做加法運算</strong></p><pre>class Calculator {<br>    fun add(a: Int, b: Int) = a + b<br>}</pre><p>你今天要測試這個模組有沒有正確的實作<strong>加法</strong>，你的單元測試可能會這樣寫</p><pre>@Test<br>fun test_calculator_add {<br>    let calculator = Calculator()<br><br>    // 用到Assert相關的操作，這個很多測試框架都有可以自行google，這邊也不多討論<br><br>    // 預期使用calculator計算5 + 5應該要等於 10<br>    assertEquals(10, calculator.add(5, 5))<br><br>    // 預期使用calculator計算10 + 15應該要等於 25<br>    assertEquals(25, calculator.add(10, 15))<br><br>    ...<br>    ...<br>}</pre><p>如果哪一天有人不小心改錯Calculator，把add()的實作從加法改為乘法，那就能透過這個測試案例 (Test Case) 找出問題囉。</p><pre>fun add(a: Int, b: Int) = a * b //test case會跑失敗</pre><p>這就是一個最基本的測試案例！</p><p>不過你可能發現了一件事，就是單元測試的輸入都是自己設定的，所以</p><blockquote>單元測試只能確保在這些輸入下你的程式沒有問題，不表示其他輸入沒有問題</blockquote><p>比如説你測試案例只寫了下面這樣，遇上加法改為乘法的狀況會被認為程式沒有問題，因為2 + 2 = 2 * 2 = 4</p><pre>assertEquals(4, calculator.add(2, 2)) // 實作是乘法的話，test case 依然會pass</pre><p>不過這就是單元測試的特性，在已知這些特性下，要怎麼確保自己程式碼的正確性呢？</p><blockquote>還是老話一句，需要動手下去做多多練習囉！</blockquote><p>了解了簡單的單元測試案例之後，我們來進入我們的正題，這跟<strong>依賴反轉原則</strong>有什麼關係？</p><p>先回到先前的範例</p><pre>class IOSProgrammer(private val mac: XcodeRunnable) {<br>    fun buildCode() {<br>        mac.build()<br>    }<br>}</pre><p>那麼這個IOSProgrammer的模組該怎麼測試呢？</p><p>首先我們希望公司的程式碼理應在公司給你的機器上面build，那預期上是當iOS Programmer的buildCode()這個method被呼叫的時候，mac的相關build()的功能應該也要被呼叫到，表示使用這台機器來build</p><p>這時候我們可以使用Mockito 中的verify這個method幫我們確認，這個verify的細節我們這邊不深入討論，他可以確認條件(VerificationMode)有沒有達成</p><p>我們這次會使用到的是times()的這個mode，來確認是不是有正確呼叫，使用上會像下面這樣</p><pre>// 確認mac這個物件的build()是不是被呼叫了1次<br>verify(mac, times(1)).build()</pre><p>你可能會想問，verify是怎麼知道這個mac的build有沒有被呼叫呢？</p><p>這時候我們要介紹一個觀念，叫做 <strong>Mock Object</strong></p><h4>什麼是Mock Object</h4><p><a href="https://zh.wikipedia.org/zh-tw/%E6%A8%A1%E6%8B%9F%E5%AF%B9%E8%B1%A1">wiki</a>:</p><blockquote>是以可控的方式模擬真實對象行為的假的對象。程式設計師通常創造模擬對象來測試其他對象的行為</blockquote><p>可以理解成你把一個<em>間諜</em>安插在某一個<em>位置</em>上，當有任何人事物跟這個間諜<em>互動</em>的時候，他都會回報給你知道，你就能掌握跟這個間諜有關所有活動</p><p>間諜可以對比到<strong>Mock Object</strong>，某一個位置則對比到<strong>class的中的成員</strong>，互動對比到<strong>函式的呼叫</strong>，所以回到範例中：</p><p><em>我們要把一個mock的mac 安插到iOSProgrammer裏面，然後看才能確認buildCode()的行為，是不是有跟mock的mac有正確的互動</em></p><pre>@RunWith(JUnit4::class)<br>class IOSProgrammerTest {<br><br>    @Mock //表示這個變數是一個Mock Object<br>    private lateinit var mockMac: XcodeRunnable<br><br>    private lateinit var iOSProgrammer: IOSProgrammer<br><br>    @Before //表示開始測試之前會跑的code<br>    fun setUp() {<br>        //生成 Mock Object: mockMac<br>        MockitoAnnotations.openMocks(this)<br><br>        // 生成要測試的對象： iOSPRogrammer<br>        iOSProgrammer = IOSProgrammer(mockMac) <br>    }<br><br>    @Test<br>    fun test_mac_build_called_once() {<br>        //執行build code的行為<br>        iOSProgrammer.buildCode()<br>        <br>        //確認是不是有呼叫到一次<br>        verify(mockMac, times(1)).build() <br>    }<br>}</pre><p>這時候應該已經發現到了一件事，就是如果這個mac變數藏在IOSPRogrammer的class裡面的話 (就是沒有使用注入的方式)，那麼安插mock object的這件事情會變得困難，就會比較難測試</p><p>另外如果沒有透過抽象化的方式<strong>符合依賴反轉原則</strong>的話，會有很多case要測，且加一個裝置就要改一次test case，也造成測試維護的麻煩</p><pre>@Mock<br>private lateinit var mockMacbookPro: MacbookPro<br>@Mock<br>private lateinit var mockMacbookAir: MacbookAir<br><br>...<br><br>iOSProgrammerMacBookPro = IOSProgrammerMacBookPro(mockMacbookPro)<br>iOSProgrammerMacBookAir = IOSProgrammerMacBookAir(mockMacbookAir)<br>...<br><br>iOSProgrammerMacBookPro.buildCode()<br>iOSProgrammerMacBookAir.buildCode()<br>verify(mockMacbookPro, times(1)).build()<br>verify(mockMacbookAir, times(1)).build()<br>...</pre><p>透過這個系列文章的範例，大家應該能感受到這幾個觀念的重要性，還有實務上到底為什麼希望大家要這麼做，期待大家都能有所收穫，多多練習！</p><p>這個系列就寫到這邊啦</p><p>祝各位Happy Coding！</p><p>一開始寫unit test的人心中應該會有個疑惑，這測試看起來也太廢了吧，這寫出來不是廢話嗎？輸入都是我的，那肯定跑得過啊！？</p><blockquote>裁判、球證、旁證都是我的人，你要怎麼跟我鬥</blockquote><p>其實一開始還真的是這樣，但隨著大家開始改code，總會有人不小心改壞東西而不自覺，這時候這種基本的檢查反而能幫忙找到一些低級失誤，又或是因為app畫面切換或是多執行緒的應用上，讓你的函式被多呼叫了幾次。</p><p>所以才會有所謂<a href="https://zh.wikipedia.org/zh-tw/%E6%B5%8B%E8%AF%95%E9%A9%B1%E5%8A%A8%E5%BC%80%E5%8F%91">TDD</a> (<strong>T</strong>est-<strong>D</strong>riven <strong>D</strong>evelopment) 的出現（這篇沒有要講啦）</p><p>大家可能覺得函式的return值不正確或許很嚴重，但函式被多呼叫幾次不是就是浪費效能而已嗎？會有什麼影響呢？</p><p>試想今天如果你開發的是銀行的程式，多扣一次錢、或是錢扣錯地方呢？應該就會造成很大的困擾囉！</p><p>所以不要輕忽單元測試的重要性，再怎麼沒空也應該寫一些基本的，才是負責的工程師喔！</p><h4>系列文章</h4><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">什麼是依賴？ 什麼是依賴反轉原則？ (一)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%BA%8C-%E6%8A%BD%E8%B1%A1%E5%8C%96-4f018896bf7a">什麼是依賴？ 什麼是依賴反轉原則？ (二)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%89-1dc81e9ded17">什麼是依賴？ 什麼是依賴反轉原則？ (三)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E5%9B%9B-714f2544228a">什麼是依賴？ 什麼是依賴反轉原則？ (四)</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=714f2544228a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[什麼是依賴？ 什麼是依賴反轉原則？ (三)]]></title>
            <link>https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%89-1dc81e9ded17?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/1dc81e9ded17</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[abstract]]></category>
            <category><![CDATA[dependency-inversion]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Mon, 26 Jun 2023 07:40:44 GMT</pubDate>
            <atom:updated>2023-07-14T01:25:01.390Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*B8X3r6xabGUNEBFrqh5gkg.jpeg" /></figure><p>前兩篇提到了<a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">依賴</a>，以及<a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%BA%8C-%E6%8A%BD%E8%B1%A1%E5%8C%96-4f018896bf7a">抽象化</a>，這一篇我們要來透過這些觀念，聊一聊<strong>依賴反轉原則</strong>，我們一樣先從定義開始</p><h4>何謂依賴反轉原則</h4><p><a href="https://zh.wikipedia.org/wiki/%E4%BE%9D%E8%B5%96%E5%8F%8D%E8%BD%AC%E5%8E%9F%E5%88%99">Wiki</a>説:</p><blockquote>高層次的模組不應該依賴於低層次的模組，兩者都應該依賴於抽象介面。</blockquote><blockquote>抽象介面不應該依賴於具體實現。而具體實現則應該依賴於抽象介面。</blockquote><p>首先我們得先了解什麼是<strong>高層模組</strong>，什麼又是<strong>低層模組</strong></p><blockquote><strong>低層模組</strong>：這個模組的實作已經不能再分割下去了，以先前的例子來說就是<strong>Macbook Pro</strong></blockquote><blockquote><strong>高層模組</strong>：這個模組的實作是由很多低層模組所組成，以先前的例子來說就是<strong>iOS Programmer</strong></blockquote><p>那<strong>反轉</strong>又是什麼？就是低層模組變成反過來依賴於高層模組對於這個抽象的實作。（好文謅謅的一句話）</p><p>意思就是低層模組的實作，會被高層模組本身決定，是不是還是有點複雜？</p><p>沒關係，我們直接來用例子看一下，我們首先把先前的範例，按照依賴反轉原則來改寫一下。</p><p>怎麼改寫？直接看定義：使用<strong>抽象介面</strong> 。</p><p>我們只需要將上一篇的寫法，將mac抽象化之後改為注入 (inject)的方式，就能符合依賴反轉原則囉</p><pre>//定義一個XcodeRunnable的interface<br>interface XcodeRunnable {<br>    fun build()<br>}<br><br>class MacbookPro: XcodeRunnable {<br>    override fun build() {<br>        // build with Macbook Pro<br>    }<br>}<br><br>class MacbookAir: XcodeRunnable {<br>    override fun build() {<br>        // build with Macbook Pro<br>    }<br>}<br><br>class IOSProgrammer(private val mac: XcodeRunnable) {<br>    fun buildCode() {<br>        mac.build()<br>    }<br>}</pre><p>使用上就是</p><pre>IOSProgrammer(MacbookPro()).buildCode() //配發新的Macbook Pro<br>IOSProgrammer(MacbookAir()).buildCode //配發新的Macbook Air<br>IOSProgrammer(oneOldMacbookPro).buildCode() //配發舊的Macbook Pro</pre><p>至於Swift也只需要做相同的動作即可</p><pre>struct IOSProgrammer {<br>    var mac: XcodeRunnable<br>    func buildCode() {<br>        mac.build()<br>    }<br>}</pre><p>對比一下先前的程式碼</p><pre>// 此為不符合反轉依賴原則的做法<br>class IOSProgrammer {<br>    private val mac: XcodeRunnable = MacbookPro()<br>    fun buildCode() {<br>        mac.build()<br>    }<br>}</pre><p>兩者在使用上的差異為</p><pre>// IOSProgrammer 一生成就決定了用哪一台機器<br>IOSProgrammer().buildCode() <br><br>// IOSProgrammer 與她依賴的mac物件，都依賴於此刻XcodeRunnable的實作，<br>// 也就是新的MacbookPro<br>IOSProgrammer(MacbookPro()).buildCode() </pre><p>應該不難發現哪一種的做法彈性比較大，也看到決定抽象介面XcodeRunnable實作的人不再是Programmer，而是在生成的當下決定，所以</p><blockquote>本來是Programmer依賴mac的狀況，變為這兩者都依賴於XcodeRunnable的實作，並且增加彈性，這就是<strong>依賴反轉原則</strong></blockquote><p>如此一來配發電腦的問題就解決了，同時你也了解了依賴反轉原則是什麼，以及該怎麼實作！</p><p>什麼！？講完了嗎？看完還是不太會用啊！</p><p>其實了解完定義 (名詞解釋) 之後就可以把他丟了，因為沒人在討論什麼誰是高層模組，誰是低層模組，實務面上誰依賴誰沒那麼重要。</p><p>重要的是<strong>模組間存在依賴關係</strong>的這件事情本身，而</p><blockquote><strong>依賴反轉原則就是要解決模組之間複雜的依賴關係而生的準則</strong></blockquote><p>而且不會用是正常的，因為沒有真的寫過。單純看範例跟自己寫還是有些差距，還是建議自己練習在專案中使用會學得比較快喔。</p><p>這個系列的三篇都沒看很懂也沒關係，教大家一個心法，先讓自己養成習慣，寫多了就會進步，那就是</p><blockquote>只要你的模組有依賴關係 (使用到別的模組)，不管一切先把依賴關係設計為interface並且使用注入 (inject)的做法再說</blockquote><p>時間久了，你就會慢慢體會到<strong>抽象化</strong>以及<strong>依賴反轉原則</strong>所帶來的好處，並且會找到抽象化的平衡點，畢竟所有的抽象都得落實到實作。</p><p>祝各位coding愉快！</p><p>另外依賴反轉原則可以帶出很多觀念跟實戰技巧。</p><p>比如說透過練習你可能會發現，其實這個範例中的Programmer也能抽象化，畢竟公司不只有iOS工程師吧？可能有Android，還有前端或是後端工程師等等。</p><p>你也可能因為按照本篇範例要用注入Inject的方式來實作，卻發現多到爆的constructor參數，不知該怎麼辦，你可能會找到DI (<a href="https://en.wikipedia.org/wiki/Dependency_injection"><strong>D</strong>ependency <strong>I</strong>njection</a>) 的相關資料。</p><p>或是因為要針對不同的case給出不同的實作而發現<a href="https://zh.wikipedia.org/zh-tw/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F_(%E8%AE%A1%E7%AE%97%E6%9C%BA)">Design Pattern</a> 中的工廠模式</p><p>再來如果你是iOS developer，你可能會發現protocol extension的強大之處。</p><p>這些觀念就讓各位自己去挖掘，期待未來有機會我們再挑幾個來講一講，但針對依賴反轉原則還有一個延伸主題也很重要。</p><p>下一篇我們來講一下依賴反轉的最直接好處：<strong>測試</strong></p><h4>系列文章</h4><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">什麼是依賴？ 什麼是依賴反轉原則？ (一)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%BA%8C-%E6%8A%BD%E8%B1%A1%E5%8C%96-4f018896bf7a">什麼是依賴？ 什麼是依賴反轉原則？ (二)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%89-1dc81e9ded17">什麼是依賴？ 什麼是依賴反轉原則？ (三)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E5%9B%9B-714f2544228a">什麼是依賴？ 什麼是依賴反轉原則？ (四)</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1dc81e9ded17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[什麼是依賴？ 什麼是依賴反轉原則？ (二)]]></title>
            <link>https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%BA%8C-%E6%8A%BD%E8%B1%A1%E5%8C%96-4f018896bf7a?source=rss-31a102e43b96------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f018896bf7a</guid>
            <category><![CDATA[kotlin-beginners]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[abstraction]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kash Yang]]></dc:creator>
            <pubDate>Sat, 24 Jun 2023 17:03:31 GMT</pubDate>
            <atom:updated>2023-07-14T01:24:34.629Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*bvfuiu5Wvs7KGU8hpqS8mg.jpeg" /></figure><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">上一篇</a>提到了什麼是依賴，這篇要聊一下學習OOP的時候的一個重要觀念：抽象化，這往往是學習路程上的一大障礙，畢竟要具體的把<strong><em>抽象</em></strong>的概念理解清楚真的不太容易。</p><p>想想以前學的時候自己也不是很懂，只是知道有這個東西，也不常用，直到工作的時候用到才體會到他的好處。</p><p>不過寫這篇的時候突然發現上一篇用的是Swift，我如果用Swift講OOP，可能會被iOS工程師砲死，人家明明是POP (<a href="https://www.pluralsight.com/guides/protocol-oriented-programming-in-swift"><strong>P</strong>rotocol-<strong>O</strong>riented <strong>P</strong>rogramming</a>)，我可不能隨便亂講。</p><p>雖然Protocol一樣能達到效果，不過我這一篇還是先換成Kotlin吧，最後再補上Swift的程式碼</p><h3>何謂抽象化</h3><p>起手式一樣，先看定義，<a href="https://zh.wikipedia.org/wiki/%E6%8A%BD%E8%B1%A1%E5%8C%96_(%E8%A8%88%E7%AE%97%E6%A9%9F%E7%A7%91%E5%AD%B8">Wiki</a>説</p><blockquote>在計算機科學中，抽象化（英語：Abstraction）是將資料與程序，以它的語意來呈現出它的外觀，但是隱藏起它的實作細節。抽象化是用來減少程式的複雜度，使得程式設計師可以專注在處理少數重要的部份。一個電腦系統可以分割成幾個抽象層（Abstraction layer），使得程式設計師可以將它們分開處理。</blockquote><p>定義看完了，似乎有些好處，但好像有看沒有懂，不知道為什麼要用？也不知道要怎麼使用？什麼時候要用？</p><p>先別急，我們從定義中找出一些蛛絲馬跡，抽象化有幾個特色</p><ul><li>只呈現出外觀，隱藏實作細節</li><li>可以減少程式複雜度</li></ul><p>綜合以上兩點，其實抽象化就是透過只定義行為的方式，達到降低程式複雜度的目的，那為什麼能降低程式複雜度呢？</p><p>大家可以回想一下上一篇提到的</p><blockquote>已知iOS Programmer以及開發電腦Macbook Pro存在依賴關係，但遇到了公司刪減預算要改為採買Macbook Air當作開發機的狀況</blockquote><p>當你勉強的修改現有的程式的時候，程式開始變得有點複雜 (醜)，如果未來公司改為採買Mac mini呢？或是哪天公司有錢的不得了要給Mac Pro呢 (有這種公司麻煩介紹給我)？</p><p>你會發現這樣做毫無彈性，硬加下去只會讓程式碼越來越不好維護，但…</p><blockquote>如果能有個方法，可以一以貫之的表示開發機器是不是就解決了呢？</blockquote><p><strong>沒錯！這也就是抽象化的精華所在。</strong></p><p>在範例中其實對開發者來說，買什麼開發機器不是很重要，不管買的是什麼機器，只要能跑Xcode能開發iOS App就可以了</p><p>在Kotlin中抽象化有兩種方法</p><ul><li>abstract class (抽象類別)</li><li>interface (介面)</li></ul><p>兩種都可以達到抽象化的目的，視情況而定要選擇哪一種，</p><p>通常這些物件除了需要抽象的行為之外，還具備有很多共同的特性以及行為，才會使用抽象類別，否則考量到Kotlin是沒辦法做多重繼承的，通常選interface比較不會出什麼意想不到的問題，不過這邊<strong>滿吃經驗</strong>的，只能多練習，找出自己與團隊的平衡點，來決定要用哪一種抽象方法</p><p>那我們來試著用interface改寫一下上一篇範例的依賴關係吧，先假設只要能跑Xcode就能寫iOS App的話</p><pre>//定義一個XcodeRunnable的interface<br>interface XcodeRunnable {<br>    fun build()<br>}<br><br>//Macbook Pro<br>class MacbookPro: XcodeRunnable {<br>    override fun build() {<br>        // build with Macbook Pro<br>    }<br>}<br><br>//Macbook Air<br>class MacbookAir: XcodeRunnable {<br>    override fun build() {<br>        // build with Macbook Air<br>    }<br>}<br><br>//Mac Mini<br>class MacMini: XcodeRunnable {<br>    override fun build() {<br>        // build with Mac Mini<br>    }<br>}<br><br>class IOSProgrammer {<br>    val mac: XcodeRunnable = MacbookPro() // MacbookAir(), MacMini(), ...<br>    fun buildCode() {<br>        mac.build()<br>    }<br>}</pre><p>現在的程式碼看起來舒服得多，那swift該怎麼用protocol改寫呢？</p><pre>//定義一個XcodeRunnable的protocol<br>protocol XcodeRunnable {<br>    func build()<br>}<br><br>//Macbook Pro<br>struct MacbookPro: XcodeRunnable {<br>    func build() {<br>        // build with Macbook Pro<br>    }<br>}<br><br>//Macbook Air<br>struct MacbookAir: XcodeRunnable {<br>    func build() {<br>        // build with Macbook Air<br>    }<br>}<br><br>//Mac Mini<br>struct MacMini: XcodeRunnable {<br>    func build() {<br>        // build with Mac Mini<br>    }<br>}<br><br>struct IOSProgrammer {<br>    let mac: XcodeRunnable = MacbookPro() // MacbookAir(), MacMini(), ...<br>    func buildCode() {<br>        mac.build()<br>    }<br>}</pre><p>事實上protocol在這個範例中的寫法還可以更好, 這邊只是先簡單演示了基本的抽象功能，其餘的部分，我們留在下一篇再來探討吧。</p><p>這一篇我們聊到了抽象化，以及他的好處，也用Kotlin改寫了上一篇的前半部範例，相信大家對抽象化已經有了基本的認識，接下來多加練習就能多掌握一點囉。</p><p>不過我知道大家一定不會這樣就滿意，下一篇我們來進入主題：<strong>什麼是依賴反轉原則</strong></p><h4>系列文章</h4><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%80-cb208820e875">什麼是依賴？ 什麼是依賴反轉原則？ (一)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%BA%8C-%E6%8A%BD%E8%B1%A1%E5%8C%96-4f018896bf7a">什麼是依賴？ 什麼是依賴反轉原則？ (二)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E4%B8%89-1dc81e9ded17">什麼是依賴？ 什麼是依賴反轉原則？ (三)</a></p><p><a href="https://medium.com/@kashkhyang/%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4-%E4%BB%80%E9%BA%BC%E6%98%AF%E4%BE%9D%E8%B3%B4%E5%8F%8D%E8%BD%89%E5%8E%9F%E5%89%87-%E5%9B%9B-714f2544228a">什麼是依賴？ 什麼是依賴反轉原則？ (四)</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f018896bf7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>