越来越有意思的地方在于Grails使用的不是源生的Java语言,配置Groovy开发条件(Windows)

这篇文章看完只是对Groovy有所精晓,只是作为学Gradle的放权知识。
设置难题请看布局Groovy开发条件(Windows)

HELLO!我们好!小编是咕噜大大,专注编制程序和独立30年!

简史

Groovy的一.0本子宣布于200七年二月六日。
二〇一二年的年中,Groovy的二.0版本公布了。
近年来最新版本是二.肆.4。

尊重原创,请我们转发时申明该作品来源:http://blog.csdn.net/ymh198816/article/details/43817435

Java的东西Groovy都能用,包罗语法和类库

诸如,新建一个SuperTest.groovy
输入一下Java代码:

public class SuperTest {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println("Java的东西Groovy都能用");
        }
        System.out.println("随便输入点啥试试");
        Scanner sc = new Scanner(System.in); // 不需要导入java.util包
        String str = sc.next();
        System.out.println("你刚才输入了:" + str);
    }

}

运维结果:

Java的东西Groovy都能用
Java的东西Groovy都能用
Java的东西Groovy都能用
随便输入点啥试试
放开那条PM,让如花来
你刚才输入了:放开那条PM,让如花来

近来自家的BOSS要起来一个新的电商项目,并初始定下开发语言为Java,因为扩充性好,安全性高,再拉长中华夏族民共和国满大街的Java开发人士和多样的Java开发资料,都让大家以为在人力能源和花费方面会相比有保险。可是后来我们在规定支付框架的时候就拿不定主意了,有局地人觉着应当使用最近周围流行的SSH框架(Struts二+Spring+Hibernate),
还有一对人希望接纳未来发展不慢的Grails框架,因为Grails是三个站式服务的框架,开发进程会比SSH框架越来越快。但难题是在中原运用和询问该框架的人少得老大,而且又是七个比较年轻的框架,稳定性和扩展性都急需通过岁月的考验和积聚,半数以上人或许持阅览的千姿百态。越发有意思的地点在于Grails使用的不是源生的Java语言,而是利用Groovy来作为该框架的支付语言。刚好近年来在做Grails框架的调查商量,所以就顺手写1篇Groovy的入门教程,希望能支援越多的人精晓Groovy那门语言。

机关导入常用包

在地点的例证里使用了Scanner却不须求导入java.util包,是因为Groovy自动导入下列包:
java.lang
java.util
java.io
java.net
java.math.BigDecimal
java.math.BigInteger
groovy.lang
groovy.util

依照Groovy的法定文书档案对该门语言的介绍,大家得以了然到Groovy有如下特点:

Groovy特点

从以上Groovy能够执行Java的例证能够感受到到以下八个特色:

  • Groovy继承了Java的持有东西,正是你突然忘了Groovy的语法能够写成Java代码,也等于Groovy和Java混在共同也能执行。
  • Groovy和Java一样运行在JVM,源码都以先编写翻译为class字节码。

除了,Groovy又对Java的语法举办了简化,成效拓展了增添。那些得学了实际语法才能感受到,可是可以先来感受下和Groovy比较Java有多啰嗦,就拿地方的大循环一次的例子来说,以下的代码达成了1样的效应:

for (i in 0..2) {
    println 'Java的东西Groovy都能用'
}

或者

3.times {
    println 'Java的东西Groovy都能用'
}

———————–开首语法内容———————–

  1. Groovy是运营在JVM(Java Virtual
    Machine)上的敏捷的动态语言,所以Groovy也是1门弱类型的语言,并且能够直接编写翻译成Java字节编码,运维在别的具有Java运营环境(JVM)的设施上。

关键字

<code>
as、assert
break
case、catch、class、const、continue
def、default、do
else、enum、extends
false、finally、for
goto
if、implements、import、in、instanceof、interface
new、null
package
return
super、switch
this、throw、throws、trait、true、try
while
</code>

二.
放弃了Java语言中少部分存在争执和不便利神速开发的片段,并结成了Ruby和Python等别的语言的不错本性,像动态类型,闭包等,使得Groovy那门语言对开发职员越发温馨并不难维护。

语句不需求分号结尾

写了也清闲

  1. 能和拥有的Java类库无缝过渡。

注释

// 单行注释
println "hello groovy," /* 我是块注释 */ + "my name is xuhongchuan."

hello groovy,my name is xuhongchuan.

四.
多数语法和特点和Java类似,使得Java开发人士对Groovy那门语言的求学曲线近乎为零。

标示符

和Java一样:
建议只用字母、数字、美金$和下划线组成。
以字母,英镑符号$或许下划线
发端,不可能以数字起先。

  1. 新投入Assert方法,方便程序员做单元测试

