三十分鐘入門基礎Go(Java小子版)

語言: CN / TW / HK

作者:京東科技 韓國凱

前言

Go語言定義

Go(又稱 Golang)是 Google 的 Robert Griesemer,Rob Pike 及 Ken Thompson 開發的一種靜態、強型別、編譯型語言。Go 語言語法與 C 相近,但功能上有:記憶體安全,GC,結構形態及 CSP-style 併發計算

適用範圍

本篇文章適用於學習過其他面嚮物件語言(Java、Php),但沒有學過Go語言的初學者。文章主要從Go與Java功能上的對比來闡述Go語言的基礎語法、面向物件程式設計、併發與錯誤四個方面。

一、基礎語法

Go語言的基礎語法與常規的程式語言基本類似,所不同的有宣告變數的方式,陣列、切片、字典的概念及功能與Java不太相同,不過Java中這些資料結構都可以通過類比功能的方式在Go中使用。

1.1 變數、常量、nil與零值、方法、包、可見性、指標

1.1.1 變數宣告

Go語言中有兩種方式

1.使用var關鍵字宣告,且需要注意的是,與大多數強型別語言不同,Go語言的宣告變數型別位於變數名稱的後面。Go語句結束不需要分號。

var num int

var result string = "this is result"

2.使用:=賦值。

num := 3 等同於 var num int = 3

其中變數的型別會根據右側的值進行匹配,例如"3"會匹配為int,"3.0"會匹配為float64,"result"會匹配為string。

1.1.2 常量宣告

使用const來宣告一個常量,一個常量在聲明後不可改變。

const laugh string = "go"

1.1.3 nil與零值

只宣告未賦值的變數,其值為nil。類似於java中的“null”

沒有明確初始值的變數宣告會被賦予它們的 零值

零值是:

  • 數值型別為 0
  • 布林型別為 false
  • 字串為 ""(空字串)。

1.1.4 方法、包

Go中方法的定義

使用func關鍵字來定義一個方法,後面跟方法名,然後是引數,返回值(如果有的話,沒有返回值則不寫)。

func MethodName(p1 Parm, p2 Parm) int{}

//學習一個語言應該從Hello World開始!
package main

import "fmt"

func main() {
	fmt.Println("Hello World!")// Hello World!
    fmt.Println(add(3, 5)) //8
    var sum = add(3, 5)
}

func add(a int, b int) int{
    return a+b;
}
多個返回值

Go 函式與其他程式語言一大不同之處在於支援多返回值,這在處理程式出錯的時候非常有用。例如,如果上述 add 函式只支援非負整數相加,傳入負數則會報錯。

//返回值只定義了型別 沒有定義返回引數
func add(a, b int) (int, error) {
    if a < 0 || b < 0 {
        err := errors.New("只支援非負整數相加")
        return 0, err
    }
    a *= 2
    b *= 3
    return a + b, nil
}

//返回值還定義了引數 這樣可以直接return 並且定義的引數可以直接使用 return時只會返回這兩個引數
func add1(a, b int) (z int, err error) {
    if a < 0 || b < 0 {
        err := errors.New("只支援非負整數相加")
        return   //實際返回0 err 因為z只定義沒有賦值 則nil值為0
    }
    a *= 2
    b *= 3
    z = a + b
    return //返回 z err
}

func main()  {
    x, y := -1, 2
    z, err := add(x, y)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Printf("add(%d, %d) = %d\n", x, y, z)
}
變長引數
func myfunc(numbers ...int) {
    for _, number := range numbers {
        fmt.Println(number)
    }
}

slice := []int{1, 2, 3, 4, 5}
//使用...將slice打碎傳入
myfunc(slice...)
包與可見性

在 Go 語言中,無論是變數、函式還是類屬性和成員方法,它們的可見性都是以包為維度的,而不是類似傳統面向程式設計那樣,類屬性和成員方法的可見性封裝在所屬的類中,然後通過 privateprotected 和 public 這些關鍵字來修飾其可見性。

