10-Go基础：面向对象

于 2022-04-25 22:51:20 发布
阅读量351 收藏
点赞数
分类专栏： Go语言基础 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq23001186/article/details/124410778
版权

目录

一、面向对象简介

  • 面向过程概念：所谓的面向过程就是 -> 强调的是步骤、过程、每一步都是自己亲自去实现的
  • 面向对象概念：所谓的面向对象其实就是找一个专门做这个事的人来做，不用关心具体怎么实现的
  • 面向对象和面向过程区别：面向过程强调的是过程，步骤。而面向对象强调的是对象，也就是干事的人
  • 编程中描述类：在程序中，可以通过属性和方法（函数）来描述类。属性就是特征，方法（函数）就是行为

二、继承

1 - 通过匿名字段来实现继承

  • 继承概念
    • 继承是一种类间关系，描述一个类从另一个类获取成员信息的类间关系
    • 继承必定发生在两个类之间，参与继承关系的双方称为父类和子类
    • 父类提供成员信息，子类获取成员信息
  • 匿名字段实现继承与初始化
type Student struct {
	Person // 匿名字段，，只有类型，没有成员的名字
	score  float64
}
type Teacher struct {
	Person
	salary float64
}
type Person struct {
	id   int
	name string
	age  int
}

func main() {
	var stu Student = Student{Person{101, "张三", 18}, 90}
	// 部分初始化
	var stu1 Student = Student{score: 90}
	var stu2 Student = Student{Person: Person{id: 101}}
	fmt.Println(stu)  // {{101 张三 18} 90}
	fmt.Println(stu1) // {{0  0} 90}
	fmt.Println(stu2) // {{101  0} 0}
}

2 - 成员操作

  • 成员的操作包含：
    • 获取成员的值：对象名.成员
    • 修改成员的值：对象名.成员 = 值
type Student struct {
	Person
	score float64
}
type Person struct {
	id   int
	name string
	age  int
}

func main() {

	var stu Student = Student{Person{101, "张三", 18}, 90}
	var stu1 Student = Student{Person{102, "李四", 18}, 80}
	stu.score = 100
	fmt.Println("张三考试成绩:", stu.score)
	fmt.Println(stu1.score)
	fmt.Println(stu1.Person.id)
	fmt.Println(stu1.id) //简化写法，先到子类中查找成员，没有找到成员后就到父类中查找
}

3 - 指针匿名字段

type Student struct {
	*Person // 匿名字段
	score   float64
}
type Person struct {
	id   int
	name string
	age  int
}

func main() {
	var stu Student = Student{&Person{101, "张三", 18}, 90}
	fmt.Println(stu.name)
}

4 - 多重继承

type Student struct {
	Person
	score float64
}
type Person struct {
	Object
	name string
	age  int
}
type Object struct {
	id int
}

func main() {
	var stu Student
	stu.age = 18
	fmt.Println(stu.Person.age)
	stu.id = 101
	fmt.Println(stu.Person.Object.id)
}

5 - 为结构体添加方法

  • 一般都将方法的接收对象使用结构体指针来接收
//语法
func  (对象 结构体类型) 方法名 (参数列表)(返回值列表) {
		代码体
}

//案例
type Student struct {
	id   int
	name string
	age  int
}

func (s Student) PrintShow() {
	fmt.Println(s)
}
func (s *Student) EditInfo() {//如果不是结构体指针，将无法修改原对象的值
	s.age = 20
}
func main() {
	stu := Student{101, "张三", 18}
	stu.PrintShow() // 完成对方法的调用, 将stu中的值，传递给了方法的s
	stu.EditInfo()
	stu.PrintShow()
}
  • 只要接收者类型不一样，这个方法就算同名，也是不同方法
type Student struct {
	id   int
	name string
	age  int
}
type Teacher struct {
	id   int
	name string
}

