七、面向对象

最新推荐文章于 2023-06-25 09:35:46 发布
最新推荐文章于 2023-06-25 09:35:46 发布
阅读量182 收藏
点赞数 1
分类专栏： Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zq9017197/article/details/86531390
版权
  • 严格意义上说，GO语言中没有类(class)的概念,但是我们可以将结构体比作为类，因为在结构体中可以添加属性（成员），方法（函数）。
  • 当然严格意义上，GO语言中是没有继承的，但是我们可以通过”匿名组合”来实现继承的效果。

1.继承

//继承
type Person struct {
	id   int
	name string
	age  int
}

/**
	通过匿名字段实现了继承，将公共的属性封装在Person中，在Student中直接包含Person,那么Student中就有了Person中所有的成员，Person就是匿名字段。
 */
type Student struct {
	Person
	score float32
}

func main() {
	//顺序初始化
	s1 := Student{Person{1, "张三", 28}, 97}
	fmt.Println(s1) //{{1 张三 28} 97}
	
	//s1.Person.name 和 s1.name是一样的效果。如果在Student中也加入了一个成员name,这样与Person中的name重名了。
	//基本的原则：如果能够在自己对象所属的类（结构体）中找到对应的成员，那么直接进行操作，如果找不到就去对应的父类（结构体）中查找。这就是所谓的就近原则。
	fmt.Println(s1.id)  //1
	fmt.Println(s1.name)  //张三
	fmt.Println(s1.age)  //28
	fmt.Println(s1.score) //97	

	//指定初始化成员
	s2 := Student{Person: Person{name: "李四"}, score: 88}
	fmt.Println(s2) //{{0 李四 0} 88}

	//成员操作
	s2.Person.id = 2
	s2.Person.age = 22
	fmt.Println(s2) //{{2 李四 22} 88}
	s2.Person = Person{3, "王五", 26}
	fmt.Println(s2) //{{3 王五 26} 88}
}
1.1 指针类型匿名字段
type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	*Person
	score float32
}

func main() {
	s1 := Student{&Person{1, "张三", 28}, 97}
	fmt.Println(s1)                                                    //{0xc04204a3a0 97}
	fmt.Println(s1.id, s1.name, s1.age, s1.score)                      //1 张三 28 97
	fmt.Println(s1.Person.id, s1.Person.name, s1.Person.age, s1.score) //1 张三 28 97

	var s2 Student
	s2.Person = new(Person)
	s2.id = 2
	s2.name = "李四"
	s2.age = 22
	s2.score = 88
	fmt.Println(s2.id, s2.name, s2.age, s2.score) //2 李四 22 88
}

2.方法

  • 方法，大家可以理解成就是函数，但是在定义使用方面与前面讲解的函数还是有区别的。
  • GO中没有方法重载(所谓重载，指的是方法名称一致，参数类型，个数不一致)。
type Integer int //给int类型指定了一个别名叫Integer,别名可以随便起，只要符合GO语言的命名规则就可以。

//定义了一个方法，方法的定义与函数的区别
func (a Integer) Sum(b Integer) Integer {
	return a + b
}

func main() {
	var num Integer = 2
	result := num.Sum(3)
	fmt.Println(result) //5
}
2.1 给结构体添加方法
  • 接收者为普通变量，非指针，是值传递
  • 接收者为指针变量，引用传递
type Person struct {
	id   int
	name string
}

type Student struct {
	Person
	score float32
}

/*
	如果给结构体(类)加上了方法，那么根据结构体（类）创建完成对象后，是不是就可以通过对象加上“点”，就可以完成方法的调用。
	这与调用类中定义的属性的方式是完全一样的。这样就完成了通过方法与属性来描述一个对象的操作。
*/
func (s Student) ShowInfo() {
	fmt.Println(s.id, s.name, s.score)
}

//要修改其对应的值，将方法的接收者，修改成对应的指针类型。
func (s *Student) ModifyInfo(id int, name string, score float32) {
	s.id = id
	s.name = name
	s.score = score
}

func main() {
	s1 := Student{Person{1, "张三"}, 97}
	s1.ShowInfo() //1 张三 97

	(&s1).ModifyInfo(2, "李四", 88)
	fmt.Println(s1.id, s1.name, s1.score) //2 李四 88
}
2.2 指针变量的方法值
  • 在上面的案例中，我们定义了两个方法，一个是ShowInfo( ), 该方法的接收者为普通方法，一个ModifyInfo( )方法，该方法的接收者为指针变量
  • 通过测试，发现结构体指针变量，可以调用PrintShow( )方法呢？原因是：先将指针s1, 转换成*s1在调用。等价于：(*(&s1)).ShowInfo()
  • 如果是普通的结构体变量也能调用ModifyInfo( )方法。原因是：将普通的结构体类型的变量转换成(&s1)在调用ModifyInfo( )方法。等价于：(&s1).ModifyInfo(1, “zhagnsan”, 99)
  • 这样的好处是非常灵活，创建完对应的对象后，可以随意调用方法，不需要考虑太多指针的问题。
