LinZiyou Dev Blog

從 WordPress 遷移到 Astro 靜態部落格

Mon, 02 Mar 2026 00:00:00 GMT

原本的部落格架在 WordPress 上，用了幾年後決定遷移到靜態網站。主要原因是也荒在這邊幾年了，加上 WordPress 需要維護伺服器和資料庫，而靜態網站產生器可以直接部署到 GitHub Pages，不用管後端，想把 GCP 上的資源關一關。

本篇記錄整個遷移過程，從技術選型到踩坑經驗。

感謝有 Claude Code，不到半個晚上的時間就完成了大約 80% 的工作，包括主題客製化、CSS 除錯、文章格式轉換腳本、圖片命名整理、README/CHANGELOG 撰寫等。剩下的 20% 主要是內容校對和個人偏好微調。

為什麼選 Astro + Firefly#

考慮過幾個方案：

方案	優點	缺點
Hugo	建置速度極快	Go template 語法不直覺
Hexo	中文社群大	生態系老化，插件品質參差
Astro	現代框架、Island Architecture、支援多種 UI 框架	相對新

最後選了 Astro，搭配 Firefly 主題。Firefly 是基於 Astro 5 + Svelte 5 + Tailwind CSS 4 的部落格主題，由 Fuwari 二次開發而來，功能完整（搜尋、暗色模式、程式碼高亮、雙側邊欄、TOC、RSS），介面設計美觀，支援多欄布局和豐富的側邊欄組件。

遷移步驟#

1. 匯出 WordPress 資料#

在 WordPress 後台 → 工具 → 匯出，選擇「所有內容」匯出成 XML 檔案（WXR 格式）。這個檔案包含所有文章、分類、標籤、圖片路徑等。

2. 安裝 Firefly#

Terminal window

1
git clone https://github.com/CuteLeaf/Firefly.git <repo目錄>
2
cd <repo目錄>
3
pnpm install

安裝完先跑 pnpm dev 確認 demo 站可以正常運作。

3. 清除 demo 內容#

刪掉 Firefly 預設的 demo 文章和圖片：

Terminal window