Go 語言沒有提供這些關鍵字,不管是變數、函式,還是自定義類的屬性和成員方法,它們的可見性都是根據其首字母的大小寫來決定的,如果變數名、屬性名、函式名或方法名首字母大寫,就可以在包外直接訪問這些變數、屬性、函式和方法,否則只能在包內訪問,因此 Go 語言類屬性和成員方法的可見性都是包一級的,而不是類一級的。

假如說一個名為domain的資料夾下有3個.go檔案,則三個檔案中的package都應為domain,其中程式的入口main方法所在的檔案,包為main

//定義了此檔案屬於 main 包
package main

//通過import匯入標註庫中包
import "fmt"

func main() {
	fmt.Println("Hello World!")// Hello World!
    fmt.Println(add(3, 5)) //8
    var sum = add(3, 5)
}

func add(a int, b int) int{
    return a+b;
}

1.1.5 指標

對於學過C語言來說,指標還是比較熟悉的,我所理解的指標,其實就是一個在記憶體中實際的16進位制的地址值,引用變數的值通過此地址去記憶體中取出對應的真實值。

func main() {
    i := 0
    //使用&來傳入地址
    fmt.Println(&i) //0xc00000c054
    
    var a, b int = 3 ,4
    //傳入 0xc00000a089 0xc00000a090
    fmt.Println(add(&a, &b)) 
}

//使用*來宣告一個指標型別的引數與使用指標
func add(a *int, b *int)int{
    //接收到 0xc00000a089 0xc00000a090
    //前往 0xc00000a089位置查詢具體資料 並取賦給x
    x := *a
    //前往 0xc00000a090位置查詢具體資料 並取賦給y
    y := *b
	return x+y
}

1.2 條件、迴圈、分支

1.2.1 條件

與Java語言的if基本相同

// if
if condition { 
    // do something 
}

// if...else...
if condition { 
    // do something 
} else {
    // do something 
}

// if...else if...else...
if condition1 { 
    // do something 
} else if condition2 {
    // do something else 
} else {
    // catch-all or default 
}

1.2.2 迴圈

sum := 0 

//普通for迴圈
for i := 1; i <= 100; i++ { 
    sum += i 
}

//無限迴圈
for{
    sum++
    if sum = 100{
        break;
    }
}

//帶條件的迴圈
for res := sum+1; sum < 15{
    sum++
    res++
}

//使用kv迴圈一個map或一個數組  k為索引或鍵值 v為值 k、v不需要時可以用_帶替
for k, v := range a {
    fmt.Println(k, v)
}

1.2.3 分支

score := 100
switch score {
case 90, 100:
    fmt.Println("Grade: A")
case 80:
    fmt.Println("Grade: B")
case 70:
    fmt.Println("Grade: C")
case 65:
    fmt.Println("Grade: D")
default:
    fmt.Println("Grade: F")
}

1.3 陣列、切片、字典

1.3.1 陣列

陣列功能與Java語言類似,都是長度不可變,並且可以使用多維陣列,也可以通過arrays[i]來儲存或獲取值。

//宣告
var nums [3]int 
//宣告並初始化
var nums = [3]int{1,2,3} <==> nums:=[3]int{1,2,3}

//使用
for sum := 0, i := 0;i<10{
	sum += nums[i]
	i++
}
//修改值
num[0] = -1

陣列使用較為簡單,但是存在著難以解決的問題:長度固定 。

例如當我們在程式中需要一個數據結構來儲存獲取到的所有使用者,因為使用者數量是會隨著時間變化的,但是陣列其長度卻不可改變,所以陣列並不適合儲存長度會發生改變的資料。因此在Go語言中通過使用切片來解決以上問題。

1.3.2 切片

切片相比於Java來說是一種全新的概念。在Java中,對於不定長的資料儲存結構,可以使用List介面來完成操作,例如有ArrayList與LinkList,這些介面可以實現資料的隨時新增與獲取,並沒有對長度進行限制。但是在Go中不存在這樣的介面,而是通過切片(Slice)來完成不定長的資料長度儲存

切片與陣列最大的不同就是切片不用宣告長度。但是切片與陣列並非毫無關係,陣列可以看作是切片的底層陣列,而切片則可以看作是陣列某個連續片段的引用。切片可以只使用陣列的一部分元素或者整個陣列來建立,甚至可以建立一個比所基於的陣列還要大的切片:

