今天是2024年05月30日 星期四 小雨
买的书，终于到了，之前也一直有学过go语言，但是学的不是很深，现在在重新的过一遍
1、安装，省略
2、基础入门
第一个go程序
在随便一个目录中创建一个helloWorld.go文件，输入：
package main
import "fmt"
func main() {
fmt.Println("Hello World~")
}运行：go run helloWorld.go
也可以先编译：go build helloWorld.go 它就会在go文件的目录下生成exe文件（可执行文件）然后再使用./helloWorld进行执行
2、break:
package main
import "fmt"
func main() {
OuterLoop: // 外层循环的标签
for i := 0; i < 2; i++ { // 双层循环
for j := 0; j < 5; j++ {
switch j { // 使用switch进行数值分支判断
case 1:
fmt.Println(i, j)
break OuterLoop
case 2:
fmt.Println(i, j)
break OuterLoop // 退出OuterLoop对应的循环之外
}
}
}
}
运行结果：
3、const:
package main
import (
"fmt"
"time"
)
func main() {
type Direction int
const (
North Direction = iota
East
South
West
)
//var (
// age int
// name string
// balance []float32
//)
const pi = 3.141519
//const (
// e = 2.7182818
// pi = 3.1415926
//)
const noTime time.Duration = 0
const timeout = 5 * time.Minute
fmt.Printf("%T %[1]v\n", noTime) // "time.Duration 0"
fmt.Printf("%T %[1]v\n", timeout) // "time.Duration 5m0s"
fmt.Printf("%T %[1]v\n", time.Minute) // "time.Duration 1m0s"
//var x float32 = math.Pi
//var y float64 = math.Pi
//var z complex128 = math.Pi
//const Pi64 float64 = math.Pi
//var x float32 = float32(Pi64)
//var y float64 = Pi64
//var z complex128 = complex128(Pi64)
}运行结果：
4、continue:
package main
import "fmt"
func main() {
OuterLoop:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
switch j {
case 3:
fmt.Println(i, j)
continue OuterLoop // 结束当前循环，开启下一次的外层循环
}
}
}
}
运行结果：
5、for:
package main
import "fmt"
func main() {
//product := 1
//for i := 1; i < 5; i++ {
// product *= i
//}
//println(product)
//i := 0
//for {
// i++
// if i > 50 {
// break
// }
// println(i) //51
//}
JumpLoop:
for j := 0; j < 5; j++ {
for i := 0; i < 5; i++ {
if i > 2 {
break JumpLoop
}
fmt.Println(i)
}
}
//j := 2
//for ; j > 0; j++ {
// fmt.Println(j)
//}
// var i int
//JumpLoop:
// for ; ; i++ {
// if i > 10 {
// println(i)
// break JumpLoop
// }
// }
//var i int
//for {
// if i > 10 {
// break
// }
// i++
//}
//var i int
//for i <= 20 {
// println(i)
// i++
//}
}
运行结果：
6、forrange:
package main
import "fmt"
func main() {
//for key, value := range []int{1, 2, 3, 4} {
// fmt.Printf("key:%d value:%d\n", key, value)
//}
var str = "hi 加油"
for key, value := range str {
fmt.Printf("key:%d value:0x%x\n", key, value)
}
//m := map[string]int{
// "go": 100,
// "web": 100,
//}
//for key, value := range m {
// fmt.Println(key, value)
//}
c := make(chan int) //创建了一个整型类型的通道
go func() { //启动了一个协程
c <- 7 //逻辑的实现
c <- 8
c <- 9
close(c)
}()
for v := range c {
fmt.Println(v)
}
//for key, value := range []int{0, 1, -1, -2} {
// fmt.Printf("key:%d value:%d\n", key, value)
//}
//m := map[string]int{
// "shirdon": 100,
// "ronger": 98,
//}
//for _, value := range m {
// fmt.Println(value)
//}
//for key, _ := range []int{9, 8, 7, 6} {
// fmt.Printf("key:%d \n", key)
//}
}
7、goto:
package main
import "fmt"
func main() {
//var isBreak bool
//for x := 0; x < 20; x++ {// 外循环
// for y := 0; y < 20; y++ {// 内循环
// if y == 2 {// 满足某个条件时, 退出循环
// isBreak = true// 设置退出标记
// break// 退出本次循环
// }
// }
// if isBreak {// 根据标记, 还需要退出一次循环
// break
// }
//}
//fmt.Println("over")
for x := 0; x < 20; x++ {
for y := 0; y < 20; y++ {
if y == 2 {
goto breakTag // 跳转到标签
}
}
}
return // 手动返回, 避免执行进入标签
breakTag: // 标签
fmt.Println("done")
}运行结果：
package main
import "fmt"
func main() {
var breakAgain bool
// 外循环
for x := 0; x < 20; x++ {
// 内循环
for y := 0; y < 20; y++ {
// 满足某个条件时, 退出循环
if y == 2 {
// 设置退出标记
breakAgain = true
// 退出本次循环
break
}
}
// 根据标记, 还需要退出一次循环
if breakAgain {
break
}
}
fmt.Println("done")
}
package main
import "fmt"
func main() {
for x := 0; x < 20; x++ {
for y := 0; y < 20; y++ {
if y == 2 {
// 跳转到标签
goto breakHere
}
}
}
// 手动返回, 避免执行进入标签
return
// 标签
breakHere:
fmt.Println("done")
}package main
import "fmt"
func main() {
//......省略前面代码
err := getUserInfo()
if err != nil {
fmt.Println(err)
exitProcess()
return
}
err = getEmail()
if err != nil {
fmt.Println(err)
exitProcess()
return
}
fmt.Println("over")
// err := getUserInfo()
// if err != nil {
// goto doExit //将跳转错误标签 onExit
// }
// err = getEmail()
// if err != nil {
// goto doExit //将跳转错误标签 onExit
// }
// fmt.Println("over")
// return
//doExit: //汇总所有流程进行错误打印并退出进程
// fmt.Println(err)
// exitProcess()
}
8、str:
package main
import "fmt"
func main() {
//str := "hello string!"
//str = "hello modify!"
//fmt.Println(str)
//
// str1 := "\"Go Web\",I love you \n"//支持转义，但不能用来引用多行
// str2 :=`"Go Web",
//I love you \n` //支持多行组成，但不支持转义
// println(str1)
// println(str2)
str := "I love" + " Go Web"
str += " programming"
fmt.Println(str) // I love Go Web programming
//str := "programming"
//fmt.Println(str[1]) //获取字符串索引位置为1的原始字节，比如r为114
//fmt.Println(str[1:3]) //截取得字符串索引位置为 1 到 2 的字符串
//fmt.Println(str[1:]) //截取得字符串索引位置为 1 到 len(s)-1 的字符串
//fmt.Println(str[:3]) //截取得字符串索引位置为 0 到 2 的字符串
//fmt.Println(len(str)) //获取字符串的字节数
//fmt.Println(utf8.RuneCountInString(str)) //获取字符串字符的个数
//fmt.Println([]rune(str)) // 将字符串的每一个字节转换为码点值，比如这里会输出[112 114 111 103 114 97 109 109 105 110 103]
//fmt.Println(string(str[1])) // 获取字符串索引位置为1的字符值
//var buffer bytes.Buffer //创建一个空的 bytes.Buffer
//for {
// if piece,ok := getNextString();ok {
// buffer.WriteString(piece) //通过 WriteString 方法将我们需要串联的字符串写入到 buffer 中
// } else {
// break
// }
//}
//fmt.Println(buffer.String()) //最后用于取回整个级联的字符串
//str := "love go web"
//for index, char := range str {
// fmt.Printf("%d %U %c \n", index, char, char)
//}
//str := "go web"
//fmt.Println(string(str[0])) //获取索引为0的字符
//str := "i love go web"
//str := `i love go web`
//chars := []rune(str) //先把字符串转为rune切片
//for _, char := range chars {
// fmt.Println(string(char))
//}
//str := "Hi 世界！"
//by := []byte(str) // 转换为 []byte，数据被自动复制
//by[2] = ',' // 把空格改为半角逗号
//fmt.Printf("%s\n", str)
//fmt.Printf("%s\n", by)
//str := "Hi 世界"
//by := []rune(str) // 转换为[]rune，数据被自动复制
//by[3] = '中'
//by[4] = '国'
//fmt.Println(str)
//fmt.Println(string(by))
}
func getNextString() (string, bool) {
return "", true
}
9、switchcase：
package main
func main() {
//var a = "love"
//switch a {
//case "love":
// fmt.Println("love")
//case "programming":
// fmt.Println("programming")
//default:
// fmt.Println("none")
//}
//var language = "golang"
//switch language {
//case "golang", "java":
// fmt.Println("program")
//}
//var r int = 11
//switch {
//case r > 10 && r < 20:
// fmt.Println(r)
//}
}
10、var：
func main() {
//var (
// age int = 28
// name string = "shirdon"
// balance float32 = 999999.99
//)
//var (
// age int
// name string
// balance float32
//)
var language string = "Go"
//var language = "Go"
//language := "Go"
//var age, name, balance = 30, "liao", 99.99
age, name, balance := 30, "shirdon", 999999.99
d, c := "D", "C"
c, d = d, c
println(c)
println(d)
println(age)
println(name)
println(balance)
println(language)
}11、varScope：
package main
import "fmt"
// 声明全局变量
var global int
func main() {
// 声明局部变量
var local1, local2 int
// 初始化参数
local1 = 8
local2 = 10
global = local1 * local2
fmt.Printf("local1 = %d, local2 = %d and g = %d\n", local1, local2, global)
}
package main
import "fmt"
func main() {
// 声明局部变量
var local1, local2, local3 int
//初始化参数
local1 = 8
local2 = 10
local3 = local1 * local2
fmt.Printf(" local1 = %d, local2 = %d and local3 = %d\n", local1, local2, local3)
}package main
import "fmt"
// 声明全局变量
var global int = 8
func main() {
// 声明局部变量
var global int = 999
fmt.Printf("global = %d\n", global)
}12、Array：
package main
import "fmt"
func main() {
var arr [6]int /* n 是一个长度为 5 的数组 */
var i, j int
for i = 0; i < 6; i++ { /* 为数组 n 初始化元素 */
arr[i] = i + 66 /* 设置元素为 i + 66 */
}
for j = 0; j < 6; j++ { /* 输出每个数组元素的值 */
fmt.Printf("Array[%d] = %d\n", j, arr[j])
}
}13、bool:
package main
import "fmt"
func main() {
var aVar = 100
fmt.Println(aVar == 50) //false
fmt.Println(aVar == 100) //true
fmt.Println(aVar != 50) //true
fmt.Println(aVar != 100) //false
var str1 string
var str2 string
if str1 == "java" && str2 == "golang" {
}
//var c int
//if 1 <= c && c <= 9 ||
// 10 <= c && c <= 19 ||
// 20 <= c && c <= 30 {
// //...
//}
i := 0
b := true
if b {
i = 1
}
fmt.Println(i)
fmt.Println(intToBool(0))
var d bool
fmt.Println(int(d) * 5)
}
// 将bool转换为int
func boolToInt(b bool) int {
if b {
return 1
}
return 0
}
func intToBool(i int) bool { return i != 0 }
14、map:
package main
import "fmt"
func main() {
//var literalMap map[string]string
//var assignedMap map[string]string
//literalMap = map[string]string{"first": "go", "second": "web"}
//createdMap := make(map[string]float32)
//assignedMap = literalMap
//createdMap["k1"] = 99
//createdMap["k2"] = 199
//assignedMap["second"] = "program"
//fmt.Printf("Map literal at \"first\" is: %s\n", literalMap["first"])
//fmt.Printf("Map created at \"k2\" is: %f\n", createdMap["k2"])
//fmt.Printf("Map assigned at \"second\" is: %s\n", literalMap["second"])
//fmt.Printf("Map literal at \"third\" is: %s\n", literalMap["third"])
//achievement := map[string]float32{
// "zhangsan": 99.5, "lisi": 88,
// "wangwu": 96, "lidong": 100,
//}
createdMap := new(map[string]float32)
createdMap["k1"] = 4.5
fmt.Println(createdMap)
//map2 := make(map[string]float32, 100)
}
15、pointer:
package main
func main() {
var b int = 66 //定义一个普通类型
var p *int = &b //定义一个指针类型
println(b)
println(p)
}
16、pointer-use:
package main
import (
"fmt"
)
func main() {
var score int = 100
var name string = "Barry"
// 使用 fmt.Printf 的动词%p输出 score 和 name 变量取地址后的指针值
fmt.Printf("%p %p", &score, &name)
}
package main
import (
"fmt"
)
func main() {
var address = "Chengdu,China" // 准备一个字符串类型
ptr := &address // 对字符串取地址, ptr类型为*string
fmt.Printf("ptr type: %T\n", ptr) // 打印ptr的类型
fmt.Printf("address: %p\n", ptr) // 打印ptr的指针地址
value := *ptr // 对指针进行取值操作
fmt.Printf("value type: %T\n", value) // 取值后的类型
fmt.Printf("value: %s\n", value) // 指针取值后就是指向变量的值
}
package main
import "fmt"
// 交换函数
func exchange(c, d *int) {
t := *c // 取c指针的值, 赋给临时变量t
*c = *d // 取d指针的值, 赋给c指针指向的变量
*d = t // 将c指针的值赋给d指针指向的变量
}
func main() {
a, b := 6, 8 // 准备两个变量, 赋值6和8
exchange(&a, &b) // 交换变量值
fmt.Println(a, b) // 输出变量值
}
package main
import "fmt"
func exchange2(c, d *int) {
d, c = c, d
}
func main() {
x, y := 6, 8
exchange2(&x, &y)
fmt.Println(x, y)
}
17、slice:
package main
import "fmt"
func main() {
//var a = [3]int{1, 2, 3}
//fmt.Println(a, a[1:2])
//var sliceBuilder [20]int
//for i := 0; i < 20; i++ {
// sliceBuilder[i] = i + 1
//}
//fmt.Println(sliceBuilder[5:15]) // 区间
//fmt.Println(sliceBuilder[15:]) // 中间到尾部的所有元素
//fmt.Println(sliceBuilder[:2]) // 开头到中间指定位置的所有元素
//a := []int{6, 7, 8}
//fmt.Println(a[:])
//a := []int{6, 7, 8}
//fmt.Println(a[0:0])
//var sliceStr []string // 声明字符串切片
//var sliceNum []int // 声明整型切片
//var emptySliceNum = []int{} // 声明一个空切片
//fmt.Println(sliceStr, sliceNum, emptySliceNum) // 输出3个切片
//fmt.Println(len(sliceStr), len(sliceNum), len(emptySliceNum)) // 输出3个切片大小
//fmt.Println(sliceStr == nil) // 切片判定空的结果
//fmt.Println(sliceNum == nil)
//fmt.Println(emptySliceNum == nil)
slice1 := make([]int, 6)
slice2 := make([]int, 6, 10)
fmt.Println(slice1, slice2)
fmt.Println(len(slice1), len(slice2))
}
18、struct:
package main
import "fmt"
type Book struct {
title string
author string
subject string
press string
}
func main() {
// 创建一个新的结构体
fmt.Println(Book{"Go Web编程实战派从入门到精通", "廖显东", "Go语言教程", "电子工业出版社"})
// 也可以使用 key => value 格式
fmt.Println(Book{title: "Go Web编程实战派从入门到精通", author: "廖显东", subject: "Go语言教程", press: "电子工业出版社"})
// 忽略的字段为 0 或 空
fmt.Println(Book{title: "Go Web编程实战派从入门到精通", author: "廖显东"})
}
package main
import "fmt"
type Books struct {
title string
author string
subject string
press string
}
func main() {
var bookGo Books //声明bookGo为Books类型
var bookPython Books //声明bookPython为Books类型
// bookGo描述
bookGo.title = "Go Web编程实战派从入门到精通"
bookGo.author = "廖显东"
bookGo.subject = "Go语言教程"
bookGo.press = "电子工业出版社"
// bookPython描述
bookPython.title = "Python教程xxx"
bookPython.author = "张三"
bookPython.subject = "Python语言教程"
bookPython.press = "xxx出版社"
//打印 bookGo 信息
fmt.Printf("bookGo title : %s\n", bookGo.title)
fmt.Printf("bookGo author : %s\n", bookGo.author)
fmt.Printf("bookGo subject : %s\n", bookGo.subject)
fmt.Printf("bookGo press : %s\n", bookGo.press)
//打印 bookPython 信息
fmt.Printf("bookPython title : %s\n", bookPython.title)
fmt.Printf("bookPython author : %s\n", bookPython.author)
fmt.Printf("bookPython subject : %s\n", bookPython.subject)
fmt.Printf("bookPython press : %s\n", bookPython.press)
}
package main
import "fmt"
type Books struct {
title string
author string
subject string
press string
}
func main() {
var bookGo Books /* 声明bookGo为Books类型 */
var bookPython Books /* 声明bookPython为Books类型 */
/* bookGo描述 */
bookGo.title = "Go Web编程实战派从入门到精通"
bookGo.author = "廖显东"
bookGo.subject = "Go语言教程"
bookGo.press = "电子工业出版社"
/* bookPython描述 */
bookPython.title = "Python教程xxx"
bookPython.author = "张三"
bookPython.subject = "Python语言教程"
bookPython.press = "xxx出版社"
/* 打印 bookPython 信息 */
printBook(bookGo)
/* 打印 bookPython 信息 */
printBook(bookPython)
}
func printBook(book Books) {
fmt.Printf("Book title : %s\n", book.title)
fmt.Printf("Book author : %s\n", book.author)
fmt.Printf("Book subject : %s\n", book.subject)
fmt.Printf("Book press : %s\n", book.press)
}
19、struct-pointer：
package main
import "fmt"
type Books struct {
title string
author string
subject string
press string
}
func main() {
var bookGo Books /* 声明bookGo为Books类型 */
var bookPython Books /* 声明bookPython为Books类型 */
/* bookGo描述 */
bookGo.title = "Go Web编程实战派从入门到精通"
bookGo.author = "廖显东"
bookGo.subject = "Go语言教程"
bookGo.press = "电子工业出版社"
/* bookPython描述 */
bookPython.title = "Python教程xxx"
bookPython.author = "张三"
bookPython.subject = "Python语言教程"
bookPython.press = "xxx出版社"
/* 打印 bookPython 信息 */
printBook(&bookGo)
/* 打印 bookPython 信息 */
printBook(&bookPython)
}
func printBook(book *Books) {
fmt.Printf("Book title : %s\n", book.title)
fmt.Printf("Book author : %s\n", book.author)
fmt.Printf("Book subject : %s\n", book.subject)
fmt.Printf("Book press : %s\n", book.press)
}20、func:
package main
import "fmt"
func main() {
array := []int{6, 8, 10} //定义局部变量
var ret int
ret = min(array) //调用函数并返回最小值
fmt.Printf("最小值是 : %d\n", ret)
}
func min(arr []int) (min int) { //获取整型数组中的最小值
min = arr[0]
for _, v := range arr {
if v < min {
min = v
}
}
return
}package main
import "fmt"
func compute(x, y int) (int, int) {
return x + y, x * y
}
func main() {
a, b := compute(6, 8)
fmt.Println(a, b)
}package main
import "fmt"
/* 定义和的函数 */
func sum(x, y int) int {
return x + y
}
func main() {
a, b := compute(6, 8)
fmt.Println(a, b)
}package main
import "fmt"
func main() {
/* 定义局部变量 */
num1 := 6
num2 := 8
fmt.Printf("交换前num1的值为 : %d\n", num1)
fmt.Printf("交换前num2的值为 : %d\n", num2)
/* 通过调用函数来交换值 */
exchange(num1, num2)
fmt.Printf("交换后num1的值 : %d\n", num1)
fmt.Printf("交换后num2的值 : %d\n", num2)
}
/* 定义相互交换值的函数 */
func exchange(x, y int) int {
var tmp int
tmp = x /* 将 x 值赋给 tmp */
x = y /* 将 y 值赋给 x */
y = tmp /* 将 tmp 值赋给 y*/
return tmp
}package main
import (
"fmt"
"math"
)
func main() {
getPow := func(x float64, y float64) float64 { //声明函数变量
return math.Pow(x, y)
}
fmt.Println(getPow(3, 4)) //使用函数
}package main
import "fmt"
func main() {
x, y := 6, 8
defer func(a int) {
fmt.Println("defer x, y = ", a, y) //y为闭包引用
}(x)
x += 10
y += 100
fmt.Println(x, y)
}package main
import (
"fmt"
)
/* 定义结构体 */
type Circle struct {
radius float64
}
func main() {
var c Circle
c.radius = 6.00
fmt.Println("圆的周长 = ", c.getCircumference())
}
func (c Circle) getCircumference() float64 { //该 method 属于 Circle 类型对象中的方法
return 2 * 3.14 * c.radius //c.radius 即为 Circle 类型对象中的属性
}
21、func-pointer:
package main
import "fmt"
func main() {
/* 定义局部变量 */
num1 := 6
num2 := 8
fmt.Printf("交换前num1的值为 : %d\n", num1)
fmt.Printf("交换前num2的值为 : %d\n", num2)
/* 通过调用函数来交换值 */
exchange(&num1, &num2)
fmt.Printf("交换后num1的值 : %d\n", num1)
fmt.Printf("交换后num2的值 : %d\n", num2)
}
/* 定义相互交换值的函数 */
func exchange(x *int, y *int) int {
var tmp int
tmp = *x /* 将 *x 值赋给 tmp */
*x = *y /* 将 *y 值赋给 *x */
*y = tmp /* 将 tmp 值赋给 y*/
return tmp
}
22、func-closure:
package main
import "fmt"
func main() {
// 定义匿名函数并赋值给f变量
f := func(data int) {
fmt.Println("hi, this is a closure", data)
}
// 此时f变量的类型是func(), 可以直接调用
f(6)
//直接声明并调用
func(data int) {
fmt.Println("hi, this is a closure, directly", data)
}(8)
}package main
import "fmt"
// 遍历切片中每个元素，通过给定的函数访问元素
func visitPrint(list []int, f func(int)) {
for _, value := range list {
f(value)
}
}
func main() {
sli := []int{1, 6, 8}
// 使用匿名函数打印切片的内容
visitPrint(sli, func(value int) {
fmt.Println(value)
})
}23、func-defer:
package main
import "fmt"
func main() {
deferCall()
}
func deferCall(){
defer func1()
defer func2()
defer func3()
}
func func1() {
fmt.Println("A")
}
func func2() {
fmt.Println("B")
}
func func3() {
fmt.Println("C")
}package main
import "fmt"
func main() {
name := "go"
defer fmt.Println(name) // 输出: go
name = "python"
defer fmt.Println(name) // 输出: python
name = "java"
fmt.Println(name)
}24、func-defer-return:
package main
import "fmt"
var name string = "go"
func myfunc() string {
defer func() {
name = "python"
}()
fmt.Printf("myfunc 函数里的name：%s\n", name)
return name
}
func main() {
myname := myfunc()
fmt.Printf("main 函数里的name: %s\n", name)
fmt.Println("main 函数里的myname: ", myname)
}
25、func-return:
package main
func change(a, b int) (x, y int) {
x = a + 100
y = b + 100
return //101, 102
//return x, y //同上
//return y, x //102, 101
}
func main(){
a := 1
b := 2
c, d := change(a, b)
println(c, d)
}26、object:
package main
import (
"fmt"
)
// 三角形结构体
type Triangle struct {
Bottom float32
Height float32
}
// 计算三角形面积
func (t *Triangle) Area() float32 {
return (t.Bottom * t.Height) / 2
}
func main() {
r := Triangle{6, 8}
// 调用 Area() 方法，计算面积
fmt.Println(r.Area())
}
//package main
//
//// 三角形结构体
//type Student struct {
// Name string
// score float32
//}
//
//func main() {
// student := new(Student)
// student.Name = "shirdon"
// student.score = 9
//
// println(student.Name)
// println(student.score)
//}
package main
import (
"fmt"
"gitee.com/shirdonl/goWebActualCombat/chapter1/person"
)
func main() {
s := new(person.Student)
s.SetName("Shirdon")
fmt.Println(s.GetName())
}
package main
import (
"./person"
"fmt"
)
func main() {
s := new(person.Student)
s.name = "shirdon"
s.Age = 22
fmt.Println(s.Age)
}
package main
type Engine interface {
Start()
Stop()
}
type Bus struct {
Engine // 包含 Engine 类型的匿名字段
}
func (c *Bus) Working() {
c.Start() //开动汽车
c.Stop() //停车
}
package main
import "fmt"
// 正方形
type Square struct {
sideLen float32
}
// 三角形结构体
type Triangle struct {
Bottom float32
Height float32
}
// 计算三角形面积
func (t *Triangle) Area() float32 {
return (t.Bottom * t.Height) / 2
}
// 接口 Shape
type Shape interface {
Area() float32
}
// 计算正方形的面积
func (sq *Square) Area() float32 {
return sq.sideLen * sq.sideLen
}
func main() {
t := &Triangle{6, 8}
s := &Square{8}
shapes := []Shape{t, s} // 创建一个 Shape 类型的数组
for n, _ := range shapes { // 迭代数组上的每一个元素并调用 Area() 方法
fmt.Println("图形数据: ", shapes[n])
fmt.Println("它的面积是: ", shapes[n].Area())
}
}
27、interface-assign:
package main
import "fmt"
type Num int
func (x Num) Equal(i Num) bool {
return x == i
}
func (x Num) LessThan(i Num) bool {
return x < i
}
func (x Num) BiggerThan(i Num) bool {
return x > i
}
func (x *Num) Multiple(i Num) {
*x = *x * i
}
func (x *Num) Divide(i Num) {
*x = *x / i
}
type NumI interface {
Equal(i Num) bool
LessThan(i Num) bool
BiggerThan(i Num) bool
Multiple(i Num)
Divide(i Num)
}
type NumI2 interface {
Equal(i Num) bool
LessThan(i Num) bool
MoreThan(i Num) bool
}
func main() {
var x Num = 8
var y NumI = &x
var a Num = 1
var b1 NumI = &a
var b2 NumI2 = a
fmt.Println(b1)
fmt.Println(b2)
}package main
type Num int
func (x Num) Equal(i int) bool {
return int(x) == i
}
func (x Num) LessThan(i int) bool {
return int(x) < i
}
func (x Num) BiggerThan(i int) bool {
return int(x) > i
}
func (x *Num) Sum(i int) {
*x = *x + Num(i)
}
func main() {
//var f1 Num = 6
//var f2 oop1.NumInterface1 = f1
//var f3 oop2.NumInterface2 = f2
//println(f3)
//var f1 Num = 6
//var f2 oop2.NumInterface2 = f1
//var f3 oop1.NumInterface1 = f2
}
28、interface:
package main
import "fmt"
func main() {
slice := make([]int, 0)
slice = append(slice, 6, 7, 8)
var I interface{} = slice
if res, ok := I.([]int); ok {
fmt.Println(res) //[6 7 8]
fmt.Println(ok)
}
}
func Len(array interface{}) int {
var length int //数组的长度
if array == nil {
length = 0
}
switch array.(type) {
case []int:
length = len(array.([]int))
case []string:
length = len(array.([]string))
case []float32:
length = len(array.([]float32))
default:
length = 0
}
fmt.Println(length)
return length
}
package main
import "fmt"
type InterfaceFile interface {
Read()
Write()
}
type InterfaceReader interface {
Read()
}
type File struct {
}
func (f *File) Read() {
}
func (f *File) Write() {
}
func main() {
f := new(File)
var f1 InterfaceFile = f
var f2 InterfaceReader = f1
var f3 InterfaceReader = new(File)
// 接口查询
if f5, ok := f3.(InterfaceFile); ok {
fmt.Println(f5)
}
// 询问接口它指向的对象是否是某个类型
if f6, ok := f3.(*File); ok {
fmt.Println(f6)
}
fmt.Println(f1, f2, f3)
}
package main
type stringer interface {
string() string
}
type tester interface {
stringer // 嵌入其他接口
test()
}
type data struct{}
func (*data) test() {
}
func (data) string() string {
return ""
}
func main() {
var d data
var t tester = &d
t.test()
println(t.string())
}
package main
func main() {
var var1, var2 interface{}
println(var1 == nil, var1 == var2)
var1, var2 = 66, 88
println(var1 == var2)
var1, var2 = map[string]string{}, map[string]string{}
println(var1 == var2)
}
package main
import "fmt"
func main() {
var a interface{} = func(a int) string {
return fmt.Sprintf("d:%d", a)
}
switch b := a.(type) { // 局部变量v是类型转换后的结果
case nil:
println("nil")
case *int:
println(*b)
case func(int) string:
println(b(66))
case fmt.Stringer:
fmt.Println(b)
default:
println("unknown")
}
}
package main
import "fmt"
// message是一个定义了通知类行为的接口
type Message interface {
sending()
}
// 定义user及user.notify方法
type User struct {
name string
phone string
}
func (u *User) sending() {
fmt.Printf("Sending user phone to %s<%s>\n", u.name, u.phone)
}
// 定义admin及admin.message方法
type admin struct {
name string
phone string
}
func (a *admin) sending() {
fmt.Printf("Sending admin phone to %s<%s>\n", a.name, a.phone)
}
func main() {
// 创建一个user值并传给sendMessage
bill := User{"Barry", "barry@gmail.com"}
sendMessage(&bill)
// 创建一个admin值并传给sendMessage
lisa := admin{"Jim", "jim@gmail.com"}
sendMessage(&lisa)
}
// sendMessage接受一个实现了message接口的值 并发送通知
func sendMessage(n Message) {
n.sending()
}
29、interface-combination：
package main
// 接口1
type Interface1 interface {
Write(p []byte) (n int, err error)
}
// 接口2
type Interface2 interface {
Close() error
}
// 接口组合
type InterfaceCombine interface {
Interface1
Interface2
}
30、reflection:
package main
import (
"fmt"
"reflect"
)
func main() {
//var x float64 = 3.4
//fmt.Println("type:", reflect.TypeOf(x))
//var x float64 = 6.8
//fmt.Println("value:", reflect.ValueOf(x)) //Valueof方法会返回一个Value类型的对象
//var x float64 = 6.8
//v := reflect.ValueOf(x)
//fmt.Println("type:", v.Type())
//fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
//fmt.Println("value:", v.Float())
//var x uint8 = 'x'
//v := reflect.ValueOf(x)
//fmt.Println("type:", v.Type()) // uint8.
//fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
//x = uint8(v.Uint())// v.Uint returns a uint64. 这个地方必须进行强制类型转换！
type DefinedInt int
var x DefinedInt = 8
v := reflect.ValueOf(x)
fmt.Println(v)
}
package main
import (
"fmt"
"reflect"
)
func main() {
var name string = "Go Web Program"
v := reflect.ValueOf(name)
fmt.Println("可写性为:", v.CanSet())
}
package main
import (
"fmt"
"reflect"
)
func main() {
var name interface{} = "shirdon"
fmt.Printf("原始接口变量的类型为 %T，值为 %v \n", name, name)
t := reflect.TypeOf(name)
v := reflect.ValueOf(name)
// 从接口变量到反射对象
fmt.Printf("从接口变量到反射对象：Type对象的类型为 %T \n", t)
fmt.Printf("从接口变量到反射对象：Value对象的类型为 %T \n", v)
// 从反射对象到接口变量
i := v.Interface()
fmt.Printf("从反射对象到接口变量：新对象的类型为 %T 值为 %v \n", i, i)
}
package main
import (
"fmt"
"reflect"
)
func main() {
var name string = "Go Web Program"
fmt.Println("真实 name 的原始值为：", name)
v1 := reflect.ValueOf(&name)
v2 := v1.Elem()
v2.SetString("Go Web Program2")
fmt.Println("通过反射对象进行更新后，真实 name 变为：", name)
}
package main
import (
"fmt"
"reflect"
)
func main() {
var name string = "Go Web Program"
v1 := reflect.ValueOf(&name)
fmt.Println("v1 可写性为:", v1.CanSet())
v2 := v1.Elem()
fmt.Println("v2 可写性为:", v2.CanSet())
}
31、gproutine:
package main
import (
"fmt"
"time"
)
func HelloWorld() {
fmt.Println("this is a goroutine msg")
}
func main() {
go HelloWorld()
time.Sleep(1 * time.Second)
fmt.Println("end")
}