1
rm -rf src/content/posts/*

4. 轉換文章格式#

這是最花時間的部分。WordPress 的 WXR XML 需要轉換成 Astro 的 Markdown 格式。

這部分是請 AI 產的 Python 轉換腳本，要求輸出需符合以下條件：

解析 WXR XML 中的文章標題、日期、分類、標籤
將 HTML 內容轉換為 Markdown（用 html2text）
移除 WordPress block comments（）
將 wp-content/uploads/ 路徑改寫為 /uploads/
將 URL 編碼的 slug 解碼回中文（urllib.parse.unquote()）
清除 XML 中的控制字元（\x00-\x08 等），避免 parser 報錯
產生符合 Astro Content Collections 的 frontmatter
檔名格式為 YYYY-MM-DD-文章標題.md

完整腳本大約 140 行，直接貼上來：

1
#!/usr/bin/env python3
2
"""
3
Parse WordPress WXR (XML) export and convert posts to Astro Markdown files.
4
"""
5
import re
6
import os
7
import json
8
from datetime import datetime
9
from lxml import etree as ET
10
import html2text
11

12
XML_FILE = "linziyoudevblog.WordPress.2026-03-01.xml"
13
OUT_DIR = "posts"
14

15
os.makedirs(OUT_DIR, exist_ok=True)
16

17
# ── Namespaces ──
18
NS = {
19
    'content': 'http://purl.org/rss/1.0/modules/content/',
20
    'wp':      'http://wordpress.org/export/1.2/',
21
    'dc':      'http://purl.org/dc/elements/1.1/',
22
    'excerpt': 'http://wordpress.org/export/1.2/excerpt/',
23
}
24

25
# ── HTML → Markdown converter ──
26
h = html2text.HTML2Text()
27
h.ignore_links = False
28
h.body_width = 0
29
h.protect_links = True
30
h.wrap_links = False
31

32
h_plain = html2text.HTML2Text()
33
h_plain.ignore_links = True
34
h_plain.ignore_images = True
35
h_plain.body_width = 0
36

37
def to_markdown(html_content):
38
    if not html_content:
39
        return ''
40
    # Rewrite wp-content/uploads URLs to relative /uploads/
41
    content = re.sub(
42
        r'https?://[^/]+/wp-content/uploads/',
43
        '/uploads/',
44
        html_content
45
    )
46
    # Remove WordPress block comments
47
    content = re.sub(r'<!-- /?wp:[^>]* -->', '', content)
48
    return h.handle(content).strip()
49

50
def to_plain(html_content):
51
    if not html_content:
52
        return ''
53
    return h_plain.handle(html_content).strip()
54

55
# ── Parse XML (with recovery for invalid chars) ──
56
parser = ET.XMLParser(recover=True, encoding='utf-8')
57
with open(XML_FILE, 'rb') as f:
58
    raw = f.read()
59
# Strip invalid XML control characters
60
raw = re.sub(rb'[\x00-\x08\x0b\x0c\x0e-\x1f]', b'', raw)
61
root = ET.fromstring(raw, parser)
62
channel = root.find('channel')
63

64
posts = []
65
for item in channel.findall('item'):
66
    post_type = item.find('wp:post_type', NS)
67
    status     = item.find('wp:status', NS)
68

69
    if post_type is None or status is None:
70
        continue
71
    if post_type.text != 'post' or status.text != 'publish':
72
        continue
73

74
    title    = item.findtext('title') or ''
75
    slug     = item.findtext('wp:post_name', namespaces=NS) or ''
76
    date_str = item.findtext('wp:post_date', namespaces=NS) or ''
77
    content  = item.findtext('content:encoded', namespaces=NS) or ''
78
    excerpt  = item.findtext('excerpt:encoded', namespaces=NS) or ''
79

80
    # Categories and tags
81
    categories, tags = [], []
82
    for cat in item.findall('category'):
83
        domain = cat.get('domain', '')
84
        name   = cat.text or ''
85
        if domain == 'category':
86
            categories.append(name)
87
        elif domain == 'post_tag':
88
            tags.append(name)
89

90
    # Parse date
91
    try:
92
        dt = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S')
93
        date_iso = dt.strftime('%Y-%m-%d')
94
    except:
95
        date_iso = date_str[:10] if date_str else '2020-01-01'
96

97
    posts.append({
98
        'title': title, 'slug': slug, 'date': date_iso,
99
        'content': content, 'excerpt': excerpt,
100
        'categories': categories, 'tags': tags,
101
    })
102

103
print(f"Found {len(posts)} published posts")
104

105
# ── Write Markdown files ──
106
for post in posts:
107
    body    = to_markdown(post['content'])
108
    excerpt = to_plain(post['excerpt']).replace('\n', ' ').strip()[:200]
109

110
    from urllib.parse import unquote
111
    slug_decoded = unquote(post['slug'])
112
    filename = f"{post['date']}-{slug_decoded}.md"
113

114
    lines = ['---']
115
    lines.append(f'title: {json.dumps(post["title"], ensure_ascii=False)}')
116
    lines.append(f'published: "{post["date"]}"')
117
    if post['categories']:
118
        lines.append(f'category: {json.dumps(post["categories"][0], ensure_ascii=False)}')
119
    if post['tags']:
120
        lines.append(f'tags: {json.dumps(post["tags"], ensure_ascii=False)}')
121
    if excerpt:
122
        lines.append(f'description: {json.dumps(excerpt, ensure_ascii=False)}')
123
    lines.append('draft: false')
124
    lines.append('---')
125
    lines.append('')
126
    lines.append(body)
127

128
    out_path = os.path.join(OUT_DIR, filename)
129
    with open(out_path, 'w', encoding='utf-8') as f:
130
        f.write('\n'.join(lines))
131

132
    print(f"  [{post['date']}] {post['title'][:60]}")
133

134
print(f"\nDone! {len(posts)} files → ./{OUT_DIR}/")

顯示更多顯示更少

跑完之後再人工檢查每篇文章的格式是否正確。

轉換後的檔案命名格式是 YYYY-MM-DD-文章標題.md，Astro 會用檔名作為 URL slug。

5. 搬移圖片#

WordPress 的圖片存在 wp-content/uploads/YYYY/MM/ 下。對應到 Astro 是放在 public/uploads/YYYY/MM/，然後在 Markdown 中用 ![alt](/uploads/YYYY/MM/filename.jpg) 引用。

轉換腳本已經會自動把 wp-content/uploads/ 路徑改寫成 /uploads/，所以只要把圖片目錄整包搬過去就好。

6. 設定 config#

Firefly 的設定集中在 src/config/ 目錄下，每個面向一個檔案：

1
src/config/
2
├── siteConfig.ts           # 站點標題、語系、主題色、favicon 等
3
├── profileConfig.ts        # 個人資料：頭像、名稱、社群連結
4
├── navBarConfig.ts         # 導航列連結
5
├── backgroundWallpaper.ts  # 橫幅背景圖
6
├── fontConfig.ts           # 自訂字體
7
├── sidebarConfig.ts        # 側邊欄組件配置
8
├── licenseConfig.ts        # CC 授權
9
└── expressiveCodeConfig.ts # 程式碼區塊高亮

7. 自訂字體#

原本 WordPress 用的字體是 SweiGothic CJK（中文）和 Allura（標題），遷移後也要保留。Firefly 有內建的字體設定系統，在 fontConfig.ts 中配置 CDN 載入即可，不需要手動修改 Layout。

8. 建置與部署#

Terminal window

1
pnpm build    # 靜態網站產生到 dist/
2
pnpm preview  # 本地預覽

部署用 GitHub Actions 自動建置，push 到 main 分支就會自動部署到 GitHub Pages。

踩到的坑#

WordPress 程式碼區塊的語言資訊#

WordPress 的 loos-hcb/code-block plugin 把語言資訊存在 HTML comment 裡面，格式是 JSON：

1
<!-- wp:loos-hcb/code-block {"langType":"java"} -->

轉換腳本需要特別解析這個 comment 才能正確產生 fenced code block 的語言標籤。

URL 編碼的檔名#

從 WordPress 匯出的 slug 是 URL 編碼的（例如 %e5%b7%a5%e5%bb%a0%e6%a8%a1%e5%bc%8f），直接拿來當檔名會導致 Astro 產生的 URL 也是亂碼。需要用 urllib.parse.unquote() 解碼回中文。

XML 中的控制字元#

WordPress 匯出的 XML 偶爾會包含控制字元（如 backspace \x08），導致 XML parser 報錯。需要先用 regex 清除：

1
import re
2
data = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f]', '', data)

搜尋功能只在 build 後才能用#

Firefly 用的是 Pagefind，它在 pnpm build 時才會建立搜尋索引。所以在 pnpm dev 模式下搜尋功能是不能用的，要測試搜尋必須先 build 再 preview。

遷移結果#

文章全部遷移完成，但關於我、專案作品等頁面還是要自己微調
所有圖片、程式碼區塊、內部連結都正常運作
靜態網站不需要伺服器，部署在 GitHub Pages 上
搜尋、RSS、Sitemap 都有

整體來說遷移過程最麻煩的是文章格式轉換，特別是 WordPress 各種 plugin 的客製化格式需要逐一處理。但一旦腳本寫好，剩下的就只是設定和微調。

就醬，掰～

2024 東京四天三夜遊記

Sat, 16 Mar 2024 00:00:00 GMT

回來一個禮拜了，趁記憶還熱的時候趕快寫下來

03/09 ~ 03/12，我們一家四口去了東京四天三夜全家第一次去日本，說來有點不好意思，身邊朋友幾乎都去過了，但我們家就是一直沒有契機💰💰

偏 J 人，出發前做了一堆功課去年 10 月開始刷 Duolingo 學日文，到出發前把舊版課程全部刷完每一段轉乘路線、每一個重要車站的平面圖，全部查過一遍成田機場到 Skyliner、上野車站怎麼轉地鐵、哪個出口接哪條線，連影片都看了，就怕到現場迷路會慌Notion 上整理了一大堆截圖跟路線圖

結果實際去了之後，排的行程大概只跑了一半，不過也沒關係，旅行嘛

行前小資訊#

項目	內容
時間	2024/03/09 (六) ~ 2024/03/12 (二)，四天三夜
成員	我 + 家人共 4 人
住宿	East Square Tokyo（39㎡，有洗衣機跟廚具，大江戶線和新宿線交會的森下站旁邊，走不用 3 分鐘）
機票	長榮 BR198 / BR197，桃園 ↔ 成田
每人總花費	約 NT$33,000（含機票、住宿、交通、門票、餐飲、網路）
匯率	約 0.211 ~ 0.214（去年底陸續用台新換的，出發前在台新提款機領日幣，手續費才 100 台幣）
上網	中華電信漫遊 6GB（不用煩惱 eSIM 相容性，家人也方便）
現金	帶了 50,000 日幣
信用卡	台新 FlyGo 卡 + 永豐 DAWHO 卡

Day 1（3/9）：成田 → 淺草 → 隅田川#

出發前一天晚上還在公司弄 CI/CD，因為 3/10 有專案要上線，雖然那天是別人負責，但該準備的東西還是得先弄好忙完回家已經很晚，對著清單收行李，整理到快一點才去睡，四點半鬧鐘就響了

五點半家人開車來接我，出發去南港車站搭高鐵到了才發現南港站停車場旁邊直接就是高鐵大廳，以前都不知道搭到桃園站轉機捷，七點二十到桃機

到的時候排隊人超多，還好有長榮地勤走過來問有沒有會員，有的話直接去旁邊小櫃台報到，省了不少時間換完登機證、掛好行李，還有空檔逛了一下入關安檢免稅區都是第一次，免稅區比想像中大很多，但登機門在 B8，最後有點距離，半跑過去的

護照跟登機證，真的要出國了

BR198，8:50 起飛第一次坐飛機，之前只在 YouTube 上看過別人拍的，現在自己坐在上面了點的是海鮮餐，有麵、魚排、小餐包、水果之類的，那個煙燻鮭魚真的好吃，平常不太吃生的，但它的熟度剛好是我能接受的飛行時間大約四小時，大部分時間盯著機上的飛行儀表板看，在高空看到那個時速的時候覺得真的很厲害

飛機餐

成田機場好大入關排隊很多人，以陸客居多，也有很多台灣人壓指紋、Visit Japan Web 那些流程，本來還擔心家人英日文不夠應付，結果完全沒事，順順的就過了

買了 Skyliner 的票上車之前做功課查的那些路線圖終於派上用場，從哪個月台搭、到上野怎麼轉，全都跟影片裡看到的一樣，有一種事先場勘然後到現場的感覺Skyliner 真的快，窗外都是千葉縣鄉下的田野跟整齊的日式住宅，跟台灣的風景完全不同

成田機場

到上野後先走去上野御徒町站的機器領東京地鐵三日券，順便儲值 Suica然後搭大江戶線到森下站，路上買了銀だこ章魚燒來吃，換算台幣才不到一百五，超便宜

Check-in 之前心裡一直有點緊張，住宿是整趟旅程最重要的環節，萬一有問題就沒地方住了還好一切順利，櫃台會給你平板進行登記，對方英文還行，基本上都聽得懂

右二張：East Square Tokyo 房間（圖片來自飯店官網，沒拍到房間照）

房間跟照片上看到的差不多，感覺如果住到 6 個人也還夠有洗衣機、桌子、冰箱、廚具，滿喜歡的缺點是離市區要搭地鐵，但大概 20 分鐘就進市區了，其實還好，跟我住南港搭車到台北車站差不多

然後上樓前家人說要問有沒有盥洗用品我走過去想用日文講，結果腦袋突然一片空白，牙刷的日文怎麼說完全忘了，英文也卡住，最後就在那邊 tooth… tooth… 然後比手畫腳，整個人狂冒汗全家在旁邊笑學了五個月的日文就這樣

休息到下午才出門，到淺草的時候已經五點半了商店街大部分都關了，人倒是還很多雷門本身還是很壯觀，第一次親眼看到那個巨大的紅燈籠，比照片裡震撼多了商店街雖然關了大半，還是買到了一直想吃的炸肉餅（浅草メンチ），不錯

本來行程排了更多地方，但因為到飯店休息比較久，到淺草也晚，離開也晚，最後就決定直接沿著隅田川走去晴空塔帶家人出門果然要把時間抓更寬鬆

Google Maps 顯示大約三十分鐘，沿途一直停下來拍照，走了快五十分鐘三月的東京晚上只有 8-10°C，隅田川的風又大，但捨不得走整座晴空塔每隔幾分鐘就換一種顏色，紫色、藍色、粉紅色、彩虹色，橋下水面的倒影也跟著變，怎麼拍都好看橋下的水岸街道店都關了，路上人少，好拍

走到晴空塔旁邊的 Solamachi 差不多快八點了在裡面的 KAMUKURA 吃拉麵，四個人 ¥4,620，換算大概 NT$990四碗拉麵不到一千台幣，而且肉跟菜都給很多0.21 的匯率真的太有感了，加上外面超冷，進到暖暖的店裡吃熱拉麵，幸福感直接雙倍

吃完先去 UNIQLO，日本有做比較厚款的發熱衣，因為日本的有做比較厚款的，滿實用的，因為後面幾天主要就是發熱衣再配長袖和外套就夠了然後繼續逛購物中心，買了些伴手禮跟餅乾買東西的時候又發生一次日文斷線，在甜點櫃台整個腦袋空白，比手畫腳比到冒汗

然後發現樓下有超市，生鮮、便當、壽司都有，一盒壽司才兩三百日圓，我們看了都傻眼難怪隔天去築地沒什麼買回飯店前去了一下 Lawson，買了布蕾冰淇淋跟布丁當宵夜，配超市買的草莓（旁邊的瓶蓋是比例尺）

Day 2（3/10）：築地、東京車站、阿美橫丁#

一早去築地，人多到有點嚇到整條街都是觀光客，價格也明顯是觀光價因為前一天在 Solamachi 超市看到那些便宜的生鮮，心裡已經有底了，沒有大買，就挑了幾樣想試的

玉子燒（有名的那間，¥300），扎實好吃超大顆的豆皮壽司（¥2,500），上面鋪滿鮭魚卵跟海膽，份量很驚人草莓霜淇淋、草莓糖葫蘆各一支還有 Creamia（¥500），就是來台灣賣很貴的那支，換算大概一百出頭，確實好吃人多到是一個人去排隊、其他人在旁邊等的模式築地的感覺就是，體驗一次知道是什麼樣子就好，想吃便宜海鮮超市其實更划算

從築地搭車到東京站，先上 KITTE 大樓的屋頂花園，免費俯瞰東京車站的紅磚站房紅磚建築配後面的現代高樓群，新舊交錯的感覺很好

午餐去 KITTE 裡的根室花丸迴轉壽司，排了大概兩個小時等的時候把 KITTE 從上逛到下，逛到沒地方逛了在旁邊找沙發睡覺終於吃到的時候，身為一個不吃生魚片的人，我覺得嗯…就還好但我爸吃的評價很好，一直說新鮮，是全場覺得最好吃的人不過我覺得鰻魚倒是真的又大、又便宜、又好吃，現在想想應該多吃幾盤的

東京車站 KITTE

下午接近晚上去逛了阿美橫丁的二木の菓子掃零食，這趟一半的零食都在這裡買的整間店塞滿了各種日本零食，價格比其他地方便宜不少，而且走進裡面，滿滿的台灣人口音掃完零食後換去 SunDrug 買清單上的藥妝

晚上因為沒什麼吃，去吃了麥當勞對，到日本吃麥當勞點餐用英文，因為日文菜單全是片假名根本看不懂薯條我覺得台灣的比較好吃，可能口味比較合不過日本的麥當勞竟然有奶昔，超懷念的東西！

回飯店的路上買了烤手羽先當宵夜這兩天走到腳超痛，藥妝店買的休足時間足部貼布，貼上去真的有差第一天沒東西貼，第二天早上起來腳超痛，有了之後第三天起來好一點

順帶一提，因為剛好專案上線，還偶爾還是會收到同事訊息，用手機打字幫忙通靈解問題工程師日常

Day 3（3/11）：神田明神、秋葉原、原宿、澀谷 Sky#

這天從早走到晚，是四天裡走最多路的一天

因為知道最後一天絕對來不及買，前一天在東京車站有先物色過了，一早大概八點就到東京車站掃伴手禮東京バナナ、NY Perfect Cheese、雪茄蛋捲，那些固定班底只有爸媽跟我去，因為我姊說要睡晚一點

回飯店路上還在車站買了平田牧場的便當，看起來漂漂亮亮的，味道也不錯！

休息夠了之後再次出門，搭車到御茶ノ水，走到神田明神

雖然是身在都市之中的神社，不過這個神社比我想像中漂亮很多，朱紅色的柱子、翠綠色的銅瓦屋頂、金色的裝飾，在藍天下特別好看因為離秋葉原很近，這裡有賣 IT 情報安全守護御守，身為工程師這個當然要買一個

從神田明神走出來才發現秋葉原就在旁邊，完全不在原本行程裡，走著走著就進去了本來以為家人對秋葉原沒興趣，結果扭蛋機、大頭貼機、夾娃娃機他們還是玩得很開心路邊還看到瑪利歐賽車在馬路上跑，很酷

逛完在秋葉原車站裡面吃了午餐，好像是烏龍麵跟咖哩飯吃完因為我姊在找美妝的東西，看到原宿有 @cosme 旗艦店，就搭山手線過去搭山手線的時候又有那種看了很多次影片、終於搭到本人的感覺

到原宿那條商店街人滿到覺得走不進去，直接去 @cosme我在裡面當小翻譯，用破日文加英文加手機翻譯 app，幫媽跟我姊跟店員溝通

最大的插曲是逛到一半，我姊的 Instagram 帳號突然被盜了我們花了大概半小時蹲在路邊搶救帳號，改密碼搞那些有的沒的，還好最後救回來了在日本美妝店門口搶救社群帳號，大概是這趟最荒謬的一幕

處理完帳號買完東西就沿路走去澀谷從原宿那邊的感覺慢慢變成澀谷的大馬路，沿途的建築、店面、人群都在變化，一切都很日本路邊販賣機還在賣精釀可樂，日本人對什麼東西都要做到極致

澀谷 Sky 大概是這趟最值得的一個點大約下午五點上去，剛好從日落待到夜景露天觀景台在 230 公尺高處，視野完全沒有遮擋，整個東京都攤在腳下遠處可以看到代代木公園的綠地、新宿的高樓群

太陽慢慢下去，整座城市的顏色開始變，從暖色調變成藍紫色，再變成一片燈海東京鐵塔在遠處亮起橘紅色的光，腳下的馬路變成紅色車尾燈的河流可能有日本濾鏡加成吧，但真的很美腳已經痛了一整天，還是不想進室內

夜景全景

上面真的很冷，風大到站不太穩去排了那個角落的拍照點，不過拍出來沒有很滿意現在想起來都出國了，應該要再放得開一點，不要拍完還沒拍好就趕快走旁邊有兩個日本小妹妹在寒風中各種 pose 自拍了超多張，感覺超 E 人，大家都在看她們

後來進去室內觀景台，才發現室內的景也不差，不用吹風又可以拍照，只是有玻璃反光門票 ¥2,200（約 NT$462），很值得，推薦傍晚上去，日景夜景一次看完

從澀谷 Sky 下來逛了一下樓下的百貨，腳已經痛到快走不動了家人有買些專櫃的東西搭新宿線回飯店，去全家買了些東西，開始收行李，因為明天要回去了

才第三天而已，怎麼就要結束了

Day 4（3/12）：回程#

大概九點退房，九點半走到京成上野從上野御徒町到上野車站有一條很長的地下道，走到一半，其中一個行李箱的輪子壞了，直接卡死不轉裝滿伴手禮的行李只能半拖半扛還好是最後一天

到了京成上野買 Skyliner 的票，機器上寫可以用信用卡，結果插了說不行難怪旁邊人工櫃台一堆人最後投紙鈔買的，¥2,570，跟第一天來的那張對稱

到成田之後還有一點時間，逛了一下機場裡面，吃了 TATSU又買了白色戀人之類的東西後來才發現出關之後裡面的店家滿多的，如果班機時間允許可以多留一點時間逛

下雨的成田機場

登機的時候外面在下雨，跑道灰灰的回程的飛機上跟去程差不多，吃個飛機餐、聽個歌但快降落看到陸地的時候就有那種「啊，太快了吧」的感覺

從窗戶看到台灣的農田跟小鎮，綠色的稻田、蜿蜒的道路，就知道到家了

降落前的台灣

下了飛機，出關，該換錢換錢該上廁所上廁所搭機捷到高鐵站人很多，等了滿久搭高鐵回南港，買了麥當勞，家人載我回租屋處，他們再開車回家

四天三夜就這樣結束了

寫在最後#

這是一趟什麼都是第一次的旅行第一次搭飛機、第一次出國、第一次去日本、第一次用日文（雖然用得很爛）

回想起來印象最深的不是什麼著名景點，反而是那些小事情在飯店櫃台忘記牙刷怎麼說然後全家笑成一團、在隅田川河邊被風吹到發抖但捨不得走、四碗拉麵不到一千塊、在澀谷 Sky 上面看整座城市從白天變成黑夜

行前做了超詳細的計畫，結果排的行程大概只跑了一半帶家人出門要把時間抓更寬鬆，不能用自己一個人的步調去排，這個學到了

本來還想說會不會有幸遇到櫻花初開，結果正好差了一點（我寫這篇的時候應該才正好開花吧） ٩( ᐛ )و

東京還想再去大阪、京都、北海道都在清單上，但排序的話東京還是第一說不太上來為什麼，就是走在這座城市裡感覺很對，很想繼續走這次跑了一半，剩下一半還在那裡

然後在觀景台上面要再放得開一點多拍幾張照

配置MariaDB或MySQL可以遠端登入

Sun, 18 Dec 2022 00:00:00 GMT

正常來說，MariaDB或MySQL的預設配置會把「—bind-address」綁定到「127.0.0.1」上，因此除了本機電腦之外，LAN及WAN上的機器將無法直接存取。

配置檔位置#

my.cnf檔案通常會在以下位置

Terminal window

1
/etc/my.cnf         (*nix/BSD)
2
$MYSQL_HOME/my.cnf  (*nix/BSD) *通常會是 /etc/mysql/my.cnf
3
SYSCONFDIR/my.cnf   (*nix/BSD)
4
DATADIR\my.ini      (Windows)

查看目前啟動選項#

查看mysqld程式位置

Terminal window

1
which mysqld
2

3
# 輸出為
4
/usr/sbin/mysqld

查看啟動選項，如果使用「sudo」啟動，指令前面要加上「sudo」；否則可以不加

Terminal window

1
sudo /usr/sbin/mysqld --print-defaults
2

3
# 輸出為
4
/usr/sbin/mysqld would have been started with the following arguments:
5
--socket=/run/mysqld/mysqld.sock --pid-file=/run/mysqld/mysqld.pid --basedir=/usr --bind-address=127.0.0.1 --expire_logs_days=10 --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci

修改配置檔#

通常會看到以下的配置選項（沒有這兩個選項也沒關係）

1
[mysqld]
2
    ...
3
    skip-networking
4
    ...
5
    bind-address =
6
    ...

將以上選項刪除後，在my.cnf的「最下面」加上

Terminal window

1
[mysqld]
2
...
3
skip-networking=0
4
skip-bind-address

或是

Terminal window

1
[mysqld]
2
...
3
bind-address = 0.0.0.0

再次查看啟動選項，

Terminal window

1
sudo /usr/sbin/mysqld --print-defaults
2

3
# 輸出為
4
/usr/sbin/mysqld would have been started with the following arguments:
5
--socket=/run/mysqld/mysqld.sock --pid-file=/run/mysqld/mysqld.pid --basedir=/usr --bind-address=127.0.0.1 --expire_logs_days=10 --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci --skip-networking=0 --skip-bind-address
6

7
# 或是
8
/usr/sbin/mysqld would have been started with the following arguments:
9
--socket=/run/mysqld/mysqld.sock --pid-file=/run/mysqld/mysqld.pid --basedir=/usr --bind-address=127.0.0.1 --expire_logs_days=10 --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci --bind-address=0.0.0.0

啟用配置#

重啟資料庫伺服器

Terminal window

1
# 重啟MariaDB
2
sudo systemctl restart mariadb
3
# 停止MariaDB
4
sudo systemctl stop mariadb
5
# 啟動MariaDB
6
sudo systemctl start mariadb

配置 Apache2 網站

Thu, 01 Dec 2022 00:00:00 GMT

正常來說，Apache的網站配置檔會在「/etc/apache2/sites-available」之下，因此可以為每個網站建立不同的配置檔。

配置HTTP (80 port)#

編輯「/etc/apache2/sites-available/<your.domain.name>.conf」

1
        # 配置網站資訊
2
        ServerName
3
        ServerAdmin admin@localhost
4
        DocumentRoot /var/www/
5

6
        # 配置LOG資訊
7
        ErrorLog ${APACHE_LOG_DIR}/error.log
8
        CustomLog ${APACHE_LOG_DIR}/access.log combined
9
        # 代理設定
10
        # ProxyPass / http://localhost:8080/                 # 導到http
11
        # ProxyPass / unix:/path/to/project/uwsgi/uwsgi.sock # 導到uwsgi
12

13
        # [可選] 配置Rewrite資訊（需要啟用mod_rewrite）
14
        #ReDirect any HTTP request to HTTPS
15
        RewriteEngine On
16
        RewriteCond %{HTTPS} off
17
        RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

顯示更多顯示更少

有些情況要啟用模組#

若有啟用RewriteEngine，要啟用模組

Terminal window

1
sudo a2enmod mod_rewrite

若有啟用proxy，要啟用模組

Terminal window

1
# PROXY
2
sudo a2enmod proxy
3

4
# PROXY到HTTP
5
sudo a2enmod proxy_balancer
6
sudo a2enmod proxy_http
7

8
# PROXY到uWSGI
9
sudo a2enmod proxy_uwsgi

若有啟用ssl，要啟用模組

Terminal window

1
sudo a2enmod ssl

配置HTTPS (SSL 443 port)#

編輯「/etc/apache2/sites-available/<your.domain.name>-ssl.conf」

1
        # 開啟SSL
2
        SSLEngine On
3
        SSLCertificateFile /path/to/you_domain_ssl_cert/cert.pem
4
        SSLCertificateKeyFile /path/to/you_domain_ssl_cert/privkey.pem
5
        SSLCertificateChainFile /path/to/you_domain_ssl_cert/fullchain.pem
6
        # 網站設定
7
        ServerName
8
        ServerAlias
9
        DocumentRoot /var/www/
10
        # 網站日誌
11
        ErrorLog ${APACHE_LOG_DIR}/error.log
12
        CustomLog ${APACHE_LOG_DIR}/access.log combined

編輯「/etc/apache2/ports.conf」打開apache監聽port

1
Listen 80
2

3

4
        Listen 443
5

6

7

8
        Listen 443

打開防火牆

Terminal window

1
ufw allow 443
2
sudo ufw reload

配置目錄存取規則#

配置目錄設定，編輯「/etc/apache2/apache2.conf」

1
 >
2
        Options Indexes FollowSymLinks # 若想禁止存取檔案，改為Options FollowSymLinks
3
        AllowOverride All
4
        Require all granted

啟用配置#

查看已啟用的conf檔

1
ls -la /etc/apache2/sites-enabled

啟用網站配置並重置伺服器（ssl和非ssl若有多個conf檔，多個都要啟用）

Terminal window

1
# 啟用網站配置
2
sudo a2ensite
3
sudo a2ensite -ssl
4

5
# 重新載入Apache2配置
6
sudo systemctl reload apache2
7
# 重啟Apache2
8
sudo systemctl restart apache2
9
# 停止Apache2
10
sudo systemctl stop apache2
11
# 啟動Apache2
12
sudo systemctl start apache2

配置NGINX網站

Mon, 08 Nov 2021 00:00:00 GMT

1. 安裝nginx#

Terminal window

1
sudo apt-get install nginx

2. 配置網站配置檔#

正常來說，nginx的網站配置檔會在「/etc/nginx/sites-available」之下，並建一個**Symbolic link至「/etc/nginx/sites-enabled」**下。

所以會看到「/etc/nginx/nginx.conf」有一句「 include /etc/nginx/sites-enabled/*;」，因此可以為每個網站建立不同的配置檔。

1
user www-data;
2
worker_processes auto;
3
pid /run/nginx.pid;
4
include /etc/nginx/modules-enabled/*.conf;
5

6
events {
7
        worker_connections 768;
8
        # multi_accept on;
9
}
10

11
http {
12
        ...
13
        include /etc/nginx/sites-enabled/*;
14
        ...
15
}

顯示更多顯示更少

這時候我們可以在「/etc/nginx/sites-available」建立一個用來放網站配置的配置檔

Terminal window

1
sudo vim /etc/nginx/sites-available/your-domain.name

然後建立軟連結至「/etc/nginx/sites-enabled」之下

Terminal window

1
sudo ln -sf /etc/nginx/sites-available/your-domain.name /etc/nginx/sites-enabled/your-domain.name

測試配置是否正常，並重新啟動Nginx伺服器

Terminal window

1
sudo nginx -t
2
sudo systemctl restart nginx

2. 常見配置方式#

配置HTTP (80 port)#

轉發至localhost:3000並啟用index

1
server {
2
    listen 80;
3
    listen [::]:80;
4
    index index.html;
5
    server_name your-domain.name;    # 若沒有domain的話，該行可以拿掉
6

7
    location / {
8
        proxy_pass http://localhost:3000;
9
        proxy_http_version 1.1;
10
        proxy_set_header Upgrade $http_upgrade;
11
        proxy_set_header Connection 'upgrade';
12
        proxy_set_header Host $host;
13
        proxy_cache_bypass $http_upgrade;
14
    }
15
}

顯示更多顯示更少

轉發至docker啟用的網站，並設定允許上傳大小及根目錄

1
server {
2
    root /var/www/html;
3
    listen 80;
4
    listen [::]:80;
5
    server_name your-domain.name;
6

7
    location / {
8
        proxy_pass http://localhost:5000;
9
        proxy_redirect     off;
10
        proxy_set_header   Upgrade $http_upgrade;
11
        proxy_set_header   Connection 'upgrade';
12
        proxy_set_header   Host $host;
13
        proxy_set_header   X-Real-IP $remote_addr;
14
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
15
        proxy_set_header   X-Forwarded-Host $server_name;
16
        proxy_set_header   X-Forwarded-Proto $scheme;
17
        proxy_cache_bypass $http_upgrade;
18
    }
19

20
    client_max_body_size 256M;
21
}

顯示更多顯示更少

配置HTTPS (SSL 443 port)#

設定SSL並轉發80至443

1
server {
2
    root /var/www/html;
3
    listen [::]:443 ssl ipv6only=on;
4
    listen 443 ssl;
5
    server_name your-domain.name;
6

7
    ssl_certificate /etc/letsencrypt/live/your-domain.name/fullchain.pem;
8
    ssl_certificate_key /etc/letsencrypt/live/your-domain.name/privkey.pem;
9
    include /etc/letsencrypt/options-ssl-nginx.conf;
10
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
11

12
    location / {
13
        proxy_pass http://localhost:5000;
14
        proxy_redirect     off;
15
        proxy_set_header   Upgrade $http_upgrade;
16
        proxy_set_header   Connection 'upgrade';
17
        proxy_set_header   Host $host;
18
        proxy_set_header   X-Real-IP $remote_addr;
19
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
20
        proxy_set_header   X-Forwarded-Host $server_name;
21
        proxy_set_header   X-Forwarded-Proto $scheme;
22
        proxy_cache_bypass $http_upgrade;
23
    }
24

25
    client_max_body_size 256M;
26
}
27

28
server {
29
    if ($host = your-domain.name) {
30
        return 301 https://$host$request_uri;
31
    } # managed by Certbot
32

33

34
    listen 80;
35
    listen [::]:80;
36
    server_name your-domain.name;
37
    return 404;
38
}

顯示更多顯示更少

用pm2在Ubuntu上部署NuxtJS的網站

Sun, 07 Nov 2021 00:00:00 GMT

pm2是什麼#

pm2 是 nodeJS 的 process manager，可以用來管理node服務、自動重啟服務、也可以設定多程序等等，透過簡單的方式部署node服務。

詳見：https://pm2.keymetrics.io/

在Ubuntu上部署NuxtJS網站#

1. 安裝nodejs及npm#

更新repositories

Terminal window

1
sudo apt-get update
2
sudo apt-get upgrade

安裝新版nodejs及npm（本文章發佈時使用的是nodejs 16）

先從Nodesource（提供nodejs的第三方repositories）取得16版的nodejs

1
curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -
2
sudo apt install -y nodejs

檢查node及npm版本

1
node -v
2

3
# 輸出
4
v16.13.0

1
npm -v
2

3
# 輸出
4
8.1.0

2. 測試部署NuxtJS#

進入專案目錄，安裝必要套件後，建立並執行nuxt

Terminal window

1
cd >
2
sudo npm install
3
sudo npm run build
4
sudo npm run start

現在應該可以在http://localhost:3000上看到建立的網站

使用pm2管理NuxtJS服務#

安裝pm2

Terminal window

1
sudo npm install pm2 -g

透過pm2啟動服務（依情況決定是否使用sudo）

1
# 以下指令做的事為 sudo npm run start
2
sudo pm2 start npm -- run start                       # 不指定服務名稱
3
sudo pm2 start npm --name "你的服務名稱" -- run start  # 指定服務名稱

也可以修改package.json裡的script，加入「deploy」讓它做「nuxt build && npm start」，就可以讓服務每次啟動時都自動執行nuxt build

1
{
2
  "scripts": {
3
    "dev": "nuxt",
4
    "build": "nuxt build",
5
    "start": "nuxt start",
6
    "generate": "nuxt generate",
7
    "lint:js": "eslint --ext \".js,.vue\" --ignore-path .gitignore .",
8
    "lint": "npm run lint:js",
9
    "deploy": "nuxt build && npm start"
10
  }
11
}

接著可以改以該指令啟動

Terminal window

1
sudo pm2 start npm --name "你的服務名稱" -- run deploy

其他相關指令#

Terminal window

1
sudo pm2 status                 # 查看所有的pm2 （sudo和非sudo是分開的）
2
sudo pm2 start service_name     # 啟動服務
3
sudo pm2 restart service_name   # 重新啟動服務（先stop再start）
4
sudo pm2 reload service_name    # 重新啟動服務（0停機，一個一個process重啟，至少有一個process在運作）
5
sudo pm2 stop service_name      # 停止服務
6
sudo pm2 delete service_name    # 刪除服務
7
sudo pm2 log                    # 查看執行log

如何產生SSH Key

Wed, 01 Sep 2021 00:00:00 GMT

SSH金鑰是一組公鑰（Public Key）和私鑰（Private Key）組成的金鑰對，它可以讓我們在登入伺服器或傳遞資訊時，避免掉輸入密碼所產生的風險，所以安全性較密碼登入來得高。但相對的，若金鑰未加密且不慎被竊取，那麼別人就可以以此金鑰進行登入。本篇文章將教你如何產生SSH Key。

產生ssh key#

首先打開命令提示字元（CMD）或是Windows 11的終端機（Terminal），並輸入以下指令來產生Key

請將 {comment} 更改為欲指定的 username，或不指定username，可不必輸入「-C {comment}」

Terminal window

1
ssh-keygen -C {comment}

輸入儲存位置，或按Enter存至預設位置

1
Generating public/private rsa key pair.
2
Enter file in which to save the key (C:\Users\user/.ssh/id_rsa):

接下來輸入密碼（可按Enter跳過，但建議輸入密碼以保護金鑰）

1
Enter passphrase (empty for no passphrase):
2
Enter same passphrase again:

接著就會看到完成的訊息

1
Your identification has been saved in C:\Users\user/.ssh/id_rsa.
2
Your public key has been saved in C:\Users\user/.ssh/id_rsa.pub.
3
The key fingerprint is:
4
SHA256:qqsnqflp5/THGJfggoVbv/Wbe5osa4KZS+HeClx4rEo testuser
5
The key's randomart image is:
6
+---[RSA 3072]----+
7
|                 |
8
|                 |
9
|   .             |
10
|  .oo .          |
11
|  .==o .S.       |
12
| .o=..+.+        |
13
| E+.+=.B .       |
14
|.o+**++ =..o.    |
15
|+++*B+o+.oB=     |
16
+----[SHA256]-----+

顯示更多顯示更少

此時在儲存的位置會看到兩個檔案

id_rsa：該檔案為SSH的私鑰，請自行保存好id_rsa.pub：該檔案為SSH的公鑰（Public），用來驗證該私鑰是否可配對（補充） *.pem格式：用來編碼金鑰和證書一個base64容器格式（Privacy Enhanced Mail）（補充） *.ppk格式：在Windows上，有些時候不支援pem格式，所以要轉為ppk格式（Putty Private Key）

有時候我們也會需要使用putty或是filezilla使用的*.ppk格式，又或是windows在ssh時所使用的pem格式，所以本篇也額外教學如何得到上述兩種格式的私鑰：

首先需要安裝PuttyGen（或是安裝Putty時也會自動安裝）：https://www.puttygen.com/

接下來開啟PuTTYgen，點選「File」、「Load Private Key」

右下角檔案類型改為「All Files」、並載入id_rsa私鑰檔

若有輸入密碼提示，請輸入密碼，接著會看到已成功載入

此時按下「Save private key」即可取得*.ppk格式的私鑰

按下「Conversions」的「Export OpenSSH key」

存檔時，副檔名加上「.pem」即可得到*.pem格式的私鑰。

到目前為止，我們會得到三種格式的私鑰「無副檔名的、ppk的、pem的」和一種格式的公鑰「pub的」

在Ubuntu中加入SWAP分區

Thu, 11 Feb 2021 00:00:00 GMT

我們在架設伺服器時，有時會選擇使用雲端主機，但是為了節省經費會選擇硬體需求較低的主機。此時，就可能會發生記憶體容量不足的問題，這時候就可以設置SWAP交換分區，它的功能就好像Windows虛擬記憶體一樣，可以把部分的硬碟空間當作記憶體進行讀寫。

SWAP分區要設多大？#

根據Ubuntu官方的解釋，如果RAM小於1GB，那SWAP至少設為1GB，至少應該要設定和RAM相等大小的SWAP；然而SWAP的大小超過RAM的2倍時，會有效益的遞減問題。並且根據休眠設定與否也會有設定上的差異，Ubuntu官方的建議值大致如下：（參考來源：https://help.ubuntu.com/community/SwapFaq）

1. 檢查SWAP空間存不存在#

如果顯示的內容是空的，表示SWAP空間不存在。

Terminal window

1
swapon -s

（如果要）取消原本的交換分區#

1
sudo swapoff /swapfile

2. 檢查空間是否足夠#

檢查一下系統是否有足夠的硬碟空間來設置SWAP。

Terminal window

1
df -hal

3. 新增SWAP分區#

bs表示每一次讀取的大小，單位是bytes；count表示數量。因此以下範例為 1024bytes * 1048576 = 1GB

Terminal window

1
sudo dd if=/dev/zero of=/swapfile bs=1024 count=1048576

會收到訊息

Terminal window

1
輸入 1048576+0 個紀錄
2
輸出 1048576+0 個紀錄
3
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 3.86487 s, 278 MB/s

4. 格式化SWAP分區#

Terminal window

1
sudo mkswap /swapfile

會收到訊息

Terminal window

1
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)
2
無標籤， UUID=cdf569da-3621-41ee-9551-9cce3bb0fd98

5. 啟動SWAP分區#

Terminal window

1
sudo swapon /swapfile

此時再查看一次SWAP交換空間

Terminal window

1
swapon -s

會發現已經存在交換分區了

Terminal window

1
Filename                                Type            Size    Used    Priority
2
/swapfile                               file            1048572 0       -2

6. 自動掛載SWAP分區#

用vim之類的文字編輯器打開 /etc/fstab 檔案，在最後面加上此行

Terminal window

1
/swapfile          swap            swap    defaults        0 0

並且設定SWAP檔案的存取權限

Terminal window

1
sudo chown root:root /swapfile
2
sudo chmod 600 /swapfile

7. 優化SWAP分區使用頻率#

Linux對於進程 (Process) （即：執行中的程式）會分成**「就緒 (Standby)」、「睡眠 (Sleep)」、和「活動 (Active)」**。當被分類為睡眠時，會被保存在SWAP分區內，但是如果RAM夠大，那麼可以透過設定swappiness來降低SWAP分區的使用頻率，讓系統不要頻繁讀寫硬碟！

當swappiness為0時表示積極使用RAM；為100時表示積極使用SWAP分區，而Ubuntu預設值為60。

我們可以透過以下指令檢查目前的swappiness：

Terminal window

1
cat /proc/sys/vm/swappiness

7-1. 臨時性調整#

若要將swappiness調整為為10（舉例），可以使用以下指令更改：

1
sudo sysctl vm.swappiness=10

7-2. 要永久性調整#

用vim之類的文字編輯器打開 /etc/sysctl.conf 檔案，在最後面加上此行

Terminal window

1
# Search for the vm.swappiness setting.  Uncomment and change it as necessary.
2
vm.swappiness=10

GoF 設計模式 Design Pattern

Wed, 20 Jan 2021 00:00:00 GMT

設計模式（design pattern）是對軟體設計中普遍存在、或是會反覆出現的各種問題所提出的解決方案，因此它提供了在各種不同的情況下，要如何解決問題的一種方案。在物件導向的設計模式中，通常會用類別、物件來描述其中的關係和相互作用，且使用設計模式能夠讓模組間有穩定的依賴、也讓實體類別依賴於抽象類別，避免引起緊密耦合，以加強軟體設計之適應未來變化的能力。

關於耦合（Coupling）與內聚（Cohesion）#

耦合與內聚，分別代表模組之間的依賴程度、以及模組本身內部的相關程度。詳細可閱讀之前的文章：

設計模式依據Gang of Four（GoF）的定義，大致可分為生成型、結構型與行為型模式：

生成型模式（Creational Patterns）#

生成型模式會牽涉到將物件實例化、它會提供一個方法，讓Client能夠從實例化物件的過程分離出來。

結構型模式（Structural Patterns）#

結構型模式可以讓小物件合併成為大型物件。

行為型模式（Behavioral Patterns）#

行為型模式可以描述類別和物件如何互動，以及它們各自的責任。

原型模式 Prototype Pattern

Tue, 22 Dec 2020 00:00:00 GMT

目的#

制訂可用原型個體生成的物件類型，爾後只須複製此原型即可生成新物件。

適用#

當系統必須與成品物件的生成、組裝、表達方式保持獨立時，以及下面三種情況之一：

在Runtime才指明欲實體化哪一種類別時（如：動態載入）；或避免造出與成品物件平行的一整族factory類別階層時；或當類別的物件個體只可能處於少數幾種可能的狀態時，替各種可能的狀態安置原型個體讓人複製，會比手動實體化類別來得方便。

結構及成員#

Collaborations: Client叫Prototype自我複製一份。

Prototype: like the Graphic宣告自我複製的介面。Client:叫原型個體自我複製一份，以生出新的物件。ConcretePrototype: like the Staff, WholeNote, HalfNote具體實作出自我複製的方法。

1
//必須實作Cloneable且必須擲出錯誤訊息
2
public interface Prototype extends Cloneable {
3
    public void getName();
4
    public Prototype clone() throws CloneNotSupportedException;
5
}
6

7
//所有try-catch皆為必須
8
public class ConcretePrototype implements Prototype{
9
    public Prototype clone(){
10
        try {
11
            return (Prototype) super.clone();
12
        } catch(CloneNotSupportedException e) {
13
            e.printStackTrace();
14
        }
15
        return null;
16
    }
17
}

顯示更多顯示更少

影響結果#

好處#

將ConcreteProduct類別隱藏起來，減少Client所能知道的類別種類，也能不修改Client即可與其他應用領域的類別協同運作。在執行期增刪成品物件類型：只要向Client註冊Prototype，就能引進新的成品物件類型，且Client可以在執行期安裝或卸除Prototype。改變內容以訂出新的物件：可透過物件複合方式制定新的行為（如：指定物件的個體變數內容）。改變結構以訂出新的物件：將小電路當原型個體，拿到電路元件上擺著。只要複合電路物件的clone()方法採取deep copy，就能將各種不同的電路結構視為原型個體來用。減少子類別數量：不像 Factory Method Pattern 會產生與成品物件類別階層平行對應的Creator類別階層，只要複製原型個體即可。

壞處#

每一個Prototype子類別都必須實作clone()方法，若是想把clone()加到早已存在的類別裡，或是類別裡有不支援複製動作的物件，或是有循環指涉（circular reference）的情形，就更不容易製作clone()。

實作#

使用原型個體管理者#

若系統內原型個體的數量不固定（會動態產生及撤銷）。用登錄表註冊存取原型個體後再複製。

製作clone()方法#

複製物件時是否會遞迴地將內含的個體變數也一併拷貝？若物件有save()和load()方法，就能先將物件save到記憶體緩衝區，再從緩衝區load到另一個物件身上。

初始化複製品#

clone()方法通常不允許傳遞初始化參數。可另外寫Initialize()方法進行參數的設定。若clone()方法是深層拷貝，則要先刪除內部的複製品。

Example: Shape#

1
Class: Shape
2

3
package shape;
4

5
public abstract class Shape implements Cloneable {
6

7
     private String id;
8
     protected String type;
9

10
     abstract void draw();
11

12
     public String getType(){
13
        return type;
14
     }
15

16
     public String getId() {
17
        return id;
18
     }
19

20
     public void setId(String id) {
21
        this.id = id;
22
     }
23

24
     public Object clone() {
25
        Object clone = null;
26

27
        try {
28
           clone = super.clone();
29

30
        } catch (CloneNotSupportedException e) {
31
           e.printStackTrace();
32
        }
33

34
        return clone;
35
     }
36
}

顯示更多顯示更少

1
Class: Rectangle
2

3
package shape;
4

5
public class Rectangle extends Shape {
6

7
     public Rectangle(){
8
       type = "Rectangle";
9
     }
10

11
     @Override
12
     public void draw() {
13
        System.out.println("Inside Rectangle::draw() method.");
14
     }
15
}

顯示更多顯示更少

1
Interface: Square
2

3

4
package shape;
5

6
public class Square extends Shape {
7

8
     public Square(){
9
       type = "Square";
10
     }
11

12
     @Override
13
     public void draw() {
14
        System.out.println("Inside Square::draw() method.");
15
     }
16
}

顯示更多顯示更少

1
Class: Circle
2

3
package shape;
4

5
public class Circle extends Shape {
6

7
     public Circle(){
8
       type = "Circle";
9
     }
10

11
     @Override
12
     public void draw() {
13
        System.out.println("Inside Circle::draw() method.");
14
     }
15
}

顯示更多顯示更少

1
Class: ShapeCache
2

3
package shape;
4

5
import java.util.Hashtable;
6

7
public class ShapeCache {
8

9
   private static Hashtable shapeMap  = new Hashtable();
10

11
   public static Shape getShape(String shapeId) {
12
      Shape cachedShape = shapeMap.get(shapeId);
13
      return (Shape) cachedShape.clone();
14
   }
15

16
   // for each shape run database query and create shape
17
   // shapeMap.put(shapeKey, shape);
18
   // for example, we are adding three shapes
19

20
   public static void loadCache() {
21
      Circle circle = new Circle();
22
      circle.setId("1");
23
      shapeMap.put(circle.getId(),circle);
24

25
      Square square = new Square();
26
      square.setId("2");
27
      shapeMap.put(square.getId(),square);
28

29
      Rectangle rectangle = new Rectangle();
30
      rectangle.setId("3");
31
      shapeMap.put(rectangle.getId(), rectangle);
32
   }
33
}

顯示更多顯示更少

1
Class: PrototypePatternDemo
2

3
package shape;
4

5
public class PrototypePatternDemo {
6
     public static void main(String[] args) {
7
        ShapeCache.loadCache();
8

9
        Shape clonedShape = (Shape) ShapeCache.getShape("1");
10
        System.out.println("Shape : " + clonedShape.getType());
11

12
        Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
13
        System.out.println("Shape : " + clonedShape2.getType());
14

15
        Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
16
        System.out.println("Shape : " + clonedShape3.getType());
17
     }
18
}

顯示更多顯示更少

1
Result:
2

3
Shape : Circle
4
Shape : Square
5
Shape : Rectangle

樣板方法模式 Template Method Pattern

Tue, 01 Dec 2020 00:00:00 GMT

目的#

對於方法，只先定義好演算法的骨架，某些步驟則留給子類別去填埔，以便在不改變演算法整體構造的情況下讓子類別去精鍊某些步驟。

適用#

希望演算法不變之處只寫一次，可變之處則留給子類別去實作時。如果許多子類別都會有共同的行為，就應該抽取出來集中至另一個共同的類別，避免重複。希望能控制子類別的擴充範圍（掛鉤）時。

結構及成員#

Collaborations: ConcreteClass仰賴AbstractClass製作出演算法的不變之處。

AbstractClass: like the Application將完整演算法裡的某些基礎步驟訂為PrimitiveOperation抽象方法，細節留給實體子類別實作。具體實作出TemplateMethod，定義出演算法的整體輪廓。它會呼叫PrimitiveOperation，也會呼叫AbstractClass或其他物件所提供的方法。ConcreteClass: like the MyApplication具體實作出PrimitiveOperation，以實施子類別該有的步驟。

影響結果#

常用於類別庫，因為它們本來就是想將程式庫裡的共同行為萃取出來。造成一種顛倒的控制結構，有時戲稱：「Hollywood Principle」：「Don’t call us, we will call you!」。TemplateMethod會呼叫以下幾種方法：實體方法（ConcreteClass的或外界的）AbstractClass的實體方法（即：對一般子類有用的方法）抽象方法（PrimitiveOperation）FactoryMethod（即：把實體化相關程序推遲給子類別去實作）掛鉤方法（hook operation）Template Method有必要明定哪些方法是掛鉤（可被覆寫）、哪些是抽象方法（必須覆寫）。由父類掌握子類可能有的擴充方法，由Template Method會去呼叫掛鉤，讓子類挑選想覆寫的掛鉤，子類比較不會忘記呼叫繼承來的父類方法。

實作#

減少PrimitiveOperation的數目。愈多要覆寫的方法，別人就得做更多的瑣事#

命名慣例：可替應覆寫的方法名稱加上固定的前綴字眼，如「doMethodXXX()」等等。#

Example: Template with Hook#

1
Abstract Class: RobotHookTemplate
2

3
package hook.robot;
4
public abstract class RobotHookTemplate
5
{
6
  public final void go()
7
  {
8
    start();
9
    getParts();
10
    assemble();
11
    if (testOK()){
12
      test();
13
    }
14
    stop();
15
  }
16

17
  public void start()
18
  {
19
    System.out.println("Starting....");
20
  }
21

22
  public void getParts()
23
  {
24
    System.out.println("Getting parts....");
25
  }
26

27
  public void assemble()
28
  {
29
    System.out.println("Assembling....");
30
  }
31

32
  public void test()
33
  {
34
    System.out.println("Testing....");
35
  }
36

37
  public void stop()
38
  {
39
    System.out.println("Stopping....");
40
  }
41

42
  public boolean testOK()
43
  {
44
    return true;
45
  }
46
}

顯示更多顯示更少

1
Class: CookieHookRobot
2

3

4
package hook.robot;
5
public class CookieHookRobot extends RobotHookTemplate
6
{
7
  private String name;
8

9
  public CookieHookRobot(String n)
10
  {
11
     name = n;
12
  }
13

14
  public void getParts()
15
  {
16
    System.out.println("Getting a flour and sugar....");
17
  }
18

19
  public void assemble()
20
  {
21
    System.out.println("Baking a cookie....");
22
  }
23

24
  public String getName()
25
  {
26
    return name;
27
  }
28

29
  public boolean testOK()
30
  {
31
    return false;
32
  }
33

34
}

顯示更多顯示更少

1
Class: TestHookTemplate
2

3
package hook.robot;
4
public class TestHookTemplate
5
{
6
  public static void main(String args[])
7
  {
8
    CookieHookRobot cookieHookRobot =
9
      new CookieHookRobot("Cookie Robot");
10

11
    System.out.println(cookieHookRobot.getName() + ":");
12
    cookieHookRobot.go();
13
  }
14
}

1
Result:
2

3
Cookie Robot:
4
Starting....
5
Getting a flour and sugar....
6
Baking a cookie....
7
Stopping....

代理人模式 Proxy Pattern

Mon, 23 Nov 2020 00:00:00 GMT

目的#

替其他物件預留代理者空位，藉此控制存取其他物件。

適用#

遠端代理者（remote proxy）用來代理位於不同定址空間的其他物件。虛擬代理者（virtual proxy）會在需要時才建立耗資源的物件，例如ImageProxy。設限代理者（protection proxy）控制原始物件的存取權限，用來對同一物件設定各種不同的存取權限。智慧型指涉者（smart reference）彌補指標的不足，可在存取物件的同時進行額外的動作。

Smart Reference典型的應用： ①累計物件被用幾次，不用時釋放空間。 ②第一次用到時才將永久性物件（persistent object）載入記憶體。 ③在使用前先檢查是否已鎖定完成，確保不會被其他物件更改內容。參見：http://corrupt003-design-pattern.blogspot.com/2016/10/proxy-pattern.html

結構及成員#

Collaborations: 如果合適（看Proxy的類型而定），Proxy會將訊息轉遞給RealSubject。

Proxy: like the ImageProxy持有指向RealSubject物件的reference以便存取真正的物件。如果RealSubject和Subject的介面完全一樣，Proxy也可以直接指向Subject。提供和Subject相同的介面，以便能用在RealSubject所能出現的任何地方。掌控對RealSubject的存取動作，可能還會負責建立及刪除。其他權責要視Proxy種類而定：遠端代理者：負責編碼訊息和參數，再送交給位於不同定址空間的RealSubject。虛擬代理者：可能會快取RealSubject的某些資訊以延緩存取時機（像ImageProxy會快取影像的寬度、高度）。設限代理者：檢查呼叫者是否有存取能力。Subject: like the Graphic制訂RealSubject和Proxy所共同遵循的介面，好讓Proxy可用在RealSubject所能出現的任何地方。RealSubject: like the Image定義Proxy所代表的真正物件。

影響結果#

遠端代理者可隱瞞「物件位於不同定址空間」一事。虛擬代理者可做些最佳化措施，像是需要時才建物件。設限代理者和智慧型指涉者都可在存取物件時做些額外的事。寫入時才拷貝：複製大而複雜的物件是很耗資源的事，如果複製對象的內容沒有被更動過，就不必虛耗資源，用Proxy延遲拷貝程序確保唯有在內容有變時才付出代價。需加上參用計數功能，此時複製Proxy就只是去遞增計數器內容。當外界更動到Subject內容，Proxy才會真的去拷貝一份並遞減計數器。計數器附為零，就砍Subject。

實作#

代理者未必需要知道RealSubject的確切型別#

如果Proxy類別只透過抽象介面來處理Subject物件，就不用替每一種RealSubject各做一個Proxy類別（Proxy會一視同仁的對待他們）。但如果Proxy會實體化RealSubject（如：虛擬代理者），就必須知道實體類別是誰。

Example: ImageProxy#

1
// Proxy 實作跟 RealSubject 共同的介面 Icon
2
public class ImageProxy implements Icon {
3

4
    // 這是我們的 RealSubject,
5
    // 也就是真正要顯示圖的物件
6
    private ImageIcon mImageIcon;
7
    private URL mUrl;
8
    private Thread mRetrievalThread;
9
    private boolean mRetrieving = false;
10

11
    // 此範例是從網路上取得圖
12
    public ImageProxy(URL url)
13
    {
14
        mUrl = url;
15
    }
16

17
    @Override
18
    public int getIconWidth()
19
    {
20
        // 在圖下載完成前, 先傳回預設的值
21
        if(mImageIcon != null)
22
        {
23
            return mImageIcon.getIconWidth();
24
        }
25
        else
26
        {
27
            return 0;
28
        }
29
    }
30

31
    @Override
32
    public int getIconHeight()
33
    {
34
        // 在圖下載完成前, 先傳回預設的值
35
        if(mImageIcon != null)
36
        {
37
            return mImageIcon.getIconHeight();
38
        }
39
        else
40
        {
41
            return 0;
42
        }
43
    }
44

45
    @Override
46
    public int paintIcon(...)
47
    {
48
        // 圖下載好了, 畫圖的事就轉給
49
        // RealSubject 做
50
        if(mImageIcon != null)
51
        {
52
            mImageIcon.paintIcon(...);
53
        }
54
        else
55
        {
56
            // 第一次下載圖
57
            drawString("Loading icon, please wait...");
58
            if(!mRetrieving)
59
            {
60
                mRetrieving = true;
61

62
                mRetrievalThread = new Thread(new Runnable() {
63

64
                    @Override
65
                    public void run()
66
                    {
67
                        mImageIcon = new ImageIcon(mUrl, "icon");
68
                    }
69
                });
70
                mRetrievalThread.start();
71
            }
72
        }
73
    }
74
}

顯示更多顯示更少

責任鏈模式 Chain of Responsibility Pattern

Tue, 17 Nov 2020 00:00:00 GMT

目的#

讓多個物件都有機會處理某一訊息，以降低訊息發送者和接收者之間的耦合關係。它將接收者物件串連起來，讓訊息流經其中，直到被處理了為止。

適用#

希望訊息不只有一個物件可處理，至於哪個會雀層中選，事先並不知情；系統會自動挑選。希望能將某一訊息丟給好幾個物件，不必指明誰是接收者。希望能動態指定哪些物件可處理某一訊息。

結構及成員#

Collaborations: 當Client發出訊息後，訊息會在串鏈裡流竄，直到有個ConcreteHandler物件處理為止。

Handler: like the HelpHandler制訂處理訊息的介面。（可有可無）實作出指向後繼者的連結。ConcreteHandler: like the PrintButton, PrintDialog處理所負責的訊息。可存取後繼者。如果訊息可處理，便處理；否則就轉傳給後繼者。Client:將訊息送到串鏈裡的ConcreteHandler物件。

影響結果#

好處#

降低耦合性。不必事先知道哪個物件會處理訊息，只須相信訊息會被「妥善」處理。更有彈性地替物件上增添權責。此Pattern將權責彈性分配到許多物件上，在Runtime仍可增添或改變訊息處理權責，也能和子類別繼承功能搭配，靜態指定特別的Handler。

壞處#

不保證會有最終接收者。

實作#

製作後繼者串鏈，大致有兩種做法#

定義新的連結，較常使用（通常寫在Handler或ConcreteHandler裡）。使用既有的連結，重複利用（指標和Composite Pattern）。

連接後繼者#

如果沒有既存的連結可用，就得自己定義。也就是說Handler要定義訊息介面，也要維護後繼者。因此Handler通常會提供一個內定的HandleRequest()版本，如果子類別ConcreteHandler不想處理這個訊息，就不必改寫這操作，直接沿用。

表達訊息？#

方法一：寫成方法（如：HandleHelp()），既方便又簡單，但只能傳遞定義過且數目固定的類型。方法二：製作一個可接收訊息代碼參數的函數，並用另一個訊息物件來承載參數。（如：定義一個Request類別，再用子類別定義各種新的訊息類型參數）。

Example: MailHandler#

1
// 所有處理郵件的子類別要繼承的介面
2
public abstract class MailHandler {
3

4
    // 每個處理郵件類別都要記錄下一個
5
    // 能處理的人是誰
6
    protected MailHandler mHandler;
7

8
    public MailHandler(MailHandler handler) {
9
        mHandler = handler;
10
    }
11

12
    public void toNext(Mail mail) {
13
        if(mHandler != null) {
14
            mHandler.handleMail(mail);
15
        } else {
16
            // 沒有後繼者, 表示是尾端了
17
            // 通常可以用最一般化的處理
18
        }
19
    }
20

21
    public abstract void handleMail(Mail mail);
22
}

顯示更多顯示更少

1
public class SpamMailHandler extneds MailHandler {
2
    SpamMailHandler(MailHandler handler){
3
        super(handler);
4
    }
5
    @Override
6
    public void handleMail(Mail mail) {
7
        // 假設已經能知道郵件分類了
8
        if(mail.isSpam()) {
9
            // 處理垃圾信
10
        } else {
11
            toNext(mail);
12
        }
13
    }
14
}

1
public class ThankMailHandler extneds MailHandler {
2

3
    ...
4
}

1
public class ComplainMailHandler extneds MailHandler {
2

3
    ...
4
}

1
public class GeneralMailHandler extends MailHandler {
2

3
    ...
4
}

1
public class Main {
2

3
  public static void main(String[] args) {
4
    // 可以這樣使用
5
    MailHandler handler = new ThankMailHandler(
6
                          new ComplainMailHandler(
7
                          new SpamMailHandler(
8
                          new GeneralMailHandler(null))));
9
    // 假設有一封郵件要處理
10
    Mail mail = new Mail(...);
11
    handler.hanldeMail(mail);
12
  }
13
}

轉接器模式 Adapter Pattern

Tue, 17 Nov 2020 00:00:00 GMT

目的#

將類別的介面轉換成外界所預期的另一種介面，讓原先囿於介面不相容的問題而無法協力合作的類別能夠兜在一起用。

適用#

想利用現有的class，但它的介面卻與你所需要的不符。想做一個可再利用的class，且能與其他毫不相關、甚至尚未出現的class搭配使用，也就是說，想與介面未必相容的class合作無間。想用一些現有的sub-class，雖然介面不相容，但又不適合一個個再去衍生sub-class修改介面。Adapter可以幫忙轉換它們的super-class。

結構及成員#

Collaborations: Client呼叫Adapter物件的操作，Adapter則會去呼叫Adaptee負責這類任務的操作。

Target: like the Shape定義Client所用的「與應用領域(domain)相關」的介面。Client: like the DrawingEditor與符合Target介面的物件合作。Adaptee: like the TextView需要被轉換的既有介面。Adapter: like the TextShape將一個Adaptee轉換成Target介面。

比較

Class Adapter#

綁死在實體adaptee類別上。可以覆寫adaptee的某些行為。只引入一個物件個體。不能在Runtime時轉換adaptee的類別。可以透過覆寫向adaptee增加新功能。

Object Adapter#

不會綁死在adaptee類別上。可能會引入adaptee的子類別用以覆寫行為（但不是覆寫adaptee本身）。引入多個物件個體。可以在Runtime時轉換adaptee的類別。可以透過衍生sub-adaptee子類別向adaptee增加新功能。

影響結果#

Adaptee轉換了多少東西？同樣是將Adaptee轉換成Target，但也有強弱之別。從簡單的介面轉換（改名字）到複雜的整組方法完全不同都有可能。即插即用轉換器類別所附帶的介面越少，就越具有再利用潛力。若類別本身就有介面轉換機制，就能避免被看到不合的介面。用雙向轉換性提供通透性轉換器對Client不夠透明化，Adapter物件不再遵從Adaptee介面，所以原本能用Adaptee物件的地方卻不能改用新的Adapter。（多重繼承可解決）

實作#

即插即用轉換器#

不論何種方法，都要先訂出想將Adaptee轉換成的Target窄介面。
用抽象操作：在TreeDisplay裡將窄介面定義成抽象操作，TreeDisplay的子類別負責讓這些操作能處理對應的Adaptee（如：FileSystemEntity）之操作。
用委託物件：TreeDisplay將存取層級結構的訊息轉傳給delegate物件處理，如果想讓TreeDisplay產生各種不同的介面轉換效果，只要委託給不同的delegate物件即可。

Example: MediaPlayer#

1
// 被轉接者（Adaptee）
2
public interface AdvancedMediaPlayer {
3
  public void playVlc(String fileName);
4
  public void playMp4(String fileName);
5
}

1
// 實體的被轉接者（Concrete Adaptee）
2
public class VlcPlayer implements AdvancedMediaPlayer {
3

4
  @Override
5
  public void playVlc(String fileName) {
6
    System.out.println("播放 vlc 檔案，檔名為："+ fileName);
7
  }
8

9
  @Override
10
  public void playMp4(String fileName) {
11
    // 此處留空不實作，意義為：假設該VlcPlayer只能播放Vlc，不能播放Mp4
12
  }
13
}

1
// 實體的被轉接者（Concrete Adaptee）
2
public class Mp4Player implements AdvancedMediaPlayer {
3

4
  @Override
5
  public void playVlc(String fileName) {
6
    // 此處留空不實作，意義為：假設該Mp4Player只能播放Mp4，不能播放Vlc
7
  }
8

9
  @Override
10
  public void playMp4(String fileName) {
11
     System.out.println("播放 mp4 檔案，檔名為："+ fileName);
12
  }
13
}

1
// 欲轉接目標／抽象的播放器類（Target）
2
public interface MediaPlayer {
3
  public void play(String audioType, String fileName);
4
}

1
// 轉接者／實體的欲轉接目標／實體的播放器類（Adapter）
2

3
// 其意義是將較特定格式的AdvancedMediaPlayer轉接至MediaPlayer
4
// 以供AudioPlayer使用
5
public class MediaAdapter implements MediaPlayer {
6

7
  AdvancedMediaPlayer advancedMusicPlayer; // 以此宣告為Object Adapter，保持彈性
8

9
  public MediaAdapter(String audioType) {
10
    // 在Adapter實例化實才決定Adaptee為何物（也可以直接傳入AdvancedMediaPlayer類物件）
11
    if (audioType.equalsIgnoreCase("vlc")) {
12
      advancedMusicPlayer = new VlcPlayer();
13
    } else if (audioType.equalsIgnoreCase("mp4")) {
14
      advancedMusicPlayer = new Mp4Player();
15
    }
16
  }
17

18
  @Override
19
  public void play(String audioType, String fileName) {
20
    // 依指定檔案格式進行播放
21
    // 也可視情況將audioType的判斷式改為AdvancedMediaPlayer實體類的判斷式
22
    if (audioType.equalsIgnoreCase("vlc")) {
23
      advancedMusicPlayer.playVlc(fileName);
24
    } else if (audioType.equalsIgnoreCase("mp4")) {
25
      advancedMusicPlayer.playMp4(fileName);
26
    }
27
  }
28
}

顯示更多顯示更少

1
// 實體的播放器類／也可視為是將MediaAdapter轉換為能相容AudioPlayer的Adapter類
2

3
// AudioPlayer與MediaPlayer的關係可視為一體的
4
// 其意義可以理解為其本身可以播放mp3檔案，但是遇到不能播放的也沒關係，可以把
5
// 工作代理給MediaAdapter做，而AudioPlayer本身不用知道MediaAdapter怎麼做的
6
public class AudioPlayer implements MediaPlayer {
7
  MediaAdapter mediaAdapter; // 以此宣告為Object Adapter，保持彈性
8

9
  @Override
10
  public void play(String audioType, String fileName) {
11
    // 內建支援*.mp3音檔
12
    if (audioType.equalsIgnoreCase("mp3")) {
13
      System.out.println("播放 mp3 檔案，檔名為：" + fileName);
14
    }
15
    // 但若非*.mp3，也能透過MediaAdapter解碼其他格式的檔案
16
    else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
17
      mediaAdapter = new MediaAdapter(audioType);  // 依檔案格式實例化MediaAdapter
18
      mediaAdapter.play(audioType, fileName);      // 依指定檔案格式播放影音檔
19
    }
20
    else {
21
      System.out.println("無效的檔案。不支援 " + audioType + " 格式的檔案");
22
    }
23
  }
24
}

顯示更多顯示更少

1
// Client
2
public class Main {
3
  public static void main(String[] args) {
4
    AudioPlayer audioPlayer = new AudioPlayer();
5
    audioPlayer.play("mp3", "beyond the horizon.mp3");
6
    audioPlayer.play("mp4", "alone.mp4");
7
    audioPlayer.play("vlc", "far far away.vlc");
8
    audioPlayer.play("avi", "mind me.avi");
9
  }
10
}

1
Result:
2

3
播放 mp3 檔案，檔名為：beyond the horizon.mp3
4
播放 mp4 檔案，檔名為：alone.mp4
5
播放 vlc 檔案，檔名為：far far away.vlc
6
無效的檔案。不支援 avi 格式的檔案

觀察者模式 Observer Pattern

Mon, 16 Nov 2020 00:00:00 GMT

目的#

定義一對多的物件依存關係，讓物件狀態一有變動，就自動通知其他相依物件做該做的更新動作。

適用#

當一個抽象觀念有兩個層面，且其中一方會依賴另一方時。可將它們分別置於兩種物件上，以便於個別改變及再利用。某一物件有變化時，其他物件也得跟著改變，但事先又不知道後者到底有多少時。當物件必須能夠通知其他物件，但又不能假設後者（其他物件）是誰；換句話說，不希望這些物件之間連結得過於緊密時。

結構及成員#

Collaborations: 當ConcreteSubject產生足以讓Observer的狀態不再一致時，就會主動通知所有該通知的Observer。當ConcreteObserver收到通知後，可向Subject洽詢資訊，利用取回的資訊同步化自己的狀態。

※如下方Sequence Diagram所示，ConcreteObserver物件會將自我更新的動作延後到aConcreteSubject通知後才執行。且Notify()不一定得由Observer發動，也可以由Subject或其他物件發動。

Subject: like the JComponent認得Observer。任何數量的Observer物件均可訂閱此Subject。提供增刪Observer物件的介面。Observer: like the ActionListener制訂自我更新的介面。在Subject有變時藉以通知自己該隨之改變。ConcreteSubject: like the JButton儲存ConcreteSubject物件感興趣的狀態。狀態有變時會通知它的Observer。ConcreteObserver: like the ButtonActionListener持有一個ConcreteSubject。儲存應該要和Subject保持一致的狀態。實作出Observer的自我更新介面，確保與Subject的狀態維持同步。

影響結果#

好處#

Subject與Observer之間屬於抽象耦合。因為Subject只知道有一堆Observer物件，但不知道他們的具體類別是誰。支援廣播功能。

壞處#

不預期的更新。由於Observer們互不知道彼此存在，所以可能改變到Subject會有連鎖反應，所以要妥善制訂或維護相依關係。

實作#

將Subject對應到Observer#

Observer們儲存在Subject裡，耗空間，速度快。Observer們儲存在雜湊表裡，省空間，速度慢。

訂閱一個以上的Subject#

擴充Update()介面，讓Observer知道究竟是哪一個Subject送來訊息，也可以讓Subject把自己當參數傳給Update()。

誰負責觸發更新程序？#

由Subject的狀態設定方法，在改變Subject狀態後呼叫Notify()。優點：Client不用自己呼叫Notify()。缺點：如果有一連串的狀態設定動作，會引發一連串的Notify()，沒有效率。由Client在適當時間呼叫Notify()。優點：一連串狀態都改變好再呼叫Notify()。缺點：容易出錯。

仍指涉至已刪除的Subject#

當Subject刪除後，應主動通知Observer刪除Subject的Reference。

確保Subject的狀態在知會他人之前就已經是完好無缺的#

因為更新過程中，Observer會跑來洽詢Subject的目前狀態。如：子類別呼叫父類別的方法時，很容易違反這項規定。可以用template method提供子類別覆寫Subject所提供的基礎操作，並在最後一個步驟才呼叫Notify()。

避免與特定Observer相關的更新協定：Push及Pull模型#

實作時，通常會讓Subject多廣播一些客外的資訊，資訊多寡有很大的彈性。Push Model（推播模型）：不管Observer要不要，Subject都會送出最詳盡的資訊。（Subject或多或少知道Observer的個別需求）Pull Model（拉力模型）：Subject只送出最少量的資訊，不夠的話，Observer再自己跟Subject取得細節。（Subject不知道Observer的個別需求）

明確指定感興趣的變動#

擴充Subject的登記介面，讓Observer只登記感興趣的事件。有事件發生時，只通知有關的Observer們。

封裝起複雜的更新語意#

若Subject和Observer之間的依存關係過於繁雜，最好另設一個ChangeManager物件來管理。（Mediator Pattern）例如：某個操作會動到數個Subject，可能要確保直到所有Subject都已更改完成之後才去通知Observer，以避免重複通知好幾次。ChangeManager的任務：將Subject對應到Observer，提供管理這種對應關係的介面，減輕Subject和Observer的負擔。定義特殊的更新策略。受Subject之託，更新所有相依的Observer。

Example: Archiver#

1
Interface: Subject
2

3
package archiver;
4

5
public interface Subject {
6

7
  public void registerObserver(Observer o);
8
  public void removeObserver(Observer o);
9
  public void notifyObserver();
10

11
}

1
Class: Database
2

3
package archiver;
4
import java.util.*;
5

6
public class Database implements Subject{
7

8
  private Vector observers;
9
  private String operation;
10
  private String record;
11

12
  public Database() {
13

14
    observers = new Vector();
15
  }
16

17
  @Override
18
  public void registerObserver(Observer o) {
19

20
    observers.add(o);
21
  }
22

23
  @Override
24
  public void removeObserver(Observer o) {
25

26
    observers.remove(o);
27

28
  }
29

30
  public void editRecord(String operation, String record) {
31
    this.operation = operation;
32
    this.record = record;
33
    notifyObserver();
34

35
  }
36
  public void notifyObserver() {
37

38
    for (int loopIndex = 0; loopIndex < observers.size(); loopIndex++) {
39
      Observer observer = (Observer)observers.get(loopIndex);
40
      observer.update(operation, record);
41
    }
42
  }
43
}

顯示更多顯示更少

1
Interface: Observer
2

3
package archiver;
4

5
public interface Observer {
6

7
  public void update(String operation, String record);
8

9
}

1
Class: Archiver
2

3
package archiver;
4

5
public class Archiver implements Observer{
6

7
  public Archiver() {
8

9
  }
10

11
  public void update(String operation, String record) {
12

13
    System.out.println("This archiver says a " + operation +
14
        " operation was performed on " + record);
15

16

17
  }
18

19
}

顯示更多顯示更少

1
Class: Client
2

3
package archiver;
4
public class Client implements Observer {
5

6
    public Client() {
7

8
    }
9

10
    public void update(String operation, String record) {
11

12
      System.out.println("This client says a " + operation
13
          + " operation was performed on " + record);
14

15
    }
16

17
}

顯示更多顯示更少

1
Class: Boss
2

3
package archiver;
4

5
public class Boss implements Observer {
6

7
public Boss() {
8

9
    }
10

11
    public void update(String operation, String record) {
12

13
      System.out.println("This Boss says a " + operation +
14
          " operation was performed on " + record);
15

16

17
    }
18
}

顯示更多顯示更少

1
Class: TestObserver
2

3
package archiver;
4

5
public class TestObserver {
6

7
  public static void main(String[] args) {
8

9
    Database database = new Database();
10
    Archiver archiver = new Archiver();
11
    Client client = new Client();
12
    Boss boss = new Boss();
13

14
    database.registerObserver(archiver);
15
    database.registerObserver(client);
16
    database.registerObserver(boss);
17
    database.editRecord("delete", "record 1");
18
  }
19

20
}

顯示更多顯示更少

1
Result:
2

3
This archiver says a delete operation was performed on record 1
4
This client says a delete operation was performed on record 1
5
This Boss says a delete operation was performed on record 1

單例模式 Singleton Pattern

Tue, 10 Nov 2020 00:00:00 GMT

目的#

只有一個實例，而且自行實例化並向整個系統提供這個實例。

Ensure a class only has one instance, and provide a global point of access to it.

適用#

當整個系統只需要、或必須只允許只有一個該類別物件存在時使用。

結構及成員#

Collaborations: 該類別本身。

Singleton:宣告外部存取該物件的介面。宣告私有的建構子，讓它不能被外界存取。

影響結果#

好處#

對唯一存在的實例化物件能夠受限制的存取。減少應用程式的命名空間。可以透過子類別擴展。實例化物件的數量可以改變。有靈活性的操作。

實作#

方法#

依情況，可以實作為積極單例（Eaget）、懶散單例（Lazy）、或懶散雙重鎖單例（Double Lazy）等等。

Example:#

Eager Singleton#

1
public class EagerSingleton {
2
  private static EagerSingleton instance = new EagerSingleton();
3
  private EagerSingleton() {}
4
  public static EagerSingleton getInstance() {
5
    return instance;
6
  }
7
}

Lazy Singleton#

1
public class LazySingleton {
2
  private static LazySingleton instance;
3
  private LazySingleton() {}
4
  public static LazySingleton getInstance() {
5
    if (instance == null) instance = new LazySingleton();
6
    return instance;
7
  }
8
}

Lazy Double Singleton#

1
public class LazyDoubleSingleton {
2
  private static LazyDoubleSingleton instance;
3
  private LazyDoubleSingleton() {}
4
  public static LazyDoubleSingleton getInstance() {
5
    if (instance == null) {
6
      synchronized(LazyDoubleSingleton.class) {
7
        if (instance == null) instance = new LazyDoubleSingleton();
8
      }
9
    }
10
    return instance;
11
  }
12
}

享元模式 Flyweight Pattern

Tue, 03 Nov 2020 00:00:00 GMT

目的#

以共享機制有效地支援一大堆小規模的物件。

適用#

Flyweight模式是否有效，端看如何使用、用在何處。請在以下條件全都成立時才考慮使用：

當應用程式使用了一大堆物件時。過多物件耗用過多空間時。物件的大部份狀態都可歸為外在狀態時，即：需要時才顯現出來（On Demand）。如果將外在狀態拿掉，就能將好幾群物件換成少數幾個共用物件時。如果應用程式不依賴「物件等同性質」時（ object.equals() ）。因為flyweight物件在觀念上會視為是同個物件。

結構及成員#

Collaborations: Flyweight 運作所需要狀態必須訂為內在（intrinsic）或外在（extrinsic）。內在狀態乃直接存於 ConcreteFlyweight 物件中，外在狀態則由Client物件計算或儲存，並在必要時將它遞給 Flyweight。 Client 不應直接具現出 ConcreteFlyweight，必須透過 FlyweightFactory 物件來取得，以確保有被妥善共用。

Flyweight:宣告存取外在狀態的介面。ConcreteFlyweight: like the Character具體實作出Flyweight介面。此物件必須是可共用的，所存的狀態必須是內在狀態，並且與所處環境無關。UnsharedConcreteFlyweight: like the Row, Column並非所有Flyweight子類別都得共用，Flyweight介面只是提供這樣的可能，而非強制。在物件結構的某一層次（如：Row、Column）常會利用UnsharedConcreteFlyweight物件包含其他的ConcreteFlyweight物件。FlyweightFactory:建立及管理 Flyweight 物件。確保 Flyweight 物件被妥善共用。當 Client 要求一個 Flyweight 物件時，Flyweight物件會給他既存的一個，如果還沒有，就建一個新的。Client:持有指向一個或多個 Flyweight 物件的指標。計算或儲存 Flyweight 的外在狀態。

影響結果#

好處#

允許我們能夠建立大量的虛擬物件。減少記憶體佔用並加快代碼速度。該Pattern簡化了代碼。我們可以透過結合Composite、Singleton、Visitor、和其他Pattern來建立非常優雅的代碼。

壞處#

搜尋、傳輸和計算外在狀態時，可能會產生Run-time的負擔。

實作#

移除外在狀態#

如果在共用物件之前早就有許多各式各樣的外在狀態，即使移掉他們也無法省下多少空間。理想情況下，可用另一個所需空間不大的物件結構來計算外在狀態。

管理共用物件#

因為物件需要共用，所以外界不應該直接實體化他們，應該用FlyweightFactory取得特定的物件來用。FlyweightFactory通常會用關聯式容器（Associative Store）（如：Map）來檢索想要的Flyweight物件。

Flyweight Pattern與Singleton Pattern相反： Flyweight：需要建立某個Class的多個實例。 Singleton：需要建立某個Class的最多一個實例。

Example: Shape#

1
Class: Shape
2

3
package shape;
4

5
public interface Shape {
6

7
  public void draw();
8
}

1
Class: Circle
2

3
package shape;
4

5
public class Circle implements Shape{
6

7
  private String color;
8
  private final int x = 10;
9
  private final int y = 20;
10
  private final int radius = 30;
11

12
  public Circle() {
13

14
  }
15

16
  public Circle( String color ) {
17
    this.color = color;
18
  }
19

20
  public String getColor() {
21
    return color;
22
  }
23

24
  public void setColor( String color ) {
25
    this.color = color;
26
  }
27

28
  @Override
29
  public void draw() {
30
    System.out.println(this+" : Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y + ", radius :" + radius);
31
  }
32
}

顯示更多顯示更少

1
Class: ShapeFactory
2

3
package shape;
4
import java.util.*;
5

6
public class ShapeFactory {
7

8
  private static final HashMap shapeMap = new HashMap();
9

10
  public static Shape getShape( String shapeType ) {
11
    Shape shape=null;
12
    if( shapeType.equalsIgnoreCase("circle") ) {
13
      shape = (Circle) shapeMap.get("circle");
14

15
      if( shape == null )
16
      {
17
        shape = new Circle();
18
        shapeMap.put("circle", shape);
19
        System.out.println("Creating circle object without any color in shapefactory : " + shape + "\n");
20
      }
21
    }
22
    return shape;
23
  }
24
}

顯示更多顯示更少

1
Class: FlyweightPatternDemo
2

3
package shape;
4
public class FlyweightPatternDemo {
5
  private static final String colors[] = { "Red", "Green", "Blue", "Orange", "Black" };
6

7
  public static void main( String[] args ) {
8

9
    System.out.println("\n################ Red color Circles ####################");
10
    for( int i = 0; i < 10; ++i ) {
11
      Circle circle = (Circle) ShapeFactory.getShape("circle");
12
      circle.setColor(colors[0]);
13
      circle.draw();
14
    }
15
    System.out.println("\n############### Green color Circles ####################");
16
    for( int i = 0; i < 10; ++i ) {
17
      Circle circle = (Circle) ShapeFactory.getShape("circle");
18
      circle.setColor(colors[1]);
19
      circle.draw();
20
    }
21
    System.out.println("\n################ Blue color Circles ####################");
22

23
    for( int i = 0; i < 10; ++i ) {
24
      Circle circle = (Circle) ShapeFactory.getShape("circle");
25
      circle.setColor(colors[2]);
26
      circle.draw();
27
    }
28
    System.out.println("\n################ Orange color Circles ####################");
29
    for( int i = 0; i < 10; ++i ) {
30
      Circle circle = (Circle) ShapeFactory.getShape("circle");
31
      circle.setColor(colors[3]);
32
      circle.draw();
33
    }
34
    System.out.println("\n################ Black color Circles ####################");
35
    for( int i = 0; i < 10; ++i ) {
36
      Circle circle = (Circle) ShapeFactory.getShape("circle");
37
      circle.setColor(colors[4]);
38
      circle.draw();
39
    }
40
  }
41
}

顯示更多顯示更少

1
Result:
2

3
################ Red color Circles ####################
4
Creating circle object without any color in shapefactory : shape.Circle@15db9742
5

6
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
7
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
8
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
9
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
10
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
11
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
12
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
13
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
14
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
15
shape.Circle@15db9742 : Circle: Draw() [Color : Red, x : 10, y :20, radius :30
16

17
############### Green color Circles ####################
18
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
19
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
20
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
21
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
22
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
23
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
24
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
25
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
26
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
27
shape.Circle@15db9742 : Circle: Draw() [Color : Green, x : 10, y :20, radius :30
28

29
################ Blue color Circles ####################
30
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
31
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
32
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
33
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
34
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
35
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
36
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
37
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
38
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
39
shape.Circle@15db9742 : Circle: Draw() [Color : Blue, x : 10, y :20, radius :30
40

41
################ Orange color Circles ####################
42
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
43
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
44
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
45
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
46
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
47
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
48
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
49
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
50
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
51
shape.Circle@15db9742 : Circle: Draw() [Color : Orange, x : 10, y :20, radius :30
52

53
################ Black color Circles ####################
54
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
55
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
56
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
57
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
58
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
59
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
60
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
61
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
62
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30
63
shape.Circle@15db9742 : Circle: Draw() [Color : Black, x : 10, y :20, radius :30

顯示更多顯示更少

備忘錄模式 Memento Pattern

Mon, 02 Nov 2020 00:00:00 GMT

目的#

在不違反封裝性的前提下，捕捉物件的內部狀態並存在外面，以便日後回復至此一狀態。

適用#

當物件的部分狀態必須先存起來（快照），以備事後能回復至此一狀態時。直接取得狀態的介面會暴露內部實作細節，因而違反物件封裝性時。

結構及成員#

Collaborations: Caretaker向Originator索取一個Memento物件，持有一陣子之後再送回給Originator。

Memento: like the SolverState存放Originator物件的內部狀態。存放資訊的多寡，要視Originator的狀況而定。避免Originator以外的人存取它。基本上Memento具有兩種介面：Caretacker只看得到窄介面——只能將Memento整個遞給其他物件Originator就能看到寬介面——可存取所有資料，以便回復至前一狀態。理論上，只有產生這個Memento物件的那個Originator才有權存取內部狀態。Originator: like the ConstraintSolver根據自己的現行狀態建立Memento物件。利用Memento回復自己的內部狀態。Caretaker:負責Memento物件的安全。絕不會操作或檢視Memento的內容。

影響結果#

好處#

維持封裝界線。Memento避免將只有Originator才能看到（但又不能置放在Originator裡面）的資訊讓第三者知道，又能讓第三者持有Memento物件。可簡化Originator。原本Originator要記錄外界可能需要用到的所有內部狀態版本，會背負過重責任。

壞處#

Memento可能很耗資源。如果Originator必須將一大堆資訊拷貝到Memento裡面，或者當Caretaker頻頻將Mementor拿來拿去時，就會很耗資源。定義寬介面和窄介面。未必所有程式語言都容易確保只有Originator才能存取Mementor狀態。管理Memento的潛在代價。Caretaker要負責刪除所持有的Memento，但他並不知道Memento裡面到底擺了多少狀態。狀似輕巧的Caretaker可能會花昂貴的代價儲存Memento物件。

實作#

儲存異動之處#

如果Memento的建立及傳遞流程完全合乎預期的話，那麼Memento就可以只儲存與Originator的內部狀態有異動之處（Incremental Change）。

Example: Memento#

1
Class: Originator
2

3
package memento;
4

5
class Originator {
6
  private String state;
7

8
  public void set(String state) {
9
    System.out.println("Originator: Setting state to " + state);
10
    this.state = state;
11
  }
12

13
  public Memento saveToMemento() {
14
    System.out.println("Originator: Saving to Memento.");
15
    return new Memento(state);
16
  }
17

18
  public void restoreFromMemento(Memento m) {
19
    state = m.getSavedState();
20
    System.out.println("Originator: State after restoring from Memento: " + state);
21
  }
22
}

顯示更多顯示更少

1
Class: Memento
2

3
package memento;
4

5
import java.util.*;
6

7
class Memento {
8
  private String state;
9

10
  public Memento(String stateToSave) {
11
    state = stateToSave;
12
  }
13

14
  public String getSavedState() {
15
    return state;
16
  }
17
}

顯示更多顯示更少

1
Class: CareTaker
2

3
package memento;
4

5
import java.util.ArrayList;
6

7
class Caretaker {
8
  private ArrayList savedStates = new ArrayList();
9

10
  public void addMemento(Memento m) {
11
    savedStates.add(m);
12
  }
13

14
  public Memento getMemento(int index) {
15
    return savedStates.get(index);
16
  }
17
}

顯示更多顯示更少

1
Class: MementoExample
2

3
package memento2;
4

5
class MementoExample {
6
  public static void main(String[] args) {
7
    Originator originator = new Originator();
8
    Caretaker caretaker = new Caretaker();
9

10
    originator.set("State1");
11
    originator.set("State2");
12
    caretaker.addMemento(originator.saveToMemento());
13
    originator.set("State3");
14
    caretaker.addMemento(originator.saveToMemento());
15
    originator.set("State4");
16

17
    originator.restoreFromMemento(caretaker.getMemento(1));
18
  }
19
}

顯示更多顯示更少

1
Result:
2

3
Originator: Setting state to State1
4
Originator: Setting state to State2
5
Originator: Saving to Memento.
6
Originator: Setting state to State3
7
Originator: Saving to Memento.
8
Originator: Setting state to State4
9
Originator: State after restoring from Memento: State3

建構者模式 Builder Pattern

Mon, 02 Nov 2020 00:00:00 GMT

目的#

將建構邏輯從物件轉移到建構器。從複雜物件的佈局中抽取出生成程序**，以便用同一個生成程序製造各種不同的物件佈局**。

適用#

欲將「建造複雜物件的演算法」與物件的零件及組裝方式保持獨立時。想讓同一個物件生成程序能夠產生數種不同佈局形式的物件時。若一個產品生產程序太過複雜，Concrete Factory可以把產品生成責任委託給Builder。設計流程和製造流程可以隨產品而變化。

結構及成員#

Collaborations: Client 先建立 Director物件，並將組態設定成想要的 Builder 物件。 Director 會在需要建立 Product 的各個零件時通知 Builder。 Builder 處理 Director 送來的命令，將零件一一加進 Product 裡。最後 Client 從 Builder 手中取得 Product。

Builder: like the TextConverter抽象介面，用來生成Product的各零件。ConcreteBuilder: like the ASCIIConverter, TeXConverter, and TextWidgetConverterBuilder介面的具體實作，負責建構及組裝Product的各零件。定義並記載它所造出的物件之佈局形式。存取Product的介面（如：GetASCIIText、GetTextWidget）Director: like the RTFReader利用Builder介面來建構物件。Product: like the ASCIIText, TeXText, TextWidget.欲產生的最終複雜物件。它的內部佈局形式以及組裝程序，全都是由ConcreteBuilder負責定義。包含各零件的類別，類別裡又含有可將這些零件組裝成最終結果的介面。

影響結果#

好處#

能夠改變成品物件的內部佈局形式。只要定義新的Builder，就能改變成品物件的內部構造。將生成程序與內部佈局的程式碼隔離開來。Client不必知道成品物件內部結構是由哪些類別所定義的，因為這些類別名稱都沒有出現在Builder的外顯介面裡。對生成程序掌控得更細緻。成品物件是在Director的監控下一步步建出來的，等到完全建好之後Director才向Builder索取成品物件。所以Builder的面比其他生成模式更著重在建構成品物件的細步程序。

實作#

組裝及建構介面#

Builder類別的介面必須一般化到能滿足各種ConcreteBuilder所需的生成程序。

為什麼成品物件沒有抽象介面？#

一般而言，ConcreteBuilder所建的成品物件內部佈局方式差異相當大，並不值得費力抽出共同的父類別。Client通常都會用適切的ConcreteBuilder去設定Director物態，它很清楚自己正在用哪一種Builder實體子類別，能夠正確處理成品物件。

　　可能有些人會覺得，同樣都是建立物件，那直接 Abstract Factory Pattern 來建立物件不就好了？這裡要注意的是，Builder 著重在隱藏複雜物件生成的步驟，且生成的物件（通常是複雜物件）彼此會有「部份」（Part of）的概念。而 Abstract Factory 則是著重在管理有關聯性的物件，但這些物件不會有「部份」（Part of）的概念。實務上這個模式還滿常被使用到的，如 JAVA SDK 裡的 StringBuilder，StringBuffer，以及 Android SDK 裡的 AlertDialog.Builder，有興趣的人可以參考看看。

　　Builder Pattern的特點就是將複雜物件的產生過程隱藏起來，使用者無法碰到，且允許物件用多個步驟建立（跟 Factory Method 只有一個步驟不同），因為它的特性，因此經常用來建立合成結構。但對於使用者而言，要是不知道有哪些 setXXX() 方法可以用，也無法建立出想要的物件，這是要注意的地方。

某些時候，會看到有些寫法會將 Builder 的各個 Setter() 回傳 Builder 物件本身（即：public XXBuilder setCompA(…)）。以便能以Fluent Interface的風格進行Builder的設定（如：Product p = builder.setCompA(…).setCompB(…).setC().build()）。

Example: Car#

1
Class: Car
2

3
package builder.car;
4

5
public class Car {
6

7
  private String bodyStyle;
8
  private String power;
9
  private String engine;
10
  private String breaks;
11
  private String seats;
12
  private String windows;
13
  private String fuelType;
14
  private String carType;
15

16
  public Car (String carType){
17
    this.carType = carType;
18
  }
19

20
  public String getBodyStyle() {
21
    return bodyStyle;
22
  }
23
  public void setBodyStyle(String bodyStyle) {
24
    this.bodyStyle = bodyStyle;
25
  }
26
  public String getPower() {
27
    return power;
28
  }
29
  public void setPower(String power) {
30
    this.power = power;
31
  }
32
  public String getEngine() {
33
    return engine;
34
  }
35
  public void setEngine(String engine) {
36
    this.engine = engine;
37
  }
38
  public String getBreaks() {
39
    return breaks;
40
  }
41
  public void setBreaks(String breaks) {
42
    this.breaks = breaks;
43
  }
44
  public String getSeats() {
45
    return seats;
46
  }
47
  public void setSeats(String seats) {
48
    this.seats = seats;
49
  }
50
  public String getWindows() {
51
    return windows;
52
  }
53
  public void setWindows(String windows) {
54
    this.windows = windows;
55
  }
56
  public String getFuelType() {
57
    return fuelType;
58
  }
59
  public void setFuelType(String fuelType) {
60
    this.fuelType = fuelType;
61
  }
62

63
  @Override
64
  public String toString(){
65
    StringBuilder sb = new StringBuilder();
66
    sb.append("--------------"+carType+"--------------------- \n");
67
    sb.append(" Body: ");
68
    sb.append(bodyStyle);
69
    sb.append("\n Power: ");
70
    sb.append(power);
71
    sb.append("\n Engine: ");
72
    sb.append(engine);
73
    sb.append("\n Breaks: ");
74
    sb.append(breaks);
75
    sb.append("\n Seats: ");
76
    sb.append(seats);
77
    sb.append("\n Windows: ");
78
    sb.append(windows);
79
    sb.append("\n Fuel Type: ");
80
    sb.append(fuelType);
81

82
    return sb.toString();
83
  }
84
}

顯示更多顯示更少

1
Class: CarDirector
2

3
package builder.car;
4

5
public class CarDirector {
6

7
  private CarBuilder carBuilder;
8

9
  public CarDirector(CarBuilder carBuilder){
10
    this.carBuilder = carBuilder;
11
  }
12

13
  public void build(){
14
    carBuilder.buildBodyStyle();
15
    carBuilder.buildPower();
16
    carBuilder.buildEngine();
17
    carBuilder.buildBreaks();
18
    carBuilder.buildSeats();
19
    carBuilder.buildWindows();
20
    carBuilder.buildFuelType();
21
  }
22
}

顯示更多顯示更少

1
Interface: CarBuilder
2

3

4
package builder.car;
5

6
public interface CarBuilder {
7

8
  public void buildBodyStyle();
9
  public void buildPower();
10
  public void buildEngine();
11
  public void buildBreaks();
12
  public void buildSeats();
13
  public void buildWindows();
14
  public void buildFuelType();
15
  public Car getCar();
16
}

顯示更多顯示更少

1
Class: SedanCarBuilder
2

3
package builder.car;
4

5
public class SedanCarBuilder implements CarBuilder{
6

7
  private final Car car = new Car("SEDAN");
8

9
  @Override
10
  public void buildBodyStyle() {
11
    car.setBodyStyle("External dimensions: overall length (inches): 202.9, " +
12
"overall width (inches): 76.2, overall height (inches): 60.7, wheelbase (inches): 112.9," + " front track (inches): 65.3, rear track (inches): 65.5 and curb to curb turning circle (feet): 39.5");
13
  }
14

15
  @Override
16
  public void buildPower(){
17
    car.setPower("285 hp @ 6,500 rpm; 253 ft lb of torque @ 4,000 rpm");
18
  }
19

20
  @Override
21
  public void buildEngine() {
22
    car.setEngine("3.5L Duramax V 6 DOHC");
23
  }
24

25
  @Override
26
  public void buildBreaks() {
27
    car.setBreaks("Four-wheel disc brakes: two ventilated. Electronic brake distribution");
28
  }
29

30
  @Override
31
  public void buildSeats() {
32
    car.setSeats("Front seat center armrest.Rear seat center armrest.Split-folding rear seats");
33
  }
34

35
  @Override
36
  public void buildWindows() {
37
    car.setWindows("Laminated side windows.Fixed rear window with defroster");
38

39
  }
40

41
  @Override
42
  public void buildFuelType() {
43
    car.setFuelType("Gasoline 19 MPG city, 29 MPG highway, 23 MPG combined and 437 mi. range");
44

45
  }
46

47
  @Override
48
  public Car getCar(){
49
    return car;
50
  }
51

52
}

顯示更多顯示更少

1
Class: SportsCarBuilder
2

3
package builder.car;
4

5
public class SportsCarBuilder implements CarBuilder{
6

7
  private final Car car = new Car("SPORTS");
8

9
  @Override
10
  public void buildBodyStyle() {
11
    car.setBodyStyle("External dimensions: overall length (inches): 192.3," +
12
" overall width (inches): 75.5, overall height (inches): 54.2, wheelbase (inches): 12.3," + " front track (inches): 63.7, rear track (inches): 64.1 and curb to curb turning circle (feet): 37.7");
13
  }
14

15
  @Override
16
  public void buildPower(){
17
    car.setPower("323 hp @ 6,800 rpm; 278 ft lb of torque @ 4,800 rpm");
18
  }
19

20
  @Override
21
  public void buildEngine() {
22
    car.setEngine("3.6L V 6 DOHC and variable valve timing");
23
  }
24

25
  @Override
26
  public void buildBreaks() {
27
    car.setBreaks("Four-wheel disc brakes: two ventilated. Electronic brake distribution. StabiliTrak stability control");
28

29
  }
30

31
  @Override
32
  public void buildSeats() {
33
    car.setSeats("Driver sports front seat with one power adjustments manual height, front passenger seat sports front seat with one power adjustments");
34
  }
35

36
  @Override
37
  public void buildWindows() {
38
    car.setWindows("Front windows with one-touch on two windows");
39

40
  }
41

42
  @Override
43
  public void buildFuelType() {
44
    car.setFuelType("Gasoline 17 MPG city, 28 MPG highway, 20 MPG combined and 380 mi. range");
45
  }
46

47
  @Override
48
  public Car getCar(){
49
    return car;
50
  }
51

52
}

顯示更多顯示更少

1
Class: TestBuilderPattern
2

3
package builder.car;
4

5
public class TestBuilderPattern {
6

7
  public static void main(String[] args) {
8
    CarBuilder carBuilder = new SedanCarBuilder();
9
    CarDirector director = new CarDirector(carBuilder);
10
    director.build();
11
    Car car = carBuilder.getCar();
12
    System.out.println(car);
13

14
    carBuilder = new SportsCarBuilder();
15
    director = new CarDirector(carBuilder);
16
    director.build();
17
    car = carBuilder.getCar();
18
    System.out.println(car);
19
  }
20

21
}

顯示更多顯示更少

1
Result:
2

3
--------------SEDAN---------------------
4
 Body: External dimensions: overall length (inches): 202.9, overall width (inches): 76.2, overall height (inches): 60.7, wheelbase (inches): 112.9, front track (inches): 65.3, rear track (inches): 65.5 and curb to curb turning circle (feet): 39.5
5
 Power: 285 hp @ 6,500 rpm; 253 ft lb of torque @ 4,000 rpm
6
 Engine: 3.5L Duramax V 6 DOHC
7
 Breaks: Four-wheel disc brakes: two ventilated. Electronic brake distribution
8
 Seats: Front seat center armrest.Rear seat center armrest.Split-folding rear seats
9
 Windows: Laminated side windows.Fixed rear window with defroster
10
 Fuel Type: Gasoline 19 MPG city, 29 MPG highway, 23 MPG combined and 437 mi. range
11
--------------SPORTS---------------------
12
 Body: External dimensions: overall length (inches): 192.3, overall width (inches): 75.5, overall height (inches): 54.2, wheelbase (inches): 112.3, front track (inches): 63.7, rear track (inches): 64.1 and curb to curb turning circle (feet): 37.7
13
 Power: 323 hp @ 6,800 rpm; 278 ft lb of torque @ 4,800 rpm
14
 Engine: 3.6L V 6 DOHC and variable valve timing
15
 Breaks: Four-wheel disc brakes: two ventilated. Electronic brake distribution. StabiliTrak stability control
16
 Seats: Driver sports front seat with one power adjustments manual height, front passenger seat sports front seat with one power adjustments
17
 Windows: Front windows with one-touch on two windows
18
 Fuel Type: Gasoline 17 MPG city, 28 MPG highway, 20 MPG combined and 380 mi. range

顯示更多顯示更少

狀態模式 State Pattern

Tue, 27 Oct 2020 00:00:00 GMT

目的#

讓物件的外顯行為隨內部狀態的改變而改變，彷彿連類別也變了似的。

適用#

當物件的行為取決於它的狀態，連執行期行為也得隨狀態而改變時。如果某些操作裡面，依據物件狀態而做的條件判斷式太過龐大時。狀態通常會以enum表示，許多操作裡面也常會有相同的條件判斷結構。State Pattern將每一個條件分支抽取成獨立的類別，以便將物件狀態也視為另一個獨立的物件，可獨立改變。

結構及成員#

Collaborations: Context將與狀態有關的訊息委託給目前持有的ConcreteState去處理。 Context可能把自己當作傳參傳給State。 Context是主要的對外窗口。Client可用State物件來設定Context的組態，設好之後便不再直接插手State物件。可令Context或ConcreteState的子類別決定在什麼情況下該切換成什麼狀態。

Context: like the CruiseControl, TCPConnection制定外界感興趣的介面。持有一個ConcreteState。State:此介面負責封裝當Context處於特定狀態時所該展現的行為。ConcreteState: like the CruisingCanceled, TCPEstablished, TCPClosed, TCPListen, etc.每一個子類別都針對某一種Context狀態實作出該展現的行為。

影響結果#

好處#

集中處理與狀態相依的行為並予以切割。只要定義新的State子類別，即可輕易增加新的狀態及狀態轉移邏輯。替每一種狀態設一個State物件，能突顯狀態轉移邏輯，也能避免Context不一致的內部狀態。（以Context來看，狀態轉移是個不可再細分的atomic動作）狀態物件可共用。若State物件不含實例變數，則Context可以共用State物件，此時State物件相當於沒有內在狀態、只有行為的Flyweight物件。

壞處#

需要額外新增類別。

實作#

誰來定義狀態轉移邏輯？#

若條件是固定的，可以全寫在Context裡；而彈性更好的做法，是讓State的子類別決定自己的下一個State是誰、何時才做轉移。Context需增加一個讓State物件可以設定Context的State的方法。只要定義新的State子類別，就能修改或擴充狀態轉移邏輯。但缺點是State子類別需要知道至少一個其他的State子類別，增加子類別之間的實作相依性。

State物件的生與死？#

取捨：有需要時才產生State物件，用完即砍。事先件立好，事後絕不殺掉。若在Run-time時不知道處於哪些狀態，且Context不常改變狀態時，第一種做法較好。若State物件含有大量資訊，且狀態常常改變，就會想避免一再刪除State物件，就該用第二種做法。

使用動態繼承#

若能在Run-time動態改變物件所隸屬的類別，就能針對特定訊息改變自身行為。

Example: Cruise Control System#

1
public abstract class State {
2
  State[] states;
3

4
  abstract void leverDown(CruiseControl c);
5
  abstract void leverUpAndHold(CruiseControl c);
6
  abstract void leverDownAndHold(CruiseControl c);
7
  abstract void leverReleased(CruiseControl c);
8
  abstract void leverPulled(CruiseControl c);
9
  abstract void brakeApplied(CruiseControl c);
10
  abstract void leverUp(CruiseControl c);
11
  abstract void onOffButtonPressed(CruiseControl c);
12

13
  void setDesiredSpeed(CruiseControl c) {
14
    System.out.println("setDesiredSpeed");
15
  }
16
}

顯示更多顯示更少

1
public class CruiseDeactivated extends State {
2
  @Override
3
  void onOffButtonPressed(CruiseControl c) {
4
    // TODO Auto-generated method stub
5
    System.out.println("CruiseDeactivated change to CruiseActivated");
6
    System.out.println("CruiseDeactivated change to CruisingCancelled");
7
    c.setState(new CruisingCancelled());
8
  }
9
  @Override
10
  void leverDown(CruiseControl c) {}
11
  @Override
12
  void leverUp(CruiseControl c) {}
13
  @Override
14
  void brakeApplied(CruiseControl c) {}
15
  @Override
16
  void leverDownAndHold(CruiseControl c) {}
17
  @Override
18
  void leverUpAndHold(CruiseControl c) {}
19
  @Override
20
  void leverPulled(CruiseControl c) {}
21
  @Override
22
  void leverReleased(CruiseControl c) {}
23
  @Override
24
  void setDesiredSpeed(CruiseControl c) {}
25
}

顯示更多顯示更少

1
public class CruiseActivated extends State {
2

3
  @Override
4
  void onOffButtonPressed(CruiseControl c) {
5
    // TODO Auto-generated method stub
6
    System.out.println("CruiseActivated change to CruiseDeactivated");
7
    c.setState(new CruiseDeactivated());
8
  }
9
  @Override
10
  void leverDown(CruiseControl c) {}
11
  @Override
12
  void leverUp(CruiseControl c) {}
13
  @Override
14
  void brakeApplied(CruiseControl c) {}
15
  @Override
16
  void leverDownAndHold(CruiseControl c) {}
17
  @Override
18
  void leverUpAndHold(CruiseControl c) {}
19
  @Override
20
  void leverPulled(CruiseControl c) {}
21
  @Override
22
  void leverReleased(CruiseControl c) {}
23
}

顯示更多顯示更少

1
public class Cruising extends CruiseActivated {
2
  @Override
3
  void leverDown(CruiseControl c) {
4
    System.out.println("Cruising change to Cruising");
5
    setDesiredSpeed(c);
6
    c.setState(new Cruising());
7
  }
8
  @Override
9
  void brakeApplied(CruiseControl c) {
10
    System.out.println("Cruising change to CruisingCancelled");
11
    c.setState(new CruisingCancelled());
12
  }
13
  @Override
14
  void leverDownAndHold(CruiseControl c) {
15
    System.out.println("Cruising change to DecreasingSpeed");
16
    c.setState(new DecreasingSpeed());
17
  }
18

19
  @Override
20
  void leverUpAndHold(CruiseControl c) {
21
    System.out.println("Cruising change to IncreasingSpeed");
22
    c.setState(new IncreasingSpeed());
23
  }
24

25
  @Override
26
  void leverPulled(CruiseControl c) {
27
    System.out.println("Cruising change to CruisingCancelled");
28
    c.setState(new CruisingCancelled());
29
  }
30
}

顯示更多顯示更少

1
public class CruisingCancelled extends CruiseActivated {
2
  @Override
3
  void leverDown(CruiseControl c) {
4
    System.out.println("CruisingCancelled change to Cruising");
5
    setDesiredSpeed(c);
6
    c.setState(new Cruising());
7
  }
8
  @Override
9
  void leverUp(CruiseControl c) {
10
    System.out.println("CruisingCancelled change to Cruising");
11
    c.setState(new Cruising());
12
  }
13
  @Override
14
  void leverDownAndHold(CruiseControl c) {
15
  System.out.println("CruisingCancelled change to DecreasingSpeed");
16
    c.setState(new DecreasingSpeed());
17
  }
18
  @Override
19
  void leverUpAndHold(CruiseControl c) {
20
  System.out.println("CruisingCancelled change to IncreasingSpeed");
21
    c.setState(new IncreasingSpeed());
22
  }
23
}

顯示更多顯示更少

1
public class DecreasingSpeed extends CruiseActivated{
2
    @Override
3
  void leverReleased(CruiseControl c){
4
    System.out.println("DecreasingSpeed change to Cruising");
5
    setDesiredSpeed(c);
6
    c.setState(new Cruising());
7
  }
8
}
9

10
public class IncreasingSpeed extends CruiseActivated{
11
  void leverReleased(CruiseControl c){
12
    System.out.println("IncreasingSpeed change to Cruising");
13
    c.setState(new Cruising());
14
  }
15
}

顯示更多顯示更少

1
public class CruiseControl {
2
  State state;
3
  public CruiseControl() {
4
    // TODO Auto-generated constructor stub
5
    this.state = new CruiseDeactivated();
6
  }
7
  public State getState() {
8
    return state;
9
  }
10
  public void setState(State state) {
11
    this.state = state;
12
  }
13
  void onOffButtonPressed() {
14
    state.onOffButtonPressed(this);
15
  }
16
  void leverDown() {
17
    state.leverDown(this);
18
  }
19
  void leverUp() {
20
    state.leverUp(this);
21
  }
22
  void brakeApplied() {
23
    state.brakeApplied(this);
24
  }
25
  void leverDownAndHold() {
26
    state.leverDownAndHold(this);
27
  }
28
  void leverUpAndHold() {
29
    state.leverUpAndHold(this);
30
  }
31
  void leverPulled() {
32
    state.leverPulled(this);
33
  }
34
  void leverReleased() {
35
    state.leverReleased(this);
36
  }
37
}

顯示更多顯示更少

1
public class Main {
2

3
  public static void main(String[] args) {
4
    // TODO Auto-generated method stub
5
    CruiseControl cruiseControl = new CruiseControl();
6
    cruiseControl.onOffButtonPressed();
7
    cruiseControl.leverDown();
8
    cruiseControl.onOffButtonPressed();
9
  }
10

11
}

1
Result:
2

3
CruiseDeactivated change to CruiseActivated
4
CruiseDeactivated change to CruisingCancelled
5
CruisingCancelled change to Cruising
6
setDesiredSpeed
7
CruiseActivated change to CruiseDeactivated

訪問者模式 Visitor Pattern

Tue, 13 Oct 2020 00:00:00 GMT

目的#

定義能逐一施行於物件結構裡各個元素的操作，讓你不必修改作用對象的類別介面，就能定義新的操作；將操作集中到物件結構上，以讓它們能獨立變化，但仍以多型方式進行。

適用#

物件結構含有許多介面各異的類別，希望能依據物件的實體類別來執行對應的動作時。需要對整個物件結構體系執行各種互不相干的操作，不會造成干擾。物件結構的類別不常變動，但施於其上的操作卻常有增減時。

結構及成員#

Collaborations: Client先建立一個ConcreteVisitor物件，再於巡訪物件結構的過程中，將Visitor物件餵給每一個遇到的Element。 Element被巡訪到時，會呼叫Visitor相對應的操作，如有必要，也會把自己列入參數傳送過去讓Visitor存取。

Visitor: like the NodeVisitor替每一種ConcreteElement制訂對應的Visit()方法。Visitor藉由方法的名字和簽名（Sinature）（多型）區分是哪個ConcreteElement送過來的訊息。將訊息轉傳給ConcreteVisitor。ConcreteVisitor: like the TypeCheckingVisitor, SpellingVisitor具體實作出Visitor。演算法可從ConcreteVisitor得知目前的Context，在整個巡訪過程中均可在此儲存局部狀態以累積資訊。Element: like the Glyph, Node宣告以Visitor物件當參數的Accept()介面。ConcreteElement: like the Row, Column, Text, Image, etc.具體實作出Accept()方法。Client:可巡訪整群Element物件。可提供高階介面讓Visitor巡訪Element。可以是Composite，也可以是容器（List、Set）。

影響結果#

好處#

容易增添新的操作，新增一個Visitor即可新增操作。每一種Visitor都將相關操作集中起來，將無關的摒除在外。處理不同的類別階層, Iterator只能巡訪Item或Item的子類別，而Visitor只要把相關類別寫入方法，就沒有巡訪限制。累積狀態。Visitor可在拜訪物件結構各個元素時順便累積狀態。

壞處#

難以增添新的ConcreteElement類別。Visitor可能會迫使ConcreteElement公開一些可存取的Element內部狀態，破壞封裝。

實作#

雙重分派（Double Dispatch）？#

在單一分派程式語言，呼叫哪個Overload方法，由方法呼叫者和方法參數共同在執行期間依靜態類別決定。如：以下程式碼所有的ride()出來都會是「騎馬」，因為他們的靜態類別都是Horse。

1
public class Mozi {
2
    public void ride(Horse h){ System.out.println("騎馬"); }
3
    public void ride(WhiteHorse wh){ System.out.println("騎白馬"); }
4
    public void ride(BlackHorse bh){ System.out.println("騎黑馬"); }
5

6
    public static void main(String[] args) {
7
        Horse wh = new WhiteHorse();
8
        Horse bh = new BlackHorse();
9
        Mozi mozi = new Mozi();
10
        mozi.ride(wh);
11
        mozi.ride(bh);
12
    }
13
}

但JAVA可以透過Override實作動態分派

1
public class Horse {
2
    public void ride(){ System.out.println("騎馬"); }
3
}
4
public class WhiteHorse extends Horse {
5
    public void ride(){ System.out.println("騎白馬"); }
6
}
7
public class BlackHorse extends Horse {
8
    public void ride(){ System.out.println("騎黑馬"); }
9
}
10
public class Mozi {
11
    public static void main(String[] args) {
12
        Horse wh = new WhiteHorse();
13
        Horse bh = new BlackHorse();
14
        wh.ride();
15
        bh.ride();
16
    }
17
}

顯示更多顯示更少

Visitor模式將真正會啟用的操作，依Visitor的型別和作用對象的型別決定，不用把靜態操作繫結在Element介面裡。

誰負責巡訪物件結構？#

有三種角色可以幫Visitor一一拜訪物件結構裡的每一個元素：物件結構、Visitor物件、Iterator物件。

Example: Liquor#

1
//Interface: Visitable
2
package liquor;
3

4
interface Visitable {
5

6
  public double accept(Visitor visitor);
7

8
}

1
//Class: Liquor
2
package liquor;
3

4
class Liquor implements Visitable {
5

6
  private double price;
7

8
  Liquor(double item) {
9
    price = item;
10
  }
11

12
  public double accept(Visitor visitor) {
13
    return visitor.visit(this);
14
  }
15

16
  public double getPrice() {
17
    return price;
18
  }
19

20
}

顯示更多顯示更少

1
//Class: Necessity
2

3
package liquor;
4
class Necessity implements Visitable {
5

6
  private double price;
7

8
  Necessity(double item) {
9
    price = item;
10
  }
11

12
  public double accept(Visitor visitor) {
13
    return visitor.visit(this);
14
  }
15

16
  public double getPrice() {
17
    return price;
18
  }
19

20
}

顯示更多顯示更少

1
//Class: Tobaco
2

3
package liquor;
4
class Tobacco implements Visitable {
5

6
  private double price;
7

8
  Tobacco(double item) {
9
    price = item;
10
  }
11

12
  public double accept(Visitor visitor) {
13
    return visitor.visit(this);
14
  }
15

16
  public double getPrice() {
17
    return price;
18
  }
19

20
}

顯示更多顯示更少

1
//Interface: Visitor
2

3
package liquor;
4

5
interface Visitor {
6

7
  public double visit(Liquor liquorItem);
8

9
  public double visit(Tobacco tobaccoItem);
10

11
  public double visit(Necessity necessityItem);
12

13
}

1
//Class: TaxVisitor
2

3
package liquor;
4

5
import java.text.DecimalFormat;
6

7
class TaxVisitor implements Visitor {
8

9

10
  DecimalFormat df = new DecimalFormat("#.##");
11

12
  public TaxVisitor() {
13
  }
14

15
  public double visit(Liquor liquorItem) {
16
    System.out.println("Liquor Item: Price with Tax");
17
    return Double.parseDouble(df.format((liquorItem.getPrice() * .18) + liquorItem.getPrice()));
18
  }
19

20
  public double visit(Tobacco tobaccoItem) {
21
    System.out.println("Tobacco Item: Price with Tax");
22
    return Double.parseDouble(df.format((tobaccoItem.getPrice() * .32) + tobaccoItem.getPrice()));
23
  }
24

25
  public double visit(Necessity necessityItem) {
26
    System.out.println("Necessity Item: Price with Tax");
27
    return Double.parseDouble(df.format(necessityItem.getPrice()));
28
  }
29

30
}

顯示更多顯示更少

1
//Class: TaxHolidayVisitor
2

3

4
package liquor;
5
import java.text.DecimalFormat;
6

7
class TaxHolidayVisitor implements Visitor {
8

9
    DecimalFormat df = new DecimalFormat("#.##");
10
  public TaxHolidayVisitor() {
11
  }
12

13
  public double visit(Liquor liquorItem) {
14
    System.out.println("Liquor Item: Price with Tax");
15
    return Double.parseDouble(df.format((liquorItem.getPrice() * .10) + liquorItem.getPrice()));
16
  }
17

18
  public double visit(Tobacco tobaccoItem) {
19
    System.out.println("Tobacco Item: Price with Tax");
20
    return Double.parseDouble(df.format((tobaccoItem.getPrice() * .30) + tobaccoItem.getPrice()));
21
  }
22

23

24
  public double visit(Necessity necessityItem) {
25
    System.out.println("Necessity Item: Price with Tax");
26
    return Double.parseDouble(df.format(necessityItem.getPrice()));
27
  }
28

29
}

顯示更多顯示更少

1
//Class: VisitorTest
2

3
package liquor;
4
public class VisitorTest {
5
  public static void main(String[] args) {
6

7
    TaxVisitor taxCalc = new TaxVisitor();
8
    TaxHolidayVisitor taxHolidayCalc = new TaxHolidayVisitor();
9

10
    Necessity milk = new Necessity(3.47);
11
    Liquor vodka = new Liquor(11.99);
12
    Tobacco cigars = new Tobacco(19.99);
13

14
    System.out.println(milk.accept(taxCalc) + "\n");
15
    System.out.println(vodka.accept(taxCalc) + "\n");
16
    System.out.println(cigars.accept(taxCalc) + "\n");
17

18
    System.out.println("TAX HOLIDAY PRICES\n");
19

20
    System.out.println(milk.accept(taxHolidayCalc) + "\n");
21
    System.out.println(vodka.accept(taxHolidayCalc) + "\n");
22
    System.out.println(cigars.accept(taxHolidayCalc) + "\n");
23

24
  }
25
}

顯示更多顯示更少

1
Result:
2

3
Necessity Item: Price with Tax
4
3.47
5

6
Liquor Item: Price with Tax
7
14.15
8

9
Tobacco Item: Price with Tax
10
26.39
11

12
TAX HOLIDAY PRICES
13

14
Necessity Item: Price with Tax
15
3.47
16

17
Liquor Item: Price with Tax
18
13.19
19

20
Tobacco Item: Price with Tax
21
25.99

顯示更多顯示更少

疊代器模式 Iterator Pattern

Wed, 07 Oct 2020 00:00:00 GMT

目的#

不用知道Aggregate Object的內部細節，即可依序存取內含的每一個元素

適用#

即使對Aggregate Object內部結構一無所知，仍可存取物件內容。以多種方式巡訪Aggregate Object。以一致介面巡訪各種不同的Aggregate Object時（多型巡訪）。

結構及成員#

Collaborations: ConcreteIterator記載已巡訪到聚合體的哪一個元素，並可依序巡訪下一個。

Iterator:宣告存取巡訪元素的介面。ConcreteIterator: like the ArrayIterator, ListIterator, PreorderIterator具體實作出Iterator。記載正在巡訪的現行元素位置。Aggregate:此介面宣告出建立Iterator物件之操作。ConcreteAggregate:具體實作出建立Iterator物件之介面，傳回適當的ConcreteIterator物件實體。

影響結果#

好處#

可提供多種巡訪方式，可以輕易改變巡訪演算法，也可以衍生新的Iterator子類別提供新的巡訪方式。Iterator可簡化Aggregate介面。Aggregate不必覆寫巡訪方法。針對同一聚合體，可以同時存在許多Iterator在其中，各Iterator物件會記載自己的巡訪狀態。

壞處#

Iterator和Aggregate之間有額外的通訊負擔。

實作#

誰來控制巡訪過程？#

如果是由Client控制，這就是外部Iterator；由Iterator自己主導，就是內部Iterator。外部Iterator比內部Iterator更有彈性。

誰來定義巡訪演算法？#

Aggregate Object也可能會定義，此時Iterator只是拿來記錄巡訪狀態而已。這種Iterator就是Cursor，Client以游標當參數呼叫Aggregate Object的Next()，而Next()會改變游標的操作。如果有Iterator負責巡訪演算法，就很容易用不同方式巡訪同一個Aggregate Object。但巡訪演算法可能需要存取Private Attribute，會破壞封裝。

Iterator有多穩健？#

在巡訪Aggregate Object的同時還去改變Aggregate Object的內容會很危險。若有增刪元素，就可能會重複存取，也可能完全略過。可以透過先複製一份Aggregate Object再巡訪來解決，但會耗效能。穩健（Robust）的Iterator不必將Aggregate Object再複製一份，大部分都需要向Aggregate Object索取Iterator物件，一有增刪動作，Aggregate Object會主動調整Iterator的內部狀態，或者乾脆自己維謢必要資訊以確保巡訪時的正常運作。

其他額外的Iterator操作#

最小的操作會包含First()、Next()、IsDone()、CurrentItem()等，但也可能有Previous()、**SkipTo()**等。

Example:#

GlyphStorage#

1
// Abstract Aggregate  （類似Java 的 abstract class List）
2
// 自己設計的Storage資料結構
3
public interface GlyphStorage {
4
    void add(int index, Glyph element);
5
    void add(Glyph element);
6
    void remove(int index);
7
    void remove(Glyph glyph);
8
    int size();
9
    Glyph get(int index);
10
    Iterator iterator();
11
}

1
// Concrete Aggregate  （類似Java 的 LinkedList或ArrayList）
2
// 在此資料型態用array，但也可以是其他種
3
// 內部的method()是為了array而設計，可以不深入研究
4
public class ArrayGlyphStorage implements GlyphStorage{
5
    private Glyph[] glyphs = new Glyph[10];
6
    private int index = 0;
7

8
    @Override
9
    public void add(int index, Glyph element) {
10
        int i = index++;
11
        expandArray(glyphs.length+1);
12
        for(int pos = i+1; i = glyphs.length)
13
            throw new ArrayIndexOutOfBoundsException();
14
        return glyphs[index];
15
    }
16

17
    @Override
18
    public Iterator iterator() {
19
        return new ArrayGlyphIterator(this);
20
    }
21

22
    private void expandArray(int size) {
23
        if(size >= glyphs.length) {
24
            Glyph[] newGlyphs = new Glyph[size];
25
            System.arraycopy(glyphs, 0, newGlyphs, 0, glyphs.length);
26
            glyphs = newGlyphs;
27
        }
28
    }
29
}

顯示更多顯示更少

1
// Concrete Aggregate  （類似Java 的 LinkedList或ArrayList）
2
// 在此資料型態用arrayList，但也可以是其他種
3
// 內部的method()是為了arrayList而設計，直接拿內建arrayList來用
4
public class ListGlyphStorage implements GlyphStorage{
5
    private ArrayList glyphs = new ArrayList<>();
6
    private int index = 0;
7

8
    @Override
9
    public void add(int index, Glyph element) {
10
        glyphs.add(index, element);
11
    }
12

13
    @Override
14
    public void add(Glyph element) {
15
        glyphs.add(element);
16
    }
17

18
    @Override
19
    public void remove(int index) {
20
        glyphs.remove(index);
21
    }
22

23
    @Override
24
    public void remove(Glyph glyph) {
25
        glyphs.remove(glyph);
26
    }
27

28
    @Override
29
    public int size() {
30
        return glyphs.size();
31
    }
32

33
    @Override
34
    public Glyph get(int index) {
35
        return glyphs.get(index);
36
    }
37

38
    @Override
39
    public Iterator iterator() {
40
        return new ListGlyphIterator(this);
41
    }
42
}

顯示更多顯示更少

1
// Concrete Iterator 繼承 Java內建的 Iterator
2
// 專屬於 ArrayGlyphStorage的Iterator
3
// 像 ArrayList和ArrayListIterator的關係
4
public class ArrayGlyphIterator implements Iterator {
5
    int position = 0;
6
    ArrayGlyphStorage arrayGlyphStorage;
7
    public ArrayGlyphIterator(ArrayGlyphStorage arrayGlyphStorage){
8
        this.arrayGlyphStorage = arrayGlyphStorage;
9
    }
10

11
    @Override
12
    public boolean hasNext() {
13
        if(position >= arrayGlyphStorage.size() || arrayGlyphStorage.get(position) == null)
14
            return false;
15
        return true;
16
    }
17

18
    @Override
19
    public Glyph next() {
20
        return arrayGlyphStorage.get(position++);
21
    }
22

23
    @Override
24
    public void remove() {
25
        arrayGlyphStorage.remove(position-1);
26
        position -= 1;
27
    }
28
}

顯示更多顯示更少

1
// Concrete Iterator 繼承 Java內建的 Iterator
2
// 專屬於 ListGlyphStorage的Iterator
3
// 像 LinkedList和LinkedListIterator的關係
4
public class ListGlyphIterator implements Iterator {
5
    int position = 0;
6
    ListGlyphStorage listGlyphStorage;
7
    public ListGlyphIterator(ListGlyphStorage listGlyphStorage){
8
        this.listGlyphStorage = listGlyphStorage;
9
    }
10

11
    @Override
12
    public boolean hasNext() {
13
        if(position >= listGlyphStorage.size() || listGlyphStorage.get(position) == null)
14
            return false;
15
        return true;
16
    }
17

18
    @Override
19
    public Glyph next() {
20
        return listGlyphStorage.get(position++);
21
    }
22

23
    @Override
24
    public void remove() {
25
        listGlyphStorage.remove(position-1);
26
        position -= 1;
27
    }
28
}

顯示更多顯示更少

1
// 用例
2
public class MyGlyphIteratorPattern {
3

4
  public static void main(String[] args) {
5
    GlyphStorage storage = new ArrayGlyphStorage();
6
     storage.add(new Row());
7
    storage.add(new Text());
8
    storage.add(new Image());
9

10
    Iterator iterator = storage.iterator();   //仿JAVA內建Iterator的用法
11
    while(iterator.hasNext()){
12
      System.out.println(iterator.next().detail());
13
    }
14
  }
15
}

顯示更多顯示更少

1
Result:
2

3
This is row glyph
4
This is text glyph
5
This is image glyph

Shape#

1
//Class: Shape
2

3
package iterator.shape;
4

5
public class Shape {
6

7
  private int id;
8
  private String name;
9

10
  public Shape(int id, String name){
11
    this.id = id;
12
    this.name = name;
13
  }
14

15
  public int getId() {
16
    return id;
17
  }
18
  public void setId(int id) {
19
    this.id = id;
20
  }
21
  public String getName() {
22
    return name;
23
  }
24
  public void setName(String name) {
25
    this.name = name;
26
  }
27

28
  @Override
29
  public String toString(){
30
    return "ID: "+id+" Shape: "+name;
31
  }
32

33
}

顯示更多顯示更少

1
//Class: ShapeStorage
2

3
package iterator.shape;
4

5
public class ShapeStorage {
6

7
  private Shape[] shapes = new Shape[5];
8
  private int index;
9

10
  public void addShape(String name){
11
    int i = index++;
12
    shapes[i] = new Shape(i,name);
13
  }
14

15
  public Shape[] getShapes(){
16
    return shapes;
17
  }
18
}

顯示更多顯示更少

1
//Class: ShapeIterator
2

3
package iterator.shape;
4

5
import java.util.Iterator;
6

7
public class ShapeIterator implements Iterator{
8

9
  private Shape [] shapes;
10
  int pos;
11

12
  public ShapeIterator(Shape[] shapes){
13
    this.shapes = shapes;
14
  }
15
  @Override
16
  public boolean hasNext() {
17
    if(pos >= shapes.length || shapes[pos] == null)
18
      return false;
19
    return true;
20
  }
21

22
  @Override
23
  public Shape next() {
24
    return shapes[pos++];
25
  }
26

27
  @Override
28
  public void remove() {
29
    if(pos <=0 )
30
      throw new IllegalStateException("Illegal position");
31
    if(shapes[pos-1] !=null){
32
      for (int i= pos-1; i<(shapes.length-1);i++){
33
        shapes[i] = shapes[i+1];
34
      }
35
      shapes[shapes.length-1] = null;
36
    }
37
  }
38
}

顯示更多顯示更少

1
//Class: TestIteratorPattern
2

3
package iterator.shape;
4

5
public class TestIteratorPattern {
6

7
  public static void main(String[] args) {
8
    ShapeStorage storage = new ShapeStorage();
9
     storage.addShape("Polygon");
10
    storage.addShape("Hexagon");
11
    storage.addShape("Circle");
12
    storage.addShape("Rectangle");
13
    storage.addShape("Square");
14

15
    ShapeIterator iterator = new ShapeIterator(storage.getShapes());
16
    while(iterator.hasNext()){
17
      System.out.println(iterator.next());
18
    }
19
    System.out.println("Apply removing while iterating...");
20
    iterator = new ShapeIterator(storage.getShapes());
21
    while(iterator.hasNext()){
22
      System.out.println(iterator.next());
23
      iterator.remove();
24
    }
25
  }
26

27
}

顯示更多顯示更少

1
Result:
2

3
ID: 0 Shape: Polygon
4
ID: 1 Shape: Hexagon
5
ID: 2 Shape: Circle
6
ID: 3 Shape: Rectangle
7
ID: 4 Shape: Square
8
Apply removing while iterating...
9
ID: 0 Shape: Polygon
10
ID: 2 Shape: Circle
11
ID: 4 Shape: Square

命令模式 Command Pattern

Tue, 06 Oct 2020 00:00:00 GMT

目的#

將訊息（請求）封裝成物件，可以參數化具有不同請求、佇列或日誌請求的Client，並且支援復原動作。

適用#

想用「欲執行之動作」來參數化物件。（登記成Callback Function）。在不同時間、佇列、執行命令時。支援復原動作。支援日誌功能，系統Crash時能再重新執行。以基礎操作組出高階的系統（常見於支援交易功能的資訊系統中）。

結構及成員#

Collaborations: Client建立ConcreteCommand物件並設定Receiver。 Invoker物件會將ConcreteCommand存起來。 Invoker呼叫所存Command之Execute()，若Command是可復原的，ConcreteCommand就會在執行Execute()前先儲存狀態。 ConcreteCommand物件呼叫所載Receiver之操作，以真正執行命令。

Command:制訂執行命令之介面。ConcreteCommand: like the CopyCommand, PasteCommand將Receiver物件和對應的動作繫結起來。實作Execute()：呼叫Receiver的對應操作。Client: like the Application建立ConcreteCommand物件並設定它的Receiver。Client基本上會持有Invoker並使用setCommand設定ConcreteCommand。Invoker: like the MenuItem要求Command執行命令。Receiver: like the Document, Application, etc.知道如何根收到的訊息執行命令，任何類別都可以是Receiver。

影響結果#

好處#

Command將「引發命令的物件」與「知道如何執行的物件」隔離開來。Command是一級物件（First-Class Object），可和一般物件一樣使用及擴充。容易新增新的Command類型，不必更改既有類別。

壞處#

會導致大量瑣碎的命令子類別。

實作#

Command該有多聰明？#

一個極端是只定義訊息接收者和執行動作之間的繫結關係，將任務全部委託給接收者，另一個極端是全都自己來，不轉傳給接收者。

若想把Command與既有類別彼此獨立，或沒有合用的接收者存在，或Command自己知道接收者是誰（如：再產生一個視窗），那可以使用後者。在這兩個極端中間，Command必須具有足夠的知識動態尋得訊息接收者。

支援復原與重做#

只要有辦法逆轉執行動作，Command就有復原及重做的能力。故ConcreteCommand可能得存放以下這些狀態：

Receiver物件，負責實際執行所要求的命令。餵給Receiver對應操作的參數。在執行操作後，所有可能有變動的Receiver原始內容。Receiver必須提供某些操作以供復原。

若想支援一層復原，則必須儲存最後執行的Command；若要多層，就要一個Command History List。

置入歷程列表前，若Command執行後狀態會變（如：DeleteCommand），就先複製一份，確保每次啟用的Command都是乾淨的。（i.e. Prototype Pattern）

避免復原過程中不斷累積錯誤#

在Command裡多存一點資訊，以確保物件能真的回復到最初狀態。可用Memento Pattern來存。

Example: SimpleRemoteControl#

1
public class Light {
2

3
    public Light() {}
4

5
    public void on() {
6
        System.out.println("Light is on");
7
    }
8

9
    public void off() {
10
        System.out.println("Light is off");
11
    }
12

13
}

1
public class GarageDoor {
2

3
    public GarageDoor() {}
4
    public void up() {
5
        System.out.println("Garage Door is Open");
6
    }
7

8
    public void down() {
9
        System.out.println("Garage Door is Closed");
10
    }
11

12
    public void stop() {
13
        System.out.println("Garage Door is Stopped");
14
    }
15

16
    public void lightOn() {
17
        System.out.println("Garage light is on");
18
    }
19

20
    public void lightOff() {
21
        System.out.println("Garage light is off");
22
    }
23
public void Off() {
24
        System.out.println("Garage Door is off");
25
    }
26
}

顯示更多顯示更少

1
public interface Command {
2
    public void execute();
3
}

1
public class GarageDoorOpenCommand implements Command {
2
     //Have its suitable receiver
3
    GarageDoor garageDoor;
4
     //Specify the Constructor
5
    public GarageDoorOpenCommand (GarageDoor garageDoor) {
6
        this.garageDoor = garageDoor;
7
    }
8

9
    //Execute the garageDoor.up() function
10
    @Override
11
    public void execute() {
12
        // TODO Auto-generated method stub
13
        garageDoor.up();
14
    }
15

16
}

顯示更多顯示更少

1
//Then describe the LightOnCommand implements Command
2
public class LightOnCommand implements Command {
3

4
    Light light;
5

6
    public LightOnCommand (Light light) {
7
        this.light = light;
8
    }
9

10
    @Override
11
    public void execute() {
12
        // TODO Auto-generated method stub
13
        light.on();
14
    }
15

16
}

顯示更多顯示更少

1
public class SimpleRemoteControl {
2

3
    Command slot;
4

5
    public SimpleRemoteControl() {}
6

7
  //Describe the important function of the invoker
8
    public void setCommand(Command command) {
9
        this.slot = command;
10
    }
11

12
    public void buttonWasPressed() {
13
        slot.execute();
14
    }
15
}

顯示更多顯示更少

1
public class SimpleRemoteControlClient{
2

3
    public static void main(String[] args) {
4
        Light light = new Light();
5
        GarageDoor garageDoor = new GarageDoor();
6
        SimpleRemoteControl remoteControl = new SimpleRemoteControl();
7

8
        Command lightOnCommand = new LightOnCommand(light);
9
        remoteControl.setCommand(lightOnCommand);
10
        remoteControl.buttonWasPressed();
11

12
        Command garageDoorOpenCommand = new GarageDoorOpenCommand(garageDoor );
13
        remoteControl.setCommand(garageDoorOpenCommand );
14
        remoteControl.buttonWasPressed();
15
    }
16
}

顯示更多顯示更少

1
Result:
2

3
Light is on
4
Garage Door is Open

橋接模式 Bridge Pattern

Tue, 06 Oct 2020 00:00:00 GMT

目的#

將實作體系與抽象體系分開，讓兩者能各自更動。

適用#

想避免將抽象和實體綁死在一起。需要一個統一的介面來交換層次結構。抽象體和實作體都能用子類別去個別擴充。實作體有變但抽象體沒變時，不應影響client。隱藏實作方式。能在多個物件之間共享實作碼，但不影響client。

結構及成員#

Collaborations: Abstraction將Client的訊息請求轉傳給對應的Implementor去處理。

Abstraction: like the Window抽象體的介面。持有Implementor。RefinedAbstraction: like the PopupWindow, IconWindow.擴充Abstraction。Implementor: like the WindowImp, ColorImp, FontImp定義實作類別之共同介面，可以和Abstraction相去甚遠。通常只含最基本的操作，讓Abstraction組出更高階的操作。ConcreteImplementor: like the XWindowImp, PMWindowImpImplementor 介面的實體實作。

影響結果#

好處#

將介面與實作隔離開來，在Run-Time，實作不會被綁死，可動態設定、抽換，系統的高階部分只需要知道Abstraction和Implementor即可。易於擴充，Abstraction和Implementor均可個別擴充。隱藏內部實作細節。

壞處#

一種尺寸適合所有（one-size-fits-all）Abstraction 和 Implementor 的 interfaces。

實作#

只有一種Implementor#

如果實作體只會有一種，那抽象類別Implementor就不必存在（如：DBMgr），但如果希望類別內容不會影響Client，那對Bridge仍有幫助。

建立正確的Implementor物件#

若Abstraction能認得所有的ConcreteImplementor，便可在建構子依參數決定要實體化哪一個。若有大小容器，可以先預設用小的容器實作，超過臨界值再用大的容器實作。也可以將決定權妥託給其他物件，如Abstract Factory。

Example#

DrawAPI#

1
public abstract class Shape {
2
   protected DrawAPI drawAPI;
3

4
   protected Shape(DrawAPI drawAPI){
5
      this.drawAPI = drawAPI;
6
   }
7
   public abstract void draw();
8
}

1
public class Circle extends Shape {
2
   private int x, y, radius;
3

4
   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
5
      super(drawAPI);
6
      this.x = x;
7
      this.y = y;
8
      this.radius = radius;
9
   }
10

11
   public void draw() {
12
      drawAPI.drawCircle(radius,x,y);
13
   }
14
}

1
public interface DrawAPI {
2
   public void drawCircle(int radius, int x, int y);
3
}

1
public class RedCircle implements DrawAPI {
2
   @Override
3
   public void drawCircle(int radius, int x, int y) {
4
      System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", " + y + "]");
5
   }
6
}

1
public class GreenCircle implements DrawAPI {
2
   @Override
3
   public void drawCircle(int radius, int x, int y) {
4
      System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", " + y + "]");
5
   }
6
}

1
public class BridgePatternDemo {
2
   public static void main(String[] args) {
3
      Shape redCircle = new Circle(100,100, 10, new RedCircle());
4
      Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
5

6
      redCircle.draw();
7
      greenCircle.draw();
8
   }
9
}

1
Result:
2

3
Drawing Circle[ color: red, radius: 10, x: 100, 100]
4
Drawing Circle[  color: green, radius: 10, x: 100, 100]

Car Remote Controller#

1
//Class: Car
2

3
package car.remotecontrol;
4

5
public abstract class Car {
6

7
  private final Product product;
8
  private final String carType;
9

10
  public Car(Product product, String carType){
11
    this.product = product;
12
    this.carType = carType;
13
  }
14

15
  public abstract void assemble();
16
  public abstract void produceProduct();
17

18
  public void printDetails(){
19
    System.out.println("Car: "+carType+", Product:"+product.productName());
20
  }
21
}

顯示更多顯示更少

1
//Class: Motoren
2

3
package car.remotecontrol;
4

5
public class Motoren extends Car{
6

7
  private final Product product;
8
  private final String carType;
9

10
  public Motoren(Product product, String carType) {
11
    super(product, carType);
12
    this.product = product;
13
    this.carType = carType;
14
  }
15

16
  @Override
17
  public void assemble() {
18
    System.out.println("Assembling "+product.productName()+" for "+carType);
19
  }
20

21
  @Override
22
  public void produceProduct() {
23
    product.produce();
24
    System.out.println("Modifing product "+product.productName()+" according to "+carType);
25
  }
26

27
}

顯示更多顯示更少

1
//Class: BigWheel
2

3
package car.remotecontrol;
4

5
public class BigWheel extends Car{
6

7
  private final Product product;
8
  private final String carType;
9

10
  public BigWheel(Product product, String carType) {
11
    super(product, carType);
12
    this.product = product;
13
    this.carType = carType;
14
  }
15

16
  @Override
17
  public void assemble() {
18
    System.out.println("Assembling "+product.productName()+" for "+carType);
19
  }
20

21
  @Override
22
  public void produceProduct() {
23
    product.produce();
24
    System.out.println("Modifing product "+product.productName()+" according to "+carType);
25
  }
26

27
}

顯示更多顯示更少

1
//Interface: Product
2

3
package car.remotecontrol;
4

5
public interface Product {
6

7
  public String productName();
8
  public void produce();
9
}

1
//Class: GearLocking
2

3
package car.remotecontrol;
4

5
public class GearLocking implements Product{
6

7
  private final String productName;
8

9
  public GearLocking(String productName){
10
    this.productName = productName;
11
  }
12

13
  @Override
14
  public String productName() {
15
    return productName;
16
  }
17

18
  @Override
19
  public void produce() {
20
    System.out.println("Producing Gear Locking System");
21
  }
22

23
}

顯示更多顯示更少

1
//Class: CentralLocking
2

3
package car.remotecontrol;
4

5
public class CentralLocking implements Product{
6

7
  private final String productName;
8

9
  public CentralLocking(String productName){
10
    this.productName = productName;
11
  }
12

13
  @Override
14
  public String productName() {
15
    return productName;
16
  }
17

18
  @Override
19
  public void produce() {
20
    System.out.println("Producing Central Locking System");
21
  }
22

23
}

顯示更多顯示更少

1
//Class: TestBridgePattern
2

3
package car.remotecontrol;
4

5
public class TestBridgePattern {
6

7
  public static void main(String[] args) {
8
    Product product = new CentralLocking("Central Locking System");
9
    Product product2 = new GearLocking("Gear Locking System");
10
    Car car = new BigWheel(product , "BigWheel xz model");
11
    car.produceProduct();
12
    car.assemble();
13
    car.printDetails();
14

15
    System.out.println();
16

17
    car = new BigWheel(product2 , "BigWheel xz model");
18
    car.produceProduct();
19
    car.assemble();
20
    car.printDetails();
21

22
    System.out.println("-----------------------------------------------------");
23

24
    car = new Motoren(product, "Motoren lm model");
25
    car.produceProduct();
26
    car.assemble();
27
    car.printDetails();
28

29
    System.out.println();
30

31
    car = new Motoren(product2, "Motoren lm model");
32
    car.produceProduct();
33
    car.assemble();
34
    car.printDetails();
35

36
  }
37

38
}

顯示更多顯示更少

1
Result:
2

3
Producing Central Locking System
4
Modifing product Central Locking System according to BigWheel xz model
5
Assembling Central Locking System for BigWheel xz model
6
Car: BigWheel xz model, Product:Central Locking System
7

8
Producing Gear Locking System
9
Modifing product Gear Locking System according to BigWheel xz model
10
Assembling Gear Locking System for BigWheel xz model
11
Car: BigWheel xz model, Product:Gear Locking System
12
-----------------------------------------------------
13
Producing Central Locking System
14
Modifing product Central Locking System according to Motoren lm model
15
Assembling Central Locking System for Motoren lm model
16
Car: Motoren lm model, Product:Central Locking System
17

18
Producing Gear Locking System
19
Modifing product Gear Locking System according to Motoren lm model
20
Assembling Gear Locking System for Motoren lm model
21
Car: Motoren lm model, Product:Gear Locking System

顯示更多顯示更少

工廠方法模式 Factory Method Pattern

Wed, 30 Sep 2020 00:00:00 GMT

目的#

定義可生成物件的介面，但讓子類別決定該實體化哪種類別的物件。讓類別把實體化的程序推遲給子類別去實作。

適用#

當類別無法明指想要生成的物件類別時。當類別希望子類別去指定想要生成的物件類型時。將類別將權力下放一個或多個子類別，你又希望將「交付給哪些子類別」的知識集中在一個地方時。

結構及成員#

Collaborations: Creator的子類別必須定義Factory Method實體，以回傳適當的Concrete Product物件。

Product: like the Document定義Factory Method所造物件的介面。ConcreteProduct: like the MyDocument.具體實作出Product介面。AbstractProduct: like the ScrollBar, AbstractProductA宣告某成品物件類型之介面。Creator: like the Application宣告Factory Method，它會回傳Product類型的物件（ConcreteProduct）。ConcreteCreator: like the MyApplicationOverride Factory Method以傳回ConcreteProduct的物件個體。

影響結果#

好處#

替子類別預留掛鉤（Provides hooks for subclasses），以Factory Method的類別產生物件比直接產生物件更有彈性，只要Override他的方法，就能生成特殊的物件。連接平行地位的類別階層（Connects parallel class hierarchies）。一般來說，Factory Method只會被Creator引用，但不一定非得如此，也可以用在平行地位類別階層的關係。如下圖所示，Figure和Manipulator會平行地各自發展。每個Figure類別預留相對應的Factory Method CreateManipulator()，讓Client能建立與Figure相對應的Manipulator。Figure也可以將自己的CreateManipulator()寫成回傳一個預設的Manipulator物件實體。可以理解為：ConcreteCreator 跟 ConcreteProduct 會成對的增加。

平行地位類別階層通常會發生在「類別將某些權責委託給其他類別處理」的情況，如繪圖程式中，特定操弄圖形的動作，**如：伸長直線要移動某個端點；伸長圖形可以移動好幾個點；伸長文字方塊要調整行距……**因此，需要被Create的Manipulator [註：Manipulator地位同Product] 也會不一樣（以操作為例，在繪圖程式中，不同的繪圖物件要有不同的Manipulator物件處理不同的行為）。

但儘管如此，一個Factory（Figure）仍只能製造一種Product（Minupulator），因此如果要讓一個Factory可以製造多個Product，或多個同Style的Product，詳見 Abstract Factory Pattern。

壞處#

潛在的缺點，客戶碼必須自Creator類別衍生出子類別，才能造出特定的ConcreteProduct物件。

實作#

兩種主要形式#

Creator是Abstract Class，Factory Method只是空殼。Creator是Concrete Class，Factory Method有預設行為。

參數化Factory Method#

可傳入參數指明要產生什麼Product。

命名慣例#

好的命名慣例會讓Factory Method更一目瞭然。

Example: DBConnection Factory#

1
//Interface: DBConnection
2

3
package db.connection;
4

5
public interface DBConnection {
6
  void getConnection();
7

8
}

1
//Class: MySQLDBConnection
2

3
package db.connection;
4

5
public class MySQLDBConnection implements DBConnection {
6
  public void getConnection(){
7
    System.out.println("MySQL DB is connected");
8
  }
9

10
}

1
//Class: JavaDBConnection
2

3
package db.connection;
4

5
public class JavaDBConnection implements DBConnection{
6
  public void getConnection(){
7
    System.out.println("Java DB is connected");
8
  }
9

10
}

1
//Class: OracleDBConnection
2

3
package db.connection;
4

5
public class OracleDBConnection implements DBConnection{
6
  public void getConnection(){
7
    System.out.println("Oracle DB is connected");
8
  }
9

10
}

1
//Interface: DBConnectionFactory
2

3
package db.connection;
4

5
public interface DBConnectionFactory {
6
  DBConnection createConnection();
7

8
}

1
//Interface: MyDBConnectionFactory
2

3
package db.connection;
4

5
public class MyDBConnectionFactory implements DBConnectionFactory{
6
  private String type;
7
  public MyDBConnectionFactory(String type){
8
    this.type=type;
9
  }
10

11
  public DBConnection createConnection(){
12
    if (type.equalsIgnoreCase("Oracle")){
13
      return new OracleDBConnection();
14
    } else if (type.equalsIgnoreCase("MySQL")){
15
      return new MySQLDBConnection();
16
      } else if (type.equalsIgnoreCase("JavaDB")){
17
        return new JavaDBConnection();
18
      } else {
19
        //default product
20
        return new OracleDBConnection();
21

22
      }
23
    }
24
  }
25
}

顯示更多顯示更少

1
//Class: Main
2

3
package db.connection;
4

5
public class Main {
6

7
  public static void main(String[] args) {
8
    MyDBConnectionFactory factory = new MyDBConnectionFactory("JavaDB");
9
    factory.createConnection().getConnection();
10

11
    factory = new MyDBConnectionFactory("MySQL");
12
    factory.createConnection().getConnection();
13

14
    factory = new MyDBConnectionFactory("Oracle");
15
    factory.createConnection().getConnection();
16

17
  }
18

19
}

顯示更多顯示更少

1
Result:
2

3
Java DB is connected
4
MySQL DB is connected
5
Oracle DB is connected

抽象工廠模式 Abstract Factory Pattern

Wed, 30 Sep 2020 00:00:00 GMT

目的#

以同一個介面建立一整族相關的物件，不需點明各物件真正所屬的實體類別。

適用#

使用者無法預測要實例化的Class時。系統必須與最終Product的生成、組合、表達方式保持獨立。能讓各陣營的Product和系統互相搭配時使用，並且需要強制約束這件事。一整族相關物件由相同Factory生成，確保不會搭配錯誤。你把類別函式庫貢獻出來，但只想公開介面，不想公開實作細節。

結構及成員#

Collaborations: 在執行期，ConcreteFactory只有單獨一個，如果想生成其他陣營的，就要換另一種ConcreteFactory。AbstractFactory將製造Product的責任交付給子類別ConcreteFactory處理。

AbstractFactory: like the GUIFactory, WidgetFactory此Interface宣告出可生成各抽象成品物件的方法。ConcreteFactory: like the MotifFactory, PMWWidgetFactory.實作出可產生實體Product物件的方法。AbstractProduct: like the ScrollBar, AbstractProductA宣告某成品物件類型之介面。ConcreteProduct: like the MotifScrollBar, PMScrollBarConcreteFactory 所建構的成品物件。AbstractProduct 介面的實體實作。Client只觸及AbstractFactory和AbstractProduct兩抽象類別所訂之介面。

影響結果#

好處#

將實體類別隔離開來，Product類別都被ConcreteFactory藏了起來，Client無從得知。易於將整族成品物件抽換掉，因為AbstractFactory可生成一整族成品物件，所以只要換成其他Factory，就能一舉將成品物件組態整個換掉。增進成品物件的一致性。

壞處#

難以提供新的成品物件種類，讓AbstractFactory產生新的Product類型，不是容易的事，得修改AbstractFatory類別及所有子類別。

實作#

將Factory做成Singleton#

正常情況下，應用程式只需對一族（陣營）的Product配一個ConcreteFactory，因此最好做成Singleton Pattern。

產生成品物件#

AbstractFactory只含製造Product的介面而已，實作是由各ConcreteFactory子類別負責。常見做法是一種Product定義一種Method，然後ConcreteFactory可以Override各自的Method。如果會有好幾族成品物件同時並存，可以採用Prototype Pattern來製作ConcreteFactory。（先將各族系各成品弄一個Prototype物件給ConcreteFactory，以複製Prototype的方式製作新成品）

定義可延伸的Factory#

AbstractFactory通常會替每種可能產生的物件定義方法，若想增加新Product類型，就得修改有牽連的類別，因此可使用Make搭配參數來決定該建造哪種Product。

Example: Parser#

1
//Abstra: AbstractParserFactory
2

3
public interface AbstractParserFactory {
4

5
  public XMLParser getParserInstance(String parserType);
6
}

1
//Class: Interface XMLParser
2

3
public interface XMLParser {
4

5
  public String parse();
6

7
}

1
//Class: ParserFactoryProducer
2

3
public final class ParserFactoryProducer {
4

5
  private ParserFactoryProducer(){
6
    throw new AssertionError();
7
  }
8

9
  public static AbstractParserFactory getFactory(String factoryType){
10

11
    switch(factoryType)
12
    {
13
      case "NYFactory": return new NYParserFactory();
14
      case "TWFactory": return new TWParserFactory();
15
    }
16

17
    return null;
18
  }
19

20
}

顯示更多顯示更少

1
//Class: NYParserFactory
2

3
public class NYParserFactory implements AbstractParserFactory {
4

5
  @Override
6
  public XMLParser getParserInstance(String parserType) {
7

8
    switch(parserType){
9
      case "NYERROR": return new NYErrorXMLParser();
10
      case "NYFEEDBACK": return new NYFeedbackXMLParser();
11
      case "NYORDER": return new NYOrderXMLParser();
12
      case "NYRESPONSE": return new NYResponseXMLParser();
13
    }
14

15
    return null;
16
  }
17

18
}

顯示更多顯示更少

1
//Class: NYErrorXMLParser
2

3
public class NYErrorXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("NY Parsing error XML...");
8
    return "NY Error XML Message";
9
  }
10

11
}

1
//Class: NYFeedbackXMLParser
2

3
public class NYFeedbackXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("NY Parsing feedback XML...");
8
    return "NY Feedback XML Message";
9
  }
10

11
}

1
//Class: NYOrderXMLParser
2

3
public class NYOrderXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("NY Parsing order XML...");
8
    return "NY Order XML Message";
9
  }
10

11
}

1
//Class: NYResponseParser
2

3
public class NYResponseXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("NY Parsing response XML...");
8
    return "NY Response XML Message";
9
  }
10

11
}

1
//Class: TWParserFactory
2

3
public class TWParserFactory implements AbstractParserFactory {
4

5
  @Override
6
  public XMLParser getParserInstance(String parserType) {
7

8
    switch(parserType){
9
      case "TWERROR": return new TWErrorXMLParser();
10
      case "TWFEEDBACK": return new TWFeedbackXMLParser();
11
      case "TWORDER": return new TWOrderXMLParser();
12
      case "TWRESPONSE": return new TWResponseXMLParser();
13
    }
14

15
    return null;
16
  }
17

18
}

顯示更多顯示更少

1
//Class: TWErrorXMLParser
2

3
public class TWErrorXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("TW Parsing error XML...");
8
    return "TW Error XML Message";
9
  }
10

11
}

1
//Class: TWFeedbackXMLParser
2

3
public class TWFeedbackXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("TW Parsing feedback XML...");
8
    return "TW Feedback XML Message";
9
  }
10

11
}

1
//Class: TWOrderXMLParser
2

3
public class TWOrderXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("TW Parsing order XML...");
8
    return "TW Order XML Message";
9
  }
10

11
}

1
//Class: TWResponseXMLParser
2

3
public class TWResponseXMLParser implements XMLParser{
4

5
  @Override
6
  public String parse() {
7
    System.out.println("TW Parsing response XML...");
8
    return "TW Response XML Message";
9
  }
10

11
}

1
//Class: TestAbstractFactoryPattern
2

3
public class TestAbstractFactoryPattern {
4

5
  public static void main(String[] args) {
6

7
    AbstractParserFactory parserFactory = ParserFactoryProducer.getFactory("NYFactory");
8
    XMLParser parser = parserFactory.getParserInstance("NYORDER");
9
    String msg="";
10
    msg = parser.parse();
11
    System.out.println(msg);
12

13
    System.out.println("************************************");
14

15
    parserFactory = ParserFactoryProducer.getFactory("TWFactory");
16
    parser = parserFactory.getParserInstance("TWFEEDBACK");
17
    msg = parser.parse();
18
    System.out.println(msg);
19
  }
20

21
}

顯示更多顯示更少

1
Result:
2

3
NY Parsing order XML...
4
NY Order XML Message
5
************************************
6
TW Parsing feedback XML...
7
TW Feedback XML Message

裝飾者模式 Decorator Pattern

Tue, 29 Sep 2020 00:00:00 GMT

目的#

動態地將額外權責附加於物件上，不必衍生子類別（透明地）即可彈性地擴增物件功能。

適用#

想擴充功能，但子類別繼承方式是不切實際時（功能太多，繼承數量龐大）。在不影響其他物件的情況下，可以動態而透明的增加權責到個別物件上，也可以動態撤銷。

結構及成員#

Collaborations: Decorator會將訊息轉傳給Component處理，且在轉傳之前或之後可以做額外的事。（簡單說就是可以在原本Component要做的事，利用Decorator多做其他事）

Component: like the Glyph制定可以被Decorator動態增加權責的物件之介面。ConcreteComponent: like the Composition, Row, Column, Character, etc.定義可以被Decorator動態增加權責的物件。Decorator: like the MonoGlyph持有一個Component（須制訂符合Component的介面/Method）。ConcoreteDecorator: like the Border, Frame, Scrollbar將額外的權責新增到Component（ConcreteComponent）身上。

影響結果#

好處#

比靜態繼承機制更有彈性，可在運行時增加、刪除職責，避免子類過多。如果有使用同個Decorator兩次，或使用多個Decorator，可以Recursive nesting（遞回嵌套）。

壞處#

Decorator和Component並不一樣，雖然它是使用透明包覆，但外覆的Component已不是原先的Component物件。小型物件太多，不同之處只在互連的方式而不在所屬類別或變數內容。易客製化，不易學習和除錯。

實作#

遵循介面／介面一致性（conformance）#

Decorator物件的介面必須和Component一係，所以每一種ConcreteDecorator類別都要繼承同一種Decorator。

（輕量化）Decorator抽象類別#

如果只要增加一個權責，則Decorator的抽象就可不定義，直接將Decorator的訊息轉入ConcreteDecorator。

維持Component類別的輕巧#

Component只設介面，不存資料。讓ConcreteComponent處理複雜的資料。

變臉 vs. 換骨#

Decorator Pattern像是包在物件外面的一層皮，而 Strategy Pattern 像是改變物件的內臟。如果Component本身太過臃腫，可以改用Strategy Pattern，Strategy Pattern同樣可以連續串接Strategy Pattern。

Example: Beverage#

1
//Class: Beverage
2

3
public abstract class Beverage {
4
    String description = "Unknown Beverage"
5

6
    public String getDescription() {
7
        return description;
8
    }
9

10
    // 留給子類別實作
11
    public abstract double cost();
12
}

1
//Class: CondimentDecorator
2

3
public abstract class CondimentDecorator extends Beverage {
4

5
    // 因為希望配料也能顯示出來,
6
    // 因此所有子類別都要實作這個 method
7
    public abstract String getDescription();
8
}

1
//Class: Espresso
2

3
public class Espresso extends Beverage {
4

5
    public Espresso {
6
        // 這個變數是繼承自 Beverage 的
7
        description = "Espresso";
8
    }
9

10
    public double cost() {
11
        // 目前這邊只是單純 Espresso 的價格,
12
        // 不含任何配料
13
        return 1.99;
14
    }
15
}

顯示更多顯示更少

1
//Class: Mocha
2

3
// 摩卡是一個裝飾者, 因此讓它繼承自 CondimentDecorator
4
// 而且別忘了, CondimentDecorator 繼承自 Beverage 喔
5
public class Mocha extends CondimentDecorator {
6

7
    // 要讓摩卡能參考到 Beverage,
8
    // 因此需要這個成員變數
9
    Beverage mBeverage;
10

11
    public Mocha(Beverage beverage) {
12
        this.mBeverage = beverage;
13
    }
14

15
    // 以下兩個 method 的作法都是利用委派(delegation) 的方式,
16
    // 從被裝飾者拿到資訊後, 再加上裝飾者的資訊
17
    public String getDescription() {
18
        return mBeverage.getDescription() + ", Mocha";
19
    }
20

21
    public double cost() {
22
        return .20 + mBeverage.cost();
23
    }
24
}

顯示更多顯示更少

1
//Class: Milk
2

3
// 牛奶裝飾者基本上寫法跟摩卡裝飾者一樣
4
public class Milk extends CondimentDecorator {
5

6
    Beverage mBeverage;
7

8
    public Milk(Beverage beverage)
9
    {
10
        this.mBeverage = beverage;
11
    }
12

13
    public String getDescription()
14
    {
15
        return mBeverage.getDescription() + ", Milk";
16
    }
17

18
    public double cost()
19
    {
20
        return .30 + mBeverage.cost();
21
    }
22
}

顯示更多顯示更少

1
//Class: BevrageTest
2

3
public class BeverageTest {
4

5
    pubilc static void main(String[] args)
6
    {
7
        // 點了一杯 Espresso, 印出它的資訊
8
        Beverage beverage = new Espresso();
9
        System.out.println(beverage.getDescription() +
10
            " $" + beverage.cost());
11

12
        // 再點一杯 Espresso
13
        Beverage beverage2 = new Espresso();
14

15
        // 用摩卡裝飾 Espresso
16
        beverage2 = new Mocha(beverage2);
17

18
        // 用牛奶裝飾加了摩卡的 Espresso
19
        beverage2 = new Milk(beverage2);
20
        System.out.println(beverage2.getDescription() +
21
            " $" + beverage2.cost());
22
    }
23
}

顯示更多顯示更少

1
Result:
2

3
Espresso $1.99
4
Espresso, Mocha, Milk $2.49

策略模式 Strategy Pattern

Tue, 29 Sep 2020 00:00:00 GMT

目的#

定義一整族演算法，將每一個演算法封裝起來，可互換使用，更可在不影響外界的情況下個別抽換所引用的演算法。

適用#

當需要同一演算法的各種變形版本時，可以自由切換行為。演算法可以被封裝，讓外界不知道複雜的資料結構。可以用一個interface合併所有不同行為的封裝為同一類別。

結構及成員#

Collaborations: Strategy和Context協議出該採用的演算法版本。Context餵給Strategy會用到的資料（也可能把自己傳給Strategy）。Client通常會先建一個ConcreteStrategy餵給Context，之後Client就和Context打交道，Context會將Client傳來的訊息轉傳給Strateg****y。

Strategy: like the Compositor制訂所有演算法的共同介面。Context透過此介面呼叫ConcreteStrategy所實作的演算法。ConcreteStrategy: like the SimpleCompositor, TeXCompositor, etc.根據Strategy所訂的介面實作演算法。Context: like the Composition用ConcreteStrategy物件來設定組態。持有一個Strategy物件。可能會定義介面讓Strategy可以存取自己的資料。

影響結果#

好處#

Strategy定義一整族演算法讓Context使用，繼承機制可將各演算法的共同功能抽取出來。若直接對Context用繼承的方法實作不同的演算法依然可執行，但會難以理解、維護、擴充和動態改變。去除條件陳述句（Eliminate conditional statements），降低複雜度。針對同一行為提供多種實作供Client動態地選擇。

壞處#

Client需要對各個Strategy有認知。Strategy可能需要知道Context的資料結構，會破壞封裝（Breaking encapsulation）。簡單的ConcreteStrategy也許不會用到Context送他的初始化參數，但Strategy介面會與Context通訊，增加負擔。會增加應用程式的物件數量，若將Strategy做成non-state物件，就可供Context共用。而其他狀態資訊院由Context維護，必要時才傳參給Strategy的方法。詳Flyweight Pattern。

實作#

制訂Strategy和Context介面#

Strategy和Context介面必須提供有效率的存取介面，讓ConcreteStrategy和Context互相存取必要資訊。

做法一：Context主動傳遞資料給Strategy，降低耦合，但也可能送出Strategy不需要的資料。做法二：Context把自己當作傳參傳給Strategy，但耦合較高。

Strategy物件可有可無#

Context可在存取Strategy之前先檢查在不在，在就使用；不在就依預設做法進行，這樣Context就不必處理任何Strategy物件。

方便vs隨便#

因為可以很方便的轉換到另一個Strategy，所以要設有限制，才不會方便當隨便（如：人類walk變成fly）。

Example: Vehicle#

1
//Class: Vehicle
2

3
package vehicle.go;
4

5
public abstract class Vehicle {
6

7
  private GoAlgorithm algorithm;
8
  public void setGoAlgorithm(GoAlgorithm algorithm) {
9
    this.algorithm = algorithm;
10
  }
11

12
  public void go() {
13
    algorithm.go();
14
  }
15

16
}

顯示更多顯示更少

1
//Class: StreetRacer
2

3
package vehicle.go;
4

5
public class StreetRacer extends Vehicle {
6

7
  public StreetRacer() {
8
    setGoAlgorithm(new GoByDriving());
9
  }
10

11
}

1
//Class: FormulaOne
2

3
package vehicle.go;
4

5
public class FormulaOne extends Vehicle {
6

7
  public FormulaOne() {
8
    setGoAlgorithm(new GoByDriving());
9
  }
10

11
}

1
//Class: Helicopter
2

3
package vehicle.go;
4

5
public class Helicopter extends Vehicle {
6

7
  public Helicopter() {
8
    setGoAlgorithm(new GoByFlying());
9
  }
10

11
}

1
//Class: Jet
2

3
package vehicle.go;
4

5
public class Jet extends Vehicle {
6

7
  public Jet() {
8
    setGoAlgorithm(new GoByFlyingFast());
9
  }
10

11
}

1
//Class: GoAlgorithm
2

3
package vehicle.go;
4

5
public interface GoAlgorithm {
6

7
  public void go();
8

9
}

1
//Class: GoByDriving
2

3
package vehicle.go;
4

5
public class GoByDriving implements GoAlgorithm {
6

7
  public void go() {
8
    System.out.println("Now I'm driving.");
9
  }
10

11
}

1
//Class: GoByFlying
2

3
package vehicle.go;
4

5
public class GoByFlying implements GoAlgorithm {
6

7
  public void go() {
8
    System.out.println("Now I'm flying.");
9
  }
10

11
}

1
//Class: GoByFlyingFast
2

3
package vehicle.go;
4

5
public class GoByFlyingFast implements GoAlgorithm {
6

7
  public void go() {
8
    System.out.println("Now I'm flying fast.");
9
  }
10

11
}

1
//Class: Main
2

3
package vehicle.go;
4

5
public class Main {
6

7
  public static void main(String[] args) {
8
    StreetRacer streetRacer = new StreetRacer();
9
    FormulaOne formulaOne = new FormulaOne();
10
    Helicopter helicopter = new Helicopter();
11
    Jet jet = new Jet();
12

13
    streetRacer.go();
14
    formulaOne.go();
15
    helicopter.go();
16
    jet.go();
17

18
    Jet realJet = new Jet();
19
    realJet.setGoAlgorithm(new GoByDriving());
20
    realJet.go();
21
    realJet.setGoAlgorithm(new GoByFlyingFast());
22
    realJet.go();
23
    realJet.setGoAlgorithm(new GoByDriving());
24
    realJet.go();
25

26

27
  }
28

29
}

顯示更多顯示更少

1
Result:
2

3
Now I'm driving.
4
Now I'm driving.
5
Now I'm flying.
6
Now I'm flying fast.
7
Now I'm driving.
8
Now I'm flying fast.
9
Now I'm driving.

合成模式 Composite Pattern

Mon, 28 Sep 2020 00:00:00 GMT

目的#

讓外界以一致的方式處理個別物件和整體物件（多個遞迴組合的物件）。

適用#

物件必須是遞迴組合（部分-全體關係）個別物件和複合物件之間沒有差異或無需考慮其差異能以一致的方式處理複合結構裡的物件

結構及成員#

Collaborations: Client透過Component類別介面，與複合結構裡的Object互動。如果對象是個Leaf，就直接處理，如果是Composite，就會將訊息傳遞給子節點去處理，在傳遞之前或之後也可能會做些額外的事情。

Component: like the Glyph宣告複合體內含物件之介面。替所有類別所共有的操作實作出合適的預設行為。宣告存取及管理子節點的介面。（可有可無）宣告存取父節點的介面；如果適當，也一併實作之。Leaf: like the Character, Rectangle, etc.複合結構之終端物件（不會有子節點）。定義基本物件的行為。Composite: like the Row, Column定義含子結構的節點之行為。儲存子節點。實作出Componet之中與子結構有關的介面。

影響結果#

好處#

定義包含基本物件（primitive object）和複合物件（composite object）的類別階層。基本物件可拼出更複雜的物件，不斷遞迴。任何能夠處理基本物件的Client也都能處理複合物件。Client能以一致性的角度處理複合結構和個別物件，不用知道所面對的是Leaf還是Composite。容易增加新的Component類型。不必修改Client程式。

壞處#

可能會讓設計過於一般化。難以對Composite能包含的Component類型設限。可能會需要防止（prohibitive）物件數量過多。

實作#

設置父節點的Reference#

較易上溯結構、刪除節點，也利於製作Chain of Responsibility Pattern。

共用Component#

如果一個組件可以有好幾個父節點，將父節點記錄在子節點中。

極大化Component介面#

Component類別應盡可能涵蓋Composite和Leaf可能會有的操作。若遇到Leaf不會有的操作（如：存取子節點），可以將其改為不會傳回任何子節點（或是Exception）。

宣告管理子節點的操作（如：add()和remove()）#

安全性（Safety）和通透性（Transparency）的取捨：

若定義在Component：通透性較好，安全性較差。無法避免別人寫出「可增、刪Leaf子節點」的程式。若定義在Composite：安全性較好，但通透性較差。因為Leaf和Composite的介面不同。

做法差異、顧及安全性的改寫方法：

在此模式中，較強調通透性。因為如果型別資訊遺失**，就必須手動將Component轉型成Composite。**

該把「一群Component」的功能做進Component類別裡面嗎？（Component裡的Component物件存放的變數）#

如果在Component裡宣告子節點的Component的變數，則Leaf也會背負這些空間。唯有整個結構中只有少數幾個子節點時才值得這麼做。

子節點之間的相對順序#

若有必要維持子節點的相對順序，就須設計存取管理子節點的介面，可以使用Iterator Pattern。

以快取機制增進效率#

若常常需要巡訪或搜尋composite object，可以使用快取處理（如快取Picture所佔的長方形區域）。但需要連帶做「向父節點申報作廢快取資訊」的介面。

誰該負責刪除Component？#

若程式語言沒有垃圾回收機制（Garbage Collection），應讓Composite負責刪除動作。但共用的Leaf不能刪除。

儲存Component的最佳資料結構為何？#

Linked List、Tree、Array、Hash Table等等都行，但有時一個變數對一個子節點就夠用。

Example: Menu#

1
//Class: MenuComponent
2

3
package composite.menu;
4

5
import java.util.*;
6

7
public abstract class MenuComponent {
8

9
  public void add(MenuComponent menuComponent) {
10
    throw new UnsupportedOperationException();
11
  }
12
  public void remove(MenuComponent menuComponent) {
13
    throw new UnsupportedOperationException();
14
  }
15
  public MenuComponent getChild(int i) {
16
    throw new UnsupportedOperationException();
17
  }
18

19
  public String getName() {
20
    throw new UnsupportedOperationException();
21
  }
22
  public String getDescription() {
23
    throw new UnsupportedOperationException();
24
  }
25
  public double getPrice() {
26
    throw new UnsupportedOperationException();
27
  }
28
  public boolean isVegetarian() {
29
    throw new UnsupportedOperationException();
30
  }
31

32
  public void print() {
33
    throw new UnsupportedOperationException();
34
  }
35
}

顯示更多顯示更少

1
//Class: Menu
2

3
package composite.menu;
4

5
import java.util.Iterator;
6
import java.util.ArrayList;
7

8
public class Menu extends MenuComponent {
9
  ArrayList menuComponents = new ArrayList();
10
  String name;
11
  String description;
12

13
  public Menu(String name, String description) {
14
    this.name = name;
15
    this.description = description;
16
  }
17

18
  public void add(MenuComponent menuComponent) {
19
    menuComponents.add(menuComponent);
20
  }
21

22
  public void remove(MenuComponent menuComponent) {
23
    menuComponents.remove(menuComponent);
24
  }
25

26
  public MenuComponent getChild(int i) {
27
    return (MenuComponent)menuComponents.get(i);
28
  }
29

30
  public String getName() {
31
    return name;
32
  }
33

34
  public String getDescription() {
35
    return description;
36
  }
37

38
  public void print() {
39
    System.out.print("\n" + getName());
40
    System.out.println(", " + getDescription());
41
    System.out.println("---------------------");
42

43
    Iterator iterator = menuComponents.iterator();
44
    while (iterator.hasNext()) {
45
      MenuComponent menuComponent = (MenuComponent)iterator.next();
46
      menuComponent.print();
47
    }
48
  }
49
}

顯示更多顯示更少

1
//Class: MenuItem
2

3
package composite.menu;
4

5
import java.util.Iterator;
6
import java.util.ArrayList;
7

8
public class MenuItem extends MenuComponent {
9
  String name;
10
  String description;
11
  boolean vegetarian;
12
  double price;
13

14
  public MenuItem(String name,
15
                  String description,
16
                  boolean vegetarian,
17
                  double price)
18
  {
19
    this.name = name;
20
    this.description = description;
21
    this.vegetarian = vegetarian;
22
    this.price = price;
23
  }
24

25
  public String getName() {
26
    return name;
27
  }
28

29
  public String getDescription() {
30
    return description;
31
  }
32

33
  public double getPrice() {
34
    return price;
35
  }
36

37
  public boolean isVegetarian() {
38
    return vegetarian;
39
  }
40

41
  public void print() {
42
    System.out.print("  " + getName());
43
    if (isVegetarian()) {
44
      System.out.print("(v)");
45
    }
46
    System.out.println(", " + getPrice());
47
    System.out.println("     -- " + getDescription());
48
  }
49
}

顯示更多顯示更少

1
//Class: Waitress
2

3
package composite.menu;
4

5
import java.util.Iterator;
6

7
public class Waitress {
8
  MenuComponent allMenus;
9

10
  public Waitress(MenuComponent allMenus) {
11
    this.allMenus = allMenus;
12
  }
13

14
  public void printMenu() {
15
    allMenus.print();
16
  }
17
}

顯示更多顯示更少

1
//Class: MenuTestDrive
2

3
package composite.menu;
4

5
import java.util.*;
6

7
public class MenuTestDrive {
8
  public static void main(String args[]) {
9
    MenuComponent pancakeHouseMenu =
10
      new Menu("PANCAKE HOUSE MENU", "Breakfast");
11
    MenuComponent dinerMenu =
12
      new Menu("DINER MENU", "Lunch");
13
    MenuComponent cafeMenu =
14
      new Menu("CAFE MENU", "Dinner");
15
    MenuComponent dessertMenu =
16
      new Menu("DESSERT MENU", "Dessert of course!");
17
    MenuComponent coffeeMenu =
18
      new Menu("COFFEE MENU", "Stuff to go with your afternoon coffee");
19

20
    MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");
21

22
    allMenus.add(pancakeHouseMenu);
23
    allMenus.add(dinerMenu);
24
    allMenus.add(cafeMenu);
25

26
    pancakeHouseMenu.add(new MenuItem(
27
      "K&B's Pancake Breakfast",
28
      "Pancakes with scrambled eggs, and toast",
29
      true,
30
      2.99));
31
    pancakeHouseMenu.add(new MenuItem(
32
      "Regular Pancake Breakfast",
33
      "Pancakes with fried eggs, sausage",
34
      false,
35
      2.99));
36
    pancakeHouseMenu.add(new MenuItem(
37
      "Blueberry Pancakes",
38
      "Pancakes made with fresh blueberries, and blueberry syrup",
39
      true,
40
      3.49));
41
    pancakeHouseMenu.add(new MenuItem(
42
      "Waffles",
43
      "Waffles, with your choice of blueberries or strawberries",
44
      true,
45
      3.59));
46

47
    dinerMenu.add(new MenuItem(
48
      "Vegetarian BLT",
49
      "(Fakin') Bacon with lettuce & tomato on whole wheat",
50
      true,
51
      2.99));
52
    dinerMenu.add(new MenuItem(
53
      "BLT",
54
      "Bacon with lettuce & tomato on whole wheat",
55
      false,
56
      2.99));
57
    dinerMenu.add(new MenuItem(
58
      "Soup of the day",
59
      "A bowl of the soup of the day, with a side of potato salad",
60
      false,
61
      3.29));
62
    dinerMenu.add(new MenuItem(
63
      "Hotdog",
64
      "A hot dog, with saurkraut, relish, onions, topped with cheese",
65
      false,
66
      3.05));
67
    dinerMenu.add(new MenuItem(
68
      "Steamed Veggies and Brown Rice",
69
      "Steamed vegetables over brown rice",
70
      true,
71
      3.99));
72

73
    dinerMenu.add(new MenuItem(
74
      "Pasta",
75
      "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
76
      true,
77
      3.89));
78

79
    dinerMenu.add(dessertMenu);
80

81
    dessertMenu.add(new MenuItem(
82
      "Apple Pie",
83
      "Apple pie with a flakey crust, topped with vanilla icecream",
84
      true,
85
      1.59));
86

87
    dessertMenu.add(new MenuItem(
88
      "Cheesecake",
89
      "Creamy New York cheesecake, with a chocolate graham crust",
90
      true,
91
      1.99));
92
    dessertMenu.add(new MenuItem(
93
      "Sorbet",
94
      "A scoop of raspberry and a scoop of lime",
95
      true,
96
      1.89));
97

98
    cafeMenu.add(new MenuItem(
99
      "Veggie Burger and Air Fries",
100
      "Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
101
      true,
102
      3.99));
103
    cafeMenu.add(new MenuItem(
104
      "Soup of the day",
105
      "A cup of the soup of the day, with a side salad",
106
      false,
107
      3.69));
108
    cafeMenu.add(new MenuItem(
109
      "Burrito",
110
      "A large burrito, with whole pinto beans, salsa, guacamole",
111
      true,
112
      4.29));
113

114
    cafeMenu.add(coffeeMenu);
115

116
    coffeeMenu.add(new MenuItem(
117
      "Coffee Cake",
118
      "Crumbly cake topped with cinnamon and walnuts",
119
      true,
120
      1.59));
121
    coffeeMenu.add(new MenuItem(
122
      "Bagel",
123
      "Flavors include sesame, poppyseed, cinnamon raisin, pumpkin",
124
      false,
125
      0.69));
126
    coffeeMenu.add(new MenuItem(
127
      "Biscotti",
128
      "Three almond or hazelnut biscotti cookies",
129
      true,
130
      0.89));
131

132
    Waitress waitress = new Waitress(allMenus);
133

134
    waitress.printMenu();
135
  }
136
}

顯示更多顯示更少

1
Result:
2

3
ALL MENUS, All menus combined
4
---------------------
5

6
PANCAKE HOUSE MENU, Breakfast
7
---------------------
8
  K&B's Pancake Breakfast(v), 2.99
9
     -- Pancakes with scrambled eggs, and toast
10
  Regular Pancake Breakfast, 2.99
11
     -- Pancakes with fried eggs, sausage
12
  Blueberry Pancakes(v), 3.49
13
     -- Pancakes made with fresh blueberries, and blueberry syrup
14
  Waffles(v), 3.59
15
     -- Waffles, with your choice of blueberries or strawberries
16

17
DINER MENU, Lunch
18
---------------------
19
  Vegetarian BLT(v), 2.99
20
     -- (Fakin') Bacon with lettuce & tomato on whole wheat
21
  BLT, 2.99
22
     -- Bacon with lettuce & tomato on whole wheat
23
  Soup of the day, 3.29
24
     -- A bowl of the soup of the day, with a side of potato salad
25
  Hotdog, 3.05
26
     -- A hot dog, with saurkraut, relish, onions, topped with cheese
27
  Steamed Veggies and Brown Rice(v), 3.99
28
     -- Steamed vegetables over brown rice
29
  Pasta(v), 3.89
30
     -- Spaghetti with Marinara Sauce, and a slice of sourdough bread
31

32
DESSERT MENU, Dessert of course!
33
---------------------
34
  Apple Pie(v), 1.59
35
     -- Apple pie with a flakey crust, topped with vanilla icecream
36
  Cheesecake(v), 1.99
37
     -- Creamy New York cheesecake, with a chocolate graham crust
38
  Sorbet(v), 1.89
39
     -- A scoop of raspberry and a scoop of lime
40

41
CAFE MENU, Dinner
42
---------------------
43
  Veggie Burger and Air Fries(v), 3.99
44
     -- Veggie burger on a whole wheat bun, lettuce, tomato, and fries
45
  Soup of the day, 3.69
46
     -- A cup of the soup of the day, with a side salad
47
  Burrito(v), 4.29
48
     -- A large burrito, with whole pinto beans, salsa, guacamole
49

50
COFFEE MENU, Stuff to go with your afternoon coffee
51
---------------------
52
  Coffee Cake(v), 1.59
53
     -- Crumbly cake topped with cinnamon and walnuts
54
  Bagel, 0.69
55
     -- Flavors include sesame, poppyseed, cinnamon raisin, pumpkin
56
  Biscotti(v), 0.89
57
     -- Three almond or hazelnut biscotti cookies

顯示更多顯示更少

迪米特法則 Low of Demeter (LoD)

Wed, 03 Jun 2020 00:00:00 GMT

定義#

對於物件 Obj 的一個方法 fun() 而言， fun() 只能存取以下類型的物件：

自己或父類別的方法（to itself (Obj itself). You can play with yourself.）自己或父類屬性中的其他物件（to objects contained in attributes of itself or a superclass (Obj’s direct component objects). You can play with your own toys.）方法可以使用參數傳進來的物件（to an object that is passed as a parameter to the method (fun’s parameters). You can play with toys that were given to you.）使用自己所創造出來的物件（to an object that is created by the method (Any objects created/instantiated within fun). And you can play with toys you’ve made yourself.）全域變數中的物件（to an object that is stored in a global variable.）

範例#

1
/* Class A */
2
public class A {
3
  private int a1;
4
  C c;
5
  F f;
6
  G g = new G();
7

8
  public A(C c) {               // LoD 1
9
    this.c = c;
10
  }
11
  public void useSelf() {       // LoD 1
12
    go();
13
  }
14
  public void go() {            // 沒有符合任何LoD，因為僅print且無使用object。
15
    System.out.println("A go");
16
  }
17
  public void setA1(int a1) {   // LoD 1
18
    this.a1 = a1;
19
  }
20
  public int getA1() {          // 沒有符合任何LoD，因為僅回傳而已。
21
    return this.a1;
22
  }
23
  public void setC(C c) {       // LoD 1
24
    this.c = c;
25
  }
26
  public C getC() {             // 沒有符合任何LoD，因為僅回傳而已。
27
    return c;
28
  }
29
  private void useC() {         // LoD 2
30
    System.out.println(c);
31
    c.go();
32
  }
33
  public void useE(E e) {       // LoD 3
34
    e.go();
35
  }
36
  public void useD() {          // LoD 4
37
    D d = new D();
38
    d.go();
39
  }
40
  public void useF() {          // LoD 4
41
    f = new F();
42
    f.go()
43
  }
44
  public void useG() {          // LoD 4
45
    g.go();
46
  }
47
}
48