func (s *Student) Show() {
	fmt.Println(s)
}
func (t *Teacher) Show() {
	fmt.Println(t)
}
func main() {
	// 如果接收者类型不同，即使方法的名字是相同的也是不同的方法
	stu := Student{101, "李四", 18}
	(&stu).Show()
	stu.Show() // 这个是go语言的优化，实际是(&stu).Show()
	teacher := Teacher{102, "老王"}
	teacher.Show()
}
  • 案例：获取学生信息
//定义一个学生类,有六个属性,分别为姓名、性别、年龄、语文、数学、英语成绩
//第一方法：打招呼的方法：介绍自己叫XX，今年几岁了。是男同学还是女同学。
//第二个方法：计算总分与平均分的方法

// 1: 定义结构体
type StudentInfo struct {
	name    string
	sex     string
	age     int
	chinese float64
	math    float64
	english float64
}

// 2: 添加方法
func (s *StudentInfo) SayHello(userName string, userAge int, userSex string) {
	// 2.1 初始化
	s.name = userName
	s.age = userAge
	s.sex = userSex
	// 2.2  初始化后的值进行判断。
	if s.sex != "男" && s.sex != "女" {
		s.sex = "男"
	}
	if s.age < 1 || s.age > 100 {
		s.age = 18
	}
	// 2.3 打印输出结果
	fmt.Printf("我叫%s,年龄是%d,性别是%s\n", s.name, s.age, s.sex)
}
func (s *StudentInfo) GetScore(chinese float64, math float64, english float64) {
	// 1: 初始化
	s.chinese = chinese
	s.math = math
	s.english = english
	// 2: 进行计算
	sum := s.chinese + s.math + s.english
	// 3： 打印输出结果
	fmt.Printf("我叫%s,总分%f,平均分%f", s.name, sum, sum/3)
}
func main() {
	var stu StudentInfo
	stu.SayHello("张三", 180, "df")
	stu.GetScore(90, 89, 87)
}

三、方法继承与重写

  • 方法继承：子类可以调用父类的方法
type Student struct {
	Person
	score float64
}
type Person struct {
	id   int
	name string
	age  int
}

func (p *Person) PrintInfo() {
	fmt.Println(*p)
}

func main() {
	stu := Student{Person{101, "张三", 18}, 90}
	stu.PrintInfo()
}
  • 方法重写：默认调用的是子类中的方法
    • 如果父类中的方法名称与子类中的方法名称一致，那么通过子类的对象调用的是子类中的方法
    • 子类方法重写，要调用父类的方法stu.Person.PrintInfo()
type Person struct {
	name string
	age  int
}

func (p *Person) PrintInfo() {
	fmt.Println("这是父类中的方法")
}

type Student struct {
	Person
	score float64
}

func (p *Student) PrintInfo() {
	fmt.Println("这是子类中的方法")
}

func main() {
	var stu Student
	stu.PrintInfo() // 如果父类中的方法名称与子类中的方法名称一致，那么通过子类的对象调用的是子类中的方法；方法重写
	stu.Person.PrintInfo()
}
  • 方法值与方法表达式：实现方法调用
type Person struct {
	name string
	age  int
}

func (p *Person) PrintInfo() {
	fmt.Println(*p)
}

func main() {
	per := Person{"张三", 18}
	per.PrintInfo()

	//方法值
	f := per.PrintInfo
	fmt.Printf("%T", f)
	f()

	//方法表达式
	f1 := (*Person).PrintInfo
	f1(&per)
}

四、接口

  • 什么是接口：
    • 接口就是一种规范与标准，只是规定了要做哪些事情。具体怎么做，接口是不管的
    • 接口把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口
  • 接口定义语法
type 接口名字  interface {
	方法声明
}
  • 接口实现与调用
type Personer interface {
	SayHello()
}
type Student struct {
}

func (s *Student) SayHello() {
	fmt.Println("老师好")
}

type Teacher struct {
}

func (t *Teacher) SayHello() {
	fmt.Println("学生好")
}

