java转go 翱翔之路(二)基础语法:匿名组合,方法,接口,map,json,异常处理,channel管道,select用法

飞奔的屎壳郎

已于 2022-04-23 11:59:19 修改

阅读量227

点赞数

分类专栏： java转go 文章标签： golang go

于 2020-06-13 14:36:34 首次发布

本文链接：https://blog.csdn.net/qq_35349982/article/details/106731972

版权

java转go 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

2.4 面向对象编程

2.4.1匿名组合


type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	Person //只有类型 没有名字,匿名字段 继承了person的成员
	garde  string
	class  string
}

2.4.1.2 定义类,赋值,修改

	//定义类
	var per1 Student = Student{Person{1, "生活", 18}, "初中", "初一"}
	fmt.Println("per1", per1)
	//自动推导类型
	per2 := Student{Person{1, "生活", 18}, "初中", "初一"}
	fmt.Printf("per2 %v\n", per2)
	//单独复制
	per3 := Student{class: "初一"}
	fmt.Printf("per3 %v\n", per3)
	per4 := Student{Person: Person{id: 5}, class: "初一"}
	per4.name = "sss"
	per4.Person = Person{5, "aaa", 22}
	fmt.Printf("per4 %v\n", per4)

2.4.1.3 匿名字段追加

//非结构匿名字段
type addColum string
func main() {
	per2 := Student{Person{1, "生活", 18}, "初中", "初一", "追加字段"}
	fmt.Printf("per2 %v\n", per2)//per2 {{1 生活 18} 初中 初一 追加字段}
}

2.4.1.4 地址匿名字段追加

//非结构匿名字段
type addColum string

type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	*Person //只有类型 没有名字,匿名字段 继承了person的成员
	garde   string
	class   string
	addColum
}

func main() {
	per2 := Student{&Person{1, "生活", 18}, "初中", "初一", "追加字段"}
	fmt.Printf("per2 %v\n", per2)
	fmt.Println(per2.id, per2.name, per2.age, per2.garde, per2.class)
	var per3 Student
	per3.Person = new(Person)
	per3.addColum = "append"
	per3.id = 5
	per3.name = "sss"
	fmt.Println(per3.id, per3.name, per3.age, per3.garde, per3.class)
}

2.4.2方法

2.4.2.1 定义

//面向对象,方法:给某个类型绑定一个函数
type long int

//tmp叫接受者,接受者传递的一个参数
func (tmp long) Add02(other long) long {
	fmt.Println("tmp =", tmp)//1
	return tmp + other

}

func main() {
	//定义一个变量
	var test long = 1
	//调用方法格式 :变量名.函数
	r := test.Add02(3)
	fmt.Println("r =", r)//4

}

2.4.2.2 赋值,输出


//输出函数
func (per Person) pringInfo() {
	fmt.Println("per =", per)
}

//赋值函数
func (per Person) setInfo(a int, b string, c int) {
	per.id = a
	per.name = b
	per.age = c

	fmt.Println("per =", per)
}

func main() {
	per1 := Person{1, "小三", 20}
	per1.pringInfo()
	per1.setInfo(2, "小三的小三", 21)

}

2.4.2.3 值传递与引用传递

type Person struct {
	id   int
	name string
	age  int
}

//赋值函数
func (per Person) setInfo(a int, b string, c int) {
	per.id = a
	per.name = b
	per.age = c

	fmt.Printf("per = %v\n", per)//per = {3 修改 22}
}

//引用传递
func (per *Person) setInfoPoint(a int, b string, c int) {
	per.id = a
	per.name = b
	per.age = c

	fmt.Printf("per = %v\n", per)//per = &{4 修改 32}
}

func main() {
	per1 := Person{1, "小三", 20}
	per1.setInfo(3, "修改", 22) //引用传递
	fmt.Println(per1)//{1 小三 20}
	per2 := Person{2, "小三的小三", 21}
	per2.setInfoPoint(4, "修改", 32) //值传递
	fmt.Println(per2) //{4 修改 32}

}

2.4.2.4 继承传递


type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	Person
	garde string
}
//输出函数
func (per Person) pringInfo() {
	fmt.Println("per =", per)
}

func main() {
	//继承
	stu := Student{Person{5, "小三5", 25}, "s"}
	stu.pringInfo()
	fmt.Println(stu)

}

2.4.2.5 方法值

	stu := Student{Person{5, "小三5", 25}, "s"}
	stu.pringInfo()
	//方法值 保存方式入口地址
	pFunc := stu.pringInfo //这个就是方法值,调用函数时,无需再传递接受者
	pFunc() //等价于 stu.pringInfo()

2.4.2.5 方法表达式

	//方法表达式
	f := (*PePerson).setInfoPoint
	f(&stu) //等价于 stu.setInfoPoint()

	f1 := (PePerson).setInfo
	f1(stu) //等价于 stu.setInfo()

	fmt.Println(stu)

