golang学习六:面向对象:继承,对象方法,接口

最新推荐文章于 2022-08-15 12:35:27 发布
最新推荐文章于 2022-08-15 12:35:27 发布
阅读量544 收藏 3
点赞数
分类专栏： Golang学习 文章标签： golang 类 interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35709559/article/details/108654072
版权

文章目录

一、概述:

1. 什么是面向对象:

  • 属性就是特征;
  • 方法就是行为;

2. Go语言中的面向对象:

严格意义上讲, Go语言中没有类(class)的概念, 但是可以将结构体比作类, 因为在结构体中可以添加属性(成员)和方法(函数);

  • 继承: 通过匿名字段实现;
  • 多态: 通过接口实现;
  • 封装: 通过方法实现;

3. 继承:

3.1 匿名字段:

// 父类
type Persion struct {
	id   int
	name string
	age  int
}

// 子类
type Student struct {
	Persion // 继承属性	结构体嵌套

	score int // 添加专属属性
}

func main() {
	// 顺序初始化
	var s1 Student = Student{Persion{101, "小明", 18}, 98}
	fmt.Println(s1) // {{101 小明 18} 98}

	// 自动推导类型
	s2 := Student{Persion{102, "张三", 19}, 90}
	fmt.Println(s2) // {{102 张三 19} 90}

	// 指定初始化: 没有初始化的部分使用默认值
	s3 := Student{score: 100}
	fmt.Println(s3) // {{0  0} 100}

}

3.2 成员操作:


func main() {
	var s1 Student = Student{Persion{101, "小明", 18}, 98}
	// 成员操作 .
	s1.score = 89
	fmt.Println(s1) // {{101 小明 18} 89}

	s1.Persion.id = 110
	fmt.Println(s1) //	{{110 小明 18} 89}

	// 因为父类被继承, 所以不需要.父类
	s1.age = 22

	s1.Persion = Persion{100, "李四", 20}
	fmt.Println(s1)	// {{100 李四 20} 89}
}

3.3 匿名字段同名成员:

子类与父类结构体有相同的成员名时, 默认赋值给子类, 采用就近原则

type Stu struct {
	Persion
	name  string
	score int
}

func main() {
	var s3 Stu
	s3.name = "王五"
	fmt.Println(s3) // {{0  0} 王五 0}

	s3.Persion.name = "wangwu"
	fmt.Println(s3)	// {{0 wangwu 0} 王五 0}
}

3.4 指针类型的匿名字段:

// 指针类型的匿名字段
// 子类
type Student3 struct {
	*Persion
	score int
}

func main() {
	var s Student3
	s.score = 90
	fmt.Println(s) // {<nil> 90}

	// s.id = 100	// err: 内存地址指向为空
	s.Persion = new(Persion)
	s.name = "赵六"
	s.id = 103
	fmt.Println(s)                     // {0xc00000c060 90}
	fmt.Println(s.id, s.name, s.score) // 103 赵六 90

	(*s.Persion).name = "周杰伦"
	fmt.Println(s.id, s.name, s.score) // 103 周杰伦 90

	s.Persion = &Persion{105, "林俊杰", 35}
	fmt.Println(s.id, s.name, s.score)	// 105 林俊杰 90
}

3.5 多重继承:

type Father struct {
	name string
	age  int
	sex  string
}

type Monther struct {
	id   int
	addr string
}

type Son struct {
	Father
	Monther
	score int
}

func main() {
	var son Son

	son.id = 200
	son.addr = "北京"
	son.name = "张三"
	son.age = 18
	son.sex = "男"
	son.score = 100

	fmt.Println(son) // {{张三 18 男} {200 北京} 100}

	// 自动推导
	s1 := Son{Father{"李四", 20, "女"}, Monther{201, "上海"}, 90} // {{李四 20 女} {201 上海} 90}
	fmt.Println(s1)

}

type Humen struct {
	id   int
	name string
}

type Persion struct {
	Humen
	age int
	sex string
}

type Student struct {
	Persion
	score int
}

func main() {
	// 初始化
	var stu Student
	stu.name = "张三"
	stu.age = 20
	stu.score = 94
	fmt.Println(stu) // {{{0 张三} 20 } 94}

	// 自动推导
	stu1 := Student{Persion{Humen{100, "李四"}, 30, "男"}, 98}
	fmt.Println(stu1) // {{{100 李四} 30 男} 98}

}

