4.Go基础速通

type Person struct{
    Name string
    Age int
    Email string
}

func main() {
    p := Person{
        Name:  "Inkka",
        Age:   17,
        Email: "inkkaplumbilibili@example.com",
    }

    // 访问结构体字段
    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
    fmt.Println("Email:", p.Email)

    // 修改结构体字段
    p.Age = 18
    fmt.Println("Updated Age:", p.Age)
}

package main

import "fmt"

func main() {
    // 初始化一个整数变量 i
    i := 114514

    // 将 i 的值赋给 j
    j := i

    // 修改 j 的值
    j = 1919810

    // 打印 i 和 j 的值
    fmt.Println("i:", i) // 输出: i: 114514
    fmt.Println("j:", j) // 输出: j: 1919810
}

package main

import "fmt"

func main(){
 a := 12

 b := &a

 *b = 13

 fmt.Println(a, *b)
}

type MyStruct struct {
    Name string
    age int
}

func NewMyStruct(name string, age int) *MyStruct {
    return &MyStruct{
        Name: name,
        age:  age,
    }
}

func (接收者变量 接收者类型) 方法名(参数列表) 返回类型 {
    函数体
}

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func main() {
    p := NewPerson("Gopher", 17)
    p.Activity()
}

func NewPerson(name string, age int) *Person {
    return &Person{
        name: name,
        age:  age,
    }
}

func (p Person) Activity() {
    fmt.Println(p.name, p.age)
}

package main

import "fmt"

type Person struct {
    name string
}

func main() {
 person1 := Person{name: "Gopher"}

 person1.SetName()
 person1.Activity()
}

func (p *Person) SetName() {
    p.name = "Inkka"
   }

func (p Person) Activity() {
    fmt.Println(p.name + "在写代码")
}

setName(newName: string) {
        this.name = newName;  // 实例属性赋值
    }

package main

import "fmt"

// 定义一个函数，接受一个 int 类型指针参数并修改它
func incrementByReference(val *int) {
    fmt.Println(1, val)
    *val++
    fmt.Println("Inside incrementByReference:", *val) // 输出: 11
}

func main() {
    num := 10
    fmt.Println(2, &num)
    incrementByReference(&num)
    fmt.Println("Outside incrementByReference:", num) // 输出: 11
}

package main

import "fmt"

// 定义一个函数，接受一个 int 类型参数并试图修改它
func incrementByValue(val int) {
    val++
    fmt.Println("Inside incrementByValue:", val) // 输出: 11
}

func main() {
    num := 10
    incrementByValue(num)
    fmt.Println("Outside incrementByValue:", num) // 输出: 10
}

type Animal interface {
    Speak() string
}

type Animal interface {
    Speak(string) string
}

//补充: 这也可以
type Animal interface {
    Speak(s string) string
}

package main

import "fmt"

// 定义 Animal 接口
type Animal interface {
    Speak() string
}

// 定义 Dog 结构体
type Dog struct {
    name string
}

// 定义 Cat 结构体
type Cat struct {
    name string
}

// Dog 实现 Animal 接口的 Speak 方法
func (d Dog) Speak() string {
    return "Woof!"
}

// Cat 实现 Animal 接口的 Speak 方法
func (c Cat) Speak() string {
    return "Nya!"
}

// 一个函数，接受 Animal 类型的参数
func MakeAnimalSpeak(a Animal) {
    fmt.Println(a.Speak())
}

func main() {
    dog := Dog{name: "Inu"}
    cat := Cat{name: "Neko"}

    // Dog 和 Cat 类型都实现了 Animal 接口
    MakeAnimalSpeak(dog) // 输出: Woof!
    MakeAnimalSpeak(cat) // 输出: Nya!
}