2.4.3接口

2.4.3.1 定义

//定义接口
type inter interface {
	say()
}

//studnt实现了say方法
func (tmp *Teacher) say() {

	fmt.Printf("Studnt %s\n", tmp.zz)
}

func main() {
	var i inter
		//只要实现 该接口,就可以给这个接口赋值
	s := &Teacher{"是啥"}
	i = s
	i.say()//Studnt 是啥
}

2.4.3.2 继承实现

type inter interface {
	say()
}
type inter1 interface {
	inter
	say1()
}

//studnt实现了say方法
func (tmp *Teacher) say() {

	fmt.Printf("Studnt %s\n", tmp.zz)
}

//studnt实现了say1方法
func (tmp *Teacher) say1() {

	fmt.Printf("Studnt %s\n", tmp.zz)
}

func main() {
	var i inter1
	//只要实现 该接口,就可以给这个接口赋值
	s := &Teacher{"是啥"}
	i = s
	i.say()
	i.say1()
}

2.4.3.3 接口转换

	var i1 inter1 //超集
	i1 = &Teacher{"是啥"}
	var i inter //子集

	i = i1 //可以 超集可以转换为子集

	i.say()

2.4.3.4 空接口

	i := make([]interface{}, 3)

	i[0] = 1
	i[1] = "ss"

	for index, data := range i {

		if value, ok := data.(int); ok == true {
			fmt.Printf("index [%v] ,x[%d]\n", index, value)
		}

	}

2.5 异常处理,字符串

2.5.1错误接口(error)

	err1 := fmt.Errorf("%s", "no error")
	fmt.Println(err1)
	err2 := errors.New("错误")
	fmt.Println(err2)

2.5.1.1错误接口的应用

func MyDiv(a, b int) (result int, err error) {
	err = nil
	if b == 0 {
		err = errors.New("B不能为0")
	} else {

		result = a / b
	}
	return

}

func main() {

	val, err := MyDiv(1, 0)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(val)
	}

}

2.5.2函数程序中断(panic)

func test() {
	//导致程序中断
	panic("this is a panic")
}

2.5.3函数程序(recover)

func test1() {

	defer func() {
		//err是该函数默认返回值
		if err := recover(); err != nil {
			fmt.Println(err)
		}

	}() //()调用此函数
}

2.5.4字符串函数的使用

	fmt.Println(strings.Contains("abcdefg", "abc")) //true

	arr := []string{"abc", "hello", "arr"}
	fmt.Println(strings.Join(arr, "@")) //abc@hello@arr

	fmt.Println(strings.Index("abcdefg", "b")) //1

	arrStr := "abc@hello@arr"
	fmt.Println(strings.Split(arrStr, "@")) //[abc hello arr]

2.5.5 strconv包

	arr1 := make([]byte, 0, 1024)
	arr1 = strconv.AppendBool(arr1, true)
	//整数转字符串
	arr2 := strconv.Itoa(6666)
	fmt.Println(arr2)
	//其他类型转换为字符串
	var str string
	str = strconv.FormatBool(false)
	fmt.Println(str)

2.6 json

2.6.1 结构体转json

import "fmt"
import "encoding/json"

//首字母必须大写
type Student struct {
	Id    int    `json:"-"`    //此字段不会输出
	Name  string `json:"name"` //返回时返回指定字段
	Sub   []string
	IsOk  bool  `json:",string"` //返回字符串
	Price float64
}

func main() {

	stu := Student{1, "小明", []string{"go", "java", "php"}, true, 50.00}
	fmt.Println(stu)
	//json转义
	buf, err := json.Marshal(stu)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(buf) //[123 34 73 100 34 58 49 44 34 78 97 109 101 34 58 34 229 176 143 230 152 142 34 44 34 83 117 98 34 58 91 34 103 111 34 44 34 106 97 118 97 34 44 34 112 104 112 34 93 44 34 73 115 79 107 34 58 116 114 117 101 44 34 80 114 105 99 101 34 58 53 48 125]
	fmt.Println(string(buf))
}

2.6.2 map转json


	map1 := make(map[string]interface{}, 4)
	map1["id"] = 5
	map1["name"] = "实时"

	buf, err := json.MarshalIndent(map1, "", " ")
	fmt.Println(string(buf))
	fmt.Println(err)

2.6.3 json转实体

func main() {

	jsonBuf := `
	{
	 "id": 5,
	 "name": "实时"
	}`

	var stu1 Student

	json.Unmarshal([]byte(jsonBuf), &stu1)

	fmt.Println(stu1)//{0 实时 [] false 0}

}

2.6.4 json转map