長度、容量

切片的長度就是它所包含的元素個數。

切片的容量是從它的第一個元素開始數,到其底層陣列元素末尾的個數。

切片 s 的長度和容量可通過表示式 len(s) 和 cap(s) 來獲取。

切片的長度從功能上類比與Java中List的size(),即通過len(slice)來感知切片的長度,即可對len(slice)進行迴圈,來動態控制切片內的具體內容。切片的容量在實際開發中運用不多,瞭解其概念即可。

建立切片
//宣告一個數組
var nums =[3]int{1, 2, 3}
//0.直接宣告
var slice =[]int{0, 1, 2}

//1.從陣列中引用切片 其中a:b是指包括a但不包括b
var slice1 = nums[0:2] //{1,2}
//如果不寫的則預設為0(左邊)或最大值(右邊)
var slice2 = slice1[:2] <==> var slice2 = slice1[0:] <==>var slice2 = slice1[:]

//2.使用make建立Slice 其中int為切片型別,4為其長度,5為容量
slice3 := make([]int, 5)
slice4 := make([]int, 4, 5)
動態操作切片
//使用append向切片中動態的新增元素
func append(s []T, vs ...T) []T

slice5 := make([]int, 4, 5) //{0, 0, 0, 0}
slice5 = append(slice5, 1) //{0,0,0,0,1}

//刪除第一個0
sliece5 = slice5[1:]
切片的常用場景

模擬上述提到的問題使用切片解決方案

//宣告切片
var userIds = []int{}
//模擬獲取所有使用者ID
for i := 0; i< 100{
    userIds = append(userIdS, i);
    i++;
}
//對使用者資訊進行處理
for k,v := range userIds{
    userIds[k] = v++
}

1.3.3 字典

字典也可稱為 ‘鍵值對’ 或 ‘key-value’,是一種常用的資料結構,Java中有各種Map介面,常用的有HashMap等。在Go中通過使用字典來實現鍵值對的儲存,字典是無序的,所以不會根據新增順序來保證資料的順序。

字典的宣告與初始化
//string為鍵型別,int為值型別
maps := map[string]int{
  "java" : 1,
  "go" : 2,
  "python" : 3,
}

//還可以通過make來建立字典 100為其初始容量 超出可擴容
maps = make(map[string]int, 100)
字典的使用場景
//直接使用
fmt.Println(maps["java"]) //1

//賦值
maps["go"] = 4

//取值 同時判斷map中是否存在該鍵 ok為bool型
value, ok := maps["one"] 
if ok { // 找到了
  // 處理找到的value 
}

//刪除
delete(testMap, "four")

二、面向物件程式設計

2.1 Go語言中的類

眾所周知,在面向物件的語言中,一個類應該具有屬性、構造方法、成員方法三種結構,Go語言也不例外。

2.1.1 類的宣告與初始化

Go語言中並沒有明確的類的概念,只有struct關鍵字可以從功能上類比為 面嚮物件語言中的“類” 。比如要定義一個學生類,可以這麼做:

type Student struct {
    id int
    name string
    male bool
    score float64
}//定義了一個學生類,屬性有id name等,每個屬性的型別都在其後面

//定義學生類的構造方法
func NewStudent(id uint, name string, male bool, score float64) *Student {
    return &Student{id, name, male, score}
}

//例項化一個類物件
student := NewStudent(1, "學院君", 100)
fmt.Println(student)

2.1.2 成員方法

Go中的成員方法宣告與其他語言不大相同。以Student類為例,

//在方法名前,新增對應的類,即可認為改方法為該類的成員方法。
func (s Student) GetName() string  {
    return s.name
}

//注意這裡的Student是帶了*的 這是因為在方法傳值過程中 存在著值傳遞與引用傳遞 即指標的概念 當使用值傳遞時 編譯器會為該引數建立一個副本傳入 因此如果對副本進行修改其實是不生效的 因為在執行完此方法後該副本會被銷燬 所以此處應該是用*Student 將要修改的物件指標傳入 修改值才能起作用
func (s *Student) SetName(name string) {
    //這裡其實是應該使用(*s).name = name,因為對於一個地址來說 其屬性是沒意義的 不過這樣使用也是可以的 因為編譯器會幫我們自動轉換
    s.name = name
}

