【OOP】go语言学习笔记(第3章)—面向对象编程

时间  2019-11-07
标签 OOP 语言 学习 笔记 面向对象 编程 栏目 软件设计 繁體版
原文   原文链接

一个典型的类型系统包括：php

  • 基础类型： byte, int, bool, float等
  • 复合类型：数组，结构体，指针
  • 能够指向任意对象的类型(Any类型)
  • 值语义和引用语义
  • 面向对象，即全部具有面向对象特征的类型
  • 接口

在GO语言中能够为任意类型(包括内置类型)添加相应的方法html

go语言学习笔记(第3章)—面向对象编程
上面的例子中咱们定义了一个新类型 Integer ，Integer和int没有本质区别，只是为内置的int增长了一个方法Less()，可让整型像一个普通的类同样使用了。git

在GO语言中没有隐藏的this指针github

1) 方法施加的目标显示传递，没有被隐藏起来golang

2) 方法施加的目标不须要非得是指针，也不用非得叫thisweb

GO语言和C语言同样，类型都是基于值传递的，要想改变变量的值，只能在函数中传递指针。面试

1. 类型系统编程

1.1.  值语义和引用语义数组

值语义和引用语义的差异在于赋值app

b = a

b.Modify()

若是b的修改不会影响a的值，那么此类型属于值类型。若是会影响a的值，那么此类型是引用类型。

GO语言中的大多数类型都属于值语义，包括：

基本类型： byte, int, bool, float32, float64和string等

复合类型： array, struct, pointer等

GO语言中的类型的值语义表现的很是完全。

1.2. 结构体

GO语言放弃了包括继承在内的大量面向对象特性，只保留了组合这个最基础的特性。

组合不能算面向对象的特性，由于在C语言这样的过程式编程语言中，也有结构体，也有组合。组合只是形式复合类型的基础。

GO语言中结构体的使用方式与C语言并无什么明显的不一样。

2. 初始化

在GO语言中，未进行显式初始化的变量都会被初始化为该类型的零值，例如bool类型的零值为false, int类型的零值为0, string类型的零值为空字符串。

结构体有多种初始方法，以下：

go语言学习笔记(第3章)—面向对象编程
3. 匿名组合

确切的说，GO语言也提供了继承，可是采用了组合的文法，因此咱们将其称为匿名组合

4. 可见性

GO语言对关键字的增长很是吝啬，没有private, protected, public这样的关键字。要使某个符号对其余包可见，须要将该符号定义为以大写字母开头。

5. 接口

GO语言的接口并非其余语言中所提供的接口概念。JAVA如今的接口是侵入式接口， GO的接口时非侵入式的。

在GO语言中，一个类只要实现了接口要求的全部函数，咱们就说这个类实现了该接口。

在GO语言中，接口赋值在GO语言中分为以下两种状况：

1. 将对象实例赋值给接口

2. 将一个接口赋值给另外一个接口

//struct
//Date：2014-4-1 09:57:37
package main
import (
	"fmt"
	"strings"
)

func StructTest01Base() {
	//structTest0101()
	//structTest0102()
	structTest0103()

}

//定义一个struct
type Student struct {
	id      int
	name    string
	address string
	age     int
}

func structTest0101() {
	//使用new建立一个Student对象,结果为指针类型
	//var s *Student = new(Student)
	s := &Student{}
	//var s *Student = new(Student)
	//var s *Student = new(Student)
	s.id = 101
	s.name = "Mikle"
	s.address = "红旗南路"
	s.age = 18

	fmt.Printf("id:%d\n", s.id)
	fmt.Printf("name:%s\n", s.name)
	fmt.Printf("address:%s\n", s.address)
	fmt.Printf("age:%d\n", s.age)
	fmt.Println(s)
}


