Go語言起別名
- 在Go語言中可以通過type給某種類型起一個別名
- 格式一:
type 新類型名 原類型名 - 格式二:
type 新類型名=原類型名
- 格式一:
-
注意點:
如果通過格式一, 代表定義了一個新的類型叫做新類型名
如果通過格式二, 代表給原類型名起了一個別名叫做新類型名
也就是說通過格式一定義的 新類型 和 原類型在編譯器看來是兩個不同的類型
通過格式二定義的 新類型 和 原類型在編譯器看來是同一個類型
package main
import "fmt"
//1.第一種起別名方式
type Integer int
//2.第二種起別名方式
type Integer = int
func main() {
/*
1.在Go語言中可以通過type給某種類型起一個別名
格式一: type 新類型名 原類型名
格式二: type 新類型名=原類型名
注意點:
如果通過格式一, 代表定義了一個新的類型叫做 `新類型名`
如果通過格式二, 代表給原類型名起了一個別名叫做`新類型名`
也就是說通過格式一定義的 新類型 和 原類型在編譯器看來是兩個不同的類型
通過格式二定義的 新類型 和 原類型在編譯器看來是同一個類型
*/
//第一種起別名方式
var num1 int = 10
fmt.Println(num1)
fmt.Printf("%T\n", num1)
var num2 Integer
//不是相同類型的不能賦值
//num2 = num1
fmt.Println(num2)
fmt.Printf("%T\n", num2)
//第二種起名方式
var num1 int = 10
fmt.Println(num1)
fmt.Printf("%T\n", num1)
var num2 Integer
//相同的類型可以相互賦值
num2 = num1
fmt.Println(num2)
fmt.Printf("%T\n", num2)
}
Go語言屬性方法公私有
- 在Go語言中, 同一個包中的內(nèi)容可以隨意訪問
- 在Go語言中, 要想訪問其它包中的內(nèi)容, 那么內(nèi)容名稱的首字母必須大寫
- 要想訪問全局變量, 導(dǎo)入對應(yīng)的包之后, 可以通過
包名.變量名的方式訪問 - 要想訪問方法, 導(dǎo)入對應(yīng)的包之后, 可以通過
包名.方法名的方式訪問 - main包中的代碼
package main
import (
"fmt"
"demo"
)
type person1 struct {
name string
}
func main() {
/*
1.在Go語言中, 同一個包中的內(nèi)容可以隨意訪問
2.在Go語言中, 要想訪問其它包中的內(nèi)容, 那么內(nèi)容名稱的首字母必須大寫
3.要想訪問全局變量, 導(dǎo)入對應(yīng)的包之后, 可以通過 `包名.變量名` 的方式訪問
4.要想訪問方法, 導(dǎo)入對應(yīng)的包之后, 可以通過 `包名.方法名` 的方式訪問
*/
//1.訪問不同包中的全局變量
//fmt.Println(demo.value1) 訪問不到
fmt.Println(demo.Value2)
//2.訪問不同包中的函數(shù)
//demo.say1() 訪問不到
demo.Say2()
//訪問本包中的結(jié)構(gòu)體
per1 := person1{"wjh"}
fmt.Println(per1)
//3.訪問不同包中的函數(shù)
//per2 := person2{"wjh"} 訪問不到
//注意點: 不僅結(jié)構(gòu)體的類型名稱首字母要大寫, 結(jié)構(gòu)體屬性的名稱首字母也要大寫
per3 := demo.Person3{"lnj"}
//4.訪問其他包中的方法
per3.Run()
}
- demo包中的代碼
package demo
import "fmt"
//1.定義全局變量
var value1 = 10
var Value2 = 20
//2.定義函數(shù)
func say1() {
fmt.Println("say1")
}
func Say2() {
fmt.Println("say2")
}
//3.定義結(jié)構(gòu)體
type person2 struct {
name string
}
type Person3 struct {
Name string
}
func (per person2)eat() {
fmt.Println("吃飯了")
}
func (per Person3)Run() {
fmt.Println("跑步啦")
}
Go語言面向?qū)ο?/h2>
面向過程和面向?qū)ο?/h5>
- 面向過程
- 強調(diào)的是功能行為
- 關(guān)注的是解決問題需要哪些步驟
- 所有事情都需要親力親為
- 面向?qū)ο?
- 強調(diào)具備了功能的對象
- 關(guān)注的是解決問題需要哪些對象
- 所有事情都可以交給具備了功能的對象完成, 不用親力親為
創(chuàng)建對象
- 在編程開發(fā)中如何創(chuàng)建一個對象?
- 定義一個類
- 通過定義的類創(chuàng)建對象
現(xiàn)實生活中要創(chuàng)建一個對象, 必須現(xiàn)有一個模型
例如: 生產(chǎn)汽車, 必須有圖紙, 然后再根據(jù)圖紙生產(chǎn)出具體的汽車
現(xiàn)實生活中的圖紙, 就是用于描述汽車有哪些屬性和行為
在編程中, 要想創(chuàng)建對象, 必須先有類編程中的類和現(xiàn)實生活中的圖紙一樣, 也是用于描述將來創(chuàng)建出來的對象有哪些屬性和行為
//根據(jù)類創(chuàng)建一個對象
per := Person{"wjh", 19}
per.eat()
per.run()
類
- 如何定義一個類
- 在類中說明有哪些屬性和行為, 在Go語言中可以通過結(jié)構(gòu)體來說明有哪些屬性和行為
結(jié)構(gòu)體的屬性 就是用于說明 屬性的
結(jié)構(gòu)體的方法 就是用于說明 行為的
//定義一個類
type Person struct {
name string //屬性
age int //屬性
}
//定義行為(方法)
func (per Person)eat() {
fmt.Println(per.name, "吃飯啦")
}
func (per Person)run() {
fmt.Println(per.name, "跑步啦")
}
面向?qū)ο笕筇卣?/h5>
- 繼承
- 當一個類把自己的成員變量暴露給外部的時候,那么該類就失去對該成員變量的管理權(quán)，別人可以任意的修改你的成員變量
- 封裝之后: 提供了數(shù)據(jù)的安全性, 將變化隔離到了自己當中, 外界不用關(guān)心內(nèi)部的處理, 只需要拿到方法使用即可
- 封裝的原則: 將不需要對外提供的內(nèi)容都隱藏起來,把屬性都隱藏,提供公共的方法對其訪問
package main
import (
"demo"
"fmt"
)
//定義一個類
//type Person struct {
// name string
// age int
//}
func main() {
//當一個類把自己的成員變量暴露給外部的時候,那么該類就失去對該成員變量的管理權(quán)，別人可以任意的修改你的成員變量
//創(chuàng)建一個對象
//per := Person{"wjh", 19}
//per.name = "haha" //外界可以隨意修改類屬性
//fmt.Println(per)
// 封裝之后: 提供了數(shù)據(jù)的安全性, 將變化隔離到了自己當中, 外界不用關(guān)心內(nèi)部的處理, 只需要拿到方法使用即可
// 封裝的原則: 將不需要對外提供的內(nèi)容都隱藏起來,把屬性都隱藏,提供公共的方法對其訪問
//創(chuàng)建一個對象
per := demo.Person{}
per.SetName("lnj")
per.SetAge(30)
fmt.Println(per)
fmt.Println(per.GetName()) //lnj
fmt.Println(per.GetAge()) //30
}
package demo
//定義一個類
type Person struct {
name string
age int
}
//給外部提供訪問
//本質(zhì)就是提供兩個公開的方法
func (per *Person)SetName(name string) {
per.name = name
}
func (per *Person)SetAge(age int) {
if age < 0 {
age = 0
}else if age >= 100 {
age = 100
}
per.age = age
}
//獲取屬性參數(shù)的方法
func (per *Person)GetName()(name string) {
name = per.name
return
}
func (per *Person)GetAge()(age int) {
age = per.age
return
}
- 繼承
- Go語言中繼承的本質(zhì)就是結(jié)構(gòu)體嵌套,父類的結(jié)構(gòu)體以子類匿名屬性存在
- 繼承注意點
- 子類可以使用父類的屬性和方法
- 如果子類和父類出現(xiàn)了重名的屬性, 那么采用就近原則
- 如果子類和父類出現(xiàn)了重名的屬性, 要想訪問父類的屬性, 必須逐級查找
- 如果子類和父類出現(xiàn)了重名的方法, 那么采用就近原則 (方法重載)
- 如果子類和父類出現(xiàn)了重名的方法, 要想訪問父類的方法, 必須逐級查找 (方法重載)
package main
import (
"fmt"
)
//定義父類結(jié)構(gòu)體
type Person struct {
name string
age int
}
func (per *Person) say1() {
fmt.Println(per.name, per.age, "是父類的方法")
}
type Student struct {
Person //繼承父類的屬性
name string //同名屬性
score float64
}
func (stu *Student) say1() {
fmt.Println(stu.name, stu.age, "是子類的重名方法")
}
func (stu *Student) say2() {
fmt.Println(stu.name, stu.age, stu.score, "是子類的方法")
}
//定義子類結(jié)構(gòu)體
func main() {
/*
Go語言中繼承的本質(zhì)就是結(jié)構(gòu)體嵌套,父類的結(jié)構(gòu)體以子類匿名屬性存在
繼承注意點:
子類可以使用父類的屬性和方法
如果子類和父類出現(xiàn)了重名的屬性, 那么采用就近原則
如果子類和父類出現(xiàn)了重名的屬性, 要想訪問父類的屬性, 必須逐級查找
如果子類和父類出現(xiàn)了重名的方法, 那么采用就近原則 (方法重載)
如果子類和父類出現(xiàn)了重名的方法, 要想訪問父類的方法, 必須逐級查找 (方法重載)
*/
//子類使用父類的屬性和方法
stu := Student{Person{"wjh", 19}, "lnj", 38.5}
stu.name = "wjh" //使用父類的屬性
stu.age = 18
stu.score = 32.5
fmt.Println(stu)
使用父類的方法
stu.say1()
stu.say2()
fmt.Println(stu.name) //lnj 就近原則
fmt.Println(stu.Person.name) //wjh 逐級查找
//方法的繼承
stu.say1() //方法重載
stu.Person.say1() //想訪問父類方法,必須逐級查找
}
- 多態(tài)
- 多態(tài)就是某一類事物的多種形態(tài)
在Go語言中通過接口來實現(xiàn)多態(tài)
package main
import "fmt"
//定義一個動物接口
type Animals interface {
eat()
}
//定義狗的類
type Dog struct {
name string
}
//實現(xiàn)接口方法
func (d Dog) eat() {
fmt.Println(d.name, "吃東西")
}
//定義貓的類
type Cat struct {
name string
}
//實現(xiàn)接口方法
func (c Cat) eat() {
fmt.Println(c.name, "吃東西")
}
func main() {
/*
1.什么是多態(tài)?
多態(tài)就是某一類事物的多種形態(tài)
2.在Go語言中通過接口來實現(xiàn)多態(tài)
*/
//旺財?shù)墓沸螒B(tài)
//var dog Dog = Dog{"旺財"}
//旺財?shù)膭游镄螒B(tài)
var dog Animals = Dog{"旺財"}
dog.eat()
//喵喵貓的形態(tài)
//var cat = Cat{"喵喵"}
//cat.eat()
//喵喵動物的形態(tài)
var cat Animals = Cat{"喵喵"}
cat.eat()
fmt.Printf("%T\n", cat)
eat(cat)
eat(dog)
}
//定義一個所有動物吃東西的函數(shù)
//提升了代碼的復(fù)用性
func eat(ani Animals) {
ani.eat()
}
- 面向過程
- 強調(diào)的是功能行為
- 關(guān)注的是解決問題需要哪些步驟
- 所有事情都需要親力親為
- 面向?qū)ο?
- 強調(diào)具備了功能的對象
- 關(guān)注的是解決問題需要哪些對象
- 所有事情都可以交給具備了功能的對象完成, 不用親力親為
創(chuàng)建對象
- 在編程開發(fā)中如何創(chuàng)建一個對象?
- 定義一個類
- 通過定義的類創(chuàng)建對象
現(xiàn)實生活中要創(chuàng)建一個對象, 必須現(xiàn)有一個模型
例如: 生產(chǎn)汽車, 必須有圖紙, 然后再根據(jù)圖紙生產(chǎn)出具體的汽車
現(xiàn)實生活中的圖紙, 就是用于描述汽車有哪些屬性和行為
在編程中, 要想創(chuàng)建對象, 必須先有類編程中的類和現(xiàn)實生活中的圖紙一樣, 也是用于描述將來創(chuàng)建出來的對象有哪些屬性和行為
//根據(jù)類創(chuàng)建一個對象
per := Person{"wjh", 19}
per.eat()
per.run()
類
- 如何定義一個類
- 在類中說明有哪些屬性和行為, 在Go語言中可以通過結(jié)構(gòu)體來說明有哪些屬性和行為
結(jié)構(gòu)體的屬性 就是用于說明屬性的
結(jié)構(gòu)體的方法 就是用于說明行為的
- 在類中說明有哪些屬性和行為, 在Go語言中可以通過結(jié)構(gòu)體來說明有哪些屬性和行為
//定義一個類
type Person struct {
name string //屬性
age int //屬性
}
//定義行為(方法)
func (per Person)eat() {
fmt.Println(per.name, "吃飯啦")
}
func (per Person)run() {
fmt.Println(per.name, "跑步啦")
}
面向?qū)ο笕筇卣?/h5>
- 繼承
- 當一個類把自己的成員變量暴露給外部的時候,那么該類就失去對該成員變量的管理權(quán)，別人可以任意的修改你的成員變量
- 封裝之后: 提供了數(shù)據(jù)的安全性, 將變化隔離到了自己當中, 外界不用關(guān)心內(nèi)部的處理, 只需要拿到方法使用即可
- 封裝的原則: 將不需要對外提供的內(nèi)容都隱藏起來,把屬性都隱藏,提供公共的方法對其訪問
package main
import (
"demo"
"fmt"
)
//定義一個類
//type Person struct {
// name string
// age int
//}
func main() {
//當一個類把自己的成員變量暴露給外部的時候,那么該類就失去對該成員變量的管理權(quán)，別人可以任意的修改你的成員變量
//創(chuàng)建一個對象
//per := Person{"wjh", 19}
//per.name = "haha" //外界可以隨意修改類屬性
//fmt.Println(per)
// 封裝之后: 提供了數(shù)據(jù)的安全性, 將變化隔離到了自己當中, 外界不用關(guān)心內(nèi)部的處理, 只需要拿到方法使用即可
// 封裝的原則: 將不需要對外提供的內(nèi)容都隱藏起來,把屬性都隱藏,提供公共的方法對其訪問
//創(chuàng)建一個對象
per := demo.Person{}
per.SetName("lnj")
per.SetAge(30)
fmt.Println(per)
fmt.Println(per.GetName()) //lnj
fmt.Println(per.GetAge()) //30
}
package demo
//定義一個類
type Person struct {
name string
age int
}
//給外部提供訪問
//本質(zhì)就是提供兩個公開的方法
func (per *Person)SetName(name string) {
per.name = name
}
func (per *Person)SetAge(age int) {
if age < 0 {
age = 0
}else if age >= 100 {
age = 100
}
per.age = age
}
//獲取屬性參數(shù)的方法
func (per *Person)GetName()(name string) {
name = per.name
return
}
func (per *Person)GetAge()(age int) {
age = per.age
return
}
- 繼承
- Go語言中繼承的本質(zhì)就是結(jié)構(gòu)體嵌套,父類的結(jié)構(gòu)體以子類匿名屬性存在
- 繼承注意點
- 子類可以使用父類的屬性和方法
- 如果子類和父類出現(xiàn)了重名的屬性, 那么采用就近原則
- 如果子類和父類出現(xiàn)了重名的屬性, 要想訪問父類的屬性, 必須逐級查找
- 如果子類和父類出現(xiàn)了重名的方法, 那么采用就近原則 (方法重載)
- 如果子類和父類出現(xiàn)了重名的方法, 要想訪問父類的方法, 必須逐級查找 (方法重載)
package main
import (
"fmt"
)
//定義父類結(jié)構(gòu)體
type Person struct {
name string
age int
}
func (per *Person) say1() {
fmt.Println(per.name, per.age, "是父類的方法")
}
type Student struct {
Person //繼承父類的屬性
name string //同名屬性
score float64
}
func (stu *Student) say1() {
fmt.Println(stu.name, stu.age, "是子類的重名方法")
}
func (stu *Student) say2() {
fmt.Println(stu.name, stu.age, stu.score, "是子類的方法")
}
//定義子類結(jié)構(gòu)體
func main() {
/*
Go語言中繼承的本質(zhì)就是結(jié)構(gòu)體嵌套,父類的結(jié)構(gòu)體以子類匿名屬性存在
繼承注意點:
子類可以使用父類的屬性和方法
如果子類和父類出現(xiàn)了重名的屬性, 那么采用就近原則
如果子類和父類出現(xiàn)了重名的屬性, 要想訪問父類的屬性, 必須逐級查找
如果子類和父類出現(xiàn)了重名的方法, 那么采用就近原則 (方法重載)
如果子類和父類出現(xiàn)了重名的方法, 要想訪問父類的方法, 必須逐級查找 (方法重載)
*/
//子類使用父類的屬性和方法
stu := Student{Person{"wjh", 19}, "lnj", 38.5}
stu.name = "wjh" //使用父類的屬性
stu.age = 18
stu.score = 32.5
fmt.Println(stu)
使用父類的方法
stu.say1()
stu.say2()
fmt.Println(stu.name) //lnj 就近原則
fmt.Println(stu.Person.name) //wjh 逐級查找
//方法的繼承
stu.say1() //方法重載
stu.Person.say1() //想訪問父類方法,必須逐級查找
}
- 多態(tài)
- 多態(tài)就是某一類事物的多種形態(tài)
在Go語言中通過接口來實現(xiàn)多態(tài)
package main
import "fmt"
//定義一個動物接口
type Animals interface {
eat()
}
//定義狗的類
type Dog struct {
name string
}
//實現(xiàn)接口方法
func (d Dog) eat() {
fmt.Println(d.name, "吃東西")
}
//定義貓的類
type Cat struct {
name string
}
//實現(xiàn)接口方法
func (c Cat) eat() {
fmt.Println(c.name, "吃東西")
}
func main() {
/*
1.什么是多態(tài)?
多態(tài)就是某一類事物的多種形態(tài)
2.在Go語言中通過接口來實現(xiàn)多態(tài)
*/
//旺財?shù)墓沸螒B(tài)
//var dog Dog = Dog{"旺財"}
//旺財?shù)膭游镄螒B(tài)
var dog Animals = Dog{"旺財"}
dog.eat()
//喵喵貓的形態(tài)
//var cat = Cat{"喵喵"}
//cat.eat()
//喵喵動物的形態(tài)
var cat Animals = Cat{"喵喵"}
cat.eat()
fmt.Printf("%T\n", cat)
eat(cat)
eat(dog)
}
//定義一個所有動物吃東西的函數(shù)
//提升了代碼的復(fù)用性
func eat(ani Animals) {
ani.eat()
}
- 當一個類把自己的成員變量暴露給外部的時候,那么該類就失去對該成員變量的管理權(quán)，別人可以任意的修改你的成員變量
- 封裝之后: 提供了數(shù)據(jù)的安全性, 將變化隔離到了自己當中, 外界不用關(guān)心內(nèi)部的處理, 只需要拿到方法使用即可
- 封裝的原則: 將不需要對外提供的內(nèi)容都隱藏起來,把屬性都隱藏,提供公共的方法對其訪問
package main
import (
"demo"
"fmt"
)
//定義一個類
//type Person struct {
// name string
// age int
//}
func main() {
//當一個類把自己的成員變量暴露給外部的時候,那么該類就失去對該成員變量的管理權(quán)，別人可以任意的修改你的成員變量
//創(chuàng)建一個對象
//per := Person{"wjh", 19}
//per.name = "haha" //外界可以隨意修改類屬性
//fmt.Println(per)
// 封裝之后: 提供了數(shù)據(jù)的安全性, 將變化隔離到了自己當中, 外界不用關(guān)心內(nèi)部的處理, 只需要拿到方法使用即可
// 封裝的原則: 將不需要對外提供的內(nèi)容都隱藏起來,把屬性都隱藏,提供公共的方法對其訪問
//創(chuàng)建一個對象
per := demo.Person{}
per.SetName("lnj")
per.SetAge(30)
fmt.Println(per)
fmt.Println(per.GetName()) //lnj
fmt.Println(per.GetAge()) //30
}
package demo
//定義一個類
type Person struct {
name string
age int
}
//給外部提供訪問
//本質(zhì)就是提供兩個公開的方法
func (per *Person)SetName(name string) {
per.name = name
}
func (per *Person)SetAge(age int) {
if age < 0 {
age = 0
}else if age >= 100 {
age = 100
}
per.age = age
}
//獲取屬性參數(shù)的方法
func (per *Person)GetName()(name string) {
name = per.name
return
}
func (per *Person)GetAge()(age int) {
age = per.age
return
}
- Go語言中繼承的本質(zhì)就是結(jié)構(gòu)體嵌套,父類的結(jié)構(gòu)體以子類匿名屬性存在
- 繼承注意點
- 子類可以使用父類的屬性和方法
- 如果子類和父類出現(xiàn)了重名的屬性, 那么采用就近原則
- 如果子類和父類出現(xiàn)了重名的屬性, 要想訪問父類的屬性, 必須逐級查找
- 如果子類和父類出現(xiàn)了重名的方法, 那么采用就近原則 (方法重載)
- 如果子類和父類出現(xiàn)了重名的方法, 要想訪問父類的方法, 必須逐級查找 (方法重載)
package main
import (
"fmt"
)
//定義父類結(jié)構(gòu)體
type Person struct {
name string
age int
}
func (per *Person) say1() {
fmt.Println(per.name, per.age, "是父類的方法")
}
type Student struct {
Person //繼承父類的屬性
name string //同名屬性
score float64
}
func (stu *Student) say1() {
fmt.Println(stu.name, stu.age, "是子類的重名方法")
}
func (stu *Student) say2() {
fmt.Println(stu.name, stu.age, stu.score, "是子類的方法")
}
//定義子類結(jié)構(gòu)體
func main() {
/*
Go語言中繼承的本質(zhì)就是結(jié)構(gòu)體嵌套,父類的結(jié)構(gòu)體以子類匿名屬性存在
繼承注意點:
子類可以使用父類的屬性和方法
如果子類和父類出現(xiàn)了重名的屬性, 那么采用就近原則
如果子類和父類出現(xiàn)了重名的屬性, 要想訪問父類的屬性, 必須逐級查找
如果子類和父類出現(xiàn)了重名的方法, 那么采用就近原則 (方法重載)
如果子類和父類出現(xiàn)了重名的方法, 要想訪問父類的方法, 必須逐級查找 (方法重載)
*/
//子類使用父類的屬性和方法
stu := Student{Person{"wjh", 19}, "lnj", 38.5}
stu.name = "wjh" //使用父類的屬性
stu.age = 18
stu.score = 32.5
fmt.Println(stu)
使用父類的方法
stu.say1()
stu.say2()
fmt.Println(stu.name) //lnj 就近原則
fmt.Println(stu.Person.name) //wjh 逐級查找
//方法的繼承
stu.say1() //方法重載
stu.Person.say1() //想訪問父類方法,必須逐級查找
}
- 多態(tài)就是某一類事物的多種形態(tài)
在Go語言中通過接口來實現(xiàn)多態(tài)
package main
import "fmt"
//定義一個動物接口
type Animals interface {
eat()
}
//定義狗的類
type Dog struct {
name string
}
//實現(xiàn)接口方法
func (d Dog) eat() {
fmt.Println(d.name, "吃東西")
}
//定義貓的類
type Cat struct {
name string
}
//實現(xiàn)接口方法
func (c Cat) eat() {
fmt.Println(c.name, "吃東西")
}
func main() {
/*
1.什么是多態(tài)?
多態(tài)就是某一類事物的多種形態(tài)
2.在Go語言中通過接口來實現(xiàn)多態(tài)
*/
//旺財?shù)墓沸螒B(tài)
//var dog Dog = Dog{"旺財"}
//旺財?shù)膭游镄螒B(tài)
var dog Animals = Dog{"旺財"}
dog.eat()
//喵喵貓的形態(tài)
//var cat = Cat{"喵喵"}
//cat.eat()
//喵喵動物的形態(tài)
var cat Animals = Cat{"喵喵"}
cat.eat()
fmt.Printf("%T\n", cat)
eat(cat)
eat(dog)
}
//定義一個所有動物吃東西的函數(shù)
//提升了代碼的復(fù)用性
func eat(ani Animals) {
ani.eat()
}