2.2 介面

介面在 Go 語言中有著至關重要的地位,如果說 goroutine 和 channel 是支撐起 Go 語言併發模型的基石,那麼介面就是 Go 語言整個型別系統的基石。Go 語言的介面不單單只是介面,下面就讓我們一步步來探索 Go 語言的介面特性。

2.2.1 傳統侵入式介面實現

和類的實現相似,Go 語言的介面和其他語言中提供的介面概念完全不同。以 Java、PHP 為例,介面主要作為不同類之間的契約(Contract)存在,對契約的實現是強制的,體現在具體的細節上就是如果一個類實現了某個介面,就必須實現該介面宣告的所有方法,這個叫「履行契約」:

// 宣告一個'iTemplate'介面
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}


// 實現介面
// 下面的寫法是正確的
class Template implements iTemplate
{
    private $vars = array();

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }

    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }

        return $template;
    }
}

這個時候,如果有另外有一個介面 iTemplate2 聲明瞭與 iTemplate 完全一樣的介面方法,甚至名字也叫 iTemplate,只不過位於不同的名稱空間下,編譯器也會認為上面的類 Template 只實現了 iTemplate 而沒有實現 iTemplate2 介面。

這在我們之前的認知中是理所當然的,無論是類與類之間的繼承,還是類與介面之間的實現,在 Java、PHP 這種單繼承語言中,存在著嚴格的層級關係,一個類只能直接繼承自一個父類,一個類也只能實現指定的介面,如果沒有顯式宣告繼承自某個父類或者實現某個介面,那麼這個類就與該父類或者該介面沒有任何關係。

我們把這種介面稱為侵入式介面,所謂「侵入式」指的是實現類必須明確宣告自己實現了某個介面。這種實現方式雖然足夠明確和簡單明瞭,但也存在一些問題,尤其是在設計標準庫的時候,因為標準庫必然涉及到介面設計,介面的需求方是業務實現類,只有具體編寫業務實現類的時候才知道需要定義哪些方法,而在此之前,標準庫的介面就已經設計好了,我們要麼按照約定好的介面進行實現,如果沒有合適的介面需要自己去設計,這裡的問題就是介面的設計和業務的實現是分離的,介面的設計者並不能總是預判到業務方要實現哪些功能,這就造成了設計與實現的脫節。

介面的過分設計會導致某些宣告的方法實現類完全不需要,如果設計的太簡單又會導致無法滿足業務的需求,這確實是一個問題,而且脫離了使用者使用場景討論這些並沒有意義,以 PHP 自帶的 SessionHandlerInterface 介面為例,該介面宣告的介面方法如下:

SessionHandlerInterface {
    /* 方法 */
    abstract public close ( void ) : bool
    abstract public destroy ( string $session_id ) : bool
    abstract public gc ( int $maxlifetime ) : int
    abstract public open ( string $save_path , string $session_name ) : bool
    abstract public read ( string $session_id ) : string
    abstract public write ( string $session_id , string $session_data ) : bool
}

使用者自定義的 Session 管理器需要實現該介面,也就是要實現該介面宣告的所有方法,但是實際在做業務開發的時候,某些方法其實並不需要實現,比如如果我們基於 Redis 或 Memcached 作為 Session 儲存器的話,它們自身就包含了過期回收機制,所以 gc 方法根本不需要實現,又比如 close 方法對於大部分驅動來說,也是沒有什麼意義的。

正是因為這種不合理的設計,所以在編寫 PHP 類庫中的每個介面時都需要糾結以下兩個問題(Java 也類似):

  1. 一個介面需要宣告哪些介面方法?
  2. 如果多個類實現了相同的介面方法,應該如何設計介面?比如上面這個 SessionHandlerInterface,有沒有必要拆分成多個更細分的介面,以適應不同實現類的需要?

接下我們來看看 Go 語言的介面是如何避免這些問題的。

2.2.2 Go 語言的介面實現

在 Go 語言中,類對介面的實現和子類對父類的繼承一樣,並沒有提供類似 implement 這種關鍵字顯式宣告該類實現了哪個介面,一個類只要實現了某個介面要求的所有方法,我們就說這個類實現了該介面