4. 对象方法:

4.1 创建对象方法和使用:

语法:

// 定义方法
func (对象名 类型)方法名(参数列表) {
	方法体
}

type Cat struct {
	name string
	age  int
}

// 定义方法需要绑定对象
func (c Cat) show() {
	fmt.Println(c.name + "喵喵叫...")
}

type Dog struct {
	name string
	age  int
}

func (d Dog) show() {
	fmt.Println("汪汪叫...")
}

func main() {
	var c Cat
	c.name = "气气"
	c.age = 2
	// 调用对象方法
	c.show() // 气气喵喵叫...

}

4.2 方法的内存模型:

type Student struct {
	id    int
	name  string
	age   int
	score int
}

func (s Student) Display() {
	s.name = "张三"
	fmt.Println(s) // {101 张三 30 -5}
}

// 对象不同, 方法名相同, 不会冲突
// 在方法调用中, 方法接收者是指针类型
// 指针类型、普通类型 表示的是相同对象的类型
func (s *Student) change(age int) {
	s.age = age
}

func main() {
	stu := Student{101, "亚索", 30, -5}
	stu.Display()
	fmt.Println(stu) // {101 亚索 30 -5}
	stu.change(18)
	fmt.Println(stu) // {101 亚索 18 -5}
}

4.3 方法继承:

type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	Person
	class int // 班级
}

func (p *Person) PrintInfo() {
	fmt.Printf("编号: %d\n", p.id)
	fmt.Printf("姓名: %s\n", p.name)
	fmt.Printf("年龄: %d\n", p.age)
}

func main() {
	p := Person{110, "张三", 18}
	p.PrintInfo()
	// 编号: 110
	// 姓名: 张三
	// 年龄: 18

	s := Student{Person{111, "李四", 20}, 2}
	// 子类可以继承父类的属性和方法
	s.PrintInfo()
	// 编号: 111
	// 姓名: 李四
	// 年龄: 20
}

4.4 方法重写:

方法重写之后使用的是子类的方法

4.5 方法值和方法表达式:

  • 方法表达式需要显示传参;

5. 接口:

5.1 接口的定义和使用:

package main

import "fmt"

// 定义接口: 一般以er结尾, 根据接口实现功能
type Humaner interface {
	// 方法:仅仅是方法的声明
	sayhi()
}

type Student struct {
	name  string
	age   int
	score int
}

func (s *Student) sayhi() {
	fmt.Printf("我是%s, 今年%d岁, 我的成绩是%d分\n", s.name, s.age, s.score)
}

type Teacher struct {
	name    string
	age     int
	subject string
}

func (t *Teacher) sayhi() {
	fmt.Printf("我是%s, 今年%d岁, 我教的科目是%s\n", t.name, t.age, t.subject)
}

func main() {
	// 定义一个接口变量
	// 接口是一种数据类型, 可以接受满足对象的信息
	// 接口是虚的, 方法是实的
	// 接口定义规则, 方法实现规则
	// 接口中定义的规则, 对象中必须有实现
	var h Humaner

	// 创建对象
	stu := Student{"小明", 18, 98}
	// stu.sayhi() // 我是小明, 今年18岁, 我的成绩是98分

	// 将对象信息赋值给接口类型变量
	h = &stu
	h.sayhi() // 我是小明, 今年18岁, 我的成绩是98分

	tea := Teacher{"老王", 30, "物理"}
	// tea.sayhi() // 我是老王, 今年30岁, 我教的科目是物理

	h = &tea
	h.sayhi()
}

5.2 多态的实现:

package main

import "fmt"

type Humaner interface {
	sayhi()
}

type Student struct {
	name  string
	age   int
	score int
}

func (s *Student) sayhi() {
	fmt.Printf("我是%s, 今年%d岁, 我的成绩是%d分\n", s.name, s.age, s.score)
}

type Teacher struct {
	name    string
	age     int
	subject string
}

func (t *Teacher) sayhi() {
	fmt.Printf("我是%s, 今年%d岁, 我教的科目是%s\n", t.name, t.age, t.subject)
}

// 多态的实现
// 将接口作为函数参数, 实现多态
func sayhello(h Humaner) {
	h.sayhi()
}