func main() {
	s1 := Student{Person{1, "张三"}, 97}
	s1.ModifyInfo(1, "zhagnsan", 99)
	s1.ShowInfo() //1 zhagnsan 99

	(&s1).ModifyInfo(2, "李四", 88)
	(&s1).ShowInfo() //2 李四 88
}

3.方法继承

type Person struct {
	id   int
	name string
}

func (p *Person) ModifyInfo(id int, name string) {
	p.id = id
	p.name = name
}

type Student struct {
	Person
	score float32
}

func main() {
	s := Student{Person{1, "张三"}, 97}
	s.ModifyInfo(1, "李四")
	fmt.Println(s.id, s.name, s.score)  //1 李四 97
}

4.方法重写

  • GO中没有方法重载(所谓重载，指的是方法名称一致，参数类型，个数不一致)。
type Person struct {
	id   int
	name string
}

func (p *Person) ModifyInfo(id int, name string) {
	p.id = id
	p.name = name
}

type Student struct {
	Person
	score float32
}

func (s *Student) ModifyInfo(id int, name string) {
	s.id = id
	s.name = "学生："+name
}

func main() {
	s := Student{Person{1, "张三"}, 97}
	s.ModifyInfo(1, "李四")
	fmt.Println(s.id, s.name, s.score)  //1 学生：李四 97
}

5.接口

type Humaner interface {
	SayHi()
}

type Student struct {
	id   int
	name string
}

func (s *Student) SayHi() {
	fmt.Println(s.id, s.name)
}

type Teacher struct {
	name string
	sex  string
}

func (t *Teacher) SayHi() {
	fmt.Println(t.name, t.sex)
}

func main() {
	var i Humaner
	s := &Student{1, "张三"}
	t := &Teacher{"张老师", "男"}

	//只要类(结构体)实现对应的接口，那么根据该类创建的对象，可以赋值给对应的接口类型。
	i = s
	i.SayHi() //1 张三
	i = t
	i.SayHi() //张老师 男
}

6.多态

type Humaner interface {
	SayHi()
}

type Student struct {
	id   int
	name string
}

func (s *Student) SayHi() {
	fmt.Println(s.id, s.name)
}

type Teacher struct {
	name string
	sex  string
}

func (t *Teacher) SayHi() {
	fmt.Println(t.name, t.sex)
}

func WhoSayHi(i Humaner) {
	i.SayHi()
}

func main() {
	s := &Student{1, "张三"}
	t := &Teacher{"张老师", "男"}

	WhoSayHi(s) //1 张三
	WhoSayHi(t) //张老师 男
}
6.1多态案例
  • 实现一个计算器功能案例
package main

import "fmt"

//定义操作父类
type Operation struct {
	numA float32
	numB float32
}

//定义接口
type Getresulter interface {
	GetResult() float32 //计算器：方法有返回值
}

//继承：加法
type OperationAdd struct {
	Operation
}

//计算器：加法实现接口
func (a *OperationAdd) GetResult() float32 {
	return a.numA + a.numB
}

//继承：减法
type OperationSub struct {
	Operation
}

//计算器：减法实现接口
func (a *OperationSub) GetResult() float32 {
	return a.numA - a.numB
}

//创建一个工厂类
type OperationFactory struct {
}

//工厂类添加方法
func (f *OperationFactory) CreateOption(option string, numA float32, numB float32) float32 {
	var result float32
	switch option {
	case "+":
		add := &OperationAdd{Operation{numA, numB}}
		result = OperationWho(add)
	case "-":
		sub := &OperationSub{Operation{numA, numB}}
		result = OperationWho(sub)
	}
	return result
}

//多态调用计算器方法
func OperationWho(i Getresulter) float32 {
	return i.GetResult()
}

func main() {
	var opfactory OperationFactory
	add := opfactory.CreateOption("+", 10, 20) //加法
	fmt.Println(add)                           //30

	sub := opfactory.CreateOption("-", 10, 20) //减法
	fmt.Println(sub)                           //-10
}