49
/* Class B */
50
public class B extends A {
51
  public B(C c) {
52
    super(c);
53
  }
54
  public void useSuperclassAttributeC() {  // LoD 2
55
    c.go();
56
  }
57
  public void useSuperclassAttributeG() {  // LoD 2
58
    g.go();
59
  }
60
}
61

62
/* Class C */
63
public class C {
64
  public void go() {
65
    System.out.println("C go");
66
  }
67
}
68

69
/* Class D */
70
public class D {
71
  public void go() {
72
    System.out.println("D go");
73
  }
74
}
75

76
/* Class E */
77
public class E {
78
  public void go() {
79
    System.out.println("E go");
80
  }
81
}
82

83
/* Class F */
84
public class F {
85
  public void go() {
86
    System.out.println("F go");
87
  }
88
}
89

90
/* Class G */
91
public class G {
92
  public void go() {
93
    System.out.println("G go");
94
  }
95
}

顯示更多顯示更少

Java建立物件的五個方法

Thu, 21 May 2020 00:00:00 GMT

1. 直接new一個物件#

1
MyObject object = new MyObject();

2. 取得class後newInstance()#

1
MyObject object = MyObject.class.newInstance();
2
MyObject object = (MyObject) Class.forName("package.MyObject").newInstance();
3
MyObject object = (MyObject) Class.forName("package.MyObject").getDeclaredConstructor().newInstance();

