16. init方法和import导包
init 早于 main
package main
import (
"GoCode/lib1"
"GoCode/lib2"
"fmt"
)
func main() {
lib1.Say1()
lib2.Say()
}
===========
package lib1
import "fmt"
//函数名首字母大写 表示对外开放,如果是小写只能在本文件内使用
func Say1() {
fmt.Print("this is lib1")
}
func init() {
fmt.Print("lib1")
}
17.匿名包
同上 如果导入了包 但是不使用，编译器会报错
import (
_ "GoCode/lib1" //可以不执行包下的方法 会自动执行init方法
mylib2"GoCode/lib2"//另起别名
."xxxx" //相当于全部方法都进行了导入
)
18.defer语法
表示最后执行的进行的操作,类似于final. 并且多个执行顺序是压栈,先写后执行
fmt.Print("hello")
defer fmt.Print("main1 dd")
defer fmt.Print("main dd")
fmt.Print("hello")
=====
//hellohellomain ddmain1 dd
注: 当defer和return同时出现,return 语句会先执行(但return 语法是写在函数最后面)
19.map
1.声明方式
1.
var mymap map[int]string
mymap=make(map[int]string,10)
mymap[1]="dda"
2.
mymap1:=make(xxx)
3.
mymap2:=make(map[int]string,2){
1:"dada"
}
2.改查
delete(mymap,"xxx")
mymap["xxx"]="xxxx"
=======
map 作为参数传递是一个引用传递,值会进行改变
func change(result map[string]string) {
result["123"] = "www"
}
20.struct(结构体作为类)
type myint int
var a myint
fmt.Printf("%T",a) //myint
============
//类名大写 表示其他包导入后 也可以根据此进行创建
type Book struct {
//小写表示私有
name string
title string
}
var book Book
book.title = "da"
book.name = "dada"
fmt.Print(book) //{dada da}
//传参是一个值传递，结构体的副本。可以传结构体指针
func change(book *Book){
}
change(&book)
21.类的表示和封装
1.给结构体添加方法
func (this Book) getName() {
fmt.Print(this.name + this.title)
}
func (b Book) getName() {
fmt.Print(b.name + b.title)
}
func (this Book) setName(newName string){
//这里的this只是调用该方法的对象的一个副本
// 使用该方法不会起到什么作用
this.name=newName
}
========= 优化 .(使用指针)
func (this *Book) setName(newName string){
this.name=newName
}
22.继承
1.组合方式
type myBook struct {
//继承直接在子类中 写上父类的结构体
Book
level int
}
========== 子类可以重写父类方法
//初始化,先进行父类的初始化,再进行子类新增变量的初始化
book := myBook{Book{"dada", "das"}, 1}
var book myBook //可以直接book.name 进行父类变量的初始化
23.多态
1.interface
//本质是一个指针
type Admin interface{
}
===
type Admin interface {
sleep()
GetColor() string
GetType() string
}
type Cat struct {
color string
}
func (this *Cat) sleep() {
fmt.Print("cat is sleep")
}
func (this *Cat) GetColor() string {
return this.color
}
func (this *Cat) GetType() string {
return "Cat"
}
func main() {
var admin Admin
!!!
admin = &Cat{"yello"} //通过取地址进行初始化
admin.sleep()
fmt.Print(admin.GetColor() + admin.GetType())
}
=========
func show(admin Admin) {
admin.sleep()
fmt.Print(admin.GetType() + admin.GetColor())
}
//main
cat := Cat{color: "yello"}
show(&cat)
多态基本要素:
1.有一个父类/接口
2.有子类(实现父类的全部接口)
3.父类类型的变量(指针)指向(引用)子类的具体数据变量
2.万能类型(空接口),断言
int,string,float... 都实现了interface接口
package main
import "fmt"
func myFunc(arg interface{}) {
fmt.Println("myFunc is called")
fmt.Println(arg)
//区分传入参数类型
//给interface提供类型断言机制
value,ok=arg.(string)
value,ok=arg.(Book) //value是arg的值,ok是判断是否为该类型
}
type Book struct {
auth string
}
func main() {
book := Book{auth: "hello"}
myFunc(book)
myFunc("123")
myFunc(123)
}
/*
myFunc is called
{hello}
myFunc is called
123
myFunc is called
123
*/