7.空接口

  • 空接口(interface{})不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值。
  • 当函数可以接受任意的对象实例时，我们会将其声明为interface{}，最典型的例子是标准库fmt中PrintXXX系列的函数，例如：
  • func Printf(fmt string, args …interface{})
  • func Println(args …interface{})
  • 如果自己定义函数，可以如下：
func Test(arg ...interface{}) {

}
  • Test( )函数可以接收任意个数，任意类型的参数。
func main() {
	//空接口万能类型，保存任意类型的值
	var i interface{} = 1
	fmt.Println(i) //1

	i = "abc"
	fmt.Println(i) //abc
}
7.1类型断言
func main() {
	arrs := make([]interface{}, 3)
	arrs[0] = 123
	arrs[1] = 3.14
	arrs[2] = "hello"

	for _, v := range arrs {
		//对数据v进行类型断言
		if data, ok := v.(int); ok {
			fmt.Println(data)
		} else if data, ok := v.(float64); ok {
			fmt.Println(data)
		} else if data, ok := v.(string); ok {
			fmt.Println(data)
		}
	}
}
事后诸葛亮
关注
专栏目录
实验七 Python面向对象程序设计
Junds0的博客
11-10 1805
任务描述本关任务：编写一个Stack类，并解决进制计算问题。相关知识为了完成本关任务，你需要掌握：1、类的定义，2、实例变量的定义，3、实例方法的定义，4、私有访问控制类的定义Python中定义类的语法格式如下：class 类名：[类变量][definit[def 函数名(self,…)]实例变量的定义Python中，实例变量的定义如下：self.变量名只要以self定义的变量都是实例变量，该变量可以定义在任何实例方法内。
Java 面向对象（七）
亮点菌
08-07 427
学习内容： 1. 掌握对象多态性的作用。2 .了解instanceof关键字。3. 掌握常见的设计模式。
面向对象七大基本原则
qq_35386002的博客
04-04 2887
一，单一职责原则（类） 单一职责原则的英文名称是Single Responsibility Principle，简称SRP。它的定义是：就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。 二，开闭原则（类、模块、函数等） 开闭原则的英文全称是Open Close Principle，简称OCP，它是Java世界里最基础的设计原则，它指导我们...
python面向对象程序设计实验_实验七 面向对象程序设计
weixin_39715290的博客
11-29 3405
实验七 面向对象程序设计一、实验目的与要求1、了解面向对象编程思想，掌握类和对象的定义和使用。2、熟悉self的使用技巧，掌握构造方法的使用。3、了解如何使用封装保护属性，掌握单继承和多继承的使用。4、掌握类属性和实例属性的使用，熟悉类方法和静态方法的使用技巧。二、实验原理在程序中使用对象来映射现实中的事物，使用对象间的关系来描述事物之间的联系，这种思想就是面向对象。面向对象编程有两个非常重要的概...
面向对象七大原则
just_learing的博客
04-25 5068
面向对象七大原则
【软件基础】面向对象分析与设计思想总结
最新发布
JosieBook
06-25 3787
面向对象的本质：通过对象之间的协作完成功能。面向对象的特点：采用封装、继承、多态和抽象等设计方法。面向过程和面向对象开发中，在分析问题面向过程：拿到问题分析问题如何解决的步骤；面向对象：拿到问题分析问题中有哪些类，类的属性与方法，类与类之间的关系。面向对象遵循：合适的方法应该出现在合适的类中。
C语言面向对象
weixin_43155199的博客
04-08 4378
创作人QQ：851301776，邮箱：lfr890207@163.com， 欢迎大家一起技术交流，本博客主要是自己学习的心得体会,只为每天进步一点点！ 个人座右铭： 1.没有横空出世，只要厚积一定发。 2.你可以学历不高，你可以不上学，但你不能不学习 一、核心点 做C语言和C++的都知道，C语言面向过程，C++面向对象。所以C语言要实现面向对象，核心组成是： （1）属性：单个物体的基本特性 （2）方法：单个物体操作类的 举例...
面向对象之七大原则
qq_41331645的博客
07-18 3924
单一职责，里氏替换，迪米特法则，依赖倒转，接口隔离，合成/聚合原则，开放-封闭 。 1.   开闭原则(Open-Closed Principle, OCP) 定义：软件实体应当对扩展开放，对修改关闭。这句话说得有点专业，更通俗一点讲，也就是：软件系统中包含的各种组件，例如模块（Modules）、类（Classes）以及功能（Functions）等等，应该在不修改现有代码的基础上，去扩展新功能...
面向对象的几个概念
Le vent se lève, il faut tenter de vivre
05-25 1187
一、抽象(abstract) 抽象是通过特定的实例抽取共同特征以后形成概念的过程。它强调主要特征，忽略次要特征。一个对象是现实世界中一个实体的抽象，一个类是一组对象的抽象，抽象是一种单一化的描述，它强调给出与应用相关的特性，抛弃不相关的特性。 二、封装(encapsulation) 封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的...
python面向对象
weixin_44992737的博客
05-25 1万+
python类详解，python类与对象
2023年实验七面向对象的程序设计.doc
11-13
面向对象的程序设计是软件开发中的一个重要概念，它基于对象模型，强调数据和操作数据的函数的封装。在这个实验中，我们将深入理解面向对象的基本概念，并通过Visual FoxPro 6.0来实践。 1. **面向对象的核心概念**...
2023年实验七面向对象的程序设计资料.doc
11-13
面向对象的程序设计是一种编程范式，它基于“对象”的概念，其中对象是数据和操作这些数据的方法的封装体。本实验旨在让学生深入理解和掌握面向对象编程的核心概念和技术，特别是针对Visual FoxPro 6.0这个环境。 ...
2023年实验七面向对象的程序设计新版.doc
11-17
面向对象的程序设计是软件开发中的核心概念，它基于实体的抽象，通过对象来表示现实世界中的事物。在2023年的实验七中，我们将深入理解和应用这一编程范式，主要涵盖以下几个方面： 1. **对象、属性、方法和事件的...
实验七面向对象1.doc
09-28
在这些实验代码中，我们可以看到几个关键的面向对象编程概念的运用，主要包括类的定义、成员函数的声明与实现、构造函数、对象的创建与销毁以及数据成员的访问控制。接下来我们将详细探讨这些知识点。 1. 类的定义...
十九、Beego框架快速入门
热门推荐
事后诸葛亮的程序人生（微信：zq9017197）
03-06 7万+
Beego框架快速入门 1.框架了解 go语言的web框架：beego,gin,echo等等，那为什么我们选择beego呢？ 第一，beego是中国人开发的，开发文档比较详细，beego官网网址: https://beego.me/ 。 第二，现在公司里面用beego的也比较多，比如今日头条，百度云盘，腾讯，阿里等。 2.环境搭建 这里默认大家已经搭建好了go语言的开发环境。 需要安装Bee...
十八、C与GO混合编程
事后诸葛亮的程序人生（微信：zq9017197）
02-20 1356
作为一门直接传承于C的语言，Go当然应该将与C语言的交互作为首要任务之一。Go确实也提供了这一功能，称为Cgo。 由于cgo需要gcc支持，所以需要配置gcc环境，如果是linux下一般可以跳过该步骤，win下则需要自己安装了，这里我们使用MinGW 由于我是64位，这里下载64位的POSIX版本。具体的安装过程就不费话了，直接解压即可。安装完成后需要配置环境变量${home}/bin http...
二十、BoltDB k-v存储
事后诸葛亮的程序人生（微信：zq9017197）
04-12 534
Bolt 是一个纯粹的 Go key/value数据库。 该项目的目标是为不需要完整数据库服务器（如Postgres或MySQL）的项目提供一个简单，快速和可靠的数据库。 如果您需要高随机写入吞吐量（> 10,000 w / sec）或者您需要使用旋转磁盘，则 LevelDB可能是一个不错的选择。 如果你的应用程序是重读的，或者做了很多范围扫描，Bolt 可能是一个不错的选择。 Bolt ...
九、文本文件处理
事后诸葛亮的程序人生（微信：zq9017197）
01-18 356
1.创建文件 GO语言中提供了一个Create( )函数专门创建文件. 该函数在创建文件时，首先会判断要创建的文件是否存在，如果不存在，则创建，如果存在，会先将文件中已有的数据清空。 同时，当文件创建成功后，该文件会默认的打开，所以不用在执行打开操作，可以直接向该文件中写入数据。 package main import ( "os" "fmt" ) func CreateFile(pa...
八、异常处理
事后诸葛亮的程序人生（微信：zq9017197）
01-17 335
1.error接口 package main import ( "fmt" "errors" ) func Test(a int, b int) (result int, err error) { err = nil if b == 0 { err = errors.New("除数不能为0") //当然fmt包中也封装了一个专门输出错误信息的方法，如下所示： //err =...
C++面向对象编程详解
面向对象编程（OOP）起源于二十世纪七十年代，是从结构化编程中发展而来的，目的是使程序设计更加符合人类的思维习惯，提高程序的稳定性和可维护性。 在C++中，面向对象主要包括以下几个关键概念： 1. **对象**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值