例如,我們定義了一個 File 類,並實現了 Read()Write()Seek()Close() 四個方法:

type File struct { 
    // ...
}

func (f *File) Read(buf []byte) (n int, err error) 
func (f *File) Write(buf []byte) (n int, err error) 
func (f *File) Seek(off int64, whence int) (pos int64, err error) 
func (f *File) Close() error

假設我們有如下介面(Go 語言通過關鍵字 interface 來宣告介面,以示和結構體型別的區別,花括號內包含的是待實現的方法集合):

type IFile interface { 
    Read(buf []byte) (n int, err error) 
    Write(buf []byte) (n int, err error) 
    Seek(off int64, whence int) (pos int64, err error) 
    Close() error 
}

type IReader interface { 
    Read(buf []byte) (n int, err error) 
}

type IWriter interface { 
    Write(buf []byte) (n int, err error) 
}

type ICloser interface { 
    Close() error 
}

儘管 File 類並沒有顯式實現這些介面,甚至根本不知道這些介面的存在,但是我們說 File 類實現了這些介面,因為 File 類實現了上述所有介面宣告的方法。當一個類的成員方法集合包含了某個介面宣告的所有方法,換句話說,如果一個介面的方法集合是某個類成員方法集合的子集,我們就認為該類實現了這個介面。

與 Java、PHP 相對,我們把 Go 語言的這種介面稱作非侵入式介面,因為類與介面的實現關係不是通過顯式宣告,而是系統根據兩者的方法集合進行判斷。這樣做有兩個好處:

  • 其一,Go 語言的標準庫不需要繪製類庫的繼承/實現樹圖,在 Go 語言中,類的繼承樹並無意義,你只需要知道這個類實現了哪些方法,每個方法是幹什麼的就足夠了。
  • 其二,定義介面的時候,只需要關心自己應該提供哪些方法即可,不用再糾結介面需要拆得多細才合理,也不需要為了實現某個介面而引入介面所在的包,介面由使用方按需定義,不用事先設計,也不用考慮之前是否有其他模組定義過類似介面。

這樣一來,就完美地避免了傳統面向物件程式設計中的介面設計問題。

三、併發與多執行緒

3.1 Goroutine

對於任何一個優秀的語言來說,併發處理的能力都是決定其優劣的關鍵。在Go語言中,通過Goroutine來實現併發的處理。

func say(s string) {
	fmt.Println(s)
}

func main() {
    //通過 go 關鍵字新開一個協程
	go say("world")
	say("hello")
}

Go語言中沒有像Java那麼多的鎖來限制資源同時訪問,只提供了Mutex來進行同步操作。

//給類SafeCounter新增鎖
type SafeCounter struct {
	v   map[string]int
	mux sync.Mutex
}

// Inc 增加給定 key 的計數器的值。
func (c *SafeCounter) Inc(key string) {
    //給該物件上鎖
	c.mux.Lock()
	// Lock 之後同一時刻只有一個 goroutine 能訪問 c.v
	c.v[key]++
    //解鎖
	c.mux.Unlock()
}

3.2 Channel

多協程之間通過Channel進行通訊,從功能上可以類比為Java的volatile關鍵字。

ch := make(chan int) 宣告一個int型的Channel,兩個協程之間可以通過ch進行int資料通訊。

通過Channel進行資料傳輸。

ch <- v    // 將 v 傳送至通道 ch。
v := <-ch  // 從 ch 接收值並賦予 v。
package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // 將和送入 c
}

//對於main方法來說 相當於就是開啟了一個協程
func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
    //通過go關鍵字開啟兩個協程 將chaneel當做引數傳入
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
    //通過箭頭方向獲取或傳入資訊
	x, y := <-c, <-c // 從 c 中接收

	fmt.Println(x, y, x+y)
}

四、錯誤處理

4.1 error

Go 語言錯誤處理機制非常簡單明瞭,不需要學習瞭解複雜的概念、函式和型別,Go 語言為錯誤處理定義了一個標準模式,即 error 介面,該介面的定義非常簡單:

type error interface { 
    Error() string 
}