func main() {

	
	jsonBuf := `
	{
	 "id": 5,
	 "name": "实时"
	}`

	map2 := make(map[string]interface{}, 4)
	json.Unmarshal([]byte(jsonBuf), &map2)
	fmt.Println(map2)
	//断言 判断类型
	var str string
	for key, value := range map2 {
		switch data := value.(type) {
		case string:
			str = data
			fmt.Printf("map[%s]的值类型为string", key)
		case []interface{}:
			fmt.Printf("map[%s]interface{}", key)

		}
	}

}

2.7 goroutine并发并行

2.7.1 demo

import "fmt"
import "time"

func newWork() {
	for {
		fmt.Println("this is newWork")
		time.Sleep(1000)
	}
}

func main() {
    //设置并行处理器
	num := runtime.GOMAXPROCS(1)
	fmt.Println(num)
	//goroutine
	go newWork() //新建一个协程任务
	for {
		fmt.Println("this is mainWork")
		time.Sleep(1000)
	}
}

2.7.2主协程退出,子协程也退出

func main() {
	//主协程退出了,其它子协程也要跟着退出
	go func() {
		for {
			fmt.Println("this is goroutine")
		}
	}()

	i := 0
	for {
		i++
		fmt.Println("this is mainFor")
		time.Sleep(1000)
		if i > 2 {
			break
		}
	}

}

2.7.3 Goschedr让出调度资源 Goexit 终止

import "runtime"
func main() {
    //设置并行处理器
	num := runtime.GOMAXPROCS(1)
	fmt.Println(num)
	//Goschedr
	go func() {

		for j := 0; j < 2; j++ {
			fmt.Println("this is goroutine")
			runtime.Goexit() //终止所有协程
		}
	}()

	i := 0
	for {
		i++
		fmt.Println("this is mainFor")
		runtime.Gosched() //让出时间片,先让其他协议执行
		if i > 2 {
			break
		}
	}

}

2.7.4

2.7.4.1 Demo channel管道

//创建一个无缓存的channel
var ch = make(chan int)

func printWork(val string) {

	fmt.Println(val)
	fmt.Println(val)
	fmt.Println(val)
	fmt.Println(val)
	fmt.Println(val)

}

func per(sendv string) {
	printWork(sendv)
	ch <- 666 //给管道协数据,发送
}

func per1(sendv string) {
	<-ch //从管道取数据,接收,如果管道没有数据阻塞
	printWork(sendv)
}

func main() {

	go per("per1")
	go per("per2")

	for {

	}

	// per2
	// per2
	// per2
	// per2
	// per1
	// per1
	// per1
}

2.7.4.2 channel 特点

func main() {
var ch3 chan<- float64 //ch3是单向channel 只用于读写float64数据
ch := make(chan int)
	//双向隐转单向
	var writhCh chan<- int = ch //只能写,不能读
	var readCh <-chan int = ch  //只能读,不能写
	
	writh <-666 //写
	<-readch//读
	

	//单向无法转换为双向
	var ch2 chan int = writhCh
	}

2.7.4.3 channel 应用

//生产者  只能写,不能读
func product(out chan<- int) {

	for i := 0; i < 10; i++ {
		out <- i * i
	}
	close(out)

}

//消费者 只能读,不能写
func consumer(in <-chan int) {

	for num := range in {
		fmt.Println("consumer=", num)
	}

}

func main() {
	//创建一个双向通道
	ch := make(chan int)

	//生产者
	go product(ch)
	//消费者
	consumer(ch)

}

2.7.4.4 定时器

import "time"

func main() {
	//只执行一次
	timer := time.NewTimer(2 * time.Second)
	//重复执行
	timer1 :=time.NewTicker(2 * time.Second)
	fmt.Println(time.Now())

	t := <-timer.C
	fmt.Println(t)

	timer.Reset(1 * time.Second) //重新设置
	timer.Stop()                 //定时器停止
	//2020-06-13 14:06:05.8875131 +0800 CST m=+0.008002001
	//2020-06-13 14:06:07.8881753 +0800 CST m=+2.008664201
}

2.7.4.5 select用法

func main() {

	ch := make(chan int)
	quit := make(chan bool)

	//新开一个协程
	//读数据
	go func() {
		for {
			select {
			case num := <-ch:
				fmt.Println("num = ", num)
			case <-time.After(3 * time.Second):
				fmt.Println("超时")
				quit <- true
			}

		}

	}() //自调用
	//写数据
	for i := 0; i < 5; i++ {
		ch <- i
		time.Sleep(time.Second)
	}
	<-quit

	fmt.Println("程序结束")

}

飞奔的屎壳郎

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java转go 翱翔之路(二)基础语法:匿名组合,方法,接口,map,json,异常处理,channel管道,select用法

2.4 面向对象编程2.4.1匿名组合type Person struct { id int name string age int}type Student struct { Person //只有类型没有名字,匿名字段继承了person的成员 garde string class string}2.4.1.2 定义类,赋值,修改 //定义类 var per1 Student = Student{Person{1, "生活", 18}, "初中", "初一"
复制链接

扫一扫

专栏目录