3. 取得Constructor後newInstance()#

1
Constructor constructor = MyObject.class.getConstructor();
2
MyObject object = constructor.newInstance();

4. 使用Clone#

1
MyObject anotherObject = new MyObject();
2
MyObject object = (MyObject) anotherObject.clone();

5. 使用input stream反序列化#

1
ObjectInputStream inStream = new ObjectInputStream(anInputStream);
2
MyObject object = (MyObject) inStream.readObject();

物件導向程式低耦合、高內聚 - 內聚編 (Cohesion)

Fri, 08 May 2020 00:00:00 GMT

1. 功能內聚力 (Functional Cohesion)#

一個模組只做一件事情，即具有唯一功能。

模組從事與問題相關的單一功能：是 Why so good：可以重用、便於維護、利於擴展

2. 順序內聚力 (Sequential Cohesion)#

模組內具有多個功能，且一功能的輸出立即成為下一功能的輸入（執行順序有相關性），且共用相同的資料。

模組從事與問題相關的單一功能：否 模組內各活動的關係：共用相同資料 資料是否有序：是

3. 溝通內聚力 (Communicational Cohesion)#

模組內具有多個功能，但它們的執行順序沒有相關性，且共用相同的資料。

模組從事與問題相關的單一功能：否 模組內各活動的關係：共用相同資料 資料是否有序：否 Why so bad：難以重用

