Groovy07_Groovy动态语言

动态类型语言中的类型是在运行时判断的，方法以及其实参也是在运行时检查的。
在使用过程中不会执行类型检查，可以通过TypeChecked开启类型检查。
同时由于使用动态节点调用，损耗性能，可以使用CompileStatic开启静态编译。

1. 和java的差异

groovy

def i = new File("")
println i.getParent()

java

public class lsn_7_0 {

    public static void main(String[] args){
        Object file = new File("");
        file.getParent();

    }
}

没运行的情况下，groovy 没报错，java代码报红了,这就是groovy的动态性

2. @TypeChecked

class Person{
    def dream(){

    }
}

class Zeking extends  Person{
    def dream(){

    }
}

@TypeChecked   //  检查调用的时候没出错，虽然可以检查，但是会牺牲掉groovy这个语言的动态性
class Test{
    @TypeChecked(TypeCheckingMode.SKIP) // 跳过 不检查
    void func(Person person){
        person.dream()
    }
}

def test = new Test()
test.func(new Zeking())     // Zeking dream..
test.func(new Person())     // Person dream..
//test.func('')             // 报错

void func2(person){
    if(person.respondsTo('dream'))      // 判断是否实现了dream方法
        person.dream()
}

println new Zeking().hasProperty('name') // 看有没有name的属性 --> null

func2('')

3. 性能对比@CompileStatic

def start = System.nanoTime()
for(i in 0..10000000){

}

def end = System.nanoTime()
println ((end - start)/1.0e9)  //0.026931463 秒

@CompileStatic      // 编译静态，关闭groovy动态性
class Test3{
    static void main(args){
        def start = System.nanoTime()
//        for(i in 0..10000000){
//
//        }
        for (int i = 0 ; i < 10000000 ; i++){

        }

        def end = System.nanoTime()
        println ((end - start)/1.0e9)  // 不使用CompileStatic ：0.00736590
                                        // 使用CompileStatic：  0.003350236 有提升，还是比不上ava，差距不大
    }
}

// grovvy 的类 都实现GroovyObject接口，

public class lsn_7_0 {

    public static void main(String[] args){
        long start = System.nanoTime();
        for (int i = 0 ; i < 10000000 ; i++){

        }
        long end = System.nanoTime();
        System.out.println(((end - start)/1.0e9)); // 0.002163498秒

        // java比groovy快，因为groovy的动态性，需要动态的找一个个节点，会牺牲掉他的一部分性能
    }
}