其中只聲明瞭一個 Error() 方法,用於返回字串型別的錯誤訊息。對於大多數函式或類方法,如果要返回錯誤,基本都可以定義成如下模式 —— 將錯誤型別作為第二個引數返回:

func Foo(param int) (n int, err error) { 
    // ...
}

然後在呼叫返回錯誤資訊的函式/方法時,按照如下「衛述語句」模板編寫處理程式碼即可:

n, err := Foo(0)

if err != nil { 
    // 錯誤處理 
} else{
    // 使用返回值 n 
}

非常簡潔優雅。

4.2 defer

defer用於確保一個方法執行完成之後,無論執行結果是否成功,都要執行defer中的語句。類似於Java中的try..catch..finally用法。例如在檔案處理中,無論結果是否成功,都要關閉檔案流。

func ReadFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    //無論結果如何 都要關閉檔案流
    defer f.Close()

    var n int64 = bytes.MinRead

    if fi, err := f.Stat(); err == nil {
        if size := fi.Size() + bytes.MinRead; size > n {
            n = size
        }
    }
    return readAll(f, n)
}

4.3 panic

Go語言中沒有太多的異常類,不像Java一樣有Error、Exception等錯誤型別,當然也沒有try..catch語句。

Panic(恐慌),意味在程式執行中出現了錯誤,如果該錯誤未被捕獲的話,就會造成系統崩潰退出。例如一個簡單的panic:a := 1/0

就會引發panic: integer divide by zero。

-w926

其中第一行表示出問題的協程,第二行是問題程式碼所在的包和函式,第三行是問題程式碼的具體位置,最後一行則是程式的退出狀態,通過這些資訊,可以幫助你快速定位問題並予以解決。

4.4 recover

當有可以預見的錯誤時,又不希望程式崩潰退出,可以使用recover()語句來捕獲未處理的panic。recover應當放在defer語句中,且該語句應該在方法中前部,避免未能執行到defer語句時就引發了系統異常退出。

package main

import (
    "fmt"
)

func divide() {
    //通過defer,確保該方法只要執行完畢都要執行該匿名方法
    defer func() {
        //進行異常捕獲
        if err := recover(); err != nil {
            fmt.Printf("Runtime panic caught: %v\n", err)
        }
    }()

    var i = 1
    var j = 0
    k := i / j
    fmt.Printf("%d / %d = %d\n", i, j, k)
}

func main() {
    divide()
    fmt.Println("divide 方法呼叫完畢,回到 main 函式")
}

-w747

可以看到,雖然會出現異常,但我們使用recover()捕獲之後,就不會出現系統崩潰退出的情形,而只是將該方法結束。其中fmt.Printf("%d / %d = %d\n", i, j, k)語句並沒有執行到,因為程式碼執行到他的上一步已經出現異常導致該方法提前結束。
4 recover

當有可以預見的錯誤時,又不希望程式崩潰退出,可以使用recover()語句來捕獲未處理的panic。recover應當放在defer語句中,且該語句應該在方法中前部,避免未能執行到defer語句時就引發了系統異常退出。

package main

import (
    "fmt"
)

func divide() {
    //通過defer,確保該方法只要執行完畢都要執行該匿名方法
    defer func() {
        //進行異常捕獲
        if err := recover(); err != nil {
            fmt.Printf("Runtime panic caught: %v\n", err)
        }
    }()

    var i = 1
    var j = 0
    k := i / j
    fmt.Printf("%d / %d = %d\n", i, j, k)
}

func main() {
    divide()
    fmt.Println("divide 方法呼叫完畢,回到 main 函式")
}

可以看到,雖然會出現異常,但我們使用recover()捕獲之後,就不會出現系統崩潰退出的情形,而只是將該方法結束。其中fmt.Printf("%d / %d = %d\n", i, j, k)語句並沒有執行到,因為程式碼執行到他的上一步已經出現異常導致該方法提前結束。

五、總結

通過以上的學習,大家可以以使用為目的的初步瞭解到go的基礎語法,但是僅憑本文想要學明白go是完全不夠的。例如go的最大優勢之一“協程”,由於文章目的就沒有特別詳細展開,有興趣的同學可以繼續學習。