Go语言没有类怎么面向对象

幸运草
幸运草
幸运草
896
文章
3
评论
2020年4月19日22:16:07 评论 87

回顾

先回顾下面向对象的三个基本特性:

  • 封装
  • 继承
  • 多态

Java作为面向对象的王者,以下示例完美的展现了面向对象的三个基本特征。

public class Main {
    public static void main(String[] args) {
        List<Payroll> all = new ArrayList<>();

        //员工类封装了数据(姓名、年龄、性别)和行为(计算薪酬)
        //销售员工和技术员工继承自员工类,都实现了计算薪酬的接口
        //机器不是员工,但实现了计算薪酬的接口,也可以计算薪酬
        all.add(new SaleEmployee());
        all.add(new TechEmployee());
        all.add(new Machine());

        //多态:不管是人还是机器,只要实现了Payroll接口,就都可以正确的计算出各自的薪酬
        for (Payroll payroll : all) {
            System.out.println(payroll.calcSalary());
        }
    }
}

那么Go语言呢?我们一起来探索下Go语言的面向对象,先从类的封装开始。

封装

员工薪酬示例中,Java里的Employee类是这样的:

public abstract class Employee implements Payroll {
    private String name;
    private String sex;
    private int age;

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

这里暂时先关注员工类的三个属性,Go里面它确实没有类,要表示上面的员工对象,它是用struct的(和C很像):

type Employee struct {
    Name string
    Sex string
    Age int
}

看起来简洁多了,注意到Go里面没有private public的修饰符,它是用属性的首个字母大小写来区分private public,小写字母开头的是私有属性,大写字母开头表示公开属性。对象的实例化和使用对比:

//由于Employee是抽象类,不能实例化,直接用子类TechEmployee实例化
Employee tech = new TechEmployee();
tech.setName("lee");
System.out.println(tech.getName());
//这里的object.是包名,Employee放在object目录下
tech := object.Employee{
    Name: "lee",
    Sex:  "male",
    Age:  20,
}
tech.Name = "bruce lee"
fmt.Println(tech.Name)

另外,struct中是没有方法(行为)的,少了这个不是等于封装特征缺了只脚吗?当然不是了,Go语言里对应面向对象里的成员方法不是定义在struct里面,而是直接定义在struct外面,和struct平级,这里定义一个类似Java中的toString方法:

type Employee struct {
    Name string
    Sex  string
    Age  int
}

func (e *Employee) ToString() string {
    return "name=" + e.Name + ";sex=" + e.Sex + ";age=" + strconv.Itoa(e.Age)
}

这里(e *Employee)叫做方法的接收者,有点怪异,我们可以这样理解:

  1. Go里没有this,要自己加个类似this的东西,用于指代方法对应的实例,括号里前面的e相当于this,当然名字可以随便取。
  2. 方法定义和struct平级,如果不加个接收者定义,哪里知道这个方法属于谁的呢,括号里后面的类型表示这个方法属性于谁的,这里可以用(e Employee)或(e *Employee),区别是传值还是传指针,一般统一用后者。

继承

接下来继承,先看看Java的:

public class TechEmployee extends Employee {
    private double salaryPerMonth;

    public double getSalaryPerMonth() {
        return salaryPerMonth;
    }

    public void setSalaryPerMonth(double salaryPerMonth) {
        this.salaryPerMonth = salaryPerMonth;
    }

    @Override
    public double calcSalary() {
        return salaryPerMonth;
    }
}

public class SaleEmployee extends Employee {
    private Double baseSalary;
    private Double extraRate;

    public Double getBaseSalary() {
        return baseSalary;
    }

    public void setBaseSalary(Double baseSalary) {
        this.baseSalary = baseSalary;
    }

    public Double getExtraRate() {
        return extraRate;
    }

    public void setExtraRate(Double extraRate) {
        this.extraRate = extraRate;
    }

