package main
import (
"encoding/json"
"fmt"
"reflect"
"strconv"
)
func printBytes(s string) {
fmt.Println("Bytes:", s)
for i := 0; i < len(s); i++ {
fmt.Printf("%x ", s[i])
}
}
func printChars(s string) {
fmt.Println("Chars: ", s)
for i := 0; i < len(s); i++ {
fmt.Printf("%c ", s[i])
}
}
func test001() {
const a int = 111
fmt.Println(a)
const b = "b"
fmt.Println(b)
const c = 'c'
fmt.Println(c) // 99
printBytes("迹忆客")
printChars("迹忆客")
}
// 使用结构体
type Profile struct {
name string
age int
gender string
mother *Profile
father *Profile
}
type company struct {
name, addr string
}
type staff struct {
name string
age int
gender string
position string
company // 匿名字段
}
func staffTest() {
com := company{
name: "阿里巴巴",
addr: "杭州",
}
fmt.Println(com)
s := staff{
name: "张三",
age: 28,
gender: "男",
position: "总经理",
company: com,
}
fmt.Println(s)
fmt.Println(s.company.name)
fmt.Println(s.company.addr)
}
// 绑定方法
// 以值做为方法接收者
func (p Profile) FmtProfile() {
fmt.Println(p.name)
fmt.Println(p.age)
fmt.Println(p.gender)
}
// 以指针做为方法接收者
func (p *Profile) increase_age() {
p.age += 1
}
func chanTest() {
ch := make(chan int) // 创建channel
go func() {
ch <- 1 // 向channel中发送数据
}()
val := <-ch // 从channel中接收数据
println(val)
}
func structTest001() {
xm := Profile{
name: "小明",
age: 19,
gender: "男",
}
fmt.Println(xm)
xm.FmtProfile()
xm.increase_age()
xm.FmtProfile()
chanTest()
staffTest()
}
func use_new_init_obj() {
xm := new(Profile)
fmt.Println(xm.name)
fmt.Println(xm)
xm.name = "iswbm"
xm.age = 18
xm.gender = "male"
fmt.Println(xm)
}
func init_obj_2() {
xm := &Profile{}
xm.name = "老王"
xm.age = 77
xm.gender = "女"
fmt.Println(xm)
}
type Phone interface {
call()
}
type Nokia struct {
name string
}
func (n Nokia) call() {
fmt.Println("我是Nokia手机, 请开始通话。。。。")
}
//定义一个商品接口
//在 Go 语言中，是通过接口来实现的多态
type Good interface {
settleAccount() int
orderInfo() string
}
type Iphone struct {
name string
quantity int
price int
}
type FreeGift struct {
name string
quantity int
price int
}
func (phone Iphone) settleAccount() int {
return phone.price * phone.quantity
}
func (phone Iphone) orderInfo() string {
return "您要购买" + strconv.Itoa(phone.quantity) + "个" +
phone.name + "计：" + strconv.Itoa(phone.settleAccount()) + "元"
}
func (gift FreeGift) settleAccount() int {
return 0
}
func (gift FreeGift) orderInfo() string {
return "您要购买" + strconv.Itoa(gift.quantity) + "个" +
gift.name + "计：" + strconv.Itoa(gift.settleAccount()) + "元"
}
func calculateAllPrice(goods []Good) int {
var allPrice int
for _, good := range goods {
fmt.Println(good.orderInfo())
allPrice += good.settleAccount()
}
return allPrice
}
func useGood() {
iphone := Iphone{
name: "Iphone",
quantity: 1,
price: 8000,
}
earphones := FreeGift{
name: "耳机",
quantity: 1,
price: 200,
}
goods := []Good{iphone, earphones}
allPrice := calculateAllPrice(goods)
fmt.Printf("该订单总共需要支付%d 元\n", allPrice)
}
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
Addr string `json:"addr,omitempty"`
}
func use_tag() {
p1 := Person{
Name: "Jack",
Age: 28,
}
data1, err := json.Marshal(p1)
if err != nil {
panic(err)
}
//没有Addr不打印 {"name":"Jack","age":28}
fmt.Printf("%s\n", data1)
p2 := Person{
Name: "json",
Age: 16,
Addr: "USA",
}
data2, err := json.Marshal(p2)
if err != nil {
panic(err)
}
fmt.Printf("%s \n", data2)
}
func tag_use_reflect() {
p := reflect.TypeOf(Person{})
name, _ := p.FieldByName("Name")
fmt.Printf("%q\n", name.Tag)
}
type PersonLabel struct {
Name string `label:"Name is: "`
Age int `label:"Age is: "`
Gender string `label:"Gender is: " default:"unknown"`
}
func Print(obj interface{}) error {
v := reflect.ValueOf(obj)
for i := 0; i < v.NumField(); i++ {
//获取tag
field := v.Type().Field(i)
tag := field.Tag
// 解析lable和default
label := tag.Get("label")
defaultValue := tag.Get("default")
value := fmt.Sprintf("%v", v.Field(i))
if value == "" {
value = defaultValue
}
fmt.Println(label + value)
}
return nil
}
func use_tab_label() {
p := PersonLabel{
Name: "Alex",
Age: 29,
}
Print(p)
}
func TypeAssertion() {
var i interface{} = 10
t1 := i.(int)
fmt.Println(t1)
// t2 := i.(string)
// fmt.Println(t2)
//panic: interface conversion: interface {} is int, not string
t2, ok := i.(string)
fmt.Println(t2, ok)
fmt.Println("=====分隔线2=====")
var k interface{} // nil
t3, ok := k.(interface{})
fmt.Println(t3, "3-", ok)
fmt.Println("=====分隔线3=====")
k = 10
t4, ok := k.(interface{})
fmt.Printf("t4 %d-%t\n", t4, ok)
t5, ok := k.(int)
fmt.Printf("t5 %d-%t\n", t5, ok)
}
func findType(i interface{}) {
switch x := i.(type) {
case int:
fmt.Println(x, "is int...")
case string:
fmt.Println(x, "is string")
case nil:
fmt.Println(x, "is nil")
default:
fmt.Println(x, "not type matched.")
}
}
/* 空接口是特殊形式的接口类型，普通的接口都有方法，而空接口没有定义任何方法口，
也因此，我们可以说所有类型都至少实现了空接口
每一个接口都包含两个属性，一个是值，一个是类型。
而对于空接口来说，这两者都是 nil，可以使用 fmt 来验证一下*/
type empty_interface interface {
}
func use_empty_interface() {
var i interface{}
fmt.Printf("type %T, value:%v", i, i)
//1.使用空接口接收任意类型的值
i = 1
fmt.Println(i)
i = "hello"
fmt.Println(i)
i = false
fmt.Println(i)
}
// 空接口： 函数接收任意类型的值，
func myPrint(i interface{}) {
fmt.Println(i)
}
// 接收多个任意类型的值
func myList(values ...interface{}) {
for _, value := range values {
fmt.Println(value)
}
}
// 定义一个可以接收任意类型的 array、slice、map、strcut
func anySlice() {
any := make([]interface{}, 5)
any[0] = 1
any[1] = "hello world"
any[2] = []int{1, 2, 3, 4}
for _, value := range any {
if value != nil {
fmt.Println(value)
}
}
}
func main() {
use_new_init_obj()
init_obj_2()
n := Nokia{name: "nokia"}
n.call()
useGood()
use_tag()
tag_use_reflect()
use_tab_label()
TypeAssertion()
findType(10)
findType("hello")
var k interface{} // nil
findType(k)
findType(10.24)
use_empty_interface()
a := 10
b := "hello"
c := true
myPrint(a)
myPrint(b)
myPrint(c)
myList(a, b, c)
anySlice()
}
网友评论