Go和Java的对比学习

对象

我们都知道java是一门面向对象的程序设计语言，它的主要思想就是类和对象；但是Go却不然，他并不是一门面向对象的语言，却有点和C语言相似，有点面向过程的意思。

那么Go语言能不能处理关于面向对象的问题呢，答案是肯定的。Go语言可以使用结构体来构建对象类型，从而实现面向对象的程序设计。

public class students {
	private String id;
	private String name;
	private String age;
	private String address;
	public students(){
	}
	public students(String id,String name,String age,String address) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.address = address;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}
public class manager {
	public static void main(String[] args) {
		students s = new students();
		s.setId("20185734");
		s.setName("msl");
		s.setAge("20");
		s.setAddress("shandong");
	}
}

type student struct {
   id string
   name string
   age string
   address string
}
func main(){
	var s student
	s.id = "20185734"
	s.name = "msl"
	s.age = "20"
	s.address = "shandong"
}

对于同样一个student类，java可以通过类的形式描述它的属性，然而golang需要用结构体来表示。另外，java可以通过private关键字限制对类里面元素的修改，安全性相对较高，但是运行效率会低。

指针

Go语言是有指针的，java则没有，例如在

type LinkNode struct {
    Data Elem
    Next *LinkNode
}

实现链表功能。

并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。
goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

在过程式编程中，当调用一个过程的时候，需要等待其执行完才返回。而调用一个协程的时候，不需要等待其执行完，会立即返回。协程十分轻量，Go语言可以在一个进程中执行有数以十万计的协程，依旧保持高性能。

package main

import (
        "fmt"
        "time"
)

func say(s string) {
        for i := 0; i < 5; i++ {
                time.Sleep(100 * time.Millisecond)
                fmt.Println(s)
        }
}

func main() {
        go say("world")
        say("hello")
}

由于这两个函数是在不同的线程中运作的，因此就不会有输出的固定顺序。

但是java中不存在协程一说。

错误处理

Go语言的错误处理是一个接口，例如如下实例：

type DivideError struct {
    dividee int
    divider int
}

func (de *DivideError) Error() string {
    strFormat := 
    `Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0`
    
    return fmt.Sprintf(strFormat, de.dividee)
}

func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
    if varDivider == 0 {
            dData := DivideError{
                    dividee: varDividee,
                    divider: varDivider,
            }
            errorMsg = dData.Error()
            return
    } else {
            return varDividee / varDivider, ""
    }

}

func main() {
    if result, errorMsg := Divide(100, 10); errorMsg == "" {
            fmt.Println("100/10 = ", result)
    }
    if _, errorMsg := Divide(100, 0); errorMsg != "" {
            fmt.Println("errorMsg is: ", errorMsg)
    }
}

然而在java中的错误处理主要是使用try{}catch{}