func main() {
	stu := Student{"小明", 18, 98}

	// 调用多态
	sayhello(&stu) // 我是小明, 今年18岁, 我的成绩是98分

	tea := Teacher{"老王", 30, "物理"}
	// 调用多态
	sayhello(&tea) // 我是老王, 今年30岁, 我教的科目是物理

}

5.3 接口继承与转换:

package main

import "fmt"

type Humaner interface {
	sayhi()
}

type Personer interface { // 超集
	Humaner // 匿名字段
	sing(string)
}

type Student struct {
	name  string
	age   int
	score int
}

func (s *Student) sayhi() {
	fmt.Printf("我是%s, 今年%d岁, 我的成绩是%d分\n", s.name, s.age, s.score)
}
func (s *Student) sing(n string) {
	fmt.Printf("我是%s, 我为大家唱首歌: %s\n", s.name, n)
}

type Teacher struct {
	name    string
	age     int
	subject string
}

func (t *Teacher) sayhi() {
	fmt.Printf("我是%s, 今年%d岁, 我教的科目是%s\n", t.name, t.age, t.subject)
}
func (t *Teacher) sing(n string) {
	fmt.Printf("我是%s, 我为大家唱首歌: %s\n", t.name, n)
}

func main0901() {
	// 定义接口
	var h Humaner

	stu := Student{"小明", 18, 98}
	h = &stu
	h.sayhi() // 我是小明, 今年18岁, 我的成绩是98分

	// 定义接口变量
	var p Personer
	p = &stu
	p.sing("小星星") // 我是小明, 我为大家唱首歌: 小星星

	// tea := Teacher{"老王", 30, "物理"}
}

func main() {
	// 接口的转换
	// 接口类型变量定义
	var h Humaner  // 子集
	var p Personer // 超集

	var stu Student = Student{"小吴", 18, 59}

	p = &stu
	// 将一个接口赋值给另一个接口
	// 超集中包含所有子集的方法
	h = p     // ok
	h.sayhi() // 我是小吴, 今年18岁, 我的成绩是59分

}

5.4 空接口:

  • 接口类型可以接收任何类型的数据;
func main() {
	var i interface{}
	// 接口类型
	fmt.Println(i)        // <nil>
	fmt.Printf("%T\n", i) // <nil>

	i = 10
	fmt.Println(i)        // 10
	fmt.Printf("%T\n", i) // int

	i = 3.14
	fmt.Println(i)        // 3.14
	fmt.Printf("%T\n", i) // float64
}

接收任意类型的数据

func test() {
	fmt.Println("test...")
}
func main() {
	// 定义空接口类型的切片
	var i []interface{}
	fmt.Printf("%T\n", i)
	i = append(i, 10, 3.14, "aaa", test)
	fmt.Println(i) // [10 3.14 aaa 0x109eb30]

	for idx := 0; idx < len(i); idx++ {
		fmt.Println(i[idx])
		// 10
		// 3.14
		// aaa
		// 0x109eb30
	}
}

5.5 类型断言:

interface的变量里面可以存储任意类型的数值. 那么如何反向知道这个变量里面实际保存了哪个类型的对象呢:

  • comma-ok断言;
  • switch测试;

Go语言里面有一个语法, 可以直接判断是否是该类型的变量: value, ok = element.(T), 这里value就是变量的值, ok是一个bool类型, element是interface变量, T是断言的类型;
如果element里面确实是存储了T类型的数值, 那么OK返回true, 否则返回false;

  • comma-ok断言:
func demo() {
	fmt.Println("hello...")
}
func main() {
	// 类型断言
	var i []interface{}
	i = append(i, 10, 3.14, "aaa", demo)
	fmt.Println(i) // // [10 3.14 aaa 0x109cfb0]

	for _, v := range i {
		fmt.Println(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)
		} else if data, ok := v.(func()); ok {
			// 函数调用
			data()
		}
		// 10
		// 整型数据 10
		// 3.14
		// 浮点数据 3.14
		// aaa
		// 字符串数据 aaa
		// 0x109cfb0
		// hello...
	}
}
  • switch测试:
