go语言之面向对象

Go 语言结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

• Title ：标题
• Author ： 作者
• Subject：学科
• ID：书籍ID

定义结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体有中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {

    // 创建一个新的结构体
    fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})

    // 也可以使用 key => value 格式
    fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})

    // 忽略的字段为 0 或 空
   fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})
}

输出结果为：

{Go 语言 www.runoob.com Go 语言教程 6495407}
{Go 语言 www.runoob.com Go 语言教程 6495407}
{Go 语言 www.runoob.com  0}

访问结构体成员

如果要访问结构体成员，需要使用点号 . 操作符，格式为：

结构体.成员名"

结构体类型变量使用 struct 关键字定义，实例如下：

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* 打印 Book2 信息 */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

以上实例执行运行结果为：

Book 1 title : Go 语言
Book 1 author : www.runoob.com
Book 1 subject : Go 语言教程
Book 1 book_id : 6495407
Book 2 title : Python 教程
Book 2 author : www.runoob.com
Book 2 subject : Python 语言教程
Book 2 book_id : 6495700

结构体作为函数参数

你可以像其他数据类型一样将结构体类型作为参数传递给函数。并以以上实例的方式访问结构体变量：

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(Book1)

   /* 打印 Book2 信息 */
   printBook(Book2)
}

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 book_id : %d\n", book.book_id);
}

以上实例执行运行结果为：

Book title : Go 语言
Book author : www.runoob.com
Book subject : Go 语言教程
Book book_id : 6495407
Book title : Python 教程
Book author : www.runoob.com
Book subject : Python 语言教程
Book book_id : 6495700

结构体指针

你可以定义指向结构体的指针类似于其他指针变量，格式如下：

var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：

struct_pointer = &Book1;

使用结构体指针访问结构体成员，使用 "." 操作符：

struct_pointer.title;

接下来让我们使用结构体指针重写以上实例，代码如下

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* Declare Book1 of type Book */
   var Book2 Books        /* Declare Book2 of type Book */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(&Book1)

   /* 打印 Book2 信息 */
   printBook(&Book2)
}
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 book_id : %d\n", book.book_id);
}

以上实例执行运行结果为：

Book title : Go 语言
Book author : www.runoob.com
Book subject : Go 语言教程
Book book_id : 6495407
Book title : Python 教程
Book author : www.runoob.com
Book subject : Python 语言教程
Book book_id : 6495700

struct 类似于 java 中的类，可以在 struct 中定义成员变量。

要访问成员变量，可以有两种方式：

    1.通过 struct 变量.成员 变量来访问。
    2.通过s truct 指针.成员 变量来访问。

    不需要通过 getter, setter 来设置访问权限。

    type Rect struct{   //定义矩形类
        x,y float64       //类型只包含属性，并没有方法
        width,height float64
    }
    func (r *Rect) Area() float64{    //为Rect类型绑定Area的方法，*Rect为指针引用可以修改传入参数的值
        return r.width*r.height         //方法归属于类型，不归属于具体的对象，声明该类型的对象即可调用该类型的方法
    }

1、go语言的结构体

package main

import "fmt"

//go语言没有类，只有结构体，struct，go语言的结构体就相当于python中的类

//定义一个结构体
//type 结构体名 struct {
//
//}

type Student struct {
	id int
	name string
	sex byte
	age int
	addr string

}

func main() {
	//1、顺序实例化一个结构体
	var s1 Student = Student{}

	fmt.Println(s1)
	//{1 test1 102 18 beijing}

	s2 := Student{id:2,name:"test2",sex:'m',age:18,addr:"beijing"}

	fmt.Println(s2)
	//{2 test2 109 18 beijing}

	//指定初始化成员，如果有的字段没有赋值，则用默认值代替
	s3 := Student{id:2,name:"test2",age:18}
	fmt.Println(s3)
	//{2 test2 0 18 }

	//取结构体中的值，用点来取
	fmt.Println(s3.age)
	//18

	//结构体作为指针变量初始化

	var s4 *Student = &Student{id:1,name:"test1",sex:'f',age:18,addr:"beijing"}
	fmt.Println(s4)
	//&{1 test1 102 18 beijing}

	//下面两种都可以取指针对象的属性
	fmt.Println((*s4).name)
	//test1
	fmt.Println(s4.name)
	//test1

	//定义一个指针变量的结构体
	s5 := &Student{id:1,name:"test1",sex:'f',age:18,addr:"beijing"}
	fmt.Println(s5)
	//&{1 test1 102 18 beijing}

}

　　

这里我们可以看到，如果传递一个指针进去，可以使用“(&指针name).”的方式调用方法，也可以直接使用"指针name."的方法调用方法，这个是go在内部替我们做了封装

2、结构体作为参数传递给方法

package main

import "fmt"

type Student struct {
	id int
	name string
	sex byte
	age int
	addr string

}

//结构体作为参数传递给方法
//定义一个传递学生对象的方法
func tmpStuent(tmp Student)  {
	tmp.id = 250
	fmt.Println(tmp)
}

//定义一个传递指针对象的方法
func tmpStudentobj(p *Student)  {
	p.id = 249
	fmt.Println(p)
}

