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

╰+攻爆jí腚メ 2022-05-27 01:39 332阅读 0赞

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
        def x=5
        y=6
        def fun2(){
            println y
            //println x  会报找不到属性的异常
        }
        fun2()
        }
    }

结果:

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
    }

结果：

10
    8
    6
    4

##### 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][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

结果：

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

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

基本语法就总结这些吧。

[https_blog.csdn.net_qq_26847293_article_details_50705071]: https://blog.csdn.net/qq_26847293/article/details/50705071