面向对象编程

  • 一、面向对象编程三大特性-封装
  • 二、面向对象编程三大特性-继承
  • 三、 接口
  • 四、面向对象编程三大特性-多态
  • 五、 类型断言
  • 总结

一、面向对象编程三大特性-封装

1）介绍

2）快速入门案例

package model
type person struct{
	Name string 
	age int
	salary float64
}
//相当于构造函数
func NewStudent(name string)*person{
	return &person{
		Name:name,
	}
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.salary
}
}
}

package main
import(
	"fmt"
	"go_code/project00/model"
)
func main(){
	var stu=model.NewStudent("tom",88.8)
	fmt.Println(*stu)
	fmt.Println("name=",stu.Name,"score=",stu.GetScore())
}


package model02
import(
	"fmt"
)
type account struct{
	accountNo string
	pwd string 
	balance float64
}
func NewAccount(No string,pwd string,balance float64)*account{
	if len(accountNo)<6||len(accountNo)>10{
		fmt.Println("账号的长度不对...")
		return nil
	}
	if len(pwd)!=6{
		fmt.Println("密码的长度不对...")
	}
	if balance<20{
		fmt.Println("余额数目不对...")
	}
	return &account{
		accountNo:No,
		pwd:pwd,
		balance:balance,
	}
	func (account *account) Deposite(money float64,pws string){
		if pwd != account.pwd {
			fmt.Println("你输入的密码不正确")
			return
			}
			//看看存款金额是否正确
			if money <= 0 {
			fmt.Println("你输入的金额不正确")
			return
			}
			account.balance += money
			fmt.Println("存款成功~~")
	}
	func (account *account) WithDraw(money float64, pwd string){
		if pwd != account.pwd {
			fmt.Println("你输入的密码不正确")
			return
			}
			if money <= 0 || money > account.balance {
				fmt.Println("你输入的金额不正确")
				return
				}
				account.balance -= money
				fmt.Println("取款成功~~")	
	}
	func (account *account) Query(pwd string) {
		//看下输入的密码是否正确
		if pwd != account.pwd {
		fmt.Println("你输入的密码不正确")
		return
		}
		fmt.Printf("你的账号为=%v 余额=%v \n", account.accountNo, account.balance)
		}
	}

二、面向对象编程三大特性-继承

1）语法

2）快速入门

package main
import(
	"fmt"
)
type Student struct{
	Name string
	Age int
	Score int
}
func (stu *Student)ShowInfo(){
	fmt.Printf("姓名：%v 年龄：%v 成绩：%v\n",stu.Name,stu.Age,stu.Score)

}
func (stu *Student)SetScore(score int){
	stu.Score=score
}
type pupil struct{
	Student
	
}
func (p *pupil)testing(){
	fmt.Println("小学生正在考试...")
}
type Graduate struct{
	Student
}
func (g *Graduate)testing(){
	fmt.Println("大学生正在考试...")
}
func main(){
	p:=pupil{}
	p.Name="tom"
	p.Age=18
	p.testing()
	p.SetScore(70)
	p.ShowInfo()

	g:=Graduate{}
	g.Name="tom"
	g.Age=18
	g.testing()
	g.SetScore(70)
	g.ShowInfo()
}

3）细节

  • 结构体可以使用嵌套匿名结构体所有的字段和方法
  • 匿名结构体字段访问可以简化
  • 结构体嵌入两个(或多个)匿名结构体，如两个匿名结构体有相同的字段和方法(同时结构体本身没有同名的字段和方法)，在访问时，就必须明确指定匿名结构体名字
  • 如果一个 struct 嵌套了一个有名结构体，这种模式是组合，如果是组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字
  • 嵌套匿名结构体后，也可以在创建结构体变量(实例)时，直接指定各个匿名结构体字段的值

三、 接口

1）为什么有接口

2）快速入门

package main
import(
	"fmt"
)
import()
type Usb interface{
	Start()
	Stop()
}
type Phone struct{

}
func (p Phone)Start(){
	fmt.Println("手机开始")
}
func (p Phone)Stop(){
	fmt.Println("手机结束")
}
type Camera struct{}
func (c Camera)Start(){
	fmt.Println("相机开始")
}
func (c Camera)Stop(){
	fmt.Println("相机结束")
}
type Computer struct{}
func (c Computer)Working(usb Usb){
	usb.Start()
	usb.Stop()
}
func main(){
	computer:=Computer{}
	phone:=Phone{}
	camera:=Camera{}
	computer.Working(phone)
	computer.Working(camera)
}

3）基本语法

  • 不包含变量
  • 接口中的方法没有方法体
  • 不需要显式的实现

4）注意细节

  • 、接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量
	var a Usb=phone
	a.Start()
	a.Stop()
  • 只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型
  • interface 类型默认是一个=指针(引用类型)，如果没有对 interface 初始化就使用，那么会输出 nil
  • 空接口 interface{} 没有任何方法，所以所有类型都实现了空接口, 即我们可以把任何一个变量赋给空接口

4）实现接口 vs 继承
接口是继承的一种补充

四、面向对象编程三大特性-多态

type Usb interface{
	Start()
	Stop()
}
type Phone struct{
	name string
}
func (p Phone)Start(){
	fmt.Println("电话开始")
}
func(p Phone)Stop(){
	fmt.Println("电话结束")
}
func (p Phone)Call(){
	fmt.Println("手机在打电话")
}
type Camera struct{
	name string
}
func (c Camera)Start(){
	fmt.Println("相机开始")
}
func (c Camera)Stop(){
	fmt.Println("相机结束")
}
type Computer struct{}
func (c Computer)Working(usb Usb){
	usb.Start()
	usb.Stop()
}
func main(){
	var usbArr [3]Usb
	usbArr[0]=Phone{"vivo"}
	usbArr[1]=Phone{"小米"}
	usbArr[2]=Camera{"索尼"}
	var computer Computer

五、 类型断言

1）需求
把一个接口变量，赋值给自定义类型的变量
2）基本介绍
3）最佳实践1

package main
import "fmt"
type Usb interface{
	Start()
	Stop()
}
type Phone struct{
	name string
}
func (p Phone)Start(){
	fmt.Println("电话开始")
}
func(p Phone)Stop(){
	fmt.Println("电话结束")
}
func (p Phone)Call(){
	fmt.Println("手机在打电话")
}
type Camera struct{
	name string
}
func (c Camera)Start(){
	fmt.Println("相机开始")
}
func (c Camera)Stop(){
	fmt.Println("相机结束")
}
type Computer struct{}
func (c Computer)Working(usb Usb){
	usb.Start()
	phone,ok:=usb.(Phone);
	if ok{
		phone.Call()
	}
	usb.Stop()
}
func main(){
	var usbArr [3]Usb
	usbArr[0]=Phone{"vivo"}
	usbArr[1]=Phone{"小米"}
	usbArr[2]=Camera{"索尼"}
	var computer Computer
	for _,v :=range usbArr{
		computer.Working(v)
		fmt.Println()
	}
}


4）最佳实践2

func TypeJudge(item... interface{}){
	for i,v:=range item{
		switch v.(type){
		case bool:
			fmt.Printf("%v个参数是bool类型,值是%v\n",i,v)
		case int:
			fmt.Printf("%v个参数是int类型,值是%v\n",i,v)
		}
	

	}
}
func main(){
	var n1=true
	var n2 int =23
	TypeJudge(n1,n2)
}

总结

本文仅仅简单介绍了Golang面向对象编程，此篇是通过b站尚硅谷Golang视频的学习做的笔记。

更多推荐

【golang面向对象编程】