golang学习笔记06

如何声明结构体:

基本语法:

type 结构体名称 struct{
    field1 type
    field2 type
}

举例:

type Student struct{
    Name string
    Age int
    Score float64
}

字段\属性

基本介绍:

  1. 从概念或叫法来看:结构体字段 = 属性 = field
  2. 字段是结构体的一个组成部分,一般是基本数据类型、数组,也可以是应用类型。

注意事项和细节说明:

  1. 字段声明语法同变量:基本语法: 字段名 字段类型( name string )
  2. 字段的类型可以是基本类型和引用类型

指针、map、slice、初始值都是nil,一开始需要分配空间

type Persion struct{
    heros map[string]map[string]string
    slice []int
}
func main(){
	var p1 Persion
    p1.heros = make(map[string]map[string]string)
	p1.heros["齐天大圣"] = make(map[string]string,2)
	p1.heros["齐天大圣"]["skill"] = "火眼晶晶"
	p1.heros["齐天大圣"]["age"] = "7500"

	p1.heros = make(map[string]map[string]string)
	p1.heros["牛魔王"] = make(map[string]string,2)
	p1.heros["牛魔王"]["skill"] = "芭蕉扇"
	p1.heros["牛魔王"]["age"] = "6500"

	fmt.Println(p1.heros)
    p1.slice = make([]int,5,6)
	p1.slice[4] = 10
	fmt.Println(p1.slice)
}

创建结构体变量和访问结构体字段

type Persion struct{
    Name string
    Age int
}
1.
var persion Persion
2.var persion Persion = Persion{"marry",15}
//相当于定义了:persion.Age = 15
//persion.Name = "marry"
3.
var persion *Persion = new (Persion)//返回的是一个指针,一个Persion结构体的指针
//后续可以接着用指针来赋值
4.
var persion *Persion = &Persion{"marry",18}

3和4 都是进行了指针的引用,返回的是一个指针。

方法:

定义:

在某些情况下,我们需要声明(定义)方法,比如Persion结构体,除了有一些字段外(年龄、姓名…)Persion还有一些行为、一些功能;

另外,golang中方法是作用与指定的数据类型上的,因此自定义类型,都有方法,而不仅仅是struct

方法的声明和调用:

type A struct{
    Num int
} 
func (a A) test1(){
    fmt.Println(a.Num)
}
  • func (a A) test1() { }表示A结构体有一种方法,方法名叫做test
  • (a A)体现test 方法是和A类型绑定的
  • 与A类型绑定后,只能由A类型变量来调用

快速入门:

package main
import "fmt"
type MethodUtils struct{
	arr [3][3]int
}//字段是一个数组
func (mu MethodUtils) fun(n1 int){
	for i:=1;i<=n1;i++{
		for j:=1;j<=i;j++{	
			fmt.Printf("%d*%d=%d\t",j,i,j*i)
		}
		fmt.Println()
	}//接收n1一个整数,乘法口诀表直到n1
}
func (mu *MethodUtils) fun2(){
	for index ,_:=range mu.arr{
		fmt.Println(mu.arr[index])
	}
	var arr2 [3][3]int
	arr2 = mu.arr
	for i:=0;i<3;i++{
		for j:=0;j<3;j++{
			mu.arr[i][j] = arr2[j][i]
		}
	}
}//方法使得二维数组变换矩形
func main(){
	var mu MethodUtils
	mu.fun(9)
	var mu1 MethodUtils
	for i:=0;i<3;i++{
		for j:=0;j<3;j++{
			fmt.Scan(&mu1.arr[i][j])
		}
	}
	mu1.fun2()
	for index ,_:=range mu1.arr{
		fmt.Println(mu1.arr[index])
	}
}//主方法,调用

方法的声明:

func (recevier type) meyhoName(参数列表) (返回值列表){
    方法体
    return 返回值    
}
  • receiver type :表示这个方法和type这个类型进行了绑定,或者说该方法用于type类型
  • receiver type 可以是结构体也可以是其他自定义的类型
  • 返回值和普通函数相同可以有多个返回值
  • return语句不是必须的