概念变量

用def定义变量,不写def也行。
概念变量不用钦定数据类型且能够随心所欲更换。

def var1 = 1024
var2 = "def不写也行"

var1 = "Integer 改 String"

安装GROOVY

定义方法

定义方法也是用def当然也足以不写。

// 使用def
def String getName() {
    return "许宏川"
}

// 不写def
String getName() {
    return "许宏川"
}

Groovy全数的章程都有重临类型,假使不写则赶回null,未有void。重返类型能够简不难单不写,不写的话自动取于最终1行代码的体系。
不写返回类型的办法就亟须抬高def。
除此以外return也能够归纳不写,都是取最终壹行。

def getName() {
    "许宏川"
    1234 // 这行是最后一行,返回Integer
}

情势参数类型可写可不写

// param1写了数据类型, 调用时必须传进来String参数
// param2没写数据类型,调用时可以传进来任意类型的参数
def getString(String param1, param2) {

}

接下去大家伊始介绍Groovy的设置方式(MAC OS):

public是暗许的

Groovy的类和章程的暗中认可修饰符都以public,且能够简简单单不写。由于修饰符能够简单、方法重返类型能够简单、方法参数类型能够省略。所以Java的类和main方法的组织能够简化为:

class SuperTest {

    static main(args) {

    }

}

居然也得以不写类和main结构,间接写main方法里的代码。编写翻译成class文件时会自动给添加上。

  1. 打开你的Ternimal,并输入以下命令设置你系统中Groovy的binary文件地址:

字符串

分二种,单引号,双引号和三引号两种。

  • 单引号是输入什么正是怎么着。
    例如:

println('my name is $ xuhongchuan')

打印结果为:

my name is $ xuhongchuan

$也平常打字与印刷出来了。

  • 而双引号能够用$引用变量的值。
    例如

name = "xuhongchuan" 
println("my name is $name")

打字与印刷结果为:

my name is xuhongchuan
  • 三引号是出口壹段文本,能够平素的加空格和换行。
    例如:

println('''这是一段文本。
换行啦!!!
    前面有四个空。。。
有换行啦!!!!''')

打字与印刷结果为:

这是一段文本。
换行啦!!!
    前面有四个空。。。
有换行啦!!!!

那几个好啊,想想写sql语句时可随便换行有多舒畅(英文名:Jennifer)。

>> export
GROOVY_HOME=~/your/groovy/path

数据类型

分基本数据类型、容器和闭包三种。

2.
并将GROOVY_HOME/bin配置进系统中path环境中,并写进bash文件中,那样就能在terminal中调用Groovy相关的授命

着力数据类型

Groovy是纯面向对象的言语,未有Java里的byte、int、double、boolean等七个值类型。不过有照应的卷入类如Integer、Double和Boolean。在那之中整数暗中同意是Integer,浮点数暗中同意是。。。你想就是Double?不,是BigDecimal。
万1想显式钦定Long类型,在末端加L,Double则加D。

var = 5
println var.class

var = 5.5
println var.class

var = 5L
println var.class

var = 5D
println var.class

var = 'hehe'
println var.class

var = false
println var.class

出口结果为:

class java.lang.Integer
class java.math.BigDecimal
class java.lang.Long
class java.lang.Double
class java.lang.String
class java.lang.Boolean

>> GROOVY=$GROOVY_HOME/bin

容器类

分List、Map和Range。

  • List

def demoList = [121, 3.14, 'hello', false, null] // 使用[]定义,元素之间用,隔开
println demoList.size // 获取集合大小
prinltn demoList[2] // 获取index为2的元素
// 在结尾添加元素的两种写法
demoList.add(100) 
demoList << 100
//在指定位置添加元素,原本index大于等于3的元素往后退一位
demoList.add(3, 100)
demoList.remove(0) // 删除指定index的元素
demoList -= [3.14, false] // 删除某集合的元素
demoList.clear() // 清空集合
// 使用集合直接调用.each可以对集合进行遍历
demoList.each {
    println it // it是迭代过程中的每一个元素
}
  • Map
    使用[key : value]概念,成分之间用,隔开。
    key必须是String,也足以不加引号自动转为String。

def demoMap = ['name' : '许宏川', 'age' : 18, 'isGay' : false]
println demoMap.size() // 获取map大小
println demoMap.name // 通过key获取值
demoMap << ['hehe' : '777'] // 添加元素
// 遍历map
demoMap.each {
    println it.key
    println it.value
}
  • Range

// 范围从1到10
def demoRange = 1..10
// 范围从1到9
def demoRange2 = 1..<10
println(demoRange2.from) // 获取起始值
println(demoRange2.to) // 获取最大值

>> echo “export PATH=$GROOVY:$PATH” >>
~/.bash_profile