    @Override
    public double calcSalary() {
        return baseSalary * (1 + extraRate);
    }
}

同样,Go里面也没有像Java中类似extend继承的语法,Go是用了类似Java里组合的东西来让语法看起来像继承:

type TechEmployee struct {
    Employee
    SalaryPerMonth float32
}

type SaleEmployee struct {
    Employee
    BaseSalary float32
    ExtraRate  float32
}

对应的实例化和使用:

//实例化时,是传了个employee
tech := object.TechEmployee{
    Employee:       object.Employee{Name: "lee"},
    SalaryPerMonth: 10000,
}
//这里看起来像拥有了Employee的name属性,可以设置和访问
tech.Name = "bruce lee"
fmt.Println(tech.Name)

多态

关于多态,必须要提接口,终于Go里也是有接口的了:

public interface Payroll {
    double calcSalary();
}
type Payroll interface {
    CalcSalary() float32
}

接口的实现:

public class Machine implements Payroll {
    @Override
    public double calcSalary() {
        return 0;
    }
}
type TechEmployee struct {
    Employee
    SalaryPerMonth float32
}

func (e *TechEmployee) CalcSalary() float32 {
    return e.SalaryPerMonth
}

type Machine struct {

}

func (e *Machine) CalcSalary() float32 {
    return 0
}

可以看出,Java里比较直观,语法里直接写着实现xxx接口,Go相比的话,没那么直观,但更灵活,它没有指定实现哪个接口,而是如果定义了一个相同名字和返回值的方法,就认为是实现了对应拥有这个方法的接口,这里假如接口有两个方法,对应也必须要两个方法都有定义了,才认为是实现了接口。

最后,看一下集成使用的对比:

List<Payroll> all = new ArrayList<>();

//员工类封装了数据(姓名、年龄、性别)和行为(计算薪酬)
//销售员工和技术员工继承自员工类,都实现了计算薪酬的接口
//机器不是员工,但实现了计算薪酬的接口,也可以计算薪酬
all.add(new SaleEmployee());
all.add(new TechEmployee());
all.add(new Machine());

//多态:不管是人还是机器,只要实现了Payroll接口,就都可以正确的计算出各自的薪酬
for (Payroll payroll : all) {
    System.out.println(payroll.calcSalary());
}
var all [3] object.Payroll

all[0] = &object.TechEmployee{
    Employee:       object.Employee{Name: "lee"},
    SalaryPerMonth: 10000,
}
all[1] = &object.SaleEmployee{
    Employee:   object.Employee{Name: "lee"},
    BaseSalary: 10000,
    ExtraRate:  0.1,
}
all[2] = &object.Machine{}

for _, item := range all {
    fmt.Println(item.CalcSalary())
}

特别声明:以上文章内容仅代表作者本人观点,不代表变化吧观点或立场。如有关于作品内容、版权或其它问题请于作品发表后的30日内与变化吧联系。

转载请注明:{{title}}-变化吧
  • 赞助本站
  • 微信扫一扫
  • weinxin
  • 赞助本站
  • 支付宝扫一扫
  • weinxin
幸运草
Go语言中的常量 函数代码

Go语言中的常量

1 概述 常量,一经定义不可更改的量。功能角度看,当出现不需要被更改的数据时,应该使用常量进行存储,例如圆周率。从语法的角度看,使用常量可以保证数据,在整个运行期间内,不会被更改。例如当前处理器的架构类型,可以保证不被更改。 语法如下 2 定义单个常量 const 常量名 <可选的类型> = 常量值 const c1 int = 1000 Go语言中,标识符(常量名)是否大小写,取决于是否需要在导出时被识别。 常量的值仅仅支持,基础类型,字符串,字符,整型,浮点,布尔。 3 类型推导 类型可以通过值推导出来,大多数情况可以省略类型,例如 const c2 = 1000 除非你想使用例如,int8, byte,float32这些非默认类型时,需要指定类型,例如 const c3 int16 = 1000 4 定义多个常量 可以一行定义多个常量,例如: const c4, c5 = 42, 1000 也可以使用 const()定义块,定义多个,每个常量单独一行,例如 const (  c6 = 42  c7 = 1000 ) 推荐使用const()块语法,一次性定义多个。 const()块定义时,如果常量未给出定义,则延续上面的定义规则,例如: const (  c7 = 42  c8 // c8 = 42  c9 // c9 = 42 ) 此时,c8, c9, 值都是42。 5 iota迭代定义常量 const配合iota关键字使用,可以定义一组由0开始+1迭代的常量 演示语法: const (  gender_secret = iota  gender_male // = iota  gender_female // = iota ) 此时,三个常量值,分别是,0, 1, 2 iota的规则是:若iota出现在const()中,那么const()定义的第一行的iota就是0,第二行就是0+1=1,不论iota是否被常量使用。演示如下: const (  c1 = 42...
Go语言的接口 函数代码

Go语言的接口

Go语言-接口 在Go语言中,一个接口类型总是代表着某一种类型(即所有实现它的类型)的行为。一个接口类型的声明通常会包含关键字type、类型名称、关键字interface以及由花括号包裹的若干方法声明。示例如下: type Animal interface { Grow() Move(string) string } 实现接口 如果一个数据类型所拥有的方法集合中包含了某一个接口类型中的所有方法声明的实现,那么就可以说这个数据类型实现了那个接口类型。 你可能已经意识到,我们无需在一个数据类型中声明它实现了哪个接口。只要满足了“方法集合为其超集”的条件,就建立了“实现”关系。这是典型的无侵入式的接口实现方法。 package main import ( "fmt" ) // 定义一个接口 type People interface { ReturnName() string } // 定义一个结构体 type Student struct { Name string } // 定义结构体的一个方法。 // 这个方法同接口People的所有方法,此时可直接认为结构体Student实现了接口People func (s Student) ReturnName() string { return s.Name } func main() { cbs := Student{Name:"咖啡色的羊驼"} var a People a = cbs name := a.ReturnName() fmt.Println(name) // 输出"咖啡色的羊驼" } 如何测试是否已实现该接口 h, ok := a.(People) 这种方式称为类型断言表达式。 a.(People)的求值结果可以有两个: 第一个结果是被转换后的那个目标类型(这里是Student)的值. 而第二个结果则是转换操作成功与否的标志。 空接口 interface{} 空接口就是不包含任何方法的接口。正因为如此,所有的数据类型都实现了空接口。就像Java中的Object类一样。 因此空接口可以存储任意类型的数据。 特别声明:以上文章内容仅代表作者本人观点,不代表变化吧观点或立场。如有关于作品内容、版权或其它问题请于作品发表后的30日内与变化吧联系。
Go语言支持的正则语法 函数代码

Go语言支持的正则语法

1 字符 语法 说明 . 任意字符,在单行模式(s标志)下,也可以匹配换行 字符类 否定字符类 d Perl 字符类 D 否定 Perl 字符类 ASCII 字符类 否定 ASCII 字符类 pN Unicode 字符类 (one-letter name) p{Greek} Unicode 字符类 PN 否定 Unicode 字符类 (one-letter name) P{Greek} 否定 Unicode 字符类 参考以下附录,获取具体字符类的内容: Perl 字符类 ASCII 字符类 Unicode 字符类 (one-letter name) Unicode 字符类 go.hellokang.net 可以获取相关内容 2 组合 语法 说明 xy xy(x 后跟随 y) x|y x 或 y (优先匹配 x) 3 重复次数 语法 说明 x* 零个或多个 x,贪婪 x+ 一个或多个 x,贪婪 x? 零个或一个 x,贪婪 x{n,m} n 到 m 个 x,贪婪 x{n,} n 个或多个 x,贪婪 x{n} n 个 x x*? 零个或多个 x,非贪婪 x+? 一个或多个 x,非贪婪 x?? 零个或一个...
Go语言的包管理 函数代码

Go语言的包管理

1 概述 Go 语言的源码复用建立在包(package)基础之上。包通过 package, import, GOPATH 操作完成。 2 main包 Go 语言的入口 main() 函数所在的包(package)叫 main,main 包想要引用别的代码,需要import导入! 3 包定义,package Go 语言的包与文件夹一一对应,同一个目录下的所有.go文件的第一行添加 包定义,以标记该文件归属的包,演示语法: package 包名 包需要满足: 一个目录下的同级文件归属一个包。 包名可以与其目录不同名。 包名为 main 的包为应用程序的入口包,其他包不能使用。 包可以嵌套定义,对应的就是嵌套目录,但包名应该与所在的目录一致,例如: // 文件:foo/bar/tool.go中 package bar // 可以被导出的函数 func FuncPublic() { } // 不可以被导出的函数 func funcPrivate() { } 包中,通过标识符首字母是否大写,来确定是否可以被导出。首字母大写才可以被导出,视为 public 公共的资源。 4 导入包,import 要引用其他包,可以使用 import 关键字,可以单个导入或者批量导入,语法演示: // 单个导入 import "package" // 批量导入 import (  "package1"  "package2"  ) 导入时,可以为包定义别名,语法演示: import (  p1 "package1"  p2 "package2"  ) // 使用时 p1.Method() 以上测试请使用系统包测试。若需要导入自定义包,需要设置GOPATH环境变量。 4 GOPATH环境变量 import导入时,会从GO的安装目录(也就是GOROOT环境变量设置的目录)和GOPATH环境变量设置的目录中,检索 src/package 来导入包。如果不存在,则导入失败。 GOROOT,就是GO内置的包所在的位置。 GOPATH,就是我们自己定义的包的位置。 通常我们在开发Go项目时,调试或者编译构建时,需要设置GOPATH指向我们的项目目录,目录中的src目录中的包就可以被导入了: 例如,我么的项目目录为: D:projectsgoProject,那么我么就需要将我们的源代码放在 D:projectsgoProjectsrc 下,同时设置GOPATH为 D:projectsgoProject。设置GOPATH的方案有: windows 通过 系统->系统信息->高级系统设置->环境变量 中完成设置。 windows 中通过 CMD 或者 powershell 也可以完成设置。通常是临时有效的,CMD或者powershell关闭失效!...