继承复习-go

继承

通过在结构体中嵌套实现继承，且继承的只是结构体的属性，若要继承方法可以通过实现接口达成

接口

多态

在golang中interface相当于类，struct相当于对象，当struct重写了interface的方法就是struct继承了interface类的方法，interface没有属性所以struct有属性没有方法，通过struct重写interface的方法实现类和对象的编程

在interface中同样的方法，不同的struct重写，导致不同的struct的实例同一方法结果不同从而实现多态

      f,_:=os.Open("D:/go.txt") //打开文件，得到一个文件指针
      fileInfo,_:=f.Stat()       //Stat()函数得到文件的信息
      b:=make([]byte,fileInfo.Size())//创建一个文件字节长度的byte数组用于存储从文件读出的内容
      f.Read(b)//将文件的内容读出到byte数组中
      fmt.Println("内容：",string(b))//将内容转为string输出

输出

filePath:="D:/go.txt"  //os包是用来操作系统文件夹以及系统文件的，所以用os.Open()d
	f,err:=os.OpenFile(filePath,os.O_APPEND,0660)//打开，判断是否存在该文件，若不存在则返回错误信息
	defer f.Close()//每次文件的打开要记得关闭流，即打开就有关闭
	if err!=nil{
		f,_:=os.Create("D:/go.txt")//在文件不存在时创建文件
	}
	f.Write([]byte("输入内容123"))//创建一个byte数组，将其中的内容输入到文件中
	f.WriteString("\r\n再一次的输入")//输出到文件中的内容即string,更为方便，不用创建byte数组
	fmt.Println("程序结束")

在对本地文件进行输出时，即程序将内容写入到本地文件中，先判断指定路径下的本地文件是否存在。

ioutil包

f,_:=os.Open("D:/go.txt")
b,_:=ioutil.ReadAll(f)//读取文件内容
fmt.Println(string(b))// hello world

等同于

b,_:=ioutil.ReadFile("D:/go.txt")
fmt.Println(string(b))

写入

ioutil.WriteFile("D:/go.txt",[]byte("这是写入的数据"),0666)
fmt.Println("写入数据")

由原来的hello world 变为 这是写入的数据

但是该方式只能先清除原有文件的内容再写入数据

Xml文件的读取

xml文件内容如下

标签之内为一组数据，即一个结构体变量的数据，其中age,hobby,place为结构体中成员变量

<?xml version="1.0" encoding="UTF-8" ?>
<people id="666" >
    <age>18</age>
    <hobby>打篮球</hobby>
    <place>图书馆</place>
</people>

如下是结构体的内容

在每一行的最右边可以看到有标记对应于xml文件的各个标签，读取xml文件内容时是按对应关系读取的，即结构体中的每个成员变量由xml标记对应到xml文件的对应标签的数据

type Student struct{
	XMLName xml.Name `xml:"people"`//对应people标签
	Id int           `xml:"id,attr"`//对应people标签里的id属性
	Age int          `xml:"age"`  //对应people标签下的age标签
	Hobby string      `xml:"hobby"`
	Place string      `xml:"place"`
}

一下是主函数的实现对xml文件的数据的读取

func main(){
	stu:=new(Student)  //创建一个Student结构体对象或者说结构体变量其中又有成员变量，如age,place等
	s,_:=ioutil.ReadFile("cemo.xml")  //ioutil读取相对路径下的xml文件
	xml.Unmarshal(s,stu)  //使用xml的方法Unmarshal解析在struct里的标记对应的反射reflect得到数据给stu对象
	fmt.Println(stu)  打印数据
}

生成xml文件

在程序中用已存有数据的结构体变量生成对应的xml文件

    stu:=Student{Id:122,Age:22,Hobby:"刷剧",Place:"宿舍"}//创建结构体变量并赋初值
	b,_:=xml.MarshalIndent(stu,"","	")//生成xml内容，第二个参数是每行标签前面隔开的形式，第三个是子标签的隔开形式，这里是tab
	b=append([] byte(xml.Header),b...)//在没有这行代码时，xml文件里没有文件头即xml文件的版本以及编码方式
	ioutil.WriteFile("D:/Student.xml",b,0777)//将生成的xml内容输入到本地路径下的文件中
	fmt.Println("执行结束")

使用go的协程可以实现并发，在这里gorutine可以创建多个窗口实现并发

	var wg sync.WaitGroup//
	wg.Add(5)//等待组内计数器加数字
	for i:=0;i<5;i++{
		go func(){
			time.Sleep(10e9)
			fmt.Println("第",i,"次执行")
			wg.Done()//每次操作借宿计数器数字-1
		}()
	}
	wg.Wait()//阻塞
	fmt.Println("程序借结束")

sync.WaitGroup等待组内部拥有一个计数器，计数器的值可以通过方法调用实现计数器的增加和减少。当我们添加了 N 个并发任务进行工作时，就将等待组的计数器值增加 N。每个任务完成时，这个值减 1。同时，在另外一个 goroutine 中等待这个等待组的计数器值为 0 时，表示所有任务已经完成。

互斥锁

提高并发时访问数据的安全性

代码同一时间只有一个人gorutine运行

var(
	num=100
    wg sync.WaitGroup
	m sync.Mutex//先声明
)
func demo(){
	m.Lock()//锁
	for i:=0;i<10;i++{
		num=num-1
	}
	m.Unlock()//解锁
	wg.Done()
}
func main(){
	wg.Add(10)
	for i:=0;i<10;i++{
		go demo()
	}
	wg.Wait()
	fmt.Println(num)
	fmt.Println("程序结束")

读写锁

表示在锁住的代码范围内数据的读写操作

func main(){
	var rwm sync.RWMutex
	var wg sync.WaitGroup
	wg.Add(10)
	m:=make(map[int]int)
	for i:=0;i<10;i++{
		go func(j int){
			rwm.Lock()
			m[j] =j
			fmt.Println(m)
			rwm.Unlock()
			wg.Done()
		}(i )
	}
	wg.Wait()
	fmt.Println("程序结束")
}

channel实现通信和同步

ch1:=make(chan string)//实现协程间的通信
	ch2:=make(chan int)//实现子协程的同步
	go func(){
		ch1 <- "传送给另一个协程的数据"
		ch2 <-1
	}()
	go func(){
		content:=<- ch1
		fmt.Println("取出数据成功",content)
		ch2 <-2
	}()
	<-ch2
	<-ch2
	fmt.Println("程序结束")
//输出
//取出数据成功 传送给另一个协程的数据
//程序结束

ch1:=make(chan string)
	ch2:=make(chan int)
	go func(){
		for i:=97;i<=97+26;i++{
			ch1<- fmt.Sprintf("%c",i)
		}
		ch2<-1
	}()
	go func(){
		for n:=range ch1{
			fmt.Println(n)
		}
	}()
	<-ch2
//输出 a b c d e f g h i j k l m n o p q r s t u v w x y z