4. 程序內聚力 (Procedural Cohesion)#

模組內具有多個功能，這些功能必須按照一定的順序來執行，但不共用資料。這些功能群集在一個模組內僅為了確保它們的執行順序。

模組從事與問題相關的單一功能：否 模組內各活動的關係：流程控制 流程是否有序：是 Why so bad：功能與模組間其他功能低相關卻與其他模組高相關、難以重用 How to fix：把要做的事abstract，如讓database等功能能直接處理read和update

5. 暫時內聚力 (Temporal Cohesion)#

模組內具有多個功能，但它們的執行順序沒有相關性，只必須在同一時間內執行完成。初始化(Initialize)系統、設定一組變數的初值。

模組從事與問題相關的單一功能：否 模組內各活動的關係：流程控制 流程是否有序：否 Why so bad：功能與模組間其他功能低相關卻與其他模組高相關、難以重用 How to fix：系統送initialization訊息，把初始化工作交給各個component自己做

6. 邏輯內聚力 (Logical Cohesion)#

模組內具有多個邏輯上相關聯的功能。模組的控制權操縱由上層模組所傳遞之參數來決定。如，input可以是tape，disk或network，但要用參數決定。

模組從事與問題相關的單一功能：否 模組內各活動的關係：無關 功能邏輯是否相關：是 Why so bad：難以理解、難以重用 How to fix：將邏輯上的功能用子類別去override