func main(){

	structTest0101()
}
//建立Student的其它方式
func structTest0102() {
	//使用&T{...}建立struct，结果为指针类型
	var s1 *Student = &Student{102, "John", "Nanjing Road", 19}
	fmt.Println(s1)
	fmt.Println("modifyStudentByPointer...")
	modifyStudentByPointer(s1)
	fmt.Println(s1)

	//使用T{...}建立struct，结果为value类型
	fmt.Println("-------------")
	var s2 Student = Student{103, "Smith", "Heping Road", 20}
	fmt.Println(s2)
	fmt.Println("modifyStudent...")
	modifyStudent(s2)
	fmt.Println(s2)
	//建立并初始化一个struct时，通常使用【上述】两种方式

	//其它方式
	var s3 *Student = &Student{id: 104, name: "Lancy"}
	fmt.Printf("s3:%d,%s,%s,%d\n", s3.id, s3.name, s3.address, s3.age)
}

//struct对象属于值类型，所以须要经过函数修改其原始值的时候必须使用指针
func modifyStudent(s Student) {
	s.name = s.name + "-modify"
}
func modifyStudentByPointer(s *Student) {
	s.name = s.name + "-modify"
}

type Person struct {
	firstName string
	lastName  string
}

//使用 *Person做为参数的函数
func upPerson(p *Person) {
	p.firstName = strings.ToUpper(p.firstName)
	p.lastName = strings.ToUpper(p.lastName)
}

//调用上述方法的三种方式
func structTest0103() {
	//1- struct as a value type:
	var p1 Person
	p1.firstName = "Will"
	p1.lastName = "Smith"
	upPerson(&p1)
	fmt.Println(p1)

	//2—struct as a pointer:
	var p2 = new(Person)
	p2.firstName = "Will"
	p2.lastName = "Smith"
	(*p2).lastName = "Smith" //this is also valid
	upPerson(p2)
	fmt.Println(p2)

	//3—struct as a literal:
	var p3 = &Person{"Will", "Smith"}
	upPerson(p3)
	fmt.Println(p3)
}

转载-golang面向对象分析

目录

一. 抽象和封装
二. 继承(Composition)
1. has-a
2. is-a(Pseudo)----Embedding
三. Interface
尾声
 
 
这篇文章写的真心是好, 把Golang的OOP诠释的很清楚.
本imi增长了, 本身的理解.
struct有内嵌(组合), 有重写, 可是没有重载; interface具备多态性.
 
说道面向对象(OOP)编程, 就不得不提到下面几个概念:
- 抽象
- 封装
- 继承(重写, 重载)
- 多态

其实有个问题Is Go An Object Oriented Language?, 随便谷歌了一下, 你就发现讨论这个的文章有不少:
1. reddit
2. google group

那么问题来了

  1. Golang是OOP吗?
  2. 使用Golang如何实现OOP?

我入门教程基本就是A Tour Of Go以及Go Web 编程. 因为以前是写C++, 可是说到Go面向对象编程, 老是感受怪怪的, 总感受缺乏点什么. 我搜集了一些资料和例子, 加上个人一些理解, 整理出这样一篇文章.

一. 抽象和封装

抽象和封装就放在一块说了. 这个其实挺简单. 看一个例子就好了.

type rect struct {
    width int
    height int
}
 
func (r *rect) area() int {
    return r.width * r.height
}
 
func main() {
    r := rect{width: 10, height: 5}
    fmt.Println("area: ", r.area())
}

完整代码

要说明的几个地方:
一、Golang中的struct和其余语言的class是同样的.

二、可见性. 这个遵循Go语法的大小写的特性

三、上面例子中, 称*rect为receiver. 关于receiver 能够有两种方式的写法:

func (r *rect) area() int {
    return r.width * r.height
}
func (r rect) area() int {
    return r.width * r.height
}

这其中有什么区别和联系呢? 关于详细解释请查看astaxie的解释, 写的很是清晰.

简单来讲, Receiver能够是值传递, 仍是能够是指针, 二者的差异在于, 指针做为Receiver会对实例对象的内容发生操做,而普通类型做为Receiver仅仅是以副本做为操做对象,并不对原实例对象发生操做。

四、当Receiver为*rect指针的时候, 使用的是r.width, 而不是(*r).width, 是因为Go自动帮我转了,两种方式都是正确的.

