go语言学习【七】

目录：
1.面向对象编程实例
2.工厂模式
3.封装
4.继承

1.面向对象编程实例

步骤：
（1）声明结构体，确定结构体名。
（2）编写结构体的字段
（3）编写结构体的方法

// 1.学生案例
package main
import "fmt"

type Student struct {
	name string
	gender string
	age int
	id int
	score float64
}

func(stu *Student) say() string {
	inforstu := fmt.Sprintf("student 的信息 name=[%v] gender=[%v] age=[%v] id=[%v] score=[%v]",
		stu.name,stu.gender,stu.age,stu.id,stu.score)
		return inforstu
}
func main() {
		var stu = Student{
			name:"Tom",
			gender:"男",
			age:18,
			id:01,
			score:99.99,
		}
		fmt.Println(stu.say())
}
//输出结果：student 的信息 name=[Tom] gender=[男] age=[18] id=[1] score=[99.99]

// 2.游客收费
package main
import "fmt"
type visitor struct {
	name string
	age int
}

func(vis *visitor) price() {
	if(vis.age>18) {
		fmt.Printf("游客的名字为：%v 年龄为：%v 收费钱数为：20\n",vis.name,vis.age)
	} else {
		fmt.Printf("游客的名字为：%v 年龄为：%v 免费\n",vis.name,vis.age)
	}
}

func main() {
    var vis visitor
	 for {
		 fmt.Print("请输入你的名字：")
		 fmt.Scan(&vis.name)
		 if vis.name == "n" {
			 fmt.Println("退出程序···")
			 break;
		 }
		 fmt.Print("请输入你的年龄：")
		 fmt.Scan(&vis.age)
		 vis.price()
	 }
}

2.工厂模式

Golang的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。

对于一些结构体，如需结构体名小写并能在其它包里引用，此时需要使用工厂模式解决。

// 一个model包，里面提供结构体。
pack model
type student struct {
	Name string
	score float64 
}
//因为结构体首字母是小写，因此只能在model这个包里使用此结构体。
//可以通过工厂模式在其它包里使用该结构体。

func Newstudent(n string , s float64) *student {//返回指针类型
			return &student {
				Name:n,
				score:s,
			}
}

//score字段小写，在其它包里使用可以绑定方法。
func(s *student)Getscore()float64{
	return s.score
}

// 引用model包里的结构体
package main
import (
	"fmt"
	"go_code/project02/func/model" //通过相关路径引入model包里的结构体
)
func main() {
	//创建Student实例
	//var stu = model.Student{
	//	name:"Tom",
	//	score:"86.6",
	//}

	//工厂模式如下
	var stu = model.Newstudent("Jack",99.5)
	fmt.Println(*stu) //&{...}
	fmt.Println("name=",stu.Name,"score=",stu.Getscore())
}

3.封装

• 封装：把抽象出的字段和对字段的操作封装在一起，数据被保护在内部，程序的其它包只有通过被授权的操作（方法），才能对字段进行操作。

//快速入门案例：设计一个程序(person.go)
//不能随便查看人的年龄，工资等隐私，并对输入的年龄进行合理的验证。
//设计model包(person.go)和main包(main.go)
//调用person结构体

package model
import "fmt"
type person struct {
	Name string
	age int //age首字母小写，其它包不能直接引用这个字段
	sal float64
}
//写一个工厂模式的函数，相当于构造函数。
func Newperson(name string) *person {
	return &person{
		Name:name,
	}
}
//为了访问age和sal，我们编写一对方法
func(p *person)Setage(age int) {
	if age>0&&age<150 {
		p.age = age
	} else {
		fmt.Println("年龄范围不正确···")
	}
}
func(p *person)Getage() int {
	return p.age
}
func(p *person)Setsal(sal float64) {
	if sal>=3000&&sal<=30000 {
		p.sal = sal
	} else {
		fmt.Println("薪水范围不正确···")
	}
}

func(p *person)Getsal() float64 {
	return p.sal
}

package main
// 第二个main包，用来引入model包里的结构体
import (
	"fmt"
	"go_code/chapter02/project06/model"
)
func main() {
	p := model.Newperson("July")
	p.Setage(48)
	p.Setsal(15000)
	fmt.Println(p)
	fmt.Println(p.Name,"age =",p.Getage(),"sal =",p.Getsal())
}

输出结果：

&{July 48 15000}
July age = 48 sal = 15000

4.继承

继承可以解决代码复用,让我们的编程更加靠近人类思维。

• 当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体，在该结构体中定义这些相同的属性和方法。
  其它的结构体不需要重新定义这些属性(字段)和方法，只需嵌套一个Student匿名结构体即可。
• 也就是说：在Golang中，如果一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性。

嵌套匿名结构体的基本语法
type Goods struct {
Name String
Price int
}
type Book struct {
Goods //这里就是嵌套匿名结构体Goods
Writer string
}

继承快速入门案例：

// 编写一个学生考试系统
package main

import "fmt"

type Student struct {
	Name string
	Score float64
}
func(a *Student) Set() { //编写Student结构体的一个方法
	if a.Score < 0 || a.Score > 100 {
		fmt.Println("成绩输入错误！")
	} else if a.Score >= 85 {
		fmt.Println(a.Name,"的成绩为优秀！成绩是",a.Score,"分")
	} else {
		fmt.Println(a.Name,"的成绩是",a.Score,"分")
	}
}
type Stu struct {
	Student //在Stu结构体里嵌套Student结构体
}
func main() {
	var a Stu
	a.Name = "小月"
	a.Score = 96.0
	a.Set()
}
// 输出结果：小月 的成绩为优秀！成绩是 96 分

• 当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则。
• 结构体嵌入两个或多个匿名结构体，如两个匿名结构体有相同的字段和方法（同时结构体本身没有同名的字段和方法），在访问时，就必须指明匿名结构体名字，否则编译报错。

type A struct {
	Name string
	age int
}
type B struct {
	Name string
	Score float64
}
type C struct {
	A
	B
}
func main() {
	var c C
	c.Name = "Mary" // 报错，不能确定是A/B两个匿名结构体中的哪一个
}