// 定義一個名為 Person 的結(jié)構(gòu)體
type Person struct {
    FirstName string
    LastName  string
    Age       int
    IsActive  bool
}

package main
import "fmt"
type Person struct {
    FirstName string
    LastName  string
    Age       int
}
func main() {
    // 方式1：聲明一個變量，默認(rèn)為零值
    var p1 Person
    fmt.Printf("p1: %+v\n", p1) // 輸出: p1: {FirstName: LastName: Age:0}
    // 方式2：使用字面量創(chuàng)建（推薦）
    p2 := Person{
        FirstName: "Alice",
        LastName:  "Smith",
        Age:       30,
    }
    fmt.Printf("p2: %+v\n", p2) // 輸出: p2: {FirstName:Alice LastName:Smith Age:30}
    // 方式3：使用字面量創(chuàng)建（按順序，不推薦，易錯）
    p3 := Person{"Bob", "Johnson", 25}
    fmt.Printf("p3: %+v\n", p3) // 輸出: p3: {FirstName:Bob LastName:Johnson Age:25}
    // 方式4：創(chuàng)建一個指向結(jié)構(gòu)體的指針
    p4 := &Person{
        FirstName: "Charlie",
        LastName:  "Brown",
        Age:       40,
    }
    fmt.Printf("p4: %+v, Type: %T\n", p4, p4) // 輸出: p4: &{FirstName:Charlie LastName:Brown Age:40}, Type: *main.Person
    // Go 會自動解引用，可以直接通過指針訪問字段
    fmt.Println("p4's first name:", p4.FirstName) // 輸出: p4's first name: Charlie
}

package main
import "fmt"
// 定義一個基礎(chǔ)結(jié)構(gòu)體
type Address struct {
    Street, City, Country string
}
// 定義一個 Person 結(jié)構(gòu)體，嵌套了 Address
// Address 是一個匿名字段，因?yàn)樗鼪]有名字
type Person struct {
    Name string
    Age  int
    Address // 匿名字段
}
func main() {
    p := Person{
        Name: "David",
        Age:  35,
        Address: Address{
            Street:  "123 Go Lane",
            City:    "Golang City",
            Country: "GoLand",
        },
    }
    // 訪問嵌套結(jié)構(gòu)體的字段
    fmt.Println("Name:", p.Name)
    // 可以直接訪問嵌套結(jié)構(gòu)體的字段，這被稱為“提升”（Promotion）
    fmt.Println("City:", p.City) // 等同于 p.Address.City
    fmt.Println("Full Address:", p.Address.Street, p.Address.City, p.Address.Country)
}

package main
import "fmt"
type Rectangle struct {
    Width, Height float64
}
// 值接收器：操作的是結(jié)構(gòu)體的副本，不會修改原始結(jié)構(gòu)體
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
// 指針接收器：操作的是結(jié)構(gòu)體本身，會修改原始結(jié)構(gòu)體
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}
func main() {
    rect := Rectangle{Width: 10, Height: 5}
    // 調(diào)用值接收器方法
    area := rect.Area()
    fmt.Printf("Original Area: %.2f\n", area) // 輸出: Original Area: 50.00
    // 調(diào)用指針接收器方法
    // Go 會自動將 rect 轉(zhuǎn)換為 &rect，這是語法糖
    rect.Scale(2)
    fmt.Printf("Scaled Rectangle: %+v\n", rect) // 輸出: Scaled Rectangle: {Width:20 Height:10}
    fmt.Printf("New Area: %.2f\n", rect.Area()) // 輸出: New Area: 200.00
}

// 提示：Stringer 是 Go SDK 的一個接口，屬于 fmt 包。
type Stringer interface {
    String() string
}

package main
import "fmt"
// 1. 定義一個接口
type Speaker interface {
    Speak() string
}
// 2. 定義幾個結(jié)構(gòu)體
type Dog struct{}
type Cat struct{}
type Person struct {
    Name string
}
// 3. 為這些結(jié)構(gòu)體實(shí)現(xiàn) Speaker 接口的方法
// Dog 實(shí)現(xiàn)了 Speaker 接口
func (d Dog) Speak() string {
    return "Woof!"
}
// Cat 實(shí)現(xiàn)了 Speaker 接口
func (c Cat) Speak() string {
    return "Meow!"
}
// Person 實(shí)現(xiàn)了 Speaker 接口
func (p Person) Speak() string {
    return "Hello, my name is " + p.Name
}
// 4. 編寫一個可以接受任何 Speaker 的函數(shù)
func LetItSpeak(s Speaker) {
    fmt.Println(s.Speak())
}
func main() {
    // 創(chuàng)建不同類型的實(shí)例
    dog := Dog{}
    cat := Cat{}
    person := Person{Name: "Alice"}
    // 將它們作為 Speaker 接口類型傳遞給函數(shù)
    // 因?yàn)?Dog, Cat, Person 都實(shí)現(xiàn)了 Speak() 方法，所以它們都實(shí)現(xiàn)了 Speaker 接口
    LetItSpeak(dog)    // 輸出: Woof!
    LetItSpeak(cat)    // 輸出: Meow!
    LetItSpeak(person) // 輸出: Hello, my name is Alice
}