方法的注意事项和和细节

  1. 结构体类型是值类型,遵循的是值类型传递机制,是值拷贝传递机制
  2. 如果程序元希望在方法中,修改结构体的值,可以通过结构体指针的方式来处理
  3. golang中的方法作用在指定的数据类型上的,因此自定义类型都可以有方法,而不仅仅是struct,比如int 、float64
type integer int
func (n1 *integer) change(){
    *n1 = *n1 + 1
}
func main(){  
    var i integer = 10
    i.change()
    fmt.Println(i)//此时输出的是11而不是10,因为用了指针,进行了改变
}

方法和函数不同

1)调用的方式不相同

函数的调用方式为: 函数名(实参列表)

方法的调用方式: 变量.方法名(实参列表)

2)

对于普通的函数,接收为值类型,不能用引用类型数据直接传递,相反也一样

对于方法,接收为值类型,但是可以用引用类型调用,接收为指针类型也可以用值类型,最终的调用方式是方法的的类型。

面向对象编程的引用实例:

步骤:

1)声明结构体变量,确定结构体名

2)编写结构体字段

3)编写结构体方法

学生与狗的案例

package main
import (
	"fmt"
)
type Student struct{
	name string
	gender string
	age int
	scores float64
}//定义一个Student结构体
type Dog struct{
	name string
	age int
	weight float64
}//Dog 结构体
func (dog *Dog) say(){
	fmt.Printf("dog的信息:\nname = %s\nage = %d\nweight =%f",
		dog.name,dog.age,dog.weight)

}//与Dog相绑定的方法say

func (stu *Student) say(){
	fmt.Printf("student的信息为 :\n"+
		"姓名 :%v\ngender : %v\n"+
		"age = %d\nscores = %.1f",stu.name,stu.gender,stu.age,stu.scores)
}//与Student相绑定的say方法

func main(){
	var stu = Student{
		name :"小明",
		age : 15,
		gender : "男",
		scores : 83.3,
	}//上面是stu,下面是dog的声明
	stu.say()
	fmt.Println()
	var dog Dog = Dog {
		name : "强子",
		age : 15,
		weight : 15.3,
	}
	dog.say()
}


景区门票案例

1)根据年龄收取不同价格的门票,比如年纪>18,收取20,其他情况免费,

2)编写Visitors结构体,根据年龄来决定收取门票价格并输出

3)代码:

package main

import "fmt"

type Visitors struct{
	Name string
	Age int
}

//func (v *Visitors) GetPrice(){
//	if v.Age>=70{
//		fmt.Println("您的年龄过大,不是适合玩此游戏")
//	}
//	if v.Age>=18&&v.Age<=70{
//		fmt.Printf("姓名:%s\n价格: 20",v.Name)
//	}else{
//		fmt.Printf("姓名:%s\n价格: 免费",v.Name)
//	}
//}
//
//func main(){
//	var v1 Visitors
//	fmt.Println("请输入您的姓名...")
//	fmt.Scanln(&v1.Name)
//	fmt.Println("请输入您的年龄...")
//	fmt.Scanln(&v1.Age)
//	v1.GetPrice()
//}
func (v *Visitors) GetPrice(){
	if v.Age>=70{
		fmt.Println("您的年龄过大,不是适合玩此游戏")
		return
	}
	if v.Age>=18&&v.Age<=70{
		fmt.Printf("姓名:%s\n价格: 20\n",v.Name)
	}else{
		fmt.Printf("姓名:%s\n价格: 免费\n",v.Name)
	}
}
func main(){
	var v Visitors
	for{
		fmt.Println("您的姓名:(按\"n\"退出程序)")
		fmt.Scanln(&v.Name)
		if v.Name == "n"{
			fmt.Println("退出程序...")
			break
		}
		fmt.Println("您的年龄:")
		fmt.Scanln(&v.Age)
		v.GetPrice()
	}
}

创建结构体变量时,指定字段值

  • 说明:

golang在创建结构体时是可以直接指定字段的值的

方式一:
var stu1 = Stu{"mary",18}
方式二:
var stu2 = Stu{
    Name : "jack",
    Age :18
}此种方法可以不与结构体字段顺序匹配
方法三:
var stu3 = &Stu{
    Name : "simth"
    Age : 89
}//返回的是一个结构体指针变量

你可能感兴趣的:(go语言学习专栏,golang,学习,开发语言)