func main() {
	// 对象名.方法名
	var stu Student
	stu.SayHello()
	var teacher Teacher
	teacher.SayHello()
	// 通过接口变量来调用,必须都实现接口中所声明的方法

	var person Personer
	person = &stu
	person.SayHello() // 调用的是Student 实现的SayHello方法
	person = &teacher
	person.SayHello()
}

五、多态

  • 多态概念：指的是多种表现形式；多态就是同一个接口，使用不同的实例而执行不同操作
  • 多态实现语法：定义函数实现
func 函数名 (参数 接口类型){
	
}
  • 多态定义与实现
type Personer interface {
	SayHello()
}
type Student struct {
}

func (s *Student) SayHello() {
	fmt.Println("老师好")
}

type Teacher struct {
}

func (t *Teacher) SayHello() {
	fmt.Println("学生好")
}

func WhoSayHi(h Personer) {
	h.SayHello()
}

func main() {
	var stu Student
	var teacher Teacher
	WhoSayHi(&stu)
	WhoSayHi(&teacher)
}
  • 案例：移动硬盘或者U盘插到电脑上进行读写数据
type Stroager interface {
	Read()
	Writer()
}

// 移动硬盘
type MDisk struct {
}

func (m *MDisk) Read() {
	fmt.Println("移动硬盘读取数据")
}
func (m *MDisk) Writer() {
	fmt.Println("移动硬盘写入数据")
}

// U盘
type UDisk struct {
}

func (u *UDisk) Read() {
	fmt.Println("U盘读取数据")
}
func (u *UDisk) Writer() {
	fmt.Println("U盘写入数据")
}

// 定义一个函数
func Computer(c Stroager) {
	c.Read()
	c.Writer()
}
func main() {
	var udisk UDisk
	var mdisk MDisk
	Computer(&udisk)
	Computer(&mdisk)
}
  • 案例：定义一个类实现计算器
type Object struct {
}

// 2: 添加一个方法。
func (o *Object) GetResult(numA int, numB int, op string) int {
	// 1: 添加参数
	// 2: 判断运算方式
	var result int
	switch op {
	case "+":
		result = numA + numB + 100
	case "-":
		result = numA - numB - 100
	}
	return result
}

func main() {
	var obj Object
	num := obj.GetResult(8, 6, "-")
	fmt.Println(num)
}
  • 案例：分离类方式实现计算器
// 加法类
type Add struct {
	Object
}

func (a *Add) GetResult() int { // 方法的实现要和接口中方法的声明保持一致
	return a.numA + a.numB
}

// 减法类
type Sub struct {
	Object
}

func (s *Sub) GetResult() int {
	return s.numA - s.numB
}

type Object struct {
	numA int
	numB int
}
type Resulter interface {
	GetResult() int
}

func main() {
	add := Add{Object{10, 20}}
	num := add.GetResult()
	fmt.Println(num)

	sub := Sub{Object{20, 10}}
	num1 := sub.GetResult()
	fmt.Println(num1)
}
  • 案例：工厂创建对象方式实现计算器
// 加法类
type Add struct {
	Object
}

func (a *Add) GetResult() int { // 方法的实现要和接口中方法的声明保持一致
	return a.numA + a.numB
}

// 减法类
type Sub struct {
	Object
}

func (s *Sub) GetResult() int {
	return s.numA - s.numB
}

type Object struct {
	numA int
	numB int
}
type Resulter interface {
	GetResult() int
}

// 对象问题
// 1: 定义一个新的类
type OperatorFactory struct {
}

// 2: 创建一个方法，在该方法中完成对象的创建
func (o *OperatorFactory) CreateOperator(op string, numA int, numB int) int {
	switch op {
	case "+":
		add := Add{Object{numA, numB}}
		return OperatorWho(&add)
	case "-":
		sub := Sub{Object{numA, numB}}
		return OperatorWho(&sub)
	default:
		return 0
	}
}
func OperatorWho(h Resulter) int {
	return h.GetResult()
}

func main() {
	var operator OperatorFactory
	num := operator.CreateOperator("-", 20, 10)
	fmt.Println(num)
}

六、接口的继承与转换