闭包

闭包是1段代码块,注意闭包也是数据类型,所以能够把闭包作为艺术的参数大概重临类型。
即便我们要筛选钦点数n范围内的奇数,普通写法如下:

def getOdd(n) {
    for (i in 1..n) {
        if (i % 2 != 0)
            println i
    }
}

getOdd(10)

一旦要得到偶数,又要再写一个格局:

def getEven(n) {
    for (i in 1..n) {
        if (i % 2 == 0)
            println i
    }
}

getEven(10)

那四个章程其实for循环部分的始末是重合的。
而只要用闭包就不会如此了,例如下边包车型大巴pick接受三个参数,1个参数n,其它二个是闭包(closure是变量名随便取)。再重复1次闭包是二个代码块,那里传进来你想在遍历进度做哪些。至于怎么把便民进程的i传递给闭包,闭包有一个隐式变量叫it,能够接过一个参数。
看代码:

def pick(n, closure) {
    for (i in 1..n) {
        closure(i)
    }
}

// 打印奇数
pick(10, {
    if (it % 2 != 0) // it代表传进来的参数,也就是上面closure(i)的i
            println it
})

// 打印偶数
pick(10, {
    if (it % 2 == 0)
        println it
})

一句话来说循环结构不要求协调写了,你只须要写你想在遍历进程中做哪些,例如尽管要打字与印刷全体数的平方能够那样:

// 平方
pick(10, {
    println it **= 2
})

以此时候善于思考的同校就要问了,作者还要本身写那个作为?
亲,那不正是动态的吸引力么,什么人知道你要在遍历进度做怎么样吗?不过假诺有部分作为是时常用的,你也给闭包取个名字固定下来啊就好像定义变量一样。
例如假如把刚刚的的打字与印刷奇数、打字与印刷偶数和打字与印刷平方定义成变量能够改成那样:

def pick(n, closure) {
    for (i in 1..n) {
        closure(i)
    }
}

// 打印奇数
def getOdd = {
    if (it % 2 != 0)
        println it
}

// 打印偶数
def getEven = {
    if (it % 2 == 0)
        println it
}

// 打印平方
def getSquare = {
    println it **= 2
}

pick(10, getOdd)
pick(10, getEven)
pick(10, getSquare)

本条时候,善于思虑的同窗又要问了,隐式变量it只好表示二个参数吧?闭包怎么接收七个参数?
是那样的,用 ->
把参数列表和作为隔绝即可。若是大家定义一个闭包接受四个参数求他们的和:

def getSum = {
    x, y -> println x + y
}

getSum(3, 4) // 闭包可以直接调用

有关闭包还有个说的,正是只要你的闭包不须要吸收参数,但是如故会自动生成隐式it,只可是它的值为null。相当于说,闭包至少含有三个参数。

接下去重启你的terminal,然后输入
>>groovysh,如果你看见下面的画面,那么证明你的GROOVY安装成功了!!!

而是上边会有3个警示:????: Module [groovy-nio] – Unable to load
extension class [org.codehaus.groovy.runtime.NioGroovyMethods]
貌似是未有大功告成加载某些class,求大拿提供化解方案和解释一下原因图片 1图片 2图片 3自身是弱鸡图片 4图片 5图片 6

GROOVY的ECLIPSE插件下载地址:

传送门:http://marketplace.eclipse.org/content/groovygrails-tool-suite-ggts-eclipse-luna-44

GROOVY文件示例:

package com.groovy.fundamental
import java.util.Date;


class basicGrammar {
    def my_list = [3.1415926, "Hello World!!", new Date()];
    def my_map = ['firstAttr':'咕噜大大','secondAttr':11.11,'thirdAttr':my_list];

        basicGrammar() {
           super();
        }

        public void printList_java() {
        println my_list.getClass();
        assert my_list.get(1) == "Hello World!!";
    }

    def printList_groovy() {
        println my_map.getClass();
        assert my_map.get('thirdAttr')[1] == "H World!!";
    }


    static main(args) {

        def test = new basicGrammar();

        test.printList_java();
        test.printList_groovy();

    }
}

从下面二个核心的groovy文件中,

一.大家得以发现groovy能够像Java一样选取包管理机制,同时仍可以够引进各类Java工具类;

2.
groovy文件中得以让Java和Groovy语法混合使用,因为Groovy最后也是编写翻译成Java的字节码文件,它事实上也是一种Java文件,但投入了祥和的壹对特征;

  1. 类的概念就像Java1样;

  2. 运用def来定义变量,并依照变量的值来动态改变变量的门类;