五、任何类型均可以声明成新的类型, 由于任何类型均可以有方法.

type Interger int
func (i Interger) Add(interger Interger) Interger {
    return i + interger
}

六、虽然Interger是从int声明而来, 可是这样用是错误的.

var i Interger = 1
var a int = b //cannot use i (type Interger) as type int in assignment

这是由于Go中没有隐式转换(写C++的同窗都会特别讨厌这个, 由于编译器背着咱们干的事情太多了). Golang中类型之间的相互赋值都必须显式声明.

上面的例子改为下面的方式就能够了.

var i Interger = 1
var a int = int(b)

二. 继承(Composition)

说道继承，其实在Golang中是没有继承(Extend)这个概念. 由于Golang舍弃掉了像C++, Java的这种传统的、类型驱动的子类。

Go Effictive says:
Go does not provide the typical, type-driven notion of subclassing, but it does have the ability to “borrow” pieces of an implementation by embedding types within a struct or interface.

换句话说, Golang中没有继承, 只有Composition.

Golang中的Compostion有两种形式, 匿名组合(Pseudo is-a)和非匿名组合(has-a)

注: 若是不了解OOP的is-a和has-a关系的话, 请自行google.

1. has-a

package main
 
import (
    "fmt"
)
 
type Human struct {
    name  string
    age   int
    phone string
}
 
type Student struct {
    h      Human //非匿名字段
    school string
}
 
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
func (s *Student) SayHi() {
    fmt.Printf("Hi student, I am %s you can call me on %s", s.h.name, s.h.phone)
}
 
func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    fmt.Println(mark.h.name, mark.h.age, mark.h.phone, mark.school)
    mark.h.SayHi()
    mark.SayHi()
 
}

 

Output

Mark 25 222-222-YYYY MIT
Hi, I am Mark you can call me on 222-222-YYYY
Hi student, I am Mark you can call me on 222-222-YYYY

完整代码

这种组合方式, 其实对于了解传统OOP的话, 很好理解, 就是把一个struct做为另外一个struct的字段.

从上面例子能够, Human彻底做为Student的一个字段使用. 因此也就谈不上继承的相关问题了.咱们也不去重点讨论.

2. is-a(Pseudo)----Embedding

type Human struct {
    name string
    age int
    phone string
}
 
type Student struct {
    Human //匿名字段
    school string
}
 
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    fmt.Println(mark.name, mark.age, mark.phone, mark.school)
    mark.SayHi()
}

Output

Mark 25 222-222-YYYY MIT
Hi, I am Mark you can call me on 222-222-YYYY

完整代码

这里要说的有几点:

一、字段
如今Student访问Human的字符, 就能够直接访问了, 感受就是在访问本身的属性同样. 这样就实现了OOP的继承.

fmt.Println("Student age:", mark.age) //输出: Student age: 25

可是, 咱们也能够间接访问:

fmt.Println("Student age:", mark.Human.age) //输出: Student age: 25

这有个问题, 若是在Student也有个字段name, 那么当使用mark.name会以Student的name为准.

fmt.Println("Student name:", mark.name) //输出:Student Name: student name

完整代码

二、方法
Student也继承了Human的SayHi()方法

mark.SayHi() // 输出: Hi, I am Mark you can call me on 222-222-YYYY

固然, 咱们也能够重写SayHi()方法:

type Human struct {
    name  string
    age   int
    phone string
}
 
type Student struct {
    Human  //匿名字段
    school string
    name   string
}
 
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
func (h *Student) SayHi() {
    fmt.Println("Student Sayhi")
}
 
func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT", "student name"}  
    mark.SayHi()
}

Output

Student Sayhi

完整代码

三、为何称其为Pseudo is-a呢?

由于匿名组合不提供多态的特性. 以下面的代码:

package main
 
type A struct{
}
 
type B struct {
    A  //B is-a A
}
 
func save(A) {
    //do something
}
 
func main() {
    b := new(B)
    save(*b);  
}

