Enjoy Coding, Enjoy Life！

原本准备一天写一篇的，只是由于工作的原因，没有那么多时间看书，所以了解的东西自然也就相应的少了，也就没什么东西可写了。

看了一些Groovy的东西后，又有另一样东西吸引了我，那就是她的纯面向对象，呵，面向对象已经听了好多年了，而且也用了好多年了，但大家都知道，既使是我们熟悉的Java，也不是纯面向对象的，在Java里，同时存在着原类型和对象，而在Groovy里，却是一切皆为对象。

大家都知道，Java里是不能对原类型执行一些平时对对象所做的操作的，如toString()这些，如果想要这样做，则需将其转换成相对应的Wrapper，在Java里原类型相应的都有一些Wrapper，如int对应的java.lang.Integer。

虽然在Groovy里，你可能也会看到如Java里定义原类型一样的语句，如：

int i = 1

表面上是一样，但实际上，她还是会把变量转换成类似于Java里的Wrapper类型的，也就是说，你可以对变量i执行如toString()这些在Java不能对原类型执行的方法。原因就是因为在Groovy里一切皆为对象，呵，是不是很吸引人？

与Java相似，在定义基本的数据类型时，可以直接根据字面指定，如：

Integer -> 100
Long -> 100L/100l
Float -> 100F/100f
Double -> 100D/100d

在这里比Java多了两个可以直接由字面表示的类型：

BigInteger -> 100G/100g
BigDecimal -> 100.123G/100.123g

在数据后加G(or g)来标识这两种类型。

BigDecimal为非整型的数字的默认类型，如果不使用Float和Double的后缀标识，如F或D，将使用BigDecimal。

在Groovy里定义变量也有很趣，可以有两种方式，一种是定义静态类型，也就是在定义之初就指定变量的类型，如：

int i = 100
String s = "hello"

还有一种，则是动态类型，在定义的时候不指定其类型，之后可以随意的更改此对象的类型，如：

def i = 100
i = "string"
i = true

在Java里，一些操作符，如+, -, *, /这些，只是对原类型数据进行操作的，虽然个别的也可以由其他类型使用。但在Groovy里，这些对应的全是方法，这样的写法只是一种简写，它还会调用相应的类里面的方法的，如100+200，其实是调用100.plus(200)；100-200调用的是100.minus(200)。所有的这些，都是对方法的调用。

在Groovy里，这些操作符将不再是原类型的专用，你完全可以执行这样的操作：

Person p1 = new Person()
Person p2 = new Person()
Person p3
p3 = p1 + p2
p3 = p1 - p2
p3 = p1 * p2
p3 = p1 / p2
println p1 == p2

执行上面的例子的前提是Person类实现了相应的方法。这里只是随便瞎写一个例子，一点实际意义都没有。另外，在重载equals时，最好复写hashCode方法，重载这个方法已经不新鲜了，参见java.lang.Object#equals，在这里一块写出来，只是为上说明，可以直接用==操作符来简写equals方法的调用。

class Person {
	private String name
	
	Person() {}
	
	Person(name) {
		this.name = name
	}
	
	Person plus(Person b) {
		if (null == b) return null
		return new Person(this.name + " + " + b.name)
	}
	
	Person minus(Person b) {
		if (null == b) return null
		return new Person(this.name + " - " + b.name)
	}
	
	Person multiply(Person b) {
		if (null == b) return null
		return new Person(this.name + " * " + b.name)
	}
	
	Person div(Person b) {
		if (null == b) return null
		return new Person(this.name + " / " + b.name)
	}
	
	Person mod(Person b) {
		if (null == b) return null
		return new Person(this.name + " % " + b.name)
	}
	
	Person power(Person b) {
		if (null == b) return null
		return new Person(this.name + " ** " + b.name)
	}
	
	boolean equals(Object b) {
		if (null == b) return false
		if (!(b instanceof Person)) return false
		if (this.name != b.name) return false
		return true
	}
	
	int hashCode() {
		return this.name.hashCode()
	}
}

看到这些，让我想起在学C++时最讨厌的运算符重载，呵呵，不过在这里确实是存在的。

在Groovy里，可以重载的方法有很多，可以相阅相关的资料来了解，在《Groovy in Action》上有详细的列表。

虽然这对于Java是一个进步，但我却不是很喜欢这种方式，因为要实现＋，我在程序里要实现的却是plus方法，而在Ruby里，直接实现+就OK了，或许是因为历史原因吧，还没有深入的研究，不过猜想应该是Java的罪过。

虽然人家都说，时间就像乳沟一样，挤挤总会有的，但这段时间确实是太忙了，所以进度也是奇慢无比，只能给自己一个借口，美其名曰：小步前进。呵