伍.
定义main方法时,不用注明方法的功效域,暗中认可为public,也能够不用注解方法的回来参数类型,同时方法中参数也足以不用评释类型,因为Groovy本人正是2个弱类型的言语。类中的构造函数也就好像;

  1. 包蕴了assert方法,方便去做单元测试。

图片 7

从上边输入的剧情大家能够瞥见Groovy中提供的assert方法充足有力和实际,同时,Groovy中的list对象和map对象分别是java.util.ArrayList对象和java.util.LinkedHashMap对象

**部分可比重大的GROOVY语法:**

Groovy中定义的最珍视的两种数据类型,1种是list(java.util.ArrayList)类型,另一种则是map(java.util.LinkedHashMap)类型,当中list类型在groovy中得以1对一Java的数组来利用

定义list:

def my_list = [3.1415926, "Hello World!!", new Date()];

定义map:

def my_map = ['firstAttr':'咕噜大大','secondAttr':11.11,'thirdAttr':my_list];

使用for循环:

for(content in my_list) {
    println content;

    }

运用range变量,用法基本与与python的range变量相同:

def myRange = 0..5;

    for(content in myRange) {
            print content;
        }

输出结果:012345

在Groovy中,你能够用“{}”定义三个”方法”来作为二个目的,并像3个String值或int值一样传入二个变量中,那即是闭包函数;在Groovy中三个闭包函数也是多少个可被调用的点子:

def my_closure = {param -> println("hello ${param}");println("你好,世界!!")};
my_closure.call("咕噜大大");

1旦不定义闭包函数的参数,则Groovy暗中认可会使用“it“来取代那么些参数:

def my_closure = {println("hello"+it);println("你好,世界!!")};
my_closure.call("咕噜大大");

闭包函数能够看作其他方法里的参数:

def fun(int i, Closure c) {
  c.call(i)
}

使用each函数合作闭包函数循环list对象,与Jquery中的each方法类似,同时也正是each()和闭包函数的成效,list和map的长度就不那么重大了,它们得以不用for循环就能取出在那之中装有的值了:

["咕噜大大", "萌萌哒", "棒棒哒"].each({ item -> print item })

并且,要是闭包函数是格局里最终的二个参数,那么闭包函数能够写在章程的括号外面

["咕噜大大", "萌萌哒", "棒棒哒"].each(){ item -> print item }

又因为Groovy中调用方法时,在不引起歧义的事态下方法后边的括号能够简单

["咕噜大大", "萌萌哒", "棒棒哒"].each { item -> print item }

关于字符串的拍卖差不多和Java的String
class①模1样,可是Groovy中新添加了“toInteger()”的方法:

println "2014".toInteger();


Groovy和Java的区别

对此定义的浮点数变量,Groovy不会将它们创制成Float或Double对象,默许下为Groovy自个儿定义的花色
BigDecimal,除非您来得地将该变量钦赐为Float或Double对象

def my_number = 3.14

在Groovy中您不可能再像Java一样用“{}”去定义数组,反而你要用list去顶替原先Java中的数组

<pre name="code" class="java">String[]  myArray = {"咕噜大大","萌萌哒"};  这是错的!!!

String[]  myArray = ["咕噜大大","萌萌哒"];  这才是对的!!!!

Groovy中的“==”相当于Java中的“equals()”;Groovy中“.is()”相当于Java中的“==”,用来相比两个指标是否分外;

def x = 5;
def y = 5; 

<pre name="code" class="java">    if(x == y) {
    println("在X == Y条件中x和Y的值相等!");
    } else if (x.is(y)) {
    println("在X is Y条件中X和Y是同一个对象!");
    }

输出结果是:在X == Y条件中x和Y的值相等!          

在Groovy中你能够不写分号,但会挑起部分谬误,比如说:

class Trial {
  private final Thing thing = new Thing ( ) ;
  { thing.doSomething ( ) ; }
}
这是正确可运行的

class Trial {
  private final thing = new Thing ( )
  { thing.doSomething ( ) }
}
会报“MissingMethodException!”异常,因为”{ thing.doSomething ( ) }“会被认为是一段闭包函数,然后传入Thing()方法中作为它的参数

故此,建议我们照旧按Java开发规范来,老老实实在每句sentence的前面写上分号!

Groovy会自动为pojo对象附上set和get方法,你不要手动去设置

JAVA的写法:
class usersBean() {
  String name;

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


Groovy的写法:
class usersBean() {
  String name;

}

Groovy中,在单引号里的字符串和平凡的Java字符串1样,而在双引号里的字符串则能分析
${param}中的值:

def param = "咕噜大大"

println "大家好!我是${param}!"
println '大家好!我是${param}!'

出口结果是:我们好!作者是咕噜大大!

                      大家好!我是${param}!

措施和类都暗许是public的;

“return”能够大致,会按代码块中最后一句表明式的结果来回到值.