func main() {
	var i []interface{}
	i = append(i, 10, 3.14, "aaa", demo)

	for _, data := range i {
		switch value := data.(type) {
		case int:
			fmt.Println("整型数据", value)
		case float64:
			fmt.Println("浮点型数据", value)
		case string:
			fmt.Println("字符串数据", value)
		case func():
			value()
		default:
			fmt.Println("类型未知...", value)
		}
	}
	// 整型数据 10
	// 浮点型数据 3.14
	// 字符串数据 aaa
	// hello...
}
浅弋、璃鱼
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
golang_learn:golang 学习笔记
04-19
golang:books:: 《Go语言编程入门与实战技巧》-黄靖钧 《Go语言核心编程》-李文塔 《Go编发编程实战》-郝林 《Go语言编程》-许式伟 《Go程序设计语言》-译本 Go语言圣经 《Go语言学习笔记》-雨痕 - 柴树杉，曹春晖 ...
表达式类型的实现_学习Lambda表达式看这篇就够了，不会让你失望的哦（续篇）...
weixin_39827625的博客
11-28 135
欢迎关注头条号：老顾聊技术精品原创技术分享，知识的组装工目录前言Lambda类型Lambda的域以及访问限制内置函数接口方法引用静态方法引用实例方法引用对象方法引用构造方法引用总结前言上一篇介绍了lambda表达式的语法和使用场景Lambda用在哪里？几种场景？ 和 为什么会出现Lambda表达式，你知道吗？，今天老顾继续介绍Lambda类型Lambda表达式可以被当做是一个Object。Lamb...
lambda表达式可以用来声明_Lambda表达式详解
weixin_42399813的博客
01-10 351
Lambda简介Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。对接口的要求#虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambd...
2020年11月28日天梯赛GPLT总决赛（全部题目 + 189分代码答案）
此地无银三百两
11-29 1万+
written by: 东篱下の悠然 L1-1 嫑废话上代码 (5分) Linux 之父 Linus Torvalds 的名言是：“Talk is cheap. Show me the code.”（嫑废话，上代码）。本题就请你直接在屏幕上输出这句话。 输入格式： 本题没有输入。 输出格式： 在一行中输出 Talk is cheap. Show me the code.。 输入样例： 无 输出样例： Talk is cheap. Show me the code. ans: #include <b
基于Html+Css+javascript的动漫网站
热门推荐
weixin_46820017的博客
01-17 1万+
1.前端三门技术 学习Web前端技术需要掌握三门基本技术：HTML，CSS，JavaScript： HTML：HTML是网页内容的载体。内容就是网页制作者放在页面上想要用户浏览的信息，可以包含文件、图片、视频等 CSS：CSS样式是表现，就像网页的外衣比字体、颜色变化等 JavaScript：JavaScript用来实现网页上的特效效果。比如鼠标滑过弹出下拉菜单、鼠标滑过北京颜色改变等 本次项目主要是介绍海贼王主题的简介，使用html+css+javascript来制作网站，实现项目的效果； index.h
lambda表达式可以用来声明_认识java 表达式
weixin_28769141的博客
12-20 130
团团圆圆吃汤圆Lambda 表达式是推动 Java 8 发布的最重要新特性，Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。使用 Lambda 表达式可以使代码变的更加简洁紧凑，比如下面的方法：String showName(String sth){ return "姓名为"+sth;}改写成Lambda：(sth)=>"姓名为"+sth;因此lambda表...
Golang 学习路线 – Part 27:Go 中的继承
01-08
这里是 Golang 教程系列的第二十七部分。 Go 语言不支持继承，但支持组合。组合的一般定义是 放在一起。举个例子比如：汽车。汽车是由轮子、发动机和其他各种零件组成的。 通过嵌入到结构体进行组合 组合可以通过在...
golang-note:Golang学习笔记
04-05
Golang学习笔记 Golang的电子笔记，方便以后查阅，建立知识体系查漏补缺 Golang学习中遇到比较好的网站汇总：煎鱼的博客： ://eddycjy.com/ 《 Go语言标准库》（查阅非常方便）： : Golang入门教程： : Golang...
桫哥-GOlang-05面向对象
06-12
基础部分带你从零到一，打牢语法基础； 进阶部分包含大量实战案例和框架封装； ?绝不浅尝辄止！ 风格依旧水煮，依旧不拘一格脑洞大开；
Golang极简入门教程（二）：方法和接口
01-20
在 Golang 中没有类，不过我们可以为结构体定义方法。我们看一个例子： 代码如下: package main import ( “fmt” “math” ) type Vertex struct { X, Y float64 } // 结构体 Vertex 的方法 // 这里的方法接收者...
C++的匿名函数（lambda表达式）
良知犹存的博客
09-23 8467
总述 C++11提供了对匿名函数的支持,称为Lambda函数(也叫Lambda表达式). 它是定义和使用匿名函数对象的一种简便的方式。匿名函数是我们需要用到的一个函数，但是又不想去费力命名一个函数的场景。我们无需为每个值或者每种类型)单独编写函数，更不必把值保存在让人厌倦的全局变量中 。利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读。 工作的时候这个是比较常用的，通过匿名函数进行函数内部变量的捕获，继而进行操作变量等。那么现在就由我来给大家分享...
java8 lambda python_Java 8 Lambda 表达式详解
weixin_39804631的博客
12-02 99
1. 引言在 Java 8 以前，若我们想要把某些功能传递给某些方法，总要去写匿名类。以前注册事件监听器的写法与下面的示例代码就很像：manager.addScheduleListener(new ScheduleListener() {@Overridepublic void onSchedule(ScheduleEvent e) {// Event listener implementatio...
GoLang接口---中
m0_53157173的博客
08-15 989
在类型转换时，*TestStruct 类型会转换成 interface{} 类型，转换后的变量不仅包含转换前的变量，还包含变量的类型信息 TestStruct，所以转换后的变量与 nil 不相等。变量 t 得到了 areaIntf 的值和类型， 所有 case 语句中列举的类型（nil 除外）都必须实现对应的接口（在上例中即 Shaper），如果被检测类型没有在 case 语句列举的类型中，就会执行 default 语句。一个接口的值可以赋值给另一个接口变量，只要底层类型实现了必要的方法。...
Golang 之 面向对象继承（四）
JaysenLeo
08-01 564
并没有为PhonePlus 实现接口，仅仅为Phone实现了接口，不过PhonePlus里面嵌入了Phone的一个内部类型，也是可以通过接口调用函数Call来调用到Communicate method。 在main函数，发现PhonePlus的methods set 里面包含了Communicate() package main import &quot;fmt&quot; type Phone st...
python单词的含义-python
q6q6q的专栏
10-28 1092
【单选题】计算机网络是地理上分散的多台( )遵循约定的通信协议,通过软硬件互联的系统。 (6.0分)【单选题】for i in range(int(n)) 语句中,i的取值范围为() (8.0分)【简答题】分析下面代码的输出结果 def fib(n): a,b=1,1 for i in range(n-1): a,b=b,a+b return a print(fib(7)) (15.0分)【单选题...
接口抽象类区别
lesley9697的博客
09-14 84
转载：https://blog.csdn.net/fenglibing/article/details/2745123 接口和抽象类有什么区别 你选择使用接口和抽象类的依据是什么？ 接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。 抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。 人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它. 所以，在高级语言上，一
详讲Java中的Lambda表达式
Top_L398的博客
09-30 474
Lambda表达式 也称闭包，是 JDK8 的一个新特性； 优点： 允许把函数作为一个方法的参数传递进方法中； 可取代大部分的匿名内部类，简化了 Java 代码； 在集合的遍历和其他操作中，可极大地优化代码结构； 1.语法 1.1.语法格式 语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。 (parameters) -> expression 或 (parameters) ->{ s
javascript入门之条件表达式，循环
smilecb的博客
10-14 873
if表达式 语法：     if(条件)          表达式 如果条件成立， 则执行表达式，否则不执行 if else表达式     if(条件)         表达式1      else  &nbs
Lambda 表达式有何用处？
勇往直前的专栏
04-25 1202
来源：zhihu.com/question/20125256/answer/324121308 什么是Lambda？ 我们知道，对于一个Java变量，我们可以赋给其一个“值”。 如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？ 比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量： 在Java 8之前，这个是做不到的。但是Java 8问世...
golang ReadAt:EOF
最新发布
06-09
在 Golang 中，ReadAt() 函数返回的第二个参数是一个 error 类型，如果读取到文件结尾，就会返回一个 EOF 错误。你可以在读取之前检查文件是否已经到达结尾，或者使用 io.ReadFull() 函数来确保读取到指定数量的字节...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浅弋、璃鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值