func main() {
	var s27_1 Student = Student{id:1,name:"test1",sex:'f',age:18,addr:"beijing"}
	tmpStuent(s27_1)
	//{250 test1 102 18 beijing}

	fmt.Println(s27_1)
	//{1 test1 102 18 beijing}

	tmpStudentobj(&s27_1)
	//&{249 test1 102 18 beijing}
	fmt.Println(s27_1)
	//{249 test1 102 18 beijing}

}

　　

通过上面的例子我们知道

如果传递一个结构体给函数，在函数中修改这个结构体，不会影响外面的结构体的值，因为他是重新复制了一份数据

但是，如果传递一个结构体的指针给函数，在函数中修改这个指针的值，是会影响外面结构体的值的，因为他们是公用一份数据

3、匿名字段，通过匿名字段来实现继承父类的字段

package main

import "fmt"

//go语言的面向对象非常的优雅和简单
//没有封装，多态，继承这些概念,但是同样通过其他方式来实现上面的功能

//封装：通过方法来实现
//继承：通过匿名字段来实现
//多态：通过接口来实现

type Person struct {
	name string
	sex byte
	age int

}

type Student1 struct {
	//匿名字段

	//默认Student_1这个结构体包含了Person这个结构体的所有的字段
	Person
	//还可以定义自己私有的字段
	i int
	addr string

}

type Student2 struct {
	//匿名字段

	//默认Student_1这个结构体包含了Person这个结构体的所有的字段
	Person
	//还可以定义自己私有的字段
	i int
	addr string
	name string

}

type myint int

type Student3 struct {
	//自定义类型
	Person

	//内置类型
	int

	//自定义类型
	myint
}

//指针类型的结构体
type Student4 struct {
	//匿名字段

	//默认Student_1这个结构体包含了Person这个结构体的所有的字段
	*Person
	//还可以定义自己私有的字段
	i int
	addr string
	name string

}

func main() {
	//使用匿名字段初始化一个子类
	s28_1 := Student1{Person:Person{name:"test1",sex:'m',age:18},addr:"beijing",i:1}
	fmt.Println(s28_1)

	//打印的结构是一个结构体包含一个结构体
	//{{test1 109 18} 1 beijing}

	//这里如果不这样写就会报错Person:Person
	//mixture of field:value and value initializers

	//同名字段的情况

	//如果有同名字段，则默认是就近原则
	var test28_2 Student2
	//test28_2.name = "test"
	//fmt.Println(test28_2)
	//{{ 0 0} 0  test}

	//如果要想给父类的name赋值怎么做

	test28_2.Person.name = "abc"
	fmt.Println(test28_2)
	//{{abc 0 0} 0  }

	//所有的内置类型和自定义类型都可以作为匿名字段使用
	//我们这里的myint和Python都可以当做一个自定义类型使用

	test28_3 := Student3{Person:Person{name:"test1",sex:'m',age:18},int:1,myint:2}
	fmt.Println(test28_3)
	//{{test1 109 18} 1 2}

	fmt.Println(test28_3.myint)
	//2

	//指针类型的匿名字段
	s28_4 := Student4{Person:&Person{name:"test1",sex:'m',age:18},addr:"beijing",i:1}

	fmt.Println(s28_4)
	//{0x1f43e0e0 1 beijing }

	fmt.Println(s28_4.age,"11")
	//18 11
}

　　

　　

匿名字段实现继承

package main

import "fmt"

type Student struct {
	sid int
	name string
	age int
	sex byte
	addr string

}

type Student1 struct {
	Student

	hobby string
	addr int

}
var s1 Student = Student{
	sid:1,
	name:"test",
	age:12,
	sex:'m',
	addr:"sz",
}

func test10_1(s Student)  {
	s.name = "test10_1"
	fmt.Println(s)
}

func test10_2(s *Student)  {
	s.name = "test10_2"
	fmt.Println(s)
}

func main()  {
	fmt.Println(s1)
	fmt.Println(s1.name)

	//这种方式必须在函数中使用
	s2 := Student{sid:1,name:"test2",age:13,sex:'f',addr:"nmg"}
	fmt.Println(s2)

	s3 := Student{age:13,sex:'f',addr:"nmg"}

	//如果在有未传的变量，则go会给一个默认值
	fmt.Println(s3.name,s3.sid,s3.addr)

	//定义一个指针类型的结构体变量
	var s4 *Student = &Student{sid:2,name:"test4",age:14,sex:'f',addr:"nmg1"}

	//通过下面两种方式都可以访问指针变量指向的结构体变量的值
	fmt.Println(s4.addr)
	fmt.Println((*s4).addr)

	s5 := &Student{sid:2,name:"test4",age:14,sex:'f',addr:"nmg1"}
	fmt.Println(s5)

	//test10_1(s2)
	//fmt.Println(s2.name)

	test10_2(s5)
	fmt.Println(s5)

	s6 := Student1{Student:Student{sid:2,name:"test4",age:14,sex:'f',addr:"nmg1"},hobby:"football",addr:12}

	//通过匿名字段实现继承，默认情况下可以访问父类和自己的字段，但是如果父类的字段和自己的字段是相同的，则默认会访问自己的字段
	//如果一定要访问父类的字段，则需要这样访问s6.Student.addr
	fmt.Println(s6.sid,s6.hobby,s6.addr,s6.Student.addr)

}