7. 偶發內聚力 (Coincidental Cohesion)#

一個模組內部需要執行多件工作，且每件工作都不相干

模組從事與問題相關的單一功能：否 模組內各活動的關係：無關 功能邏輯是否相關：否 Why so bad：難以維護、難以重用 How to fix：將各個功能獨立出來自成一模組，使其成為功能內聚力

參考文獻#

https://hackmd.io/@k139/r1y-9LmK4/%2Fs%2FH1x46U7KN?type=book#%E8%80%A6%E5%90%88%E5%8A%9Bhttps://www.slideshare.net/AdilAslam4/coupling-and-cohesion-in-software-engineeringhttps://courses.cs.washington.edu/courses/cse403/96sp/coupling-cohesion.html

物件導向程式低耦合、高內聚 - 耦合編 (Coupling)

Thu, 07 May 2020 00:00:00 GMT

1. 資料耦合 (Data Coupling)#

模組間以簡單資料型別作為參數時，參數過多（3個）就會發生。因為使用者必須傳遞所有參數到模組裡（即使是空資料也要傳null）。可以拆分成多個函數，或是建立一個專門傳遞簡單資料型別的Class來儲存資料。

2. 結構耦合 (Stamp Coupling)#

模組間以資料結構/物件型別作為參數。且對於資料結構/物件做的更改將影響到其他使用該資料結構/物件的模組弱化方式：　1. 使用interface作為參數類型。　2. 只傳遞資料結構/物件內要用到的簡單資料作為參數。

1
// 壞例 :
2
public void sendEmail(Employee e, String text) {
3
    EmailUtil.send(e.getName(), e.getEmail(), text);
4
}
5
// 優解 :
6
public void sendEmail(String name, String email, String text) {
7
    EmailUtil.send(name, email, text);
8
}

3. 控制耦合 (Control Coupling)#

依參數不同而使動作不同的相依關係，模組傳遞旗標去控制另一個模組內的內部邏輯。

1
// 壞例1 :
2
public void run(){
3
    takeAction(1);
4
}
5
public void takeAction(int key) {
6
    switch (key) {
7
        case 1:
8
            System.out.println("ONE RECEIVED");
9
            break;
10
        case 2:
11
            System.out.println("TWO RECEIVED");
12
            break;
13
    }
14
}
15
// 優解1-1 :
16
public void run(){
17
    Printable printable = new PrinterOne();
18
    takeAction(printable);
19
}
20
public void takeAction(Printable printable){
21
    printable.print();
22
}
23
public interface Printable{
24
    void print();
25
}
26
public class PrinterOne implements Printable{
27
    @Override
28
    public void print() {
29
        System.out.println("ONE RECEIVED");
30
    }
31
}
32
public class PrinterTwo implements Printable{
33
    @Override
34
    public void print() {
35
        System.out.println("TWO RECEIVED");
36
    }
37
}
38
// 優解1-2 :
39
public static void main(String ... args){
40
    new Printer().takeAction(1);
41
}
42
@CommandsMapFactory
43
public class Printer {
44
    private final CommandsMap map = CommandsMap.of(this);
45
    public void takeAction(int key){
46
        map.execute(key);
47
    }
48
    @Command(1)
49
    void printOne() {
50
        System.out.println("ONE RECEIVED");
51
    }
52
    @Command(2)
53
    void printTwo() {
54
        System.out.println("TWO RECEIVED");
55
    }
56
}
57
//--------------------
58
// 壞例2 :
59
void updateView(boolean isError) {
60
    if (isError) {
61
        resultView.setVisible(true);
62
        errorView.setVisible(false);
63
        iconView.setImage(CROSS_MARK_IMAGE);
64
    } else {
65
        resultView.setVisible(false);
66
        errorView.setVisible(true);
67
        iconView.setImage(CHECk_MARK_IMAGE);
68
    }
69
}
70
// 優解2 :
71
void updateView(boolean isError) {
72
    resultView.setVisible(isError);
73
    errorView.setVisible(!isError);
74
    iconView.setImage(getIconImage(isError));
75
}
76
Image getIconImage(boolean isError):  return (!isError) ? CHECk_MARK_IMAGE : CROSS_MARK_IMAGE

