golang:面向对象总结
所谓的面向对象其实就是找一个专门做这个事的人来做,不用关心具体怎么实现的。所以说,面向过程强调的是过程,步骤。而面向对象强调的是对象,也就是干事的人。
Go语言:面向对象语言特性
方法
嵌入
接口
没有类
支持类型。 特别是, 它支持structs。 Structs是用户定义的类型。 Struct类型(含方法)提供类似于其它语言中类的服务。
Structs
一个struct定义一个状态。 这里有一个strudent struct。 它有一个Name属性和一个布尔类型的标志Real,告诉我们它是一个真实的strudent还是一个虚构的strudent。 Structs只保存状态,不保存行为。
type Creature struct {
Name string
Real bool
}
为结构体添加方法
方法是对特定类型进行操作的函数。 它们有一个接收器条款,命令它们对什么样的类型可进行操作。 这里是一个Hello()方法,它可对student结构进行操作,并打印出它们的状态:
func (s Student) Hello() {
fmt.Printf("Name: '%s', Real: %t\n", s.Name, s.Real)
}
func (s Student) func_name(){}
这是一个不太常见的语法,但是它非常的具体和清晰,不像this的隐喻性。
一般在定义方法时,需要定义为结构体的指针,值类型的在修改结构体属性时,无法修改其内容
package main
import "fmt"
type human struct {
Name string
Real bool
}
type Student struct {
human
Id int
}
func (h human) Hello() {
fmt.Printf("姓名:%s\n", h.Name)
}
func (s Student) PrintId() {
fmt.Printf("学号:%d\n", s.Id)
}
func (s Student) EditId(id int) {
s.Id = id
}
func main() {
zhangsan := Student{
human: human{"zhangsan", true},
Id: 10,
}
zhangsan.Hello()
zhangsan.EditId(101)
zhangsan.PrintId()
}
嵌入(继承)
可以将匿名的类型嵌入进struct。 如果你嵌入一个匿名的struct那么被嵌入的struct对接受嵌入的struct直接提供它自己的状态(和方法)。 比如,strudent
有一个匿名子的被嵌入的 human
struct,这意味着一个 student
就是一个 hunman
。
package main
import "fmt"
type human struct {
Name string
Real bool
}
type Student struct {
human
Id int
}
func (h *human) Hello() {
fmt.Printf("姓名:%s", h.Name)
}
func main() {
zhangsan := &Student{
human: human{"zhangsan", true},
Id: 10,
}
zhangsan.Hello()
}
重写
就是子类(结构体)中的方法,将父类中的相同名称的方法的功能重新给改写了
注意:在调用时,默认调用的是子类中的方法
方法值和表达式值
方法表达式,即方法对象赋值给变量,方法表达式有两种使用方式:
- 隐式调用:方法值,调用函数时,无需再传递接收者,隐藏了接收者
- 显式调用:方法表达式,显示的把接收者*Student传递过去
实例:
package main
import "fmt"
type human struct {
Name string
Real bool
}
type Student struct {
human
Id int
}
func (h *human) Hello() {
fmt.Printf("姓名:%s\n", h.Name)
}
func (s Student) PrintId() {
fmt.Printf("学号:%d\n", s.Id)
}
func (s Student) EditId(id int) {
s.Id = id
}
func main() {
zhangsan := Student{
human: human{"zhangsan", true},
Id: 10,
}
// 常规调用
zhangsan.Hello()
// 方法值 无需传递接收者
hello := zhangsan.Hello
hello()
// 方法表达式,调用函数式,传递接收者
hello1 := (*Student).Hello // 括号是因为 . 的优先级要高于取指符,需要做特殊处理
hello1(&zhangsan)
}
Go语言:面向对象的设计
接口
接口是Go语言对面向对象支持的标志。 接口是声明方法集的类型。 实现所有接口方法的对象自动地实现接口。 它没有继承或子类或 implements
关键字。
接口的定义
type 接口名字 interface {
方法声明
}
接口的继承
package main
import "fmt"
type Fooer interface {
Foo1()
}
type Fooerson interface {
Fooer
Foo2()
}
type Foo struct {
}
type Fooson struct {
}
func (f Fooson) Foo1() {
fmt.Println("Foo1() here")
}
func (f Fooson) Foo2() {
fmt.Println("Foo2() here")
}
func (f Foo) Foo1() {
fmt.Println("Foo1() here")
}
func main() {
var fooerson Fooson
var fooson Fooerson
fooson = &fooerson
fooson.Foo1()
fooson.Foo2()
var foo Fooer
foo = fooson
fooson = foo // 这样是不允许的,fooson为Fooerson接口的实现,而foo是一个Fooer接口类型的变量,可以子转换为父不能反之
foo.Foo1()
}
空接口
空接口(interface{})不包含任何的方法,正因为如此,所有的类型都实现了空接口,因此空接口可以存储任意类型的数值
package main
import "fmt"
func main() {
var arr []interface{}
arr = append(arr, 1, "zhangsan", 3.3)
fmt.Println(arr)
}
类型断言
通过类型断言,可以判断空接口中存储的数据类型。
语法:value, ok := m.(T)
m:表空接口类型变量
T:是断言的类型
value: 变量m中的值。
ok: 布尔类型变量,如果断言成功为true,否则为false
func main() {
var a interface{}
a = 10
ok, value := a.(int)
fmt.Println(ok, value)
ok1, value1 := a.(string)
fmt.Println(ok1, value1)
}
封装
Go语言在包的级别进行封装。 以小写字母开头的名称只在该程序包中可见。 可以隐藏私有包中的任何内容,只暴露特定的类型,接口和工厂函数。
例如,在这里要隐藏上面的Foo类型,只暴露接口,你可以将其重命名为小写的foo,并提供一个NewFoo()函数,返回公共Fooer接口:
type foo struct {
}
func (f foo) Foo1() {
fmt.Println("Foo1() here")
}
func (f foo) Foo2() {
fmt.Println("Foo2() here")
}
func (f foo) Foo3() {
fmt.Println("Foo3() here")
}
func NewFoo() Fooer {
return &Foo{}
}
在另一个包的代码可以使用NewFoo()
并访问由内部foo类型实现的Footer接口:
f := NewFoo()
f.Foo1()
f.Foo2()
f.Foo3()
继承
Go语言没有任何类型层次结构。 它允许你通过组合来共享实现的细节。 但Go语言,允许嵌入匿名组合。
通过嵌入一个匿名类型的组合等同于实现继承,这是它所有意图和目的。 一个嵌入的struct与基类一样脆弱。 你还可以嵌入一个接口, 如果嵌入类型没有实现所有接口方法,它甚至可能导致产生在编译时未被发现的运行错误。
这里SuperFoo嵌入Fooer接口,但是SuperFoo没有实现Foo的方法。 Go编译器会愉快地让你创建一个新的SuperFood并调用Fooer的方法,但很显然这在运行时会失败。 这会编译:
package main
import "fmt"
type Fooer interface {
Foo1()
Foo2()
Foo3()
}
type Foo struct {
}
func (f Foo) Foo1() {
fmt.Println("Foo1() here")
}
func (f Foo) Foo2() {
fmt.Println("Foo2() here")
}
func (f Foo) Foo3() {
fmt.Println("Foo3() here")
}
type SuperFooer struct {
Fooer
}
func main() {
s := SuperFooer{}
s.Foo3()
}
多态
多态性是面向对象编程的本质:只要对象坚持实现同样的接口,Go语言就能处理不同类型的那些对象。 Go接口以非常直接和直观的方式提供这种能力。
Golang当中的接口解决了这个问题,只要接口中定义的方法能对应的上,那么就可以认为这个类实现了这个接口。同一个接口,使用不同的实例而执行不同操作
package main
import (
"fmt"
)
type animal interface {
Say()
}
type human struct {
}
type cat struct {
}
func (h human) Say() {
fmt.Println("人类")
}
func (c cat) Say() {
fmt.Println("猫")
}
func main() {
var a animal
a = cat{}
a.Say()
a = human{}
a.Say()
}
golang:面向对象总结的更多相关文章
- golang面向对象和interface接口
一. golang面向对象介绍 1.golang也支持面向对象编程,但是和传统的面向对象编程有区别,并不是纯粹的面向对象语言.2.golang没有类(class),golang语言的结合体(struc ...
- Golang面向对象编程-struct(结构体)
Golang面向对象编程-struct(结构体) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.什么是面向对象编程 面向对象编程(Object Oriented Program ...
- golang 面向对象编程
概述 Golang语言的面向对象与c++,py等语言有所不同,是由于Golang不支持继承:与上述支持聚合和继承的面向对象的语言不同,Golang只支持聚合(也叫做组合)和嵌入.聚合和嵌入的区别: t ...
- 【GoLang】golang 面向对象编程 & 面向接口编程
005.面向对象&接口编程 1 面向函数编程 1.1 将数据作为参数传递到函数入参 1.2 对象与函数是分离的 2 面向对象编程 2.1 使用者看起来函数作为对象的属性而非参数 2.2 函数属 ...
- golang面向对象实现
面向对象编程三大特点:封装.继承.多态. 1. 构造函数 Go不支持构造器.如果某类型的零值不可用,需要提供NewT(parameters)函数,用来初始化T类型的变量.按照Go的惯例,应该把创建T类 ...
- golang面向对象分析
说道面向对象(OOP)编程, 就不得不提到下面几个概念: 抽象 封装 继承 多态 其实有个问题Is Go An Object Oriented Language?, 随便谷歌了一下, 你就发现讨论这个 ...
- golang面向对象初识
struct是变量的集合 interface是方法的集合 struct与interface都支持匿名字段, 换言之, 支持组合实现继承. golang的struct与C++的class一样, 只能声明 ...
- golang 面向对象
深入理解GO语言的面向对象_Golang_脚本之家 https://www.jb51.net/article/94030.htm 深入理解GO语言的面向对象 更新时间:2016年10月04日 10:4 ...
- Golang面向对象_继承
package main import "fmt" type Person struct { name string //名字 sex byte //性别 age int //年龄 ...
- Golang 中的 面向对象: 方法, 类, 方法继承, 接口, 多态的简单描述与实现
前言: Golang 相似与C语言, 基础语法与C基本一致,除了广受争议的 左花括号 必须与代码同行的问题, 别的基本差不多; 学会了C, 基本上万变不离其宗, 现在的高级语言身上都能看到C的影子; ...
随机推荐
- PAT (Advanced Level) Practice 1027 Colors in Mars (20 分) 凌宸1642
PAT (Advanced Level) Practice 1027 Colors in Mars (20 分) 凌宸1642 题目描述: People in Mars represent the c ...
- jQuery核心函数和静态方法
jQuery核心函数 从jQuery文档中可以看出,jQuery核心函数一共3大类4小类 jQuery(callback) 当DOM加载完成后执行传入的回调函数 <script> $(fu ...
- OO_Unit1总结
OO的第一单元作业告一段落,这周是总结而不是码代码,甚至心中有点落空感.OO课给我的一周构建了一个完整的循环,从周二的作业发布到接下来几天的思考和构建程序,再到面向中测进行一部分的bug修复,最后到互 ...
- 案例 | 荔枝微课基于 kubernetes 搭建分布式压测系统
王诚强,荔枝微课基础架构负责人.热衷于基础技术研发推广,致力于提供稳定高效的基础架构,推进了荔枝微课集群化从0到1的发展,云原生架构持续演进的实践者. 本文根据2021年4月10日深圳站举办的[腾讯云 ...
- Day02_14_可变长参数
Java 可变参数 一个方法中只能有一个可变参数 它必须是该方法的最后一个形参(必须放在参数列表最后一个的位置) 传递给可变参数的数据类型必须一致 实例 public class 可变长参数 { pu ...
- Javascript图片懒加载
懒加载的意义 懒加载的主要目的是作为服务器前端的优化,减少请求数或延迟请求数. 懒加载的实现 1.第一种是纯粹的延迟加载,使用setTimeOut或setInterval进行加载延迟. 2.第二种是条 ...
- MySQL数据库干货分享!mysql每月自动创建表结构
如果你刚好在学MySQL,博主推荐一套很详细的MySQL教程 主要详细讲解了MySQL的相关知识,包括MySQL概述,MySQL应用环境,MySQL系统特性,MySQL初学基础,MySQL管理工具,如 ...
- w1R3s靶机work_through
前言 这靶机挺简单的.虽然网友们有分享oscp向的靶机集,但是没有一个难度梯度,做起来就怪怪的. 打点 nmap -sP 192.168.218.0/24 发现主机IP 192.168.218.134 ...
- JDK8新特性(二) 流式编程Stream
流式编程是1.8中的新特性,基于常用的四种函数式接口以及Lambda表达式对集合类数据进行类似流水线一般的操作 流式编程分为大概三个步骤:获取流 → 操作流 → 返回操作结果 流的获取方式 这里先了解 ...
- LINQPad,我的C#/.NET学习诀窍
LINQPad,我的C#/.NET学习诀窍 在我以往的文章中,尤其涉及代码演示的,都使用了同一个工具--LINQPad.但许多客户面对我分享的.linq源文件都迷茫不知所措,因此有必要来聊聊一下这个强 ...