对象
首先创建一个 Person 类
class Person {
String name;
Integer age;
/**
* 定义方法 ，def 代表的就是 object
* @param years
*/
def increateAge(Integer years) {
this.age += years;
}
上面我们定义了一个 Person 类，注意他和 java 类还是有所不同的。区别如下：
1，groovy 中的所有类 都继承自 GroovyObject
2，groovy 中的所有 class ，方法等都是 public 类型的
接着看一下使用：
def Person person = new Person(name: "张三", age: 20);
println "the name is ${person.name} ， the age is ${person.age}"
尽管没有构造方法，但是在 groovy 中依然可以进行赋值，而且是想给那个就给那个赋值
还有一点要注意：最后一行的打印语句使用的是 .name 和 .age , 在 groovy 中，无论直接使用 . 字段或者是 get / set 方法，最终调用的都是 get / set 。
接口
首先定义一个接口
interface Action {
void eat()
void drink()
void play()
}
其实这和 java 中的接口基本一样，没有多大区别 。但是需要注意的是在 groovy 中定义的接口方法不能是 protected 类型的。其他的基本都一样
trait
我感觉 trait 是介于接口和抽象之间的。他内部可以定义抽象方法，也可以定义具体的实现方法。如下：
trait DefaultAction {
//抽象类型
abstract void eat()
//空实现
void pay() {
println 'i can pay'
}
}
如果你有一个接口，接口中的方法非常多。而实现类只用到了一个特定的方法，这种情况就会造成代码非常臃肿，这种情况就可以使用 trait。只需要将特定的方法抽象即可其他的默认实现即可。
元编程
说白了就是运行时期的一个策略。例如调用一个对象的某一个方法，如果这个方法不存在，编译器也不会报错，而是通过一系列的查找最终确定是调用还是抛出异常，下面就是简化后的流程：
这里我们来实现一下这个过程，我们从底部往上看，这样比较简单，首先还是一个 Person类：
class Person {
String name;
Integer age;
}
这里并没有任何方法，我们创建一个对象，并调用一个不存在的方法，如下：
def Person person = new Person(name: "张三", age: 205);
person.cry()
调用 cry 方法后编译器没有任何报错，但是运行时会报错如下：
Caught: groovy.lang.MissingMethodException: No signature of method: variable.Person.cry()
下面在 Person 中重写一个方法 invokeMethod ，如下：
/**
* 一个方法找不到时 ，会调用这个方法
* @param name
* @param Object
* @return
*/
def invokeMethod(String name, Object) {
println "the name is ${name} ， the age is ${age}";
}
接着在运行一下：
the name is cry ， the age is 205
就会发现没有报错，虽然没有 cry 方法，但是 invokMethod 方法被执行了。当某个方法找不到的时候这个方法就会被执行。
接着继续重写一个方法：methodMissing
/**
* 比 invokeMethod 优先级高，如果重写了此方法，则 invokeMethod 不会调用
* @param name
* @param args
* @return
*/
def methodMissing(String name, Object args) {
println "this missing ${name}"
}
结果如下：
this missing cry
这个方法会在 invokeMethod 之前执行，如果执行这个方法，invokeMethod 不会被带调用，这个方法在 倒着第二层
MetaClass
metaClass 元类，通过它我们可以给某一个类动态的添加字段，方法，静态方法。下面分别实现一些
动态添加属性
Person.metaClass.sex = 'male' //添加属性
def Person per = new Person(name: "张三", age: 205);
per.sex = 'female'
println "the new sex is:" + per.sex;
//结果：the new sex is:female
动态添加方法
//添加属性
Person.metaClass.sex = 'male'
//为类动态的添加方法
Person.metaClass.sexUpperCase = {
->
//将 sex 转为大写，这个方法 String 中的方法
sex.toUpperCase()
}
def Person per = new Person(name: "张三", age: 205);
//调用动态添加的方法
println per.sexUpperCase()
//结果：MALE
动态添加静态方法
Person.metaClass.static.createPerson = {
String name, Integer age ->
//创建对象
return new Person(name: name, age: age)
}
Person pe = Person.createPerson("张三",20)
println pe.name + "----" + pe.age
//结果 :张三----20
通过这种动态的注入有什么好处呢：例如你你使用了某个第三方库，想要添加某些方法，这个时候就可以使用这种方法来实现，而不用新建一个类去继承他。特别是某些类被修饰为 final ，那我们更不可能去修改他的内容了。但是通过这种方法可以，如下：
//注意，这里需要初始化一下，否则无法确定其类型
String.metaClass.lv = '';
String string = "String"
string.lv = "我是自定义属性"
println string.lv
//结果：我是自定义属性
当然，这个动态创建的方法等都不是全局的，在别的类中如果用就需要重新注入。的确，groovy 提供了设置全局的方法，下面通过一个例子来看一下：
首先，还是一个 Person 类。
class Person {
String name;
Integer age;
}
接着是 PersonManager 类
/**
* PerSon 管理类
*/
class PersonManager {
static Person createPerson(String name, int age) {
//调用 Person 不存在的方法
return Person.createPerson(name, age)
}
}
上面调用一个不存在的方法。
class ApplicationManager {
static void init() {
//设置全局
ExpandoMetaClass.enableGlobally()
//创建 Person 静态方法
Person.metaClass.static.createPerson = {
String name, Integer age ->
return new Person(name: name, age: age)
}
}
}
在 init 方法中设置全局，动态注入了一个静态方法，获取 Person 对象。最后看一下使用：
class Entry {
public static void main(String[] args) {
println '应用程序正在启动'
//初始化
ApplicationManager.init()
println '应用程序初始化完成'
def person = PersonManager.createPerson("张三", 20)
println person.name + "----" + person.age
}
}
最终结果如下：
应用程序正在启动
应用程序初始化完成
张三----20
可以看到通过动态注入的静态方法创建了 Person 对象
plicationManager.init()
println ‘应用程序初始化完成’
def person = PersonManager.createPerson("张三", 20)
println person.name + "----" + person.age
}
}
最终结果如下：
```java
应用程序正在启动
应用程序初始化完成
张三----20
可以看到通过动态注入的静态方法创建了 Person 对象
