英文原文在此www.nada.kth.se/~snilsson/go_for_java_programmers

译文同步至http://blog.csdn.net/kkkloveyou/article/details/8308534

http://bbs.gocn.im/thread-73-1-1.html

====================接上文，以下正文========================.

条件语句

Go在条件语句中并不使用括号，像 if条件语句 , for 条件语句的表达式, switch 条件语句的值. 另一方面，它并不需要在if或 for条件语句中加花括号

if a < b { f() }
if (a < b) { f() }           // 括号是不必要的.
if (a < b) f()               // 无效的
for i = 0; i < 10; i++ {}
for (i = 0; i < 10; i++) {}  // 无效的

此外, if和switch 接收一个可选的初始化的状态，那么惯用做法是建一个局部变量

if err := file.Chmod(0664); err != nil {
    log.Print(err)
    return err
}

For 语句

Go没有while和do-while语句. 当for语句的条件比较单一时，他的作用就像是while语句. 完全省略条件则产生一个死循环。

for语句可能包含range遍历 strings, arrays, slices, maps, 或 channels。除了写成下面这样

for i := 0; i < len(a); i++ { ... }

去遍历a的元素，也可以写成

for i, v := range a { ... }

这里的i指索引， v代表的array, slice, 或者string的连续元素。对于字符串，i是一个字节的索引，v指向rune类型（rune类型是int32)的一个别名）。maps迭代产生键 - 值对，而channels只产生一个迭代值。

Break和continue

像Java一样，GO许可break和continue指定一个标签，但标签上必须指的for, switch, 或者select 语句.

Switch 语句

在 switch 语句，case 标签默认情况下不通过，但你可以让他们 fallthrough语句结束的情况下通过了。

switch n {
case 0:  // empty case body
case 1:
    f()  // f is not called when n == 0.
}

但是一个case可以包含过个值

switch n {
case 0, 1:
    f()  // f is called if n == 0 || n == 1.
}

case的值可以支持任何类型的相等比较操作符，如字符串或指针。一个丢失表达式的switch语句 等价于表达式为 true。

switch {
case n < 0:
    f1()
case n == 0:
    f2()
default:
    f3()
}

++ 和 -- 语句

++和--只能作为后缀操作符，和仅在语句中，而不是在表达式中。例如，你不可以写n = i++。

defer语句

defer语句调用一个函数的执行被推迟到函数返回那一刻。defer语句执行时，被递延的函数的参数被计算，并保存，以备将来使用

f, err := os.Open("filename")
defer f.Close()  // f will be closed when this function returns.

Constants（常量）

GO中的常数可能是untyped的。这适用于无类型的常量表达式的数字文本，和使用const声明的无类型的常量表达式。当它被用在需要一个带类型的值的背景下，一个无类型的常量的可以被转变成有类型的值。这样常量的使用相对自由，即使Go没有隐式类型转换

var a uint
f(a + 1)    // The untyped numeric constant 1 becomes typed as uint.
f(a + 1e3)  // 1e3 is also typed as uint.

语言对非类型化的数字常量不限制大小。限制仅适用于使用一个常量时，其中一种类型是必需的。

const huge = 1 << 100
var n int = huge >> 98

如果是不存在的变量声明的类型和相应的表达式的计算结果为一个非类型化的数字常数，这个常数是被转换为 rune, int,float64, 或者complex128 类型，取决于该值是否一个字符，整数，浮点，或复杂的常数。

c := 'ä'      // rune (alias for int32)
n := 1 + 2    // int
x := 2.7      // float64
z := 1 + 2i   // complex128

GO 不存在枚举类型。相反，你可以使用特殊的名字iota在单一的const声明中从而得到一系列累加值。当初始化表达式省略为一个const，它重用了前面的表达式。

const (
    red = iota  // red == 0
    blue        // blue == 1
    green       // green == 2
)

Structs（结构体）

结构体对应于Java中的类，但一个结构的成员不能是方法，而是变量。结构体的指针是类似Java的的引用变量。与Java类不同的是，结构也可以被定义为直接值。在这两种情况下使用.来访问结构体的成员。

type MyStruct struct {
    s string
    n int64
}

var x MyStruct      // x is initialized to MyStruct{"", 0}.
var px *MyStruct    // px is initialized to nil.
px = new(MyStruct)  // px points to the new struct MyStruct{"", 0}.

x.s = "Foo"
px.s = "Bar"

在Go中，方法可以与任何命名的类型关联，而不仅仅是与结构体。详情见方法和接口的讨论。

Pointers（指针）

如果你有一个int或struct或者array需要分配对象的内容复制。 想达到Java的引用变量的效果，Go使用指针。对于任何类型e T,有一个相应的指针类型*T，表示指针类型 T的值

给指针变量分配存储空间，使用内置函数new，传入一个类型，并返回一个指针，指向分配的存储空间。分配的空间将被零初始化的类型。例如，new(int) 分配存储为一个新的int，初始化它的值为e 0，并返回它的地址，类型 *int。

Java代码T p = new T()，其中 T是一个两个int型实例变量a和b的类，对应于

type T struct { a, b int }
var p *T = new(T)

或者习惯性这样干

p := new(T)

var v T代表声明，声明了一个变量包含一个值类型 T，这在Java中是没有的。也可使用复合方式创建并初始化值。

v := T{1, 2}

等同于

var v T
v.a = 1
v.b = 2

对于类型T的操作数x，地址运算符 &x提供值类型为*T的x的地址，

===================未完待续.......==========

===================转载注明出处=============

2012-12-17

---