2022/02/06
package main
import (
"fmt"
)
/*
*/
/*
编写结构体，编写一个方法，方法不需要参数，
在方法中打印一个 10*8 的矩形，在main方法中调用该方法
*/
type MethodsUtils struct {
//无字段
}
func (med1 MethodsUtils) func1() {
for i := 0; i < 8; i++ {
for j := 0; j < 10; j++ {
fmt.Printf("*")
}
fmt.Println()
}
}
/*
编写结构体，编写一个方法，提供m和n两个参数，
在方法中打印一个 m*n 的矩形，在main方法中调用该方法
*/
type Methods2 struct {
}
func (med2 Methods2) func2(m int, n int) {
for i := 0; i < n; i++ {
for j := 0; j < m; j++ {
fmt.Printf("*")
}
fmt.Println()
}
}
/*
编写一个方法，计算该矩形的面积，可以接收长len，宽width，
并将其作为方法返回值
在main中调用，接收返回值打印
*/
func (med3 Methods2) func3(len int, width int) int {
return len * width
}
/*
编写一个方法，判断一个数字是奇数还是偶数
*/
func (med3 *Methods2) func4(len int) {
if len%2 == 0 {
fmt.Println("是偶数")
} else {
fmt.Println("是奇数")
}
}
/*
编写一个方法，实现加减乘除功能
接收两个数字和一个运算符
*/
type Calcuator struct {
Num1 int
Num2 int
}
func (jisuan *Calcuator) func5(op byte) float64 {
res := 0.0
switch op {
case '+':
res = float64(jisuan.Num1) + float64(jisuan.Num2)
case '-':
res = float64(jisuan.Num1) - float64(jisuan.Num2)
case '*':
res = float64(jisuan.Num1) * float64(jisuan.Num2)
case '/':
res = float64(jisuan.Num1) / float64(jisuan.Num2)
default:
fmt.Println("输入运算符错误")
}
return res
}
/*
编写方法，给指定的一个二维数组(3*3)转置
1 2 3 1 4 7
4 5 6 2 5 8
7 8 9 3 6 9
*/
type arrStr struct {
}
func (arr2 arrStr) arrFunc(arrInt [][]int) {
for i := 0; i < len(arrInt); i++ {
for j := 0; j < i; j++ {
if i != j {
temp := arrInt[i][j]
arrInt[i][j] = arrInt[j][i]
arrInt[j][i] = temp
}
}
}
fmt.Println(arrInt)
}
type Test struct {
Name string
}
func (a1 Test) makeTest() { //由 Test 决定到底是值拷贝还是引用
a1.Name = "levi 2"
fmt.Println(a1)
}
/*
1.不管调用形式如何，真正决定是值拷贝还是地址拷贝，看这个方法是和哪个类型绑定
2.如果是和值类型，比如(b Test)，则是值拷贝，
如果是指针类型，比如(b *Text),则是地址拷贝
*/
/*
1.编写一个student结构体，包含name，gender，age，id，score字段，
分别为string，string，int，int，float64类型
2.结构体中声明一个say方法，返回string类型，方法返回信息中包含所有字段值
3.在main方法中，创建student结构体实例,并访问say方法，并将调用结果打印输出
*/
type Student struct {
name string
gender string
age int
id int
score float64
}
func (stu *Student) say() string {
info := fmt.Sprintf("student message: name=[%v], gender=[%v], age=[%v], id=[%v], score=[%v],",
stu.name, stu.gender, stu.age, stu.id, stu.score)
return info
}
/*
1.一个景区根据游人的年龄收取不同的价格的门票，
比如年龄大于17，收费20，其他情况门票免费
2.编写Visitor结构体，根据年龄段决定能够购买的门票价格并输出
*/
type Visitor struct {
Name string
Age int
}
func (tick *Visitor) Ticket() {
if tick.Age > 18 {
fmt.Printf("游客名字为: %v, 收费为: %v\n", tick.Name, tick.Age)
} else {
fmt.Println("免费")
}
}
func main() {
var me1 MethodsUtils
me1.func1()
var med2 Methods2
med2.func2(3, 5)
var med3 Methods2
ret := med3.func3(3, 5)
fmt.Println("ret=", ret)
med3.func4(11)
var jisuan Calcuator = Calcuator{1, 2}
fmt.Println("res = ", jisuan.func5('.'))
var arr [][]int = [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
fmt.Println(arr)
var res arrStr
res.arrFunc(arr)
test1 := Test{"levi 1"}
test1.makeTest()
fmt.Println(test1)
stu := Student{"levi", "man", 18, 1, 100}
fmt.Println(stu.say())
var v Visitor
for {
fmt.Println("请输入你的名字")
fmt.Scanln(&v.Name)
if v.Name == "n" {
break
}
fmt.Println("请输入你的年龄")
fmt.Scanln(&v.Age)
v.Ticket()
}
}
package main
/*
通过嵌入一个匿名结构体实现继承特性
*/
//基本语法
type Goods struct {
Name string
Price float64
}
type Book struct {
Goods
Writer string
}
func main() {
var boo *Book = &Book{}
boo.Goods.Name = "levi"
boo.Goods.Price = 1.123
}
package main
/*
封装的理解和好处
1.隐藏实现细节
2.可以对数据进行验证，保证安全合理
如何实现封装
1.对结构体中的属性进行封装
2.通过方法，包实现封装
封装的实现步骤
1.将结构体，字段的首字母小学
2.给结构体所在的包提供一个工厂模式的函数，首字母大写，类似一个构造函数
3.提供一个首字母大写的Set方法
*/
package model
import "fmt"
type account struct {
AccountNo string
money float64
pswd int
}
//工厂模式
func NewAccount(accNo string) *account {
if len(accNo) < 6 || len(accNo) > 10 {
fmt.Println("账号的长度不对")
return nil
}
return &account{
AccountNo: accNo,
}
}
//account 的 set 和 get方法
func (acc *account) SetMoney(mon float64) {
acc.money = mon
}
func (acc *account) GetMoney() float64 {
return acc.money
}
//pswd 的 set 和 get方法
func (acc *account) SetPswd(pswd int) {
acc.pswd = pswd
}
func (acc *account) GetPswd() int {
return acc.pswd
}