顯示更多顯示更少

4. 外部耦合 (External Coupling)#

當對外部庫或系統有依賴關係時，就會發生這種耦合。如：外部文件、裝置介面、通訊協定、資料格式

5. 共同耦合 (Common Coupling)#

全域狀態的相依關係，如全域變數，兩模組使用相同的資料區且都可讀寫資料區內之資料。可使用Singleton Pattern解決。參考：https://skyyen999.gitbooks.io/-study-design-pattern-in-java/content/singleton.html 但Singleton也是共同耦合的一種，因為他也是全域可存取的。參考：https://pttgame.com/gamedesign/M.1505060613.A.66F.html

6. 內容耦合 (Content Coupling)#

一模組使用另一個模組內之部分程式碼或改變其他模組內的局部變數，極端例子為使用GoTo語法跳至特定Procedure。即一個Class能直接修改另個Class的內部狀態，若不當修改狀態，則會另執行出錯或修改困難。

1
// 壞例1 :
2
public int sumValues(Calculator c){
3
    int result = c.getFirstNumber() + c.getSecondNumber();
4
    c.setResult(result);
5
    return c.getResult();
6
}
7
// 優解1 :
8
public int sumValues(Calculator c){
9
 //其他過程由Calculator內部執行
10
    c.sumAndUpdateResult();
11
    return c.getResult();
12
}
13
//--------------------
14
// 壞例2 :
15
public int callCalculator(Calculator c) {
16
    c.setParameter(42);
17
    c.prepare();
18
    c.calculate();
19
    c.tearDown();
20
    return c.getResult();
21
}
22
// 優解2 :
23
public int callCalculator(Calculator c) {
24
    //其他過程由Calculator內部執行
25
    c.setAndCalculateResult(42);
26
    return c.getResult();
27
}

顯示更多顯示更少

參考文獻#

https://hackmd.io/@k139/r1y-9LmK4/%2Fs%2FH1x46U7KN?type=book#%E8%80%A6%E5%90%88%E5%8A%9Bhttps://engineering.linecorp.com/zh-hant/blog/code-readability-vol4/https://www.slideshare.net/AdilAslam4/coupling-and-cohesion-in-software-engineeringhttps://www.linkedin.com/pulse/types-coupling-ahmed-adelhttps://www.educative.io/edpresso/what-are-the-different-types-of-couplinghttp://tedlike.blogspot.com/2016/01/message-couplin.html

OO的五大原則：SOLID

Wed, 08 Apr 2020 00:00:00 GMT

單一職責原則 (Single Responsibility Principle, SRP)#

一個類別只做一件事。讓一個類別只有一個職責，且該功能應由這個類完全封裝，兩件改變的事應分離成兩個類或兩個功能。正常情況下一個類別該做的事情，應該要能夠只用一句話描述出來。

舉例來說，我們的數據機功能如下，它的職責是連接管理(dial、handup)和資料通訊(send、recv)

1
interface Modem {
2
    void dial(String pNo);
3
    void handup();
4
    void send(char c);
5
    char recv();
6
}

一旦和連接相關的功能要修改，或通訊相關的功能要修改，都必須讓無關的另一個功能重新編譯和部署，因此因該把這兩個職責抽離出來：

1
interface Connection {
2
    void dial(String pNo);
3
    void handup();
4
}
5

6
interface DataTransmission {
7
    void send(char c);
8
    char recv();
9
}
10

11
class Modem implements Connection, DataTransmission {
12
    // ...
13
}

開閉原則 (Open-Close principle, OCP)#

OO的高層原則，Closed for Modification; Open for Extension（對修改關閉；對擴充開放），以Abstraction和Polymophism將靜態結構變成動態結構，維持設計的封閉性。不會牽一髮動全身，修改 A 的程式碼，B 也要跟著一起修改

假設原本有以下計算面積的程式碼：

1
import java.util.ArrayList;
2

3
class Square {
4
    private double width;
5
    Square(double width){
6
        this.width = width;
7
    }
8
    public double getWidth() { return width; }
9
}
10

11
class Circle {
12
    private double radius;
13
    Circle(double radius){
14
        this.radius = radius;
15
    }
16
    public double getRadius() { return radius; }
17
}
18

19
class Traingle {
20
    private double width;
21
    private double height;
22
    Traingle(double width, double height){
23
        this.width = width;
24
        this.height = height;
25
    }
26
    public double getWidth() { return width; }
27
    public double getHeight() { return height; }
28
}
29

30
public class AreaExample {
31

32
    public static void main(String[] args){
33
        ArrayList shapes = new ArrayList<>();
34
        shapes.add(new Square(10));
35
        shapes.add(new Circle(5));
36
        shapes.add(new Traingle(2,3));
37
        for(Object shape: shapes) {
38
            double area = 0;
39
            if(shape instanceof Square){
40
                area = Math.pow(((Square) shape).getWidth(), 2);
41
            } else if (shape instanceof Circle) {
42
                area = Math.pow(((Circle) shape).getRadius(), 2) * Math.PI;
43
            } else if (shape instanceof Traingle) {
44
                area = ((Traingle) shape).getWidth() * ((Traingle) shape).getHeight();
45
            }
46
            System.out.println("面積是：" + area);
47
        }
48
    }
49
}

顯示更多顯示更少

如果今天要再新增一種形狀，還要修改計算area的方法，不僅失去靈活性，還難以擴充新功能。

因此，可以將實作不同的地方進行抽象，達成如下程式碼：

1
import java.util.ArrayList;
2

3
interface Shape {
4
    double getArea();
5
}
6

7
class Square implements Shape{
8
    private double width;
9
    Square(double width){
10
        this.width = width;
11
    }
12
    public double getArea() { return width * width; }
13
}
14

15
class Circle implements Shape{
16
    private double radius;
17
    Circle(double radius){
18
        this.radius = radius;
19
    }
20
    public double getArea() { return radius * radius * Math.PI; }
21
}
22

23
class Traingle implements Shape{
24
    private double width;
25
    private double height;
26
    Traingle(double width, double height){
27
        this.width = width;
28
        this.height = height;
29
    }
30
    public double getArea() { return width * height; }
31
}
32

33
public class AreaExample {
34

35
    public static void main(String[] args){
36
        ArrayList shapes = new ArrayList<>();
37
        shapes.add(new Square(10));
38
        shapes.add(new Circle(5));
39
        shapes.add(new Traingle(2,3));
40
        for(Shape shape: shapes) {
41
            System.out.println("面積是：" + shape.getArea());
42
        }
43
    }
44
}

顯示更多顯示更少

如此一來，新增新的Shape只要去實作getArea()方法就好，並不用修改其他所有的類別！

里氏替換原則 (Liskov substitution principle, LSP)#

所有子類別都可以代理父類別的工作，也就是說必須確保子類別在override父類別的方法的時候，必須要能相容父類別的行為，遵照父類別設計開發，讓已經寫好的方法能夠被重用。

舉例來說，原本有計算正方形和矩形的程式：

1
class Rectangle{
2
    private int width;
3
    private int height;
4
    Rectangle(){}
5
    public void setWidth(int width){ this.width = width; }
6
    public void setHeight(int height){ this.height = height; }
7
    public int area(){
8
        return width * height;
9
    }
10
}
11

12
class Square extends Rectangle{
13
    Square(){}
14
    public void setWidth(int width){
15
        this.width = width;
16
        this.height= width;
17
    }
18
    public void setHeight(int height){
19
        this.width = height;
20
        this.height= height;
21
    }
22
}
23

24
public class ShapeLSP {
25
    public static void main(String[] args) {
26
        Rectangle rectangle = new Rectangle());
27
        rectangle.setWidth(5);
28
        rectangle.setHeight(10);
29
        Rectangle square = new Square();
30
        square.setWidth(5);
31
        square.setHeight(10);
32

33
        System.out.println(rectangle.area());
34
        System.out.println(square.area());
35
    }
36
}

顯示更多顯示更少

我們在語義上會說正方形是長方形的一種，但是正方形和長方形不同之處在於，正方形的長和寬是相等的。因此，我們計算的時候，雖然執行了一樣的行為（且這個行為是父類別定義好的），卻得到不同的結果（上述程式碼rectangle面積為50；square面積為100）。這就違反了LSP。

因此我們應該對它進行以下修改：

1
interface Shape{
2
    public int area();
3
}
4

5
class Square implements Shape{
6
    private int edge;
7
    Square(){}
8
    public void setEdge(){ this.edge = edge; }
9
    public int area(){
10
        return edge * edge;
11
    }
12
}
13

14
class Rectangle implements Shape{
15
    private int width;
16
    private int height;
17
    Rectangle(){}
18
    public void setWidth(int width){ this.width = width; }
19
    public void setHeight(int height){ this.height = height; }
20
    public int area(){
21
        return width * height;
22
    }
23
}
24

25
public class ShapeLSP {
26
    public static void main(String[] args) {
27
        Shape rectangle = new Rectangle());
28
        rectangle.setWidth(5);
29
        rectangle.setHeight(10);
30
        Shape square = new Square();
31
        square.setEdge(5);
32

33
        System.out.println(rectangle.area());
34
        System.out.println(square.area());
35
    }
36
}

顯示更多顯示更少

如此一來，我們期望的面積計算，就能因為不用的Shape而有所不同，而且不會因為override造成父、子類別的行為期望不一致！

介面隔離原則 (Interface segregation principle, ISP)#

一個interface相當於一種角色，而此角色由誰來演出，就相當於它的concrete class。因此一個interface應該當簡單的代表一個角色。也就是說，應該把interface依各個方法拆出來，不應強迫依賴於不使用的interface。

舉例來說，如果今天有個角色是超級英雄，而我們在超級英雄這個介面寫了各種超級英雄的行為：

1
interface SuperHero {
2
    void fightVillains();
3
    void growLarge();
4
    void shrink();
5
    void fly();
6
}

但是不是每個超級英雄都會用到所有的行為，這時候就很可能被迫依賴於這些行為而進行空實作，如：

1
class FlyingSuperHero implements SuperHero {
2
    void fightVillains() {
3
        System.out.println("打擊壞人！");
4
    }
5
    void growLarge(){}
6
    void shrink(){}
7
    void fly() {
8
        System.out.println("我是會飛的英雄");
9
    }
10
}

如果要改善這種情況，重新設計成符合ISP的介面，它應該會長這樣：

1
// 介面隔離
2
interface SuperHero {
3
    void fightVillains();
4
}
5
interface GrowingLargeSkill {
6
    void grwoLarge();
7
}
8
interface ShinkingSkill {
9
    void shrink();
10
}
11
interface FlyingSkill {
12
    void fly();
13
}
14

15
// 實作需要的部分
16
class FlyingSuperHero implements SuperHero, FlyingSkill {
17
    void fightVillains() {
18
        System.out.println("打擊壞人！");
19
    }
20
    void fly() {
21
        System.out.println("我是會飛的英雄");
22
    }
23
}

顯示更多顯示更少

符合ISP

而這個觀點可能看前面提到的SRP有點像，但是ISP和SRP最主要的差別是：

SRP：一個模組應該只承擔一個單一的責任。ISP：不應該被迫實作太多不需要的方法。

依賴反轉原則 (Dependency inversion principle, DIP)#

One should “depend upon abstractions, [not] concretions.”

DIP簡單說就是以下原則：

高階模組不應該依賴於低階模組，兩者都該依賴抽象。抽象不應該依賴於具體實作方式。具體實作方式則應該依賴抽象。能夠動態替換原本依賴的模組，降低耦合，做到隔離修改及單元測試。

高階依賴低階模組#

1
class Programmer {
2
    Computer computer = new Computer();
3

4
    void forFun(){
5
        computer.watchVideo();
6
    }
7
}
8

9
class Computer {
10
    void watchVideo() { System.out.println("播放影片"); }
11
    void playGame() { System.out.println("玩遊戲"); }
12
    void runProgram() { System.out.println("執行程式"); }
13
}

這時候，Programmer依賴於Computer，也就是說Programmer必須知道電腦有什麼方法可以用，才能做事情，一旦Computer變了，Programmer也必須跟著變！

但是現在電腦是Programmer自己創建的，假如電腦出了問題，那Programmer就不能做事情了，所以我們可以改寫這個方法，讓它變成依賴注入。

Dependency Injection 依賴注入#

1
class Programmer {
2
    Computer computer;
3
    Programmer(Computer computer) {
4
        this.computer = computer;
5
    }
6
    void setComputer(Computer computer) {
7
        this.computer = computer;
8
    }
9
    void forFun(){
10
        computer.watchVideo();
11
    }
12
}
13

14
class Computer {
15
    void watchVideo() { System.out.println("播放影片"); }
16
    void playGame() { System.out.println("玩遊戲"); }
17
    void runProgram() { System.out.println("執行程式"); }
18
}
19

20
public class Company {
21
    Computer computer;
22
    Programmer programmer;
23
    public Programmer getProgrammer(){
24
        computer = new Computer();
25
        programmer = new Programmer(computer);
26
        return programmer
27
    }
28
}
29

30
public class Client {
31
    public static void main(String[] args){
32
        Company company = new Company();
33
        Programmer programmer = company.getProgrammer();
34
    }
35
}

顯示更多顯示更少

這樣比起把電腦在Programmer裡面寫死，有更大的彈性，讓使用Programmer的人負責建立這些物件。

IoC 控制反轉#

把原本A對B控制權移交給第三方容器降低A對B物件的耦合性，讓雙方都倚賴第三方容器。這也是經典的好萊塢法則：「don’t call us, we’ll call you」

Programmer原本直接耦合於Computer，但使用IoC Container (Company)，Programmer就直接對Company，至於Programmer要用什麼Computer，由Company決定也就是說，原本Programmer直接控制於Computer，但透過一個IoC容器我們控制權反轉給了容器

依賴反轉#

現在Programmer還是直接依賴於Computer，但假設今天他要換用筆電做事情，那我們除了要新增一個Laptop類別之外，還要修改Programmer和相關的Class，這時候我們應該讓Programmer依賴於interface，而不是Concrete Class本身：

1
interface ElectronicDevice {
2
    void watchVideo();
3
    void playGame();
4
    void runProgram();
5
}
6

7
class Computer implements ElectronicDevice {
8
    void watchVideo() { System.out.println("我用電腦播放影片"); }
9
    void playGame() { System.out.println("我用電腦玩遊戲"); }
10
    void runProgram() { System.out.println("我用電腦執行程式"); }
11
}
12

13
class Laptop implements ElectronicDevice {
14
    void watchVideo() { System.out.println("我用筆電播放影片"); }
15
    void playGame() { System.out.println("我用筆電玩遊戲"); }
16
    void runProgram() { System.out.println("我用筆電執行程式"); }
17
}
18

19
class Programmer {
20
    ElectronicDevice device;
21
    Programmer(ElectronicDevice device) {
22
        this.device = device;
23
    }
24
    void setDevice(ElectronicDevice device) {
25
        this.device = device;
26
    }
27
    void forFun(){
28
        device.watchVideo();
29
    }
30
}
31

32
public class Company {
33
    ElectronicDevice device;
34
    Programmer programmer;
35
    public Programmer getProgrammer(){
36
        device = new Laptop();
37
        programmer = new Programmer(device);
38
        return programmer
39
    }
40
}
41

42
public class Client {
43
    public static void main(String[] args){
44
        Company company = new Company();
45
        Programmer programmer = company.getProgrammer();
46
    }
47
}

顯示更多顯示更少

這樣就算之後還要新增其他裝置，也不會影響到原本的Programmer類別了，完成依賴反轉！

Python Flask + uwsgi 部屬在 Ubuntu 的 Apache 上

Fri, 27 Mar 2020 00:00:00 GMT

1. 安裝Apache2#

執行以下操作之前，要先在Ubuntu上安裝Apache2網頁伺服器，還沒安裝的人可以先看之前寫過的LAMP安裝文章進行安裝

2. 安裝必要項目#

以 apt-get 安裝 python 必要項目（本文章發佈時最新版為python 3.8）

Terminal window

1
sudo apt-get install python3.8, python3-pip, python3.8-dev, build-essential

以 sudo su 安裝 uwsgi

Terminal window

1
sudo su
2
pip3 install uwsgi

安裝apache2-mod-proxy-uwsgi

Terminal window

1
sudo apt-get install libapache2-mod-proxy-uwsgi

啟用proxy_uwsgi模組

Terminal window

1
sudo a2enmod proxy_uwsgi
2
sudo service apache2 restart

3. 更改flask的執行參數#

建立一個uwsgi.ini檔，並放在能夠存取的目錄（建議放在flask程式目錄的uwsgi目錄下，如：/var/www/<project_name/uwsgi/uwsgi.ini），內容如下：（※：port的5000是對內開放的，到時候會用Apache的Proxy到uWSGI開放對放的port）

1
[uwsgi]
2
;app代表flask主程式為程式專案目錄下的app.py
3
module = app:app
4
;設定一個埠號對內開放的埠號（例：5000）
5
http-socket = :5000
6
;程式進程數量
7
processes = 3
8
;Project根目錄
9
chdir = /var/www/
10
;sock檔之權限
11
chmod-socket = 666
12
;log檔之權限
13
logfile-chmod = 664
14
;系統服務之前綴，例如：「myFlask」
15
procname-prefix-spaced = myFlask
16
;python程式更新時是否自動重載
17
py-autoreload = 1
18
;是否自動清理status, pid 及 socket檔
19
vacuum = true
20
;使用apache或nginx代理需用到
21
socket = %(chdir)/uwsgi/uwsgi.sock
22
;查看uwsgi狀態
23
status = %(chdir)/uwsgi/uwsgi.status
24
;查看uwsgi之PID（關閉、重啟需要）
25
pidfile = %(chdir)/uwsgi/uwsgi.pid
26
;後台啟動，並將訊息寫入log
27
daemonize = %(chdir)/uwsgi/uwsgi.log

顯示更多顯示更少

例用uwsgi啟動flask相關指令如下

Terminal window

1
sudo uwsgi --ini /var/www//uwsgi/uwsgi.ini                 //啟動
2
sudo tail -f /var/www//uwsgi/uwsgi.log                     //查看log
3
sudo uwsgi --stop /var/www//uwsgi/uwsgi.pid                //關閉
4
sudo uwsgi --reload /var/www//uwsgi/uwsgi.pid              //重啟

若啟動時，查看log發現port被佔用，那可能是因為前次執行的時候uwsgi沒有被正常關閉。

可以用以下指令查詢佔用的PID

Terminal window

1
sudo netstat -tulpn      //(方法一) 查詢所有port
2
ps aux | grep myFlask    //(方法二) 查詢特定PID（myFlask為uwsgi.ini設定之前綴）

然後執行以下指令關閉程式

Terminal window

1
sudo kill -9

4. 配置Apache2 的 VHost#

編輯「/etc/apache2/sites-available/000-default.conf」

1
    ServerName :6000
2
    ServerAlias
3
    # 代理設定
4
    ProxyPass / unix:/var/www//uwsgi/uwsgi.sock|uwsgi://127.0.0.1:5000/

編輯「/etc/apache2/ports.conf」打開apache監聽port

1
    Listen 6000
2

3

4
    Listen 6000

打開防火牆

Terminal window

1
ufw allow 6000
2
sudo ufw reload

此時前往 your.domain.name:6000 應該就能成功了！

在 Ubuntu 20.04 LTS 上安裝 Apache、MariaDB及php

Tue, 24 Mar 2020 00:00:00 GMT

更新 Ubuntu Server#

Terminal window

1
sudo apt update && sudo apt upgrade && sudo apt dist-upgrade

改時區 Asia/Taipei （依需求執行）#

Terminal window

1
sudo timedatectl set-timezone Asia/Taipei

改語言 zh_TW （依需求執行）#

下載語言包

Terminal window

1
sudo apt-get install language-pack-zh-hant language-pack-zh-hant-base manpages

將 /etc/default/locale 打開，將檔案內容改為以下內容

1
LANG="zh_TW.UTF-8"

最後，執行以下指令進行套用，或重開機自動套用

Terminal window

1
. /etc/default/locale

安裝LAMP#

1. Apache 網頁伺服器#

安裝

Terminal window

1
sudo apt install -y apache2 apache2-utils

檢查安裝結果

Terminal window

1
systemctl status apache2

以下為其他常用指令

Terminal window

1
sudo systemctl start apache2    #將apache2啟用為系統服務
2
sudo systemctl enable apache2   #將apache2自系統服務關閉
3
apache2 -v                      #檢查apache2版本

開啟防火牆的 80 port

Terminal window

1
sudo iptables -I INPUT -p tcp --dport 80 -j ACCEPT
2
sudo ufw allow http

將Web根目錄的擁有者設為「www-data」

Terminal window

1
sudo chown -R www-data:www-data /var/www/html/

檢查設定檔是否有誤

Terminal window

1
sudo apache2ctl -t

若執行上述程式碼時遇到錯誤「AH00558: apache2: …」錯誤時，編輯「/etc/apache2/conf-available/servername.conf」並加入一行「ServerName localhost」之後執行以下指令

Terminal window

1
sudo a2enconf servername.conf
2
sudo systemctl reload apache2

2. MariaDB 資料庫#

安裝 software-properties-common 並下載金鑰

Terminal window

1
sudo apt-get install software-properties-common
2
sudo apt-key adv --fetch-keys 'https://mariadb.org/mariadb_release_signing_key.asc'

指定版本安裝（此文章發布時最新版為 mariadb 10.5版）

Terminal window

1
sudo add-apt-repository 'deb [arch=amd64] http://mariadb.mirror.globo.tech/repo/10.5/ubuntu focal main'
2
sudo apt-get update
3
sudo apt-get install mariadb-server mariadb-client

檢查安裝結果

Terminal window

1
systemctl status mariadb

以下為其他常用指令

Terminal window

1
sudo systemctl start mariadb    #將mariadb啟用為系統服務
2
sudo systemctl enable mariadb   #將mariadb自系統服務關閉
3
mariadb --version               #檢查mariadb版本

以root帳號（有密碼）登入資料庫指令

Terminal window

1
mysql -u root -p

3. php 7.4#

安裝php及常用的相關模組

Terminal window

1
sudo apt install php7.4 libapache2-mod-php7.4 php7.4-mysql php-common php7.4-cli php7.4-common php7.4-json php7.4-opcache php7.4-readline

啟用php模組並重啟apache2

Terminal window

1
sudo a2enmod php7.4
2
sudo systemctl restart apache2

檢查php版本

Terminal window

1
php --version

安裝phpMyAdmin#

執行指令，並依照畫面提示安裝

Terminal window

1
sudo apt install phpmyadmin

設定資料庫root密碼#

1. 安裝 mysql_secure 設定#

執行指令，並依照畫面提示設定

Terminal window

1
sudo mysql_secure_installation

2. 進入資料庫手動設定#

Terminal window

1
sudo mysql -u root mysql

1
#mysql(mariadb)指令頁
2
UPDATE user SET plugin='mysql_native_password' WHERE User='root';
3
FLUSH PRIVILEGES;
4
exit;

1
#查看密碼設定
2
select User,Host,Password,Plugin from mysql.user;
3
#變更密碼Plugin
4
ALTER USER root@localhost IDENTIFIED VIA mysql_native_password;
5
#變更密碼
6
ALTER USER root@localhost IDENTIFIED VIA mysql_native_password USING PASSWORD("password");

【後記】安裝 mariaDB後無法正常運作之排除#

發生mariadb常常自己關掉開了mariadb沒多久就關掉下了service mariadb start指令後直接timeout

1. 安裝AppArmor管理工具#

安裝 AppArmor 並查詢 /usr/sbin/mysqld

Terminal window

1
sudo apt-get install apparmor-utils
2
sudo aa-status

2. 移掉/usr/sbin/mysqld#

方法一

Terminal window

1
sudo ln -s /etc/apparmor.d/usr.sbin.mysqld /etc/apparmor.d/disable/
2
sudo reboot

方法二

Terminal window

1
sudo aa-remove-unknown
2
sudo reboot

3. 故障排除參考來源#

http://n.sfs.tw/content/index/10657https://stackoverflow.com/questions/40997257/mysql-service-fails-to-start-hangs-up-timeout-ubuntu-mariadb

摘要：

Terminal window

1
sudo aa-complain /usr/sbin/mysqld

1
Setting /usr/sbin/mysqld to complain mode.
2
ERROR: /etc/apparmor.d/usr.sbin.mysqld contains no profile

add the lines to /etc/apparmor.d/usr.sbin.mysqld, and then I could set it to complain mode successfully.

1
/usr/sbin/mysqld {
2
}

可SSH登入，但無法透過瀏覽器SSH連線到GOOGLE Compute Engine Instance的解決方案

Sat, 21 Mar 2020 00:00:00 GMT

檢查服務運作狀態#

Terminal window

1
sudo systemctl list-unit-files | grep google | grep enabled

顯示如下：

1
google-accounts-daemon.service             enabled
2
google-clock-skew-daemon.service           enabled
3
google-instance-setup.service              enabled
4
google-network-daemon.service              enabled
5
google-shutdown-scripts.service            enabled
6
google-startup-scripts.service             enabled

啟動列表中沒啟動的項目#

Terminal window

1
sudo systemctl enable {SERVICE_NAME}
2
sudo systemctl start {SERVICE_NAME}

檢查network daemon和accounts daemon是否有在運行#

Terminal window

1
sudo ps aux | grep google

將 Ubuntu 18.04 的 python 換至 python 3.7

Thu, 19 Mar 2020 00:00:00 GMT

替換Python版本至3.7#

Terminal window

1
sudo apt update -y
2
sudo apt install python3.7

將Python 3.6和Python 3.7添加到更新替代選項#

Terminal window

1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.6 1
2
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 2

更新Python 3以指向Python 3.7#

Terminal window

1
sudo update-alternatives --config python3

備用更新Python 3指向Python3.7#

Terminal window

1
sudo rm /usr/bin/python3
2
sudo ln -s python3.7 /usr/bin/python3

測試python3的版本#

Terminal window

1
python3 -V

錯誤排除#

若後續使用python3時出現若「ModuleNotFoundError: No module named ‘apt_pkg’」，則執行以下指令，複製python3.6的套件給python3.7

※其他套件同理，複製一份並將路徑當中之「36m」改為「37m」

Terminal window

1
 cd /usr/lib/python3/dist-packages/
2
 sudo cp apt_pkg.cpython-36m-x86_64-linux-gnu.so apt_pkg.cpython-37m-x86_64-linux-gnu.so

讓image最大化適應canvas的寬高

Sat, 01 Feb 2020 00:00:00 GMT

取得canvas

1
var canvas = ctx.canvas;

設定比例並繪圖

1
var wRatio = canvas.width / img.width;                //寬度比
2
var hRatio = canvas.height / img.height;              //高度比
3
var ratio = Math.min(wRatio, hRatio);                 //min者，依寬高比小者為主，寬高比大者留白； max者，依寬高比大者為主，寬高比小者裁切
4
var shiftX = (canvas.width - img.width * ratio) / 2;  //若此值不為0，表示有留白或虛裁切，左右區域應同寬
5
var shiftY = (canvas.height - img.height * ratio) / 2;//若此值不為0，表示有留白或虛裁切，上下區域應同高

設定至canvas上

1
ctx.clearRect(0, 0, canvas.width, canvas.height);
2
ctx.drawImage(img, 0,0, img.width, img.height, shiftX, shiftY,img.widthratio, img.heightratio);

[C/C++] AVL樹，插入及刪除

Tue, 26 Nov 2019 00:00:00 GMT

【輸入】#

可以對AVL樹進行插入或刪除數字

【輸出】#

依前序追蹤輸出AVL樹

【完整程式碼】#

1
#include
2
#include
3
#include
4

5
using namespace std;
6

7
class Node{
8
    private:
9
        int data;
10
        int height;
11
        Node *left, *right;
12
    public:
13
        Node(int val){ data = val; left = right = NULL; height = 1;}
14
        friend class AVLTree;
15
};
16

17
class AVLTree{
18
    private:
19
        int height(Node* node){
20
            return (!node)? 0: node->height;
21
        }
22
        int getBF(Node* node){
23
            return (!node)? 0: height(node->left) - height(node->right);
24
        }
25
        //旋轉方法
26
        Node* rotate(Node* old_rootT, char direct) {
27
            //重新定義此子樹的rootT節點
28
            Node *new_rootT = (direct=='L')? old_rootT->right: old_rootT->left;  //若左轉，新的rootT會是舊rootT->R，若右轉，新的rootT會是舊rootT->L
29
            Node *temp = (direct=='L')? new_rootT->left: new_rootT->right;       //若左轉，暫存子樹會是舊rootT->R->L（即新的rootT>L），若右轉，暫存子樹會是舊rootT->L->R（即新的rootT>R）
30

31
            //旋轉
32
            if(direct=='L'){                           //若左轉
33
                new_rootT->left = old_rootT;               //舊rooT會變成新的rootT->L
34
                old_rootT->right = temp;                   //舊rootT->R會是暫存子樹temp（即舊rootT->R->L, 亦即新的rootT->L)
35
            }else{                                     //若右轉
36
                new_rootT->right = old_rootT;              //舊rooT會變成新的rootT->R
37
                old_rootT->left = temp;                    //舊rootT->L會是暫存子樹temp（即舊rootT->L->R, 亦即新的rootT->R)
38
            }
39

40
            //更新有改變到的高度（從底至上），所以先update舊rootT
41
            old_rootT->height = max(height(old_rootT->left), height(old_rootT->right)) + 1;
42
            new_rootT->height = max(height(new_rootT->left), height(new_rootT->right)) + 1;
43

44
            return new_rootT;
45
        }
46

47
        //插入遞迴式
48
        Node* insertRecursive(Node* rootT, int val){
49
            //使用一般的BST樹插入方法插入數字
50
            if(!rootT) return (new Node(val));                                              //若目前節點 (或作 目前子樹的根) 為空，即樹葉節點插入新節點至樹葉 (回傳給上一層，此例中上一層也等同rootT，因為是用 rootT = insert(rootT, val)呼叫 )
51
            else if(val data) rootT->left = insertRecursive(rootT->left, val);     //若 數字 左子 = insert(rootT->左子) 會 return 一個插入完數字 的子樹 的rootT 給 rootT->左子)
52
            else if(val > rootT->data) rootT->right = insertRecursive(rootT->right, val);   //若 數字 > 目前節點，則插入右子樹
53
            else return rootT;                                                              //二元樹原則上非key-value數對型態者，不會有重複值
54
                                                                                            //把rootT 回傳給rootT (即：把自己丟回給自己，不作修改)
55

56
            rootT->height = max(height(rootT->left), height(rootT->right)) + 1;             //插入後，更新目前這個節點的樹高 (取左右子樹高之大者 + 1(自己))
57
            int bf = getBF(rootT);                                                          //取得平衡因子
58

59
            //process if abs(bf)>1
60
            if(bf > 1 && val left->data){       //(平衡因子>1) => 左子樹高，前面必插左邊;   (插入數  前面必插左子樹的左邊 {LL}
61
                return rotate(rootT, 'R');                      //自己 (目前子樹) 右轉，然後把rootT 回傳給上一層 (同前面提到，此例中上一層也等同rootT，即原本呼叫這個函數的人rootT = insert(rootT, val) )
62
            }
63
            if(bf > 1 && val > rootT->left->data){       //(平衡因子>1) => 左子樹高，前面必插左邊;   (插入數 > 左子樹值) => 前面必插左子樹的右邊 {LR}
64
                rootT->left = rotate(rootT->left, 'L');         //自己的左邊 (目前子樹的左子樹) 先左轉
65
                return rotate(rootT, 'R');                      //自己 (目前子樹) 再右轉
66
            }
67
            if(bf  rootT->right->data){     //(平衡因子 右子樹高，前面必插右邊;   (插入數 > 右子樹值) => 前面必插右子樹的右邊 {RR}
68
                return rotate(rootT, 'L');                      //自己 (目前子樹) 左轉
69
            }
70
            if(bf right->data){     //(平衡因子 右子樹高，前面必插右邊;   (插入數  前面必插右子樹的左邊 {RL}
71
                rootT->right = rotate(rootT->right, 'R');       //自己的右邊 (目前子樹的左子樹) 先右轉
72
                return rotate(rootT, 'L');                      //自己 (目前子樹) 再左轉
73
            }
74

75
            return rootT;
76
        }
77
        //找子樹中最小的樹 (從根開始往左走直到不能走)
78
        Node* minValue(Node* rootT){
79
            Node* ptr = rootT;
80
            while(ptr->left)
81
                ptr = ptr->left;
82
            return ptr;
83
        }
84
        //自AVL樹中刪除
85
        Node* removeRecursive(Node* rootT, int val){
86
            //使用一般的BST樹插入方法刪除數字
87
            if(!rootT) return NULL;                                                           //若為空值，那不用刪除，直接回傳給剛剛叫他的人(亦作 return rootT;) (rootT==NULL 即剛剛叫他的人傳入的子樹為空)
88
            else if(val data) rootT->left = removeRecursive(rootT->left, val);       //若 數字  rootT->data) rootT->right = removeRecursive(rootT->right, val);     //若 數字 > 目前節點，要刪除的數字在目前子樹的右子樹
89
            else{                                                                             //上面都不成立，即找到相等的數，進入刪除階段
90
                if(!rootT->left || !rootT->right){                                                  //若目前節點的子樹數量為 0(無子樹) 或 只有單邊子樹
91
                    Node* childT = (rootT->left)? rootT->left: rootT->right;                                //暫存左或右子樹
92
                    delete rootT;                                                                           //釋放目前子樹樹根記憶體
93
                    rootT = childT;                                                                         //令左或右子樹樹根為樹根 (左或右樹直接上拉)
94
                }else{                                                                              //若目前節點 左、右子樹皆有
95
                    Node* minT = minValue(rootT->right);                                                    //取得 右子樹最小的節點
96
                    rootT->data = minT->data;                                                               //設目前子樹樹根的數字 為剛剛找到的節點的數字
97
                    rootT->right = removeRecursive(rootT->right, minT->data);                               //刪除剛剛找到的節點 (註：因為右子樹最小的節點必無左子樹，故遞迴結果必為第1或第2個if)
98
                }
99
            }
100

101
            if(!rootT) return rootT;                                                          //若目前子樹樹根為空，必平衡且樹高為0，直接回傳
102

103
            rootT->height = max(height(rootT->left), height(rootT->right)) + 1;               //更新目前這個節點的樹高
104
            int bf = getBF(rootT);                                                            //取得平衡因子
105

106
            //process if abs(bf)>1
107
            if(bf > 1 && getBF(rootT->left) >= 0){          //(平衡因子>1) => 左子樹高，前面必刪右邊;   (左子節點平衡因子>=0的話) => 右轉後必變為-1或0，故不用先轉; {LL}
108
                return rotate(rootT, 'R');                          //自己 (目前子樹) 右轉
109
            }
110
            if(bf > 1 && getBF(rootT->left) 1) => 左子樹高，前面必刪右邊;   (左子節點平衡因子 右轉後必變為-2，故要先轉; {LR}
111
                rootT->left = rotate(rootT->left, 'L');             //自己的左邊 (目前子樹的左子樹) 先左轉
112
                return rotate(rootT, 'R');                          //自己 (目前子樹) 再右轉
113
            }
114
            if(bf right)  右子樹高，前面必刪左邊;  (右子節點平衡因子 左轉後必變為1或0，故不用先轉; {RR}
115
                return rotate(rootT, 'L');                          //自己 (目前子樹) 左轉
116
            }
117
            if(bf right) > 0){         //(平衡因子 右子樹高，前面必刪左邊;  (右子節點平衡因子>0的話) => 左轉後必變為2，故要先轉; {RL}
118
                rootT->right = rotate(rootT->right, 'R');           //自己的右邊 (目前子樹的右子樹) 先右轉
119
                return rotate(rootT, 'L');                          //自己 (目前子樹) 再左轉
120
            }
121

122
            return rootT;
123
        }
