Groovy语法学习(一) 基本语法

Groovy很像java，甚至可以直接在groovy文件中直接写java代码，这点Kotlin就做不到了，本章基本语法主要说一下变量定义，循环，字符串、类以及一些和java语法的区别。这篇文章是鉴于对java比较熟悉的基础上来阅读的，如果没不了解编程语言可能读起来会稍微困难。

一、基本语法

(一) 变量

首先注意几个点

groovy默认的权限是public，似乎没有了类似java的default。注释的方法和java一致。
调用方法时不需要加括号，每行代码末尾不需要加分号。
变量定义使用def定义，因为是动态语言将在运行时判定类型。强制指定类型使用as关键字。数据类型和java一致。
方法定义的参数不加类型可以接受任意类型的参数，object。
println是未Object的扩展方法，后面还会看到很多类似的方法。
a.class相当于a.getClass(),这也是一种语法糖。groovy的数字貌似都变成的包装类了。java里的int,float类型是不能直接调用方法的。
groovy中 ==是equals, 而要==需要用到is方法。
有无def变量定义是否是全局会有差别

例如:

class Learn1{
    static void main(args){
    def a=1;
    def b=2 as int
    def c=3.asType(String)
    def d=4 as float
    def e="1" as Integer
    def f=1 as String
    def g="1".asType(int)
    println a.class
    println b.class
    println c.class
    println d.class
    println e.class
    println f.class
    println g.class
    //测试def定义
    def c = 5
    assert c == 5
    d = 6
    assert d == 6 //def keyword optional because we're within a script context
    assert binding.variables.c == null
    assert binding.variables.d == 6

    def fun(){
        h=10
    }
    fun()
    assert binding.variables.h == 10

    }
}

结果:

class java.lang.Integer
class java.lang.Integer
class java.lang.String
class java.lang.Float
class java.lang.Integer
class java.lang.String
class java.lang.Integer

(二) 循环

1.普通循环方式

groovy使用IntRange类型来进行循环操作
IntRange的第一个参数是是否包含to的值，这里具体也就是说不包括2，
其他的参数只要稍微看一下就理解了

for(i in new IntRange(false,10,2).step(2)){
    println i
}

简单写法
使用xx..xx的写法实际上也就是一个IntRange类
这两种写法完全一致，这里的 < 符号如果加上就不包括2，不加就包括2。

for(i in (10..<2).step(2)){
    println i
}

结果：

2.扩展方法的循环

groovy中方法的最后一个参数如果是闭包，那么就可以直接用大括号接在外面，闭包这里就直接可以理解为一段可执行的代码，其实和lambda表达式一样的，默认的参数是it,可以不用明确写出。

(1)times

10.times {
    print it + ' '
}

结果：

0 1 2 3 4 5 6 7 8 9

(2)step

10.step(6,-2){
    print it+" "
}

结果：

10 8

注意这两个方法都是不包含最后一个值的。

(三)运算符及条件判断

1.运算符

运算符基本上和java一样，主要提一个三目运算符的写法，其他的差异暂时没有发现，新的会补上去。

def t=true
println t?:false

结果:

true

和java的区别很明显了，判断为真时，如果返回自己则可以省略不写。

问号表达式

def num=null
println num?.toUpperCase()

在num==null是会返回null而不是抛异常。

2.if条件判断

groovy中可以这样写

def s=""

if(!s){
    print true
}

结果:

true

这里其实是调用了对应类的asBoolean方法，如果想让自己的类也具有这种功能，仿照写一个就好了，比如

class AsB {
    static boolean asBoolean(AsB self) {
        return true;
    }
}

很多Number包装类也有这种写法

if(1){
    println true
}

感觉和c++ operator bool()一样，这里就不多提了。

3.switch范围筛选

def age = 36
def rate

switch (age) {
    case 10..26:
        rate = 0.05
        break
    case 27..36:
        rate = 0.06
        break
    case 37..46:
        rate = 0.07
        break
}

println( rate)

这里不多说，大家都能看懂
switch和if一样都有类默认的实现方法。isCase(switchValue)
注意这里调用的是case里的内容的isCase方法，将switch的值传去来进行判断。

class Score {
    def score


    boolean isCase(switchValue){
        println score
        switchValue.score<score
    }

    @Override
    public String toString() {
        return "Score{" +
                "score=" + score +
                '}';
    }
}

def s = new Score(score: 100)


switch (s) {
    case new Score(score:50):
        println '小于100'
        break;
    case new Score(score:200):
        println '大于100'
        break;
}

结果:

50
200
大于100

4.展开操作符

这里有点特殊，直接参考这篇文章https://blog.csdn.net/qq_26847293/article/details/50705071
使用展开操作符基本上都会返回一个集合

class A{
    def b=10
}
def l=[1,3,4]*.minus(5)
def k=new A()*.b
println l
println k

结果：

[-4, -2, -1]
[10]

(三)字符串

字符串有三种方式

def a='1'
def b="2"
def c="""3"""

单引号的最后得到的类型也是String，如果要用char需要用as强转

双引号可以在字符串中间拼接变量，例如

  def k = 'a' as char
  def i = 'Gro${k}ovy'

如果中间是闭包是惰性求值，对比一下。

结果：

Gro${k}ovy
Grobovy
Groaovy

三个引号是按照文本可是取值，这样就可以不用写换行符之类的转义了

def j = """<xml>
</xml>"""
 println j

结果：

<xml>
</xml>

直接使用减法，结果不多说了。

println "java"-"ja"

使用下标直接取值

 String sample = "Hello world"; 
      println(sample[4]) 
      println(sample[-1]) 
      println(sample[1..2])
      println(sample[4..2])

结果:

o 
d 
el 
oll

直接执行cmd命令

 println "cmd /c groovy -v".execute().text

首先execute是String的扩展方法，执行命令，text从inputStream中读取值，其实和java实现一样，语法糖就简单很多了。
结果：

Groovy Version: 2.4.15 JVM: 1.8.0_131 Vendor: Oracle Corporation OS: Windows 10

字符串分割，直接赋值给变量。

def str = 'org.codehaus.groovy:groovy-all:2.4.9'

def (group, name, version,classifier) = str.split(":")
println group
println name
println version

结果

org.codehaus.groovy
groovy-all
2.4.9

四、正则表达式快速写法

def m = 'Groovy' =~ '\\w+'

if(m.find()){
    println m.group(0)
}else {
    println "not found"
}
if("java" =~ 'j'){
    println true
}

=~直接接正则表达式就可以返回Matcher，如果跟在if里或者bool返回值就会直接返回是否查找到。
结果:

Groovy
true

五、类的简单定义使用

//groovy方法调用
class Person {
    def name
    def age

    def getName() {
        return name + '_'
    }

    void setName(name) {
        this.name = name
    }

    def execute(x, y, z) {
        println "$x $y $z"
    }
}


//直接指定值进行构造
def person = new Person(name: 'Jack')
println person.name
person.name = 'Jack'
println person.name
println person.'name'
//利用字符串取值
def str = 'name'
println person."$str"
println person['name']
//普通取值是调用get,@是直接取值
println person.@name
//键值对优先赋值给第一个变量
person.execute(4,x: 1, y: 2, z: 3,5)

结果:

Jack_
Jack_
Jack_
Jack_
Jack_
Jack
[x:1, y:2, z:3] 4 5

基本语法就总结这些吧。