这篇文章主要介绍“golang中有类吗”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“golang中有类吗”文章能帮助大家解决问题。

golang中没有类。golang不是一门纯面向对象编程语言，它没有class（类）的概念，也就没有继承的说法，但Go也可以模拟面向对象的编程方式。在Go中，可以将struct比作其它语言中的class；通过struct定义结构体，表征一类对象，例“type person struct {...}”。

面向对象三大特征：封装，继承，多态。

Go不是一门纯面向对象编程语言，它没有class（类）的概念，也就没有继承的说法。但Go也可以模拟面向对象的编程方式，即可以将struct比作其它语言中的class。

对象

Go没有class的概念，通过struct定义结构体，表征一类对象。



type person struct {
	Age  int
	Name string
}

对象是状态与行为的有机体。例如下面的java代码：



public class Person {

    int age;

    String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

不同于Java，Go的方法不需要跟类的数据绑定在一个class的定义里面，只需要定义在同一个包内。这一点可能初学Go的同学，会感觉很奇怪。



type person struct {
	Age  int
	Name string
}

func (p *person) GetAge() int {
	return p.Age
}

func (p *person) SetAge(age int)  {
	p.Age = age
}

func (p *person) GetName() string {
	return p.Name
}

func (p *person) SetName(name string) {
	p.Name = name
}

构造函数

Go没有构造函数，对象的数据载体就是一个struct。Java支持构造函数，构造函数名字就跟类名字一样，多个构造函数通过函数重载实现。

而Go构造函数则通过工厂函数进行模拟。实例如下：



type person struct {
	Age  int
	Name string
}

/**
	构造函数1--通过名字初始化
 */
func newPersonByName(name string) *person {
	return &person{
		Name: name,
	}
}

/**
	构造函数2--通过年龄初始化
 */
func newPersonByAge(age int) *person {
	return &person{
		Age: age,
	}
}

需要注意的是，person结构体的名称首字母要小写，避免外部直接越过模拟的构造函数

访问权限

Java有四种访问权限，如下所示：

java访问控制符
public protected

friendly

(default)

 private
同一个类 yes yes yes yes
同一个包 yes yes yes no
不同包子类 yes yes no no
不同包非子类 yes no no no

Go则做了简化，可见性的最小粒度是包。也就是说，Go保留两种，friendly和public。Go的变量名如果首字母是小写，则代表包内可见；如果首字母是大写，则代表任何地方都可见。

封装

封装，把抽象出来的结构体跟操作结构体内部数据的函数绑定在一起。外部程序只能根据导出的函数API（public方法）修改结构体的内部状态。

封装有两个好处：

隐藏实现：我们只希望使用者直接使用API操作结构体内部状态，而无需了解内部逻辑。就好像一座冰山，我们只看到它露出水面的那一部分。

保护数据：我们可以对数据的修改和访问施加安全措施，调用setter方法的时候，我们可以对参数进行校验；调用getter方法，我们可以增加访问日志等等。

一个简单的bean定义如下所示：



type person struct {
	Age  int
	Name string
}

func NewPerson(age int, name string) *person{
	return &person{age, name}
}

func (p *person) SetAge(age int)  {
	p.Age = age
}

func (p *person) SetName(name string) {
	p.Name = name
}

func main() {
	p:= NewPerson(10, "Lily")
	p.SetName("Lucy")
	p.SetAge(18)
}

需要注意的是，Go的方法是一种特殊的函数，只是编译器的一种语法糖，编译器瞧瞧帮我们把对象的引用作为函数的第一个参数。例如，下面的代码是等价的



func main() {
	p:= NewPerson(10, "Lily")

	p.SetName("Lily1")
	// 等价于下面的写法
	// p是一个引用，函数引用
	setNameFunc := (*person).SetName
	setNameFunc(p, "Lily2")
	fmt.Println(p.Name)
}

继承

继承，子类继承父类，则获得父类的特征和行为。继承的主要目的是为了重用代码。Java实现代码重用的两大利器，就是继承和组合。

Go没有class的概念，谈不上继承。但Go可以通过匿名组合来模拟继承。

如下所示，Cat通过匿名聚合了Animal结构体，就自动获得了Animal的move()和Shout()方法：



type Animal struct {
	Name string
}

func (Animal) move()  {
	fmt.Println("我会走")
}

func (Animal) shout()  {
	fmt.Println("我会叫")
}

type Cat struct {
	Animal // 匿名聚合
}

func main() {
	cat := &Cat{Animal{"猫"}}

	cat.move()
	cat.shout()
}

多态

多态，申明为基类的变量，可以在运行期指向不同的子类，并调用不同子类的方法。多态的目的是为了统一实现。

我们通过接口来实现多态。在java里，我们通过interface来定义接口，通过implements来实现接口。



interface Animal {

    void move();

    void shout();
}

class Dog implements Animal {

    @Override
    public void move() {
        System.out.println("我会走");
    }

    @Override
    public void shout() {
        System.out.println("我会叫");
    }
}

而Go则是通过鸭子类型推断，只要某个对象长得想鸭子，叫起来像鸭子，那么它就是鸭子。也就是说，Go的接口是比较隐匿的，只要某个对象实现来接口申明的所有方法，那么就认为它属于该接口。



type Animal interface {

	move()
	shout()
}

type Cat struct {
	Animal // 匿名聚合
}

func (Cat)move()  {
	fmt.Println("猫会走")
}

func (Cat)shout()  {
	fmt.Println("猫会叫")
}

type Dog struct {
	Animal  // 匿名聚合
}


func (Dog)move()  {
	fmt.Println("狗会走")
}

func (Dog)shout()  {
	fmt.Println("狗会叫")
}

func main() {
	cat := Cat{}
	dog := Dog{}
    // 申明接口数组
 	animals := []Animal{cat, dog}
	for _,ele := range animals {
        // 统一访问
		ele.move()
		ele.shout()
	}
}