JVM语言之Groovy第一篇

写在前面的话
时至今日，Java在面向对象编程语言领域依然处于绝对领先的水平。Java现在无处不在，尤其是服务器领域，在这个领域编写web应用、报文系统和服务器基础架构。现在，Java程序员数量的庞大和Java程序员的需求数量也是情理之中的事情。总之，Java是一个绝对成功的故事。

既然Java如此好，我们为什么又要学习Groovy呢？这个Groovy号称Java的动态伴侣，他又是怎么样的一回事呢？

工欲善其事，必先利其器
注意：学习Groovy是假定有Java基础的程序员学习的。
安装Groovy：
1、首先，JDK必须安装完成，环境变量设置无误。检测方法就是在终端完成java -version、java、javac等命令
2、其次，安装Groovy。进入网址：http://www.groovy-lang.org/download.html 根据自己操作系统选择不同的安装方式。这里给出Mac的安装命令：

curl -s get.sdkman.io | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install groovy
groovy -version

依次执行上面4条命令，就可以完成Groovy的安装。
3、等价于第2步的安装手段，直接使用Mac自带的命令：

//方法一
brew install groovy
//方法二
sudo port install groovy

4、上面任一种方式完成以后都只能在终端编写Groovy程序，严重影响编码体验。于是，默认使用Eclipse4.6+Groovy。同样默认用户已经安装了Eclipse4.6。在这个网址下面有插件在线安装的地址：
https://github.com/groovy/groovy-eclipse/wiki

为何Groovy也叫JVM语言？
这是因为，无论是test.java源码还是test.groovy源码，都实现编译成bytecode，然后在JVM中解释执行。所以，Groovy和Java同属于JVM语言。

Java语言的“瑕疵”特性
Java是静态类型；
Java的所有方法都必须属于某一个类；
Java禁止运算符重载；
Java的属性和方法的默认访问权限是包级私有；
Java区分原始数据类型和类类型。
上面的5个特性都会随着时间的推移，会让Java显得越来越矛盾和冗余。

静态类型是一个bug还是一种特性？
静态类型的意思就是在声明变量的时候必须同时说明变量的类型。
JVM在执行时候的动态绑定，也就是存在多态机制的根本原因。
静态类型和动态绑定使得Java在编译时候可以很快发现错误和异常。
静态类型也使得IDE的自动提示功能更加的便捷。
但是，静态类型使得变量之间的赋值变得很严格，不利于代码编写。
动态类型Groovy中关键字def就可以完成不在乎类型的时候简便用法。

方法必须属于某一个类
在Java里面名词，也就是类是一等公民；动词，也就是方法是二等公民。而且，二等公民必须依托于一等公民才能生存。
举个例子：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortStrings{
    public static void main(String args[]){
        //实例化
        List<String> strings = new ArrayList<String>();
        //填充数据
        strings.add("this");
        strings.add("is");
        strings.add("a");
        strings.add("list");
        strings.add("of");
        strings.add("strings");
        //排序
        Collections.sort(strings);
        System.out.println(strings);
    }
}

每一步都是不可缺少的，并且所有的操作都在类里面。并且，上述的排序还只是一个默认的字典顺序，如果需要按照字符串的长度排序呢？那么我们还需要再写一个类，如下例：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StringSorter{
    public List<String> sortLexicographically(List<String> strings){
        Collections.sort(strings);
        return strings;
    }

    public List<String> sortByDecreasingLength(List<String> strings){
        Collections.sort(strings, new Comparator<String>(){
            public int compare(String s1, String s2)
            {   
                return s2.length() - s1.length();
            }
        });
        return strings;
    }
}

上面的两个例子都只为了一个String集合的排序，先写类，再写方法，写了方法还要写匿名内部类，很是繁杂。
下面是Groovy的写法：

def strings = {'this','is','a','list','of','strings'}
Collections.sort(strings,{s1,s2 -> s2.size() - s1.size()} as Comparator)
assert strings*,size() ==[7,4,4,2,2,1]

相比Java代码而言，这类没有类作为外壳，只有简单的3行代码。其实和Python、Swift和Kotlin的风格是一样的。这就是大名鼎鼎的函数式编程。把函数也当成对象使用。

Java的冗长证明
直接看例子：

import java.util.Date;

public class Task {

    private String name;
    private int priority;
    private Date startDate;
    private Date endDate;

    public Task(String name, int priority, Date startDate, Date endDate) {
        this.name = name;
        this.priority = priority;
        this.startDate = startDate;
        this.endDate = endDate;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public Date getStartDate() {
        return startDate;
    }

    public void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    @Override
    public String toString() {
        return "Task [name=" + name + ",priority=" + priority + ",startDate=" + startDate + ",endDate=" + endDate;
    }

}

这个类很冗长，但这就是Java的特性。
改写成Groovy以后：

import groovy.transform.EqualsAndHashCode

@EqualsAndHashCode
class Task {
    String name
    int priority
    Date startDate
    Date endDate

    String toString(){
        "($name,$priority,$startDate,$endDate)"
    }
}

对比一下，Groovy和Java的优缺点就明显了。

Groovy的特性使Java更加方便
Groovy为已经存在的Java添加新功能；
Groovy使用Java类库；
Groovy处理XML和JSON更加方便；
Groovy简化数据库操作；
Groovy支持元数据编程；
Groovy可以为Java代码测试；
Groovy有更多的编译工具，Ant、Maven、Gradle；
Groovy为基础的Grails可以进行快速Web开发。

结语
学习Groovy，让Java更加美好。

JVM语言之Groovy第一篇

猜你喜欢