var i interface{}
i = 42
i = "hello"
i = Dog{}
fmt.Println(i) // 輸出: {}

package main
import "fmt"
func main() {
    var i interface{} = "hello, world"
    // 方式1：直接斷言，如果斷言失敗會 panic
    s := i.(string)
    fmt.Println(s) // 輸出: hello, world
    // 方式2：安全斷言，使用 "ok" 模式
    // 如果斷言成功，ok 為 true；如果失敗，ok 為 false，str 為該類型的零值
    if str, ok := i.(string); ok {
        fmt.Println("i is a string:", str) // 輸出: i is a string: hello, world
    } else {
        fmt.Println("i is not a string")
    }
    // 嘗試斷言為其他類型
    if num, ok := i.(int); ok {
        fmt.Println("i is an int:", num)
    } else {
        fmt.Println("i is not an int") // 輸出: i is not an int
    }
}

func doSomething(i interface{}) {
    switch v := i.(type) {
    case string:
        fmt.Printf("It's a string: %q\n", v)
    case int:
        fmt.Printf("It's an int: %d\n", v)
    case Dog:
        fmt.Printf("It's a Dog: %v\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}
func main() {
    doSomething("hello")
    doSomething(123)
    doSomething(Dog{})
    doSomething(3.14)
}

package main
import "fmt"
// 定義基礎(chǔ)接口
type Reader interface {
    Read(p []byte) (n int, err error)
}
type Writer interface {
    Write(p []byte) (n int, err error)
}
// 通過組合接口，創(chuàng)建一個更復(fù)雜的接口
// ReadWriter 接口包含了 Reader 和 Writer 的所有方法
type ReadWriter interface {
    Reader
    Writer
}
// 定義一個結(jié)構(gòu)體來實(shí)現(xiàn) ReadWriter
type File struct {
    name string
}
func (f *File) Read(p []byte) (n int, err error) {
    fmt.Println("Reading from file:", f.name)
    // ... 模擬讀取
    return len(p), nil
}
func (f *File) Write(p []byte) (n int, err error) {
    fmt.Println("Writing to file:", f.name)
    // ... 模擬寫入
    return len(p), nil
}
func main() {
    file := &File{name: "data.txt"}
    // 因?yàn)?File 實(shí)現(xiàn)了 Read 和 Write，所以它也實(shí)現(xiàn)了 ReadWriter
    var rw ReadWriter = file
    rw.Read([]byte{})
    rw.Write([]byte{})
}

package main
import (
	"fmt"
	"math"
)
// --- 1. 定義接口 ---
// 定義一個描述幾何圖形的接口
type Geometry interface {
	Area() float64
	Perimeter() float64
}
// --- 2. 定義結(jié)構(gòu)體 ---
// 定義一個矩形結(jié)構(gòu)體
type Rectangle struct {
	Width, Height float64
}
// 定義一個圓形結(jié)構(gòu)體
type Circle struct {
	Radius float64
}
// --- 3. 為結(jié)構(gòu)體實(shí)現(xiàn)接口方法 ---
// Rectangle 實(shí)現(xiàn) Geometry 接口
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}
// Circle 實(shí)現(xiàn) Geometry 接口
func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
	return 2 * math.Pi * c.Radius
}
// --- 4. 編寫使用接口的函數(shù) ---
// 這個函數(shù)不關(guān)心傳入的是矩形還是圓形，只要它實(shí)現(xiàn)了 Geometry 接口即可
func Measure(g Geometry) {
	fmt.Println(g)
	fmt.Printf("Area: %.2f\n", g.Area())
	fmt.Printf("Perimeter: %.2f\n", g.Perimeter())
	fmt.Println("--------------------")
}
// 為了讓打印更友好，實(shí)現(xiàn) fmt.Stringer 接口
func (r Rectangle) String() string {
	return fmt.Sprintf("Rectangle (Width: %.2f, Height: %.2f)", r.Width, r.Height)
}
func (c Circle) String() string {
	return fmt.Sprintf("Circle (Radius: %.2f)", c.Radius)
}
// --- 5. 在 main 函數(shù)中使用 ---
func main() {
	// 創(chuàng)建具體的圖形實(shí)例
	r := Rectangle{Width: 10, Height: 5}
	c := Circle{Radius: 7}
	// 將它們作為 Geometry 接口類型傳遞
	// Measure 函數(shù)可以處理任何實(shí)現(xiàn)了 Geometry 接口的新類型，無需修改 Measure 函數(shù)本身
	// 這就是接口帶來的強(qiáng)大擴(kuò)展性！
	Measure(r)
	Measure(c)
	// 未來如果我們想增加一個三角形，只需定義 Triangle 結(jié)構(gòu)體并實(shí)現(xiàn) Geometry 接口，
	// Measure 函數(shù)就能立刻處理它，完美體現(xiàn)了“對擴(kuò)展開放，對修改關(guān)閉”的開閉原則。
}