Output

cannot use *b (type B) as type A in argument to save

完整代码

还有一个面试题的例子(说明go的匿名组合只有重写, 没有重载)

type People struct{}
 
func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}
 
type Teacher struct {
    People
}
 
func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}
 
func main() {
    t := Teacher{}
    t.ShowA()
}

输出结果是什么呢?

Output

ShowA
ShowB

Effective Go Says:

There's an important way in which embedding differs from subclassing. When we embed a type, the methods of that type become methods of the outer type, but when they are invoked the receiver of the method is the inner type, not the outer one

也就是说, Teacher因为组合了People, 因此Teacher也有了ShowA()方法, 可是在ShowA()方法里执行到ShowB时, 这个时候的receiver是*People而不是*Teacher, 主要缘由仍是由于embedding是一个Pseudo is-a, 没有多态的功能.

四、 "多继承"的问题(go没有多重继承, 必须显示引用)

package main
 
import "fmt"
 
type School struct {
    address string
}
 
func (s *School) Address() {
    fmt.Println("School Address:", s.address)
}
 
type Home struct {
    address string
}
 
func (h *Home) Address() {
    fmt.Println("Home Address:", h.address)
}
 
type Student struct {
    School
    Home
    name string
}
 
func main() {
    mark := Student{School{"aaa"}, Home{"bbbb"}, "cccc"}
    fmt.Println(mark)
    mark.Address()
    fmt.Println(mark.address)
 
    mark.Home.Address()
    fmt.Println(mark.Home.address)
}

输出结果:

30: ambiguous selector mark.Address
31: ambiguous selector mark.address

完整代码

由此能够看出, Golang中不论是方法仍是属性都不存在相似C++那样的多继承的问题. 要访问Embedding相关的属性和方法, 须要在加那个相应的匿名字段, 如:

mark.Home.Address()

五、Embedding value和 Embedding pointer的区别

package main
 
import (
    "fmt"
)
 
type Person struct {
    name string
}
 
type Student struct {
    *Person
    age int
}
 
type Teacher struct {
    Person
    age int
}
 
func main()  {
    s := Student{&Person{"student"}, 10}
    t := Teacher{Person{"teacher"}, 40}
    fmt.Println(s, s.name)
    fmt.Println(t, t.name)
}

Output

{0x1040c108 10} student
{{teacher} 40} teacher

完整代码

I. 二者对于结果来讲, 没有啥区别, 只是对传参的时候有影响
II. Embedding value是比较常规的写法
III. Embedding pointer比较有优点一点, 不须要关注指针是什么时间被初始化的.

三. Interface

Golang中Composite不提供多态的功能, 那是否Golang不提供多态呢? 答案确定是否认. Golang依靠Interface实现多态的功能.

下面是我工程里面一段代码的简化:

package main
 
import (
    "fmt"
)
 
type Check interface {
    CheckOss()
}
 
type CheckAudio struct {
    //something
}
 
func (c *CheckAudio) CheckOss() {
    fmt.Println("CheckAudio do CheckOss")
}
 
func main() {
    checkAudio := CheckAudio{}
 
    var i Check
 
    i = &checkAudio //想一下这里为啥须要&, 这一点是不少书里面提到的, 
//即指针才具备指针的方法
//而反过来是不成立的, 非指针不会具备指针的方法
    i.CheckOss()
}

完整代码

一、Interface 如何Composite ?

type Reader interface {
    Read(p []byte) (n int, err error)
}
 
type Writer interface {
    Write(p []byte) (n int, err error)
}
 
type ReadWriter interface {
    Reader
    Writer
}

其实很简单, 就是把Reader, Writer嵌入到ReadWriter中, 这样ReadWriter就拥有了Reader和Writer的方法.

尾声

至此, 基本说完了Golang的面向对象. 有哪里我理解的不对的地方, 请给我留言.

参考资料
1. Effective Go: Embedding
2. Go面试题
3. Is Go An Object Oriented Language?
4. go web编程
5. object-oriented-programming-in-go

0
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程