type Humaner interface {
	SayHello()
}
type Personer interface {
	Humaner
	Say()
}
type Student struct {
}

func (s *Student) SayHello() {
	fmt.Println("大家好")
}
func (s *Student) Say() {
	fmt.Println("你好")
}
func main() {
	var stu Student
	var per Personer
	per = &stu
	per.Say()
	per.SayHello() // 可以调用所继承的接口中的方法

	var h Humaner
	h = per
	h.SayHello()
}

七、空接口与类型断言

  • 空接口概念：空接口(interface{})不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值
  • 定义与使用空接口
func main() {
	var i interface{} // i就是一个空接口类型的变量
	i = 123
	i = "abc"
	fmt.Println(i)
	var s []interface{} // 空接口类型的切片
	s = append(s, 123, "abc", 12.3)
	for j := 0; j < len(s); j++ {
		fmt.Println(s[j])
	}
}
  • 类型断言：通过类型断言，可以判断空接口中存储的数据类型
  • 类型断言语法：value, ok := m.(T)
    • m:表空接口类型变量
    • T:是断言的类型.
    • value: 变量m中的值
    • ok: 布尔类型变量，如果断言成功为true,否则为false
func main() {
	var i interface{}
	i = "abc"
	value, ok := i.(int)
	if ok {
		fmt.Println(value + 10)
	} else {
		fmt.Println("类型推断错误")
	}
}
  • 案例：空接口与类型断言实现计算器数据校验
package main

import "fmt"

// 加法类
type Add struct {
	Object
}

func (a *Add) GetResult() int { // 方法的实现要和接口中方法的声明保持一致
	return a.numA + a.numB
}
func (a *Add) SetData(data ...interface{}) bool {
	// 1: 对数据的个数进行校验。
	var b bool = true
	if len(data) > 2 {
		fmt.Println("参数个数错误！！")
		b = false
	}
	value, ok := data[0].(int)
	if !ok {
		fmt.Println("第一个数类型错误")
		b = false
	}
	value1, ok1 := data[1].(int)
	if !ok1 {
		fmt.Println("第二个数据类型错误")
		b = false
	}
	a.numA = value
	a.numB = value1
	// 2: 类型进行校验。
	return b
}

// 减法类
type Sub struct {
	Object
}

func (s *Sub) GetResult() int {
	return s.numA - s.numB
}

func (s *Sub) SetData(data ...interface{}) bool {
	// 1: 对数据的个数进行校验。
	var b bool = true
	if len(data) > 2 {
		fmt.Println("参数个数错误！！")
		b = false
	}
	value, ok := data[0].(int)
	if !ok {
		fmt.Println("第一个数类型错误")
		b = false
	}
	value1, ok1 := data[1].(int)
	if !ok1 {
		fmt.Println("第二个数据类型错误")
		b = false
	}
	s.numA = value
	s.numB = value1
	// 2: 类型进行校验。
	return b
}

type Object struct {
	numA int
	numB int
}
type Resulter interface {
	GetResult() int
	SetData(data ...interface{}) bool // 完成参数运算的数据的类型校验。
}

// 对象问题
// 1: 定义一个新的类
type OperatorFactory struct {
}

