Go基础（7）-golang面向对象三大特征（封装，继承，多态）

已于 2023-01-16 18:47:22 修改
阅读量198 收藏
点赞数
分类专栏： Golang基础语法 文章标签： go
于 2023-01-16 17:30:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w7635122886/article/details/128707200
版权

在这里插入图片描述

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])
}

在这里插入图片描述

李乃龙1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang的封装继承与多态
韩小超的博客
09-26 601
文章目录类的封装及方法绑定类的继承类的访问权限（访问修饰符）多态（通过interface实现）接口的使用多态 类的封装及方法绑定 Golang支持类的操作，但是没有class关键字，使用struct类模拟类 在struct中定义函数需要在外部绑定，通过在方法前面指定数据类型类绑定方法到指定类，有点类似于C#的扩展函数 package main import "fmt" // C++ 创建类的方式 /* class Person{ public: string name int ag
【Golang】封装、继承、接口、多态
豆豆花的博客
01-22 1695
案例：写一个简单的AMT程序，实现存取款和查询功能。 package main ​ import ( "fmt" ) ​ type Pay struct { Account string Pwd string Money float64 } ​ func (pay *Pay) SaveMoney(num float64, pwd string) { if pwd != pay.Pwd { fmt.Println("密码输入错误") ...
封装的golang model
qq_20124631的博客
02-07 448
model package models import ( "database/sql" "encoding/json" "fmt" _ "github.com/go-sql-driver/mysql" "lianxi/log" // "log" "reflect" // "strconv" "strings" "time" ) const ( userName = "r...
Go最新Go语言基础（二）封装继承多态、方法、接口，2024Golang网络编程总结篇
最新发布
2401_84911535的博客
05-12 284
(img-c1AXJYvl-1715516615709)](img-ENusMMxb-1715516615709)](img-fd9sgPcH-1715516615710)]//基本类型不能作为对象直接使用，为基本类型绑定方法，需要起别名才可以。//*代表是否可以读写（修改），*代表接收者为指针。//方法继承和重写（给结构体绑定方法）/p = h //这样是不可以的。//将接口作为函数参数实现多态。//结构体实现接口方法1。//结构体实现接口方法2。
Golang 继承，多态
浴血重生-学习空间
07-03 357
package main import "fmt" type P struct { PA string PB string PI interface{} } func (p *P) Read() error { fmt.Println("P.Read") fmt.Println("P.PI:",p.PI) return nil } type C struct { P PI
GOLANG面向对象：封装 继承 多态
masterphp的博客
08-23 623
Golang面向对象：封装 继承 多态
桫哥-GOlang-05面向对象
06-12
在本课程"桫哥-GOlang-05面向对象"中，我们将深入探讨Go语言的面向对象编程特性。面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”概念，让代码组织更加模块化，易于理解和维护...
Go-Golang系列教程(译)
08-13
《Go-Golang系列教程(译)》是一套全面而深入的Go语言学习资源，专为对Go编程感兴趣的初学者和有经验的开发者设计。Go语言，又称为Golang，是Google在2009年推出的静态类型、编译型、并发型且具有垃圾回收功能的编程...
深入理解GO语言的面向对象
09-21
面向对象的主要特点包括封装、继承和多态，Go语言通过其独特的语法结构巧妙地实现了这些概念。 1. 封装：在Go语言中，封装是通过结构体（struct）和方法（method）实现的。结构体用来定义对象的数据字段，方法则是...
《8小时转职Golang工程师-语法部分》1
08-04
Go语言特别适合构建分布式系统、网络服务以及云计算基础设施，因其简洁的语法、高效的并发支持和强大的标准库而受到广泛欢迎。 在Golang中，声明方式遵循一定的规则。首字母大写的标识符（类名、属性名、方法名）...
大厂Golang开发工程师面试题集锦 后端 - Java.zip
09-25
- **面向对象编程**：封装、继承、多态是Java的核心特性。 - **垃圾回收（Garbage Collection）**：Java自动进行内存管理，理解GC的工作原理和调优是重要的。 - **集合框架**：包括ArrayList、LinkedList、...
Golang接口实现多态
weixin_34388207的博客
05-23 369
package main import ( "fmt" ) func main() { user := &User{name: "Chris"} user.ISubUser = &NormalUser{} user.sayHi() user.ISubUser = &ArtisticUser{} u...
Go语言基础（二）封装继承多态、方法、接口
Sir的专栏
08-18 424
封装 go语言中可以简单地看作对struct的封装 type Person struct { name string } type Student struct { name string } type Teacher struct { name string } 继承 go语言中没有继承，但可以通过“匿名组合”实现继承 结构体继承，方法继承，方法重写 //父类 type Person struct { name string age int } type Stud
go封装、继承、多态
qq_38324542的博客
08-17 348
go面向对象编程
golang利用组合实现继承
qq_26847293的博客
04-07 752
package main import "fmt"type Base struct { Name string }func (b *Base) SetName(name string) { b.Name = name }func (b *Base) GetName() string { return b.Name }// 组合，实现继承 type Child struct
Go后端开发 -- 面向对象特征：结构体 && 继承 && 多态 && interface
kissland96166的博客
01-16 2133
type用来声明数据类型//声明一种新的数据类型myint，是int的一个别名 type myint int使用type定义结构体可以先定义后初始化；也可以直接在{}中初始化// 定义一个结构体//可以先定义后初始化book1.author = "李四"//也可以直接在{}中初始化book2 := Book{title: "c++", author: "王五"}上面实例的结构体类型Hero的首字母是大写的go语言的封装是针对包来封装的，类的公有和私有都是针对包来的。
Golang 面向对象（封装、继承、多态）
热门推荐
baolingye的博客
12-15 2万+
前言 Go语言并不像Java那样有类的概念，以及extends这样的关键字，但是可以用其特有的数据结构来实现类似面向对象的特性。主要有结构体实现封装，组合实现继承，接口实现多态。当然，Go语言还有其特有的类型判断与断言。 文章目录前言一、结构体实现封装二、组合实现继承三、接口实现 一、结构体实现封装 在Go语言中，我们可以对结构体的字段进行封装，并通过结构体中的方法来操作内部的字段。如果结构体中字段名的首字母是小写字母，那么这样的字段是私有的，相当于private字段。外部包裹能直接访问，如果是在名的首字母
golang 面向对象 （继承，封装，多态）结构体
qq_39657769的博客
03-07 461
结构体基础操作 package main import( "fmt" ) type Cat struct{ Name string `json:"name"`//返回时 Name会变成name Age int } func main(){ //声明方式一 var cat1 Cat cat1.Name ="小白" cat1.Age = 21 fmt.Println(cat1) //声明方式二 p1 := Cat{"tom",1} fmt.Pr
【入门Golang中的结构体、封装、继承、接口和多态】
小墨蛇的博客
07-21 938
默认情况下，结构体字段和方法是对外可见的，但通过使用大写字母开头的标识符，可以实现对外部的封装。在Golang中，由于接口的存在，实现了接口的类型可以以不同的方式执行相同的操作。通过理解这些概念，你可以在Golang中设计和实现更加灵活和可扩展的代码结构，提升代码的复用性和可维护性。接口是一种契约，规定了类型需要实现的方法。Golang中的接口是隐式实现的，只要一个类型实现了接口中定义的所有方法，就被视为实现了该接口。Golang中没有传统意义上的类继承，但通过结构体的嵌入和组合，可以实现类似的功能。
golang多态编程
10-12
在 Golang 中，多态是通过接口实现的。一个类型只要实现了某个接口中定义的所有方法，就可以被看作是该接口类型的实例。这种方式实现的多态性被称为接口多态。 举个例子，假设我们有一个接口 Animal，其中定义了一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值