1，抽象

1.1 抽象的练习

package main

import "fmt"

type Account struct {
	AccountNo string
	Pwd string
	Balancd float64
}
//存钱
func (account *Account)Deposite(money float64,pwd string)  {
	if(pwd!=account.Pwd){
		fmt.Println("密码不正确")
		return
	}
	if(money <= 0){
		fmt.Println("余额不正确")
		return
	}
	account.Balancd += money
	fmt.Println("存款成功")
}
//取钱
func (account *Account)WithDraw(money float64,pwd string)  {
	if(pwd!=account.Pwd){
		fmt.Println("密码不正确")
		return
	}
	if(money <= 0 || money>account.Balancd){
		fmt.Println("余额不正确")
		return
	}
	account.Balancd -= money
	fmt.Println("取款成功")
}
//查询余额
func (account *Account)Query(pwd string)  {
	if(pwd!=account.Pwd){
		fmt.Println("密码不正确")
		return
	}
	fmt.Println("你的账号为:",account.AccountNo)
	fmt.Println("你的余额为:",account.Balancd)
}
func main() {
	account:=Account{
		AccountNo: "gsyh111",
		Pwd: "666666",
		Balancd:   100,
	}
	//查询余额
	account.Query("666666")
	//取钱
	account.WithDraw(65,"666666")
	account.Query("666666")
	//存钱
	account.Deposite(1000,"666666")
	account.Query("666666")
}

2，封装

2.1，封装的介绍

2.2，封装的好处

2.3，封装的步骤

2.4，封装的入门案例

2.4.1，创建 person

package model

import "fmt"

type person struct {
	Name string
	age int //其他包不能访问
	sal float64 //其他包不能访问
}

func NewPerson(name string)*person  {
	return &person{
		Name: name,
	}
}

//为了访问age和sal我们编写一对Setxxx个Getxxx的方法
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.sal
}

2.4.2，创建main方法

package main

import (
	"demo10_面向对象三大特性/demo02_封装/model"
	"fmt"
)

func main() {
	p:= model.NewPerson("李乃龙")
	fmt.Println(*p)
	p.SetAge(25)
	p.SetSal(10500.00)
	fmt.Println(p.Name)
	fmt.Println(p.GetAge())
	fmt.Println(p.GetSal())
}

3，继承

3.1，继承的概念

3.2，继承的基本语法

3.3，基础的入门演示

package main

import "fmt"

type student struct {
	Name string
	Age int
	Score float64
}
//小学生
type Pupil struct {
	student
}

//大学生
type Graduate struct {
	student
	Hoddy string
}
//研究生

func (student *student)ShowInfo()  {
	fmt.Println("姓名=>",student.Name)
	fmt.Println("年龄=>",student.Age)
	fmt.Println("分数=>",student.Score)
}

//设置分数
func (student *student)SetScore(score float64)  {
	student.Score = score
}

func (student *student)Testing(str string)  {
	fmt.Println(str)
}

func main() {
	var pupil Pupil
	pupil.Testing("小学生考试中")
	pupil.SetScore(100)
	pupil.Name = "小学生李乃龙"
	pupil.Age = 11
	pupil.ShowInfo()

	var graduate Graduate
	graduate.Testing("大学生考试中")
	graduate.SetScore(100)
	graduate.Name = "大学生李乃龙"
	graduate.Hoddy = "写代码"
	graduate.Age = 20
	graduate.ShowInfo()
	fmt.Println("大学生爱好=>",graduate.Hoddy)
}

4，接口

4.1，为什么要接口

4.2，接口快速入门

package main

import "fmt"

//声明/定义一个接口
type Usb interface {
	//声明了两个没有实现的方法
	Start()
	Stop()
}
type Phone struct {

}
//让phone实现Usb接口的方法
func (p Phone) Start()  {
	fmt.Println("手机开始工作...")
}

func (p Phone) Stop()  {
	fmt.Println("手机停止工作...")
}

//让Camera实现Usb接口的方法
type Camera struct {

}
func (c Camera) Start()  {
	fmt.Println("相机开始工作...")
}

func (c Camera) Stop()  {
	fmt.Println("相机停止工作...")
}

//计算机
type Computer struct {

}
//只要是实现类usb接口的都可以传过来
func (c *Computer) Working(usb Usb){
	usb.Start()
	usb.Stop()
}
func main() {
	var computer Computer
	var camera Camera
	var phone Phone
	computer.Working(camera)
	computer.Working(phone)
}

4.3，接口介绍

4.4，接口的应用场景

4.5，接口的注意事项和细节

4.6，验证第1点细节

package main

import "fmt"

type AinterFace interface {
	Say()
}

type Stu struct {
	Name string
}

func (stu Stu)Say(){
	fmt.Println("Stu Say()")
}
func main() {
	var stu Stu
	var a AinterFace = stu
	a.Say()
}

4.7，验证第5,6点细节

package main

import "fmt"
type AinterFace1 interface {
	Say()
}
type AinterFace2 interface {
	Hello()
}

type interger int

func (i interger) Say()  {
	fmt.Println(" interger say ==>",i)
}

func (i interger) Hello()  {
	fmt.Println(" interger Hello ==>",i)
}

func main() {
	var i interger
	var a AinterFace1 = i
	var b AinterFace2 = i
	a.Say()
	b.Hello()
}

4.8，验证第8点细节

package main

import "fmt"

type AinterFace3 interface {
	AinterFace4
	Hello3()
}

type AinterFace4 interface {
	Say()
}
type Stu2 struct {

}

func (stu2 Stu2) Hello3(){
	fmt.Println("Hello3")
}

func (stu2 Stu2) Say(){
	fmt.Println("Say")
}

func main() {
	var stu Stu2
	var a AinterFace3 = stu
	a.Say()
	a.Hello3()
}

5，多态

package main

import "fmt"

//声明/定义一个接口
type Usb interface {
	//声明了两个没有实现的方法
	Start()
	Stop()
}
type Phone struct {
	Name string
}
//让phone实现Usb接口的方法
func (p Phone) Start()  {
	fmt.Println("手机开始工作...")
}

func (p Phone) Stop()  {
	fmt.Println("手机停止工作...")
}

//让Camera实现Usb接口的方法
type Camera struct {
	Name string
}
func (c Camera) Start()  {
	fmt.Println("相机开始工作...")
}

func (c Camera) Stop()  {
	fmt.Println("相机停止工作...")
}

//计算机
type Computer struct {

}
//只要是实现类usb接口的都可以传过来
func (c *Computer) Working(usb Usb){
	usb.Start()
	usb.Stop()
}
//多态数组
func main() {
	//定义一个Usb接口数组,里面存放Camera和Phone的结构体变量
	var usbArr[3]Usb
	usbArr[0]=Phone{"小米"}
	usbArr[1]=Phone{"Oppo"}
	usbArr[2]=Camera{"尼康"}
	fmt.Println(usbArr[1])
	var computer Computer
	computer.Working(usbArr[2])
}