// 2: 创建一个方法，在该方法中完成对象的创建
func (o *OperatorFactory) CreateOperator(op string) Resulter {
	switch op {
	case "+":
		add := new(Add)
		return add
	case "-":
		sub := new(Sub)
		return sub

	default:
		return nil
	}
}
func OperatorWho(h Resulter) int {
	return h.GetResult()
}
func main() {
	var operator OperatorFactory
	obj := operator.CreateOperator("-")
	b := obj.SetData(30, 10)
	if b {
		num := OperatorWho(obj)
		fmt.Println(num)
	}
}
无休止符
关注
专栏目录
go method使用
余功鹏的专栏
02-03 516
转载：https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.5.md method 现在假设有这么一个场景，你定义了一个struct叫做长方形，你现在想要计算他的面积，那么按照我们一般的思路应该会用下面的方式来实现 package main import "fm
Go基础之面向对象（封装篇）
coding
08-29 624
一．封装：  go中一般使用CamelCase 首字母大写：public 首字母小写：private public与private针对的是包 二．包 每个目录下一个包，与其他语言不同的是，目录名和包名可以不同 main包包含可执行入口main()函数 为结构定义的方法必须在同一个包内，但可以是不同的文件 ...
Go基础编程：面向对象—方法
秋叶原 && Mike || 麦克
12-28 3930
1 概述 在面向对象编程中，一个对象其实也就是一个简单的值或者一个变量，在这个对象中会包含一些函数，这种带有接收者的函数，我们称为方法(method)。 本质上，一个方法则是一个和特殊类型关联的函数。 一个面向对象的程序会用方法来表达其属性和对应的操作，这样使用这个对象的用户就不需要直接去操作对象，而是借助方法来做这些事情。 在Go语言中，可以给任意自定义类型（包括内置类型，但不包括指针类型...
c#基础--属性
weixin_34268169的博客
12-12 608
定义一个public的变量，在这个变量中含有get/set两个方法，这个变量是为了保护一个私有变量的。 属性是为了保护与之相对应的字段的，保证对字段的读取和赋值符合要求。 属性可分为：读写，只读，只写。 允许外部访问的变量一定要声明为属性 具有get/set方法的属性就叫做读写属性 只有get方法的属性就叫做只读属性 只有set方法的属性就叫做只写属性 练习题： 定义一个学生类，有六...
面向对象与类
qq_43864695的博客
06-18 999
面向对象 类 1、类的概念：类是一个模板，确定了一个对象应该有的属性与方法，简单理解就是属性相当于一个人的特征，而方法相当于一个人的行为,在资源管理器中添加新类 2、在新建好一个类后在类之前添加一个public 3、类的语法 [访问修饰符] class 类名 { 类的成员;(字段，属性，方法) } 访问修饰符：public 类名：书写规则是要求每个单词的首字母都要大写 4、类的实例化（创建对象）：...
桫哥-GOlang基础-Go语言实战：并发爬虫
06-12
在本课程"桫哥-GOlang基础-Go语言实战：并发爬虫"中，我们将深入学习Go语言（Golang）的基础知识以及如何利用其强大的并发特性来构建高效的网络爬虫。Go语言，由Google开发，因其简洁的语法、内置并发支持和高性能而...
桫哥-GOlang基础-Go语言实战：多人聊天室（上）
06-12
在本课程"桫哥-GOlang基础-Go语言实战：多人聊天室（上）"中，我们将深入学习Go语言的基础语法以及如何运用这些基础知识来构建一个多人聊天室的实战项目。Go语言，又称为Golang，是Google在2009年推出的一种静态类型...
阿罗哈-高朗（Aloha-Golang）：Newhand
02-15
2. **源码文件夹**：可能包含多个Go源代码文件（*.go），这些文件通常按照功能组织，展示了Go语言的基础语法、面向对象编程、并发控制、错误处理等方面的知识。 3. **测试文件**：Go语言鼓励编写测试，你可能会看到...
udemy-go-programming：Todd Mcleod入门基础课程
02-17
Go语言，又称Golang，是Google在2009年推出的开源编程语言，由Robert Griesemer、Rob Pike及Ken Thompson三位大神设计。它旨在提供一种简洁、高效且具有现代特性的编程环境，特别适合构建高并发、分布式系统。在 ...
You-Dont-Know-X：:see-no-evil_monkey:精选的启发性资源列表，显示您对自己以为知道的事情不太了解
02-05
6. **Paradigms（范式）**：面向过程、面向对象、函数式、命令式、反应式、声明式编程等，这些编程范式影响着代码的组织和执行方式。 7. **Datastructures（数据结构）**：这部分与标签中的数据结构相呼应，强调了...
声明Student类
05-08
a) 声明Student类。属性包括学号、姓名、英语成绩、数学成绩、计算机成绩和总成绩。方法包括构造方法、get方法、set方法、toString方法、equals方法、compare方法（比较两个学生的总成绩，结果分大于、小于、等于）、sum方法（计算总成绩）和testScore方法（计算评测成绩，即平均成绩）。
学生信息管理系统， 实现学生信息包括：学号、姓名、性别、年龄、班级等信息
10-06
学生信息管理系统，实现学生信息包括：学号、姓名、性别、年龄、班级等信息。 小学生除了包括学生所有信息外，还包括英语、数学和语文成绩。 中学生除了包括小学生所有信息外，还包括地理、历史成绩、家庭住址等信息。 大学生除了包括学生所有信息外，还包括专业、家庭地址、联系方式等信息。 2、功能要求 （1）添加功能：（2）查询功能：（3）显示功能：（4）编辑功能：（5）删除功能：（6）统计功能：（7）保存功能：（8）读取功能：
Go基础之面向对象（结构体与方法篇）
coding
08-29 1477
go语言的面向对象相对简单，只支持封装，不支持继承和多态，go中用面向接口来做继承和多态的任务 go中没有class ,只有struct struct的创建 type treeNode struct {     value int     left, right *treeNode } struct的声明和初始化 //声明一个结构体类型     var root treeNode   ...
定义一个学生类,有六个属性,一个打招呼的方法，一个计算自己总分数和平均分的方法...
weixin_30402085的博客
04-30 2061
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace test5 7 { 8 class Program 9 { 10 // 定义一个学生...
python定义一个学生类姓名、年龄、性别、成绩、你成绩评价_python练习------类的练习...
weixin_39744554的博客
12-06 7789
类的练习题：1.创建一个名为User 的类，其中包含属性first_name 和last_name ，还有用户简介通常会存储的其他几个属性。在类User 中定义一个名为describe_user() 的方法，它打印用户信息摘要；再定义一个名为greet_user() 的方法，它向用户发出个性化的问候。创建多个表示不同用户的实例，并对每个实例都调用上述两个方法。– pythonclass User:...
4-17 封装一个学生类，有姓名，有年龄，有性别，有英语成绩，数学成绩，语文成绩，封装方法，求总分，平均分，以及打印学生的信息。...
chuanjuhuo9680的博客
04-19 2246
package ZUOYE; /* * 2、封装一个学生类，有姓名，有年龄，有性别，有英语成绩，数学成绩，语文成绩，封装方法， * 求总分，平均分，以及打印学生的信息。 * */ public class zuoye2 { public stati...
1.定义一个学生类(Student)，属性有private的名字(name), public的年龄(age),专业（specialty）和封装name属性的方法：setName(),getName()
热门推荐
liz999111的博客
05-14 2万+
 class student{ private String name; public String specialty; public int age; public student(String name,int age,String specialty) { this.name=name; this.age=age; this.specialty=specialty; } publ...
定义一个学生类，要求有名字，年龄，成绩属性，获取姓名，年龄，成绩，根据以下同学信息测试：xm = Student(‘小明’,20, [69, 88, 100]) 返回结果： 小明 20 100
leeleezi的博客
05-31 5055
定义一个学生类 已知学生类有以下属性: 名字(name) 年龄(age) 成绩(scores)（语文，数学，英语)[每课成绩的类型为整数] 已知学生类有以下方法: 获取学生的姓名：get_name() 返回类型:str 获取学生的年龄：get_age() 返回类型:int 返回3门科目中最高的分数。get_course() 返回类型:int 最终效果: 定义好类以后，可以定义1个同学测试下: xm = Student(‘小明’,20, [69, 88, 100]) 返回结果： 小明 ..
Go语言结构体教程：面向对象编程基础与实例
在Go语言教程中，结构体是核心概念之一，它是在面向对象编程（OOP）中用于封装数据和行为的重要工具。首先，让我们理解对象的基本概念。在编程中，对象是将属性（如车的颜色、名字、长度）和方法（如车的驾驶行为，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

无休止符

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值