變數宣告與賦值

• Java

    int i;    // 宣告
    int j = 1; // 宣告+賦值

• Go

    var i int    // 宣告
    i := 1        // 宣告+賦值

1. 變數宣告：var是關鍵字，格式：var 變數名稱 變數型別
2. 變數宣告與賦值： := 符號支援自動推導型別

異常處理

• Java

// 宣告
int execute(){
    throw new RuntimeException(”msg”); // 有錯誤
    return 0;    // 無錯誤
}
// 處理
try{
    int code = execute();
}catch(Exception e){
    // TODO 異常情況如何處理
}
 

• Go

// 宣告
func Execute() (int , error) {
        return 1,error.New(“msg”) // 有錯誤
        return 0 // 無錯誤
}
// 處理
if code,err=c.Execute();err!=nil {
    // TODO 異常情況如何處理
}

1. go的異常是做為函式返回值的，通過判斷是否存在error，來判斷異常。 （不能夠像Java一樣丟擲異常）
2. go的if語句支援初始條件，即先執行if之後的語句（分號之前），再執行分號之後的判斷語句，此語句經常用於異常處理。
   
3. go的大括號必須在行末
4. go函式或者變數為”公有”，首字母大寫，”私有”則小寫。

引數傳遞

• Java

  略，見Go實現中的註釋

• Go

package main // 入口必須是main
import "fmt"    // 引包

type People struct {    // 結構體，類似Java中的class
        age int    // 變數宣告，變數型別放在後面
        name string
}
// 類似Java方法的函式
func change(p People){    // func為關鍵字
        p.age = 18
}
// 傳遞指標
func change2(p *People){
        p.age = 18
}
func main(){
        p := People{22,"lsq"}    // 新建物件並賦值
        change(p)    // 呼叫函式change,傳遞物件
        fmt.Println(p)    // 控制檯列印
        change2(&p)    // 呼叫函式change2,傳遞指標
        fmt.Println(p)
}
// 執行結果
{22 'lsq'}
{18 'lsq'}
 

1. change函式是傳遞的物件，函式呼叫的時候，會拿到物件的拷貝。
2. change2函式是傳遞的指標，函式呼叫的時候，會拿到一個指向改物件的指標。
3. go沒有引用傳遞

多型

此例有點長，是一個求面積的問題，針對與圓形和矩形兩種型別

• Java

import java.lang.Math;
public class Polymorphism{
        public static class Rectangle implements Areable{    //矩形
                double width;
                double height;
                public Rectangle(double width,double height){   
                        this.width = width;
                        this.height = height;}
                public double area(){
                        return width * height;}
        }
        public static class Circle implements Areable{ // 圓形
                double radius;
                public Circle(double radius){
                        this.radius = radius;}
                public double area(){
                        return radius * radius * Math.PI;}
        }

        public static interface Areable{
              double area();
        }
public static void main(String[] args){
      Areable arear = new Rectangle(5.0,5.0);
      Areable areac = new Circle(2.5);
      System.out.println(arear.area());
      System.out.println(areac.area());
    }
}

• Go

package main
import (
        "fmt"
        "math"
)

type Rectangle struct {    // 矩形
        width float64
        height float64
}
type Circle struct {    // 圓形
        radius float64
}

type Areable interface{    // 介面：一組method簽名的組合，通過interface來定義物件的一組行為。
//  只要是實現了interface中的所有的method的結構體，就可以認為是這個interface的例項，Duck typing
        area() float64
}
func (r Rectangle) /* 函式的接受者Receiver */ area() float64 /* 返回值型別*/ {    
        return r.width * r.height
}

func (c Circle) /* 函式的另一個接受者Receiver */  area() float64 /* 返回值型別*/{  
        return c.radius * c.radius * math.Pi
}

func main(){
        ra := Rectangle{5,5}
        ca := Circle{2.5}
        fmt.Println(ra.area())
        fmt.Println(ca.area())
}