Groovy面向对象一

        类型

        与Java一样，Groovy包括8种原始类型，整形：byte、short、int、long；浮点型：float、double；布尔型：boolean、字符型：char。Groovy与Java一样在需要的时候可以自动装箱，将原始类型包装成对应的包装类。

        类

        Groovy类与Java类非常类似，并且两者在JVM级别上是兼容的。类中有方法、字段和属性。类和类成员有相同的修饰符：public、protected、private、static等。
        Groovy和Java的区别在于：Groovy中类和方法如果没有显示的修饰符，默认为public。没有修饰符的字段会自动转为属性，类不需要与源文件名相同，但是大多数情况下还是建议相同。一个源文件可以包含一个或多个类，如果文件中包含任何不在类中的代码就认为是脚本。脚本只是带有一些特殊约定的类，并且具有与源文件相同的名称，所以不要在脚本中包含与脚本源文件同名的类定义。

       普通类

       普通类指的是顶级的具体类，可以在没有其他类或脚本的限制下实例化，所以它们都是public的。可以通过使用new关键字调用它们的构造方法来实例化类。

       内部类

        内部类定义在其他类中，封闭类可以正常的使用内部类，内部类也可以访问封闭类的成员，即使是私有的。内部类通常是一些接口的实现，以便外部类使用接口的方法。

        匿名内部类

        匿名内部类是没有名字的内部类。有些内部类只需要使用一次，因此没有必要定义新的类，可以是用匿名内部类。

        抽象类

        抽象类不能被实例化，不能被创建为子类，抽象类的成员包括字段或属性，抽象或具体的方法。抽象方法没有具体实现，需要子类去实现。抽象类和抽象方法需要用abstract关键字声明。

        接口

        接口只定义需要实现的方法列表，但没有定义方法实现。实现接口的类需要实现这些方法。接口使用interface关键字进行定义。接口方法必须是public的，如果是protected或private，编译时会报错。接口还可以继承其他接口。一个类做为一个接口的实现必须是显示的，如果一个类实现了接口的所有方法，但是没有显示声明实现接口，那么这个类不会被认为是接口的实现。但是在Groovy中，通过as强制转换运算符，可以将一个类的实例在运行时做为一个接口的实现。Groovy接口不支持Java8接口中的默认实现。

class Foo {
  static int i
}

assert Foo.class.getDeclaredField('i').type == int.class
assert Foo.i.class != int.class && Foo.i.class == Integer.class


//普通类
class Person {                       

    String name                      
    Integer age

    def increaseAge(Integer years) { 
        this.age += years
    }
}
def p = new Person()
//内部类
class Outer {
    private String privateStr

    def callInnerMethod() {
        new Inner().methodA()       
    }

    class Inner {                   
        def methodA() {
            println "${privateStr}." 
        }
    }
}

class Outer2 {
    private String privateStr = 'some string'

    def startThread() {
       new Thread(new Inner2()).start()
    }

    class Inner2 implements Runnable {
        void run() {
            println "${privateStr}."
        }
    }
}
//匿名内部类
class Outer3 {
    private String privateStr = 'some string'

    def startThread() {
        new Thread(new Runnable() {      
            void run() {
                println "${privateStr}."
            }
        }).start()                       
    }
}
//抽象类
abstract class Abstract {         
    String name

    abstract def abstractMethod() 

    def concreteMethod() {
        println 'concrete'
    }
}
//接口
interface Greeter {                                         
    void greet(String name)                                 
}

class SystemGreeter implements Greeter {                    
    void greet(String name) {                               
        println "Hello $name"
    }
}

def greeter = new SystemGreeter()
assert greeter instanceof Greeter

interface ExtendedGreeter extends Greeter {                 
    void sayBye(String name)
}

class DefaultGreeter {
    void greet(String name) { println "Hello" }
}

greeter = new DefaultGreeter()
assert !(greeter instanceof Greeter)

class DefaultGreeter {
    void greet(String name) { println "Hello" }
}

greeter = new DefaultGreeter()
assert !(greeter instanceof Greeter)