124
    public:
125
        Node *root;
126

127
        AVLTree(){ root = NULL; }
128

129
        void insert(int val) {
130
            root = insertRecursive(root, val);
131
        }
132

133
        void remove(int val) {
134
            root = removeRecursive(root, val);
135
        }
136
        //前序印出AVL樹
137
        void preOrder(Node* root) {
138
            if(root) {
139
                cout data left? (cout left->data right? (cout right->data left);
140
                preOrder(root->right);
141
            }
142
        }
143
};
144

145
int main(void){
146
    AVLTree AVLTree;
147
    int val;
148
    char SENT;
149

150
    //對AVL樹的操作
151
    cout    " > SENT;
152
    while(SENT != 'q'){
153
        switch(SENT) {
154
            case '1':
155
                cout > val;
156
                AVLTree.insert(val);
157
                break;
158
            case '2':
159
                cout > val;
160
                AVLTree.remove(val);
161
                break;
162
            case '3':
163
                cout    " > SENT;
164
    }
165

166
    system("pause");
167
    return 0;
168
}

顯示更多顯示更少

[C/C++] BST樹，插入及刪除（使用指標）

Wed, 20 Nov 2019 00:00:00 GMT

【輸入】#

可以對BST樹進行插入或刪除數字

【輸出】#

依前序追蹤輸出BST樹

【完整程式碼】#

1
#include
2
#include
3

4
typedef struct Node{
5
    int data;
6
    struct Node *left, *right;
7
} Node;
8

9
Node* BSTroot = NULL;
10

11
//建新節
12
Node* newNode(int val)  {
13
    Node* node = (Node*)malloc(sizeof(Node));
14
    node->data = val;
15
    node->right = node->left = NULL;
16

17
    return node;
18
}
19

20
//前序印出BST樹
21
void preOrder(Node* root) {
22
    if(root) {
23
        printf("%d ", root->data);
24
        preOrder(root->left);
25
        preOrder(root->right);
26
    }
27
}
28

29
//插入BST樹（用while迴圈配合指標做）
30
void insert(int val){
31
    Node **ptr = &BSTroot;                  //依址找值
32
    while(*ptr != NULL){                    //找要插入的樹葉的位址
33
        if(val data)
34
            ptr = &(*ptr)->left;
35
        else if(val > (*ptr)->data)
36
            ptr = &(*ptr)->right;
37
        else
38
            break;
39
    }
40
    if(*ptr == NULL)                        //要插位的位置為空表示無重複
41
        *ptr = newNode(val);                        //新節點插入此位址
42
}
43

44
//找子樹中最小的樹 (從根開始往左走直到不能走)
45
Node* minValue(Node* rootT){
46
    Node* ptr = rootT;
47
    while(ptr->left)
48
        ptr = ptr->left;
49
    return ptr;
50
}
51

52
//自BST樹中刪除（用while迴圈配合指標做）
53
void remove(int val){
54
    Node **ptr = &BSTroot;                          //依址找值
55
    while(*ptr == NULL || (*ptr)->data != val){     //找要刪除的節點的位址
56
        if(val data)
57
            ptr = &(*ptr)->left;
58
        else if(val > (*ptr)->data)
59
            ptr = &(*ptr)->right;
60
    }
61
    if(*ptr != NULL){                               //要刪位的位置為空表示有找到值
62
        if((*ptr)->left == NULL || (*ptr)->right == NULL){                      //若目前節點的子樹數量為 0(無子樹) 或 1(僅左或右子樹)
63
            Node* childT = ((*ptr)->left!=NULL)? (*ptr)->left: (*ptr)->right;           //暫存左子樹或右子樹
64
            free((*ptr));                                                               //釋放目前子樹樹根記憶體
65
            (*ptr) = childT;                                                            //若無子樹，令目前節點為空 否則令其為其暫存的子樹
66
        }else{                                                                  //若目前節點 左、右子樹皆有
67
            Node* minNode = minValue((*ptr)->right);                                    //取得 右子樹最小的節點
68
            int minValue = minNode->data;                                               //取得 右子樹最小的節點的值
69
            remove(minValue);                                                           //刪除剛剛找到的節點 (註：因為右子樹最小的節點必無左子樹，故遞迴結果必為第1或第2個if)
70
            (*ptr)->data = minValue;                                                    //設目前子樹樹根的數字 為剛剛找到的節點的數字
71
        }
72
    }
73
}
74

75
int main(void){
76
    int val;
77
    char SENT;
78

79
    //對BST樹的操作
80
    printf("   \n選擇操作 : ");
81
    scanf(" %c", &SENT);
82
    while(SENT != 'q'){
83
        switch(SENT) {
84
            case '1':
85
                printf("輸入要插入的數: ");
86
                scanf("%d", &val);
87
                insert(val);
88
                break;
89
            case '2':
90
                printf("輸入要刪除的數: ");
91
                scanf("%d", &val);
92
                remove(val);
93
                break;
94
            case '3':
95
                preOrder(BSTroot);
96
                putchar('\n');
97
                break;
98
            default:
99
                break;
100
        }
101
        printf("\n   \n選擇操作 : ");
102
        scanf(" %c", &SENT);
103
    }
104

105
    system("pause");
106
    return 0;
107
}

顯示更多顯示更少

Terminal window

1
測試資料1：
2

3
依序插入：10 20 30 40 50 25
4
列出結果：10 20 30 25 40 50
5

6
測試資料2：
7
依序插入：9 5 10 0 6 11 -1 1 2
8
列出結果：9 5 0 -1 1 2 6 10 11
9
刪除節點：10
10
列出結果：9 5 0 -1 1 2 6 11
11
刪除節點：5
12
列出結果：9 6 0 -1 1 2 11
13
刪除節點：9
14
列出結果：11 6 0 -1 1 2

[C/C++] 中序轉前後序

Sun, 03 Nov 2019 00:00:00 GMT

【輸入】#

輸入一串中序運算式

【輸出】#

輸出該運算式的前序及後序

【完整程式碼】#

1
#include
2
#include
3
#include
4

5
typedef struct Node{
6
    char value;
7
    Node* link;
8
}Node;
9

10
typedef struct Stack{
11
    Node* top;
12
}Stack;
13

14
void push(Stack* This, char ch){
15
    Node* newp = new Node{ch, This->top};
16
    This->top = newp;
17
}
18

19
char pop(Stack* This){
20
    char res;
21
    Node* temp = This->top;
22
    This->top = temp->link;
23
    res = temp->value;
24
    free(temp);
25
    return res;
26
}
27

28
char top(Stack* This){
29
    return (This->top == NULL)? '\0': This->top->value;
30
}
31

32
int empty(Stack* This){
33
    return (This->top == NULL)? true: false;
34
}
35

36
int priority(char x){
37
    switch(x){
38
        case '^':           return 3;
39
        case '*': case '/': return 2;
40
        case '+': case '-': return 1;
41
        default:            return 0;
42
    }
43
}
44

45
char* infixToPostfix(char str[100]){
46
    char ch, *rsl = (char*)malloc(sizeof(char) * 100);
47
    int idx = 0;
48
    Stack *stack = new Stack{NULL};
49
    for(int i = 0; i = priority(ch))
50
                    rsl[idx++] = pop(stack);
51
                push(stack, ch);
52
                break;
53
            default:
54
                rsl[idx++] = ch;
55
        }
56
    }
57
    //rest
58
    while(!empty(stack))
59
        rsl[idx++] = pop(stack);
60
    return &rsl[0];
61
}
62

63
char* infixToPrefix(char str[100]){
64
    char ch, *rsl = (char*)malloc(sizeof(char) * 100);
65
    int idx = 0;
66
    Stack *stack = new Stack{NULL};
67
    Stack *prefix = new Stack{NULL};
68
    for(int i = strlen(str)-1; i >= 0; i--){
69
        ch = str[i];
70
        //--------------------prefix--------------------
71
        switch(ch){
72
            case ')':
73
                push(stack, ch);
74
                break;
75
            case '(':
76
                while(!empty(stack) && (ch=pop(stack)) != ')')
77
                    push(prefix, ch);
78
                break;
79
            case '+': case '-': case '*': case '/': case '^':
80
                while(priority(top(stack)) > priority(ch))
81
                    push(prefix, pop(stack));
82
                push(stack, ch);
83
                break;
84
            default:
85
                push(prefix, ch);
86
        }
87
    }
88
    //rest
89
    while(!empty(stack))
90
        push(prefix, pop(stack));
91

92
    while(!empty(prefix))
93
        rsl[idx++] = pop(prefix);
94
    return rsl;
95
}
96

97
int main(void){
98
    char str[100];
99

100
    printf("請輸入中序運算式：");
101
    scanf(" %s", str);
102
    printf("後序: %s\n", infixToPostfix(str));
103
    printf("前序: %s\n", infixToPrefix(str));
104
    system("pause");
105
    return 0;
106
}

顯示更多顯示更少

Terminal window

1
測試資料：
2

3
請輸入中序運算式：1+(2-3)*4+5/(2+1)
4
後序: 123-4*+521+/+
5
前序: ++1*-234/5+21

[C/C++] 環狀鏈結：尋找特別數

Sun, 03 Nov 2019 00:00:00 GMT

【輸入】#

輸入任意男女名單，O為男；X為女，並找出一個特別數，從環狀鏈結依序點人，點到的人可以登船，並且這個特別數要能滿足讓所有的男性登船。

【輸出】#

特別數

【完整程式碼】#

1
#include
2
#include
3
#include
4
#include
5
using namespace std;
6

7
/*-------------------- 定義環狀串列結構 --------------------*/
8
// 定義節點結構
9
class Node{
10
    public:
11
        char sex;
12
        Node *next;
13
        // Constructor
14
        Node(char c){ sex = c; next = NULL; }
15
};
16

17
// 定義串列結構
18
class CircularList{
19
    public:
20
        Node *rear;
21

22
        CircularList(){ rear = NULL; }
23

24
        // 清空節點方法
25
        void clearNode(){
26
            if(rear != NULL){
27
                Node *ptr, *lnk;                //ptr是存取的指針，從頭（rear->next）開始存取
28
                for(ptr = rear->next; ptr != rear; ptr = lnk){
29
                    lnk = ptr->next;            //lnk暫存下個節點的指針
30
                    delete ptr;                 //刪除目前節點
31
                }
32
                delete ptr;                     //刪除最後一個節點
33
                rear = NULL;                    //重新初始化串列
34
            }
35
        }
36
        // 加入新節點
37
        void addNode(char c){
38
            Node *newp = new Node(c);
39
            if(rear == NULL)            //若環狀串列為空，則自己連到自己
40
                rear = newp->next = newp;
41
            else {                      //否則
42
                newp->next = rear->next;    //新節點的下個節點連到頭節點
43
                rear = rear->next = newp;   //原本的尾的下一個連到新節點，再把尾改成新節點
44
            }
45
        }
46
        // 移除節點
47
        void deleteNode(Node *target){
48
            Node *prev = rear;
49
            while(prev->next != target)     //從頭節點（rear->next）開始找
50
                prev = prev->next;
51

52
            prev->next = target->next;      //若在A->B->C中找到B，目前prev是A，target是B，將A的next重新指向C
53
            if(target == rear)              //若B是尾，
54
                rear = prev;                    //則將尾指定給A
55

56
            delete target;
57
        }
58
};
59

60
CircularList circularList;  //宣告並初始化環狀鏈結
61

62
/*-------------------- 特別數驗證 --------------------*/
63
bool isTrue(int num, int ALL_MALE){
64
    int count = 0;                          //已登船的人數
65
    Node *ptr = circularList.rear, *tbk;    //ptr == 第一次被計算的人之前的人 == 被允許登船的人之前的人
66
    while(count != ALL_MALE) {              //【若 NUMBERS_OF_ON_BOARD != ALL_MALE】
67
        /*--- Counting ---*/
68
        for(int i = 1; i next;                                //算人數移動PTR.
69

70
        /*--- Checking ---*/
71
        tbk = ptr->next;                            //tbk = 第N個人 (ptr->next)
72
        if(tbk->sex == 'O'){                        //【若第N個人 (tbk) 是男性】
73
            circularList.deleteNode(tbk);                   //刪除節點（該人被允許登船）
74
            count++;                                        //已登船的人數+1
75
        }else return false;                         //【否則，這不是個特別數】
76
    }
77
    return true;
78
}
79

80
/*-------------------- Data input --------------------*/
81
// 建立新的環狀鏈結
82
void createCircular(string members){
83
    for(int i = 0; i > *members;
84
}
85

86
/*-------------------- Main Function --------------------*/
87
int main(void) {
88
    string MemberList;              //名單的清單
89
    int maleCount, specialNum = 0;  //男性數量及特別數
90

91
    input("請輸入男女生名單（O為男X為女）：", &MemberList);
92
    maleCount = count(MemberList.begin(), MemberList.end(), 'O');
93

94
    if(maleCount>0)
95
        do{
96
            specialNum++;                   //從1開始找特別數
97
            circularList.clearNode();       //清除環狀鏈結
98
            createCircular(MemberList);     //重建環狀鏈結
99
        }while(!isTrue(specialNum, maleCount));
100

101
    cout << "Number: " << specialNum << endl;
102
    system("pause");
103
    return 0;
104
}

顯示更多顯示更少

Terminal window

1
測試資料：
2

3
請輸入男女生名單（O為男X為女）：OXOOXOOOOXOO
4
Number: 54

[C/C++] 單向鏈結實作矩陣相乘轉矩陣表示式

Mon, 14 Oct 2019 00:00:00 GMT

【輸入】#

兩組矩陣，大小需為M×N及N×P

【輸出】#

兩組矩陣轉換成表示式兩個矩陣相乘後的矩陣和表示式

【完整程式碼】#

1
//定義一個串列結構，用來存表示式的每一列
2
typedef struct MatrixRep {
3
    int row, col, value;
4
    struct MatrixRep *next;
5
} MatrixRep;
6

7
void createMatrixRepList(MatrixRep **front);                                            //建立表示式結構的Front
8
void inputMatrixRep(char *matrixName, MatrixRep **front);                               //輸入表示式
9
MatrixRep *indexOfRep(int r, int c, MatrixRep **rep);                                   //找某[i,j]是否位於某表示式中的一個節點
10
void multipliedMatrixRep(MatrixRep **frontA, MatrixRep **frontB, MatrixRep **frontC);   //表示式直接相乘
11
void printMatrix(char *matrixName, MatrixRep **front);                                  //印出表示式轉矩陣
12
void printMatrixRep(char *matrixName, MatrixRep **front);                               //印出表示式
13

14
int main(void) {
15
    MatrixRep *matrixRepFrontA, *matrixRepFrontB, *matrixRepFrontC;
16

17
    //輸入兩組一般矩陣且直接轉表示式
18
    inputMatrixRep("A", &matrixRepFrontA);      //輸入矩陣A且直接轉表示式A
19
    printMatrixRep("A", &matrixRepFrontA);      //印出表示式A
20
    printf("====================\n");
21
    inputMatrixRep("B", &matrixRepFrontB);      //輸入矩陣B且直接轉表示式B
22
    printMatrixRep("B", &matrixRepFrontB);      //印出表示式B
23
    printf("====================\n");
24

25
    //判斷能不能相乘
26
    if(matrixRepFrontA->next->col == matrixRepFrontB->next->row){
27
        multipliedMatrixRep(&matrixRepFrontA, &matrixRepFrontB, &matrixRepFrontC);  //兩組表示式直接相乘存入表示式C
28
        printMatrix("C", &matrixRepFrontC);                                         //印出矩陣C
29
        printMatrixRep("C", &matrixRepFrontC);                                      //印出表示式C
30
    }
31
    else{
32
        printf("兩個矩陣無法相乘\n");
33
    }
34

35
    system("pause");
36
    return 0;
37
}
38

39
/*-----建立表示式結構的Front-----*/
40
void createMatrixRepList(MatrixRep **front){
41
    (*front) = new MatrixRep;  //等同C的 (**front) = (MatrixRep *)malloc(sizeof(MatrixRep));
42
    (*front)->next = NULL;
43
}
44

45
/*-----輸入表示式-----*/
46
void inputMatrixRep(char *matrixName, MatrixRep **front){
47
    int num;
48
    createMatrixRepList(front);                                 //建立表示式結構的Front【front為&(*front)的縮寫】
49
    MatrixRep *current = (*front)->next = new MatrixRep;
50
    //等同C的 MatrixRep *current = (*front)->next = (MatrixRep *)malloc(sizeof(MatrixRep));
51

52
    printf("請輸入矩陣%s的大小（m*n請輸入 m n）:\n", matrixName);
53
  scanf("%d%d", &(current->row), &(current->col));            //存表示式第0列的row及col
54
    current->value = 0;                                         //將第0列的value設為0
55
    current->next = NULL;                                       //將第0列尾端設為空
56

57
  printf("請輸入矩陣%s的元素 :\n", matrixName);
58
  for (int i = 0; i next->row; i++)
59
    for (int j = 0; j next->col; j++){
60
      scanf("%d", &num);                                  //讀入矩陣元素
61
            if(num!=0){                                         //若元素非0，存入表示式新的一列
62
                ((*front)->next->value)++;
63
                current = current->next = new MatrixRep{i, j, num, NULL};
64
                /*等同C的
65
                  current = current->next = (MatrixRep *)malloc(sizeof(MatrixRep));
66
                  current->row=i; current->col=j; current->value=num; current->next=NULL;*/
67
            }
68
        }
69
}
70

71
/*-----找某[i,j]是否位於某表示式中的一個節點-----*/
72
MatrixRep *indexOfRep(int r, int c, MatrixRep **rep){
73
    for(MatrixRep *cur=(*rep)->next->next; cur!=NULL; cur=cur->next)
74
        if(cur->row == r && cur->col == c)
75
            return cur;
76
    return NULL;
77
}
78

79
/*-----表示式直接相乘-----*/
80
void multipliedMatrixRep(MatrixRep **frontA, MatrixRep **frontB, MatrixRep **frontC){
81
    createMatrixRepList(frontC);              //建立表示式結構的Front【frontC為&(*frontC)的縮寫】
82
    MatrixRep *currentA = (*frontA)->next;    //currentA指向表示式A的第0列
83
    MatrixRep *currentB = (*frontB)->next;    //currentB指向表示式B的第0列
84
    MatrixRep *currentC = (*frontC)->next = new MatrixRep{currentA->row, currentB->col, 0, NULL};
85
    /*等同C的
86
      MatrixRep *currentC = (*frontC)->next = (MatrixRep *)malloc(sizeof(MatrixRep));
87
      currentC->row=currentA->row; currentC->col=currentB->col;
88
      currentC->value=0; currentC->next=NULL;*/
89

90
    //相乘
91
    for(currentA = currentA->next; currentA!=NULL; currentA = currentA->next){
92
        for(currentB = (*frontB)->next->next; currentB!=NULL; currentB = currentB->next){
93
            //依數學定義，給定任兩數分別位於矩陣A[i,j]與矩陣B[s,t]，若且唯若j=s時，此兩數之乘積會累加於C[i,t]中
94
            //故遍歷表示式A，表示式A之每數再遍歷表示式B，當curA->col == curB->row時，即有非零乘積產生
95
            if(currentA->col == currentB->row){
96
                //若目前C[i,j]已存在於表示式C中，則累加進去，否則就宣告一個新的節點來放
97
                MatrixRep *findC = indexOfRep(currentA->row, currentB->col, frontC);   //找C[i,j]是否存在於表示式C中【frontC為&(*frontC)的縮寫】
98
                if((*frontC)->next->value>0 && findC!=NULL){
99
                    findC->value += currentA->value * currentB->value;
100
                }else{
101
                    ((*frontC)->next->value)++; //已紀錄的元素個數+1
102
                    currentC = currentC->next = new MatrixRep{currentA->row, currentB->col, currentA->value * currentB->value, NULL};
103
                    /*等同C的
104
                      currentC = currentC->next = (MatrixRep *)malloc(sizeof(MatrixRep));
105
                      currentC->row=currentA->row; currentC->col=currentB->col;
106
                      currentC->value=currentA->value*currentB->value; currentC->next=NULL;*/
107
                }
108
            }
109
        }
110
    }
111
}
112

113
/*-----印出表示式轉矩陣-----*/
114
void printMatrix(char *matrixName, MatrixRep **front){
115
    MatrixRep *cur=(*front)->next->next;
116
    printf("矩陣%s：\n", matrixName);
117
    for(int i = 0; i next->row; i++){
118
        for(int j = 0; j next->col; j++){
119
            if(cur != NULL && i == cur->row && j == cur->col){
120
                printf("%2d ", cur->value);
121
                cur = cur->next;
122
            }else{
123
                printf("%2d ", 0);
124
            }
125
        }
126
        putchar('\n');
127
    }
128
}
129

130
/*-----印出表示式-----*/
131
void printMatrixRep(char *matrixName, MatrixRep **front){
132
  printf("矩陣%s的表示式:\n 列 行 元素\n", matrixName);
133
    for(MatrixRep *cur=(*front)->next; cur!=NULL; cur=cur->next)
134
        printf("%2d %2d %2d\n", cur->row, cur->col, cur->value);
135
}

顯示更多顯示更少

[C/C++] 矩陣相乘輸出為矩陣表示法

Mon, 07 Oct 2019 00:00:00 GMT

【輸入】#

兩組矩陣，大小需為M×N及N×P

【輸出】#

兩組矩陣轉換成表示式兩個矩陣相乘後的矩陣和表示式

【完整程式碼】#

1
#include
2
#include
3
using namespace std;
4

5
//定義一個串列結構，用來存表示式的每一列
6
typedef struct MatrixRep {
7
    int row, col, value;
8
    struct MatrixRep *next;
9
} MatrixRep;
10

11
//定義一個矩陣結構，用來矩陣的列、欄及一個二維陣列
12
typedef struct Matrix {
13
    int row, col, **elements;
14
} Matrix;
15

16
void inputMatrix(char *matrixName, Matrix *matrix);      //輸入矩陣
17
void matrixMultiplied(Matrix *A, Matrix *B, Matrix *C);  //矩陣相乘
18
void matrixToRep(Matrix *from, MatrixRep **to);          //矩陣轉表示式
19
void printMatrixRep(char *matrixName, MatrixRep *mRep);  //印出表示式
20
void printMatrix(char *matrixName, Matrix *matrix);      //印出矩陣
21

22
int main(void) {
23
    //A、B、C為矩陣；  *matrixRepA、B、C為矩陣表示式
24
    MatrixRep *matrixRepA, *matrixRepB, *matrixRepC;
25
    Matrix A, B, C;
26

27
    //輸入兩組矩陣
28
    inputMatrix("A", &A);
29
    matrixToRep(&A, &matrixRepA);        //矩陣A轉表示式
30
    printMatrixRep("A", matrixRepA);     //印出表示式A，避免表示式A的指向被改掉，故傳值
31
    printf("====================\n");
32
    inputMatrix("B", &B);
33
    matrixToRep(&B, &matrixRepB);        //矩陣B轉表示式
34
    printMatrixRep("B", matrixRepB);     //印出表示式B
35
    printf("====================\n");
36

37
    //兩組矩陣相乘存入矩陣C
38
    if(A.col == B.row)
39
        matrixMultiplied(&A, &B, &C);
40
    else{
41
        printf("兩個矩陣無法相乘\n");
42
        system("pause");
43
        return 0;
44
    }
45

46
    //矩陣C轉換為表示式並輸出
47
    matrixToRep(&C, &matrixRepC);     //矩陣C轉表示式
48
    printMatrix("C", &C);             //印出矩陣C
49
    printMatrixRep("C", matrixRepC);  //印出表示式C
50

51
    system("pause");
52
    return 0;
53
}
54

55
/*-----輸入矩陣-----*/
56
void inputMatrix(char *matrixName, Matrix *matrix){
57
    //輸入矩陣大小
58
    printf("請輸入矩陣%s的大小（m*n請輸入 m n）:", matrixName);
59
  scanf("%d%d", &matrix->row, &matrix->col);
60

61
    //輸入矩陣元素
62
  printf("請輸入矩陣%s的元素 :\n", matrixName);
63
    matrix->elements = new int*[matrix->row];        //動態配置陣列ROW大小
64
    //等同C的 matrix->elements = (int **)malloc(sizeof(int*) * matrix->row);
65

66
  for (int i = 0; i row; i++) {
67
        matrix->elements[i] = new int[matrix->col];  //動態配置陣列COL大小
68
        //等同C的 matrix->elements[i] = (int *)malloc(sizeof(int) * matrix->col);
69

70
    for (int j = 0; j col; j++)
71
      scanf("%d", &matrix->elements[i][j]);
72
  }
73
}
74

75
/*-----矩陣相乘-----*/
76
void matrixMultiplied(Matrix *A, Matrix *B, Matrix *C){
77
    //存矩陣C的ROW、COL
78
    C->row = A->row;
79
    C->col = B->col;
80

81
    //存相乘存入矩陣C
82
    C->elements = new int*[C->row];           //動態配置陣列ROW大小
83
    //等同C的 C->elements = (int **)malloc(sizeof(int*) * C->row);
84

85
    for(int i = 0; i row; i++){
86
        C->elements[i] = new int[C->col]{0};  //動態配置陣列COL大小 //給定 C[i,j] 初值0
87
        //等同C的 C->elements[i] = (int *)malloc(sizeof(int) * C->col);  C->elements[i][j] = 0;
88

89
        for(int j = 0; j col; j++)
90
            for(int k = 0; k col; k++)
91
                C->elements[i][j] += A->elements[i][k] * B->elements[k][j];
92
                // 矩陣C[i,j] = 矩陣A[i,k] * 矩陣B[k,j] for k in A.COL
93
    }
94
}
95

96
/*-----矩陣轉表示式-----*/
97
void matrixToRep(Matrix *from, MatrixRep **to){
98
    //宣告並指定Rep第一列的ROW、COL、COUNT資訊；  並將current指向第一列：current = *to
99
    MatrixRep *current;
100
    current = *to = new MatrixRep{from->row, from->col, 0, NULL};
101
    /*等同C的
102
      current = *to = (MatrixRep *)malloc(sizeof(MatrixRep));
103
      (*to)->row=from->row; (*to)->col=from->col; (*to)->value=0; (*to)->next=NULL;*/
104

105
    //非零元素存入表示式
106
    for(int i = 0; i row; i++)
107
        for(int j = 0; j col; j++)
108
            if(from->elements[i][j] != 0){
109
                //宣告並指定新一列表示式[i, j, VALUE]；  然後表示式鏈結起來；  並將current指向新一列：current = current->next；
110
                current = current->next = new MatrixRep{i, j, from->elements[i][j], NULL};
111
                /*等同C的
112
                  current = current->next = (MatrixRep *)malloc(sizeof(MatrixRep));
113
                  current->row=i; current->col=j; current->value=from->elements[i][j]; current->next=NULL;*/
114

115
                ((*to)->value)++; //將非零元素個數+1
116
            }
117
}
118

119
/*-----印出表示式-----*/
120
void printMatrixRep(char *matrixName, MatrixRep *mRep){
121
  printf("矩陣%s的表示式:\n 列 行 元素\n", matrixName);
122
    for(; mRep!=NULL; mRep = mRep->next)
123
        printf("%2d %2d %2d\n", mRep->row, mRep->col, mRep->value);
124
}
125

126
/*-----印出矩陣-----*/
127
void printMatrix(char *matrixName, Matrix *matrix){
128
    printf("矩陣%s：\n", matrixName);
129
    for(int i = 0; i row; i++){
130
        for(int j = 0; j col; j++)
131
            printf("%2d ", matrix->elements[i][j]);
132
        putchar('\n');
133
    }
134
}

顯示更多顯示更少

Terminal window顯示更多顯示更少

1
測試資料：
2

3
請輸入矩陣A的大小（m*n請輸入 m n）:2 3
4
請輸入矩陣A的元素 :
5
0 6 0
6
40 0      0 0
7
矩陣A的表示式:
8
 列 行 元素
9
 2  3  2
10
 0  1  6
11
 1  0  4
12
====================
13
請輸入矩陣B的大小（m*n請輸入 m n）:3 2
14
請輸入矩陣B的元素 :
15
0 2
16
0 0
17
2 0
18
矩陣B的表示式:
19
 列 行 元素
20
 3  2  2
21
 0  1  2
22
 2  0  2
23
====================
24
矩陣C：
25
 0  0
26
 0  8
27
矩陣C的表示式:
28
 列 行 元素
29
 2  2  1
30
 1  1  8

顯示更多顯示更少