精华内容
下载资源
问答
  • groovy 教程

    2007-12-24 11:45:32
    groovy 教程groovy 教程
  • Groovy 教程

    2019-05-22 21:30:05
    Groovy 教程 Groovy 概述 Groovy是一种基于JVM(Java虚拟机)的敏捷开发语言,它结合了Python、Ruby和Smalltalk的许多强大的特性,Groovy 代码能够与 Java 代码很好地结合,也能用于扩展现有代码。由于其运行在 JVM ...

    Groovy 概述

    Groovy是一种基于JVM(Java虚拟机)的敏捷开发语言,它结合了Python、Ruby和Smalltalk的许多强大的特性,Groovy 代码能够与 Java 代码很好地结合,也能用于扩展现有代码。由于其运行在 JVM 上的特性,Groovy 可以使用其他 Java 语言编写的库。

    Groovy 1.0于2007年1月2日发布,其中Groovy 2.4是当前的主要版本。 Groovy通过Apache License v 2.0发布。

    简单地说,Groovy 是下一代的java语言,跟java一样,它也运行在 JVM 中。作为跑在JVM中的另一种语言,groovy语法与 Java 语言的语法很相似。同时,Groovy 抛弃了java烦琐的文法。同样的语句,使用groovy能在最大限度上减少你的击键次数——这确实是“懒惰程序员们”的福音。

    Groovy 的特点

    1. 同时支持静态和动态类型。
    2. 支持运算符重载。
    3. 本地语法列表和关联数组。
    4. 对正则表达式的本地支持。
    5. 各种标记语言,如XML和HTML原生支持。
    6. Groovy对于Java开发人员来说很简单,因为Java和Groovy的语法非常相似。
    7. 您可以使用现有的Java库。
    8. Groovy扩展了java.lang.Object。
    

    Groovy 环境搭建

    下载和安装 -进入该链接Groovy安装软件获得Windows安装程序部分。需要注意的是它依赖的JDK版本最好是1.8版本,否则会报警告.
    在这里插入图片描述
    启动Groovy安装程序,然后依次执行即可。值得注意的是,该软件会帮我们自动配置PATH和GROOVY_HOME.如下图所示,不要取消勾选.系统安全软件也会拦截,记得允许哟!!
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    一旦上述步骤之后,你就可以开始使用Groovy shell,有助于测试我们的Groovy,而不需要为Groovy提供一个完整的集成开发环境。可以通过在命令提示符下命令groovysh来完成。在这里插入图片描述
    如果你想包含groovy二进制文件作为maven或gradle构建的一部分,你可以添加以下行
    Gradle

    'org.codehaus.groovy:groovy:2.4.5'
    

    Maven

    <groupId>org.codehaus.groovy</groupId> 
    <artifactId>groovy</artifactId>  
    <version>2.4.5</version>
    

    Groovy 基本语法

    没有类型的JAV

    作为动态语言,groovy中所有的变量都是对象(类似于.net framework,所有对象继承自java.lang.Object),在声明一个变量时,groovy不要求强制类型声明,仅仅要求变量名前使用关键字def。

    不需要的public

    你可以把main方法前面的public去掉,实际上,groovy中默认的修饰符就是public,所以public修饰符你根本就不需要写,这点跟java不一样。

    不需要的语句结束符

    Groovy中没有语句结束符,当然为了与java保持一致性,你也可以使用;号作为语句结束符。在前面的每一句代码后面加上;号结束,程序同样正常运行(为了接受java程序员的顽固习惯)。

    字符串连接符

    跟java一样,如果你需要把一个字符串写在多行里,可以使用+号连接字符串。代码可以这样写:

    def var="hello "+
           "world"+
           ",groovy!"
    //当然更groovy的写法是:
    def var="""hello
    		   world
    		   groovy!"""
    //三个双引号或单引号之间不在需要+号进行连接(不过字符串中的格式符都会被保留,包括回车和tab)
    

    一切皆对象

    听起来象是“众生平等”的味道,事实上groovy对于对象是什么类型并不关心,一个变量的类型在运行中随时可以改变,一切根据需要而定。如果你赋给它boolean ,那么不管它原来是什么类型,它接受boolean值之后就会自动把类型转变为boolean值。看下面的代码:

    def var="hello "+
           "world"+
           ",groovy!"
           println var;
           println var.class;
           var=1001
           println var.class
    // 输出结果:
    hello world,groovy!
    class java.lang.String
    class java.lang.Integer
    

    var这个变量在程序运行中,类型在改变。一开始给它赋值String,它的类型就是String,后面给它赋值Integer,它又转变为Integer。

    循环

    // 删除整个源文件内容,用以下代码替代:
    def var="hello "+
           "world"+
           ",groovy!"
    def repeat(val){
    	for(i = 0; i < 5; i++){
    		println val
    	}
    }
    repeat(var)
    // 输出:
    hello world,groovy!
    hello world,groovy!
    hello world,groovy!
    hello world,groovy!
    hello world,groovy!
    // 注意循环变量i前面没有def。当然也没有java中常见的int,但如果你非要加上int也不会有错,因为从Groovy1.1beta2之后开始(不包括1.1beta2),groovy开始支持java经典的for循环写法。
    // 此外,上面的for语句还可以写成:
    for(i in 0..5)
    // 这样的结果是一样的。 
    

    String 和 Gstring

    类似于ES的模板字符串,变量用${} EL表达式来引用,还可以做相应的算术运算.

    def name="Tom"   //可选的类型定义,系统会根据值进行自动识别类型,类似于js的var
    println 'my name is tom' //单引号只能输出字符串
    println "Myname is ${"John"+name}"  //双引号可以插入变量
    println "Myname is ${"Tom"==name}"  //双引号可以进行简单的逻辑判断
    println ''' 
    		Myname 
    		is 
    		tom 
    '''   //三个单引号可以保留格式,完成见到那拼接
    
    //输出:
    Myname is JohnTom
    Myname is true
    

    范围

    在前面的for循环介绍中我们已经使用过的for(i in 0…5)这样的用法,其中的0…5就是一个范围。
    范围 是一系列的值。例如 “0…4” 表明包含 整数 0、1、2、3、4。Groovy 还支持排除范围,“0…<4” 表示 0、1、2、3。还可以创建字符范围:“a…e” 相当于 a、b、c、d、e。“a…<e” 包括小于 e 的所有值。
    范围主要在for循环中使用。

    默认参数值

    可以为方法指定默认参数值。我们修改repeat方法的定义:

    def repeat(val,repeat=3){
       for(i in 0..<repeat){
          println "This is ${i}:${val}"
       }
    }
    

    可以看到,repeat方法增加了一个参数repeat(并且给了一个默认值3),用于指定循环次数。
    当我们不指定第2个参数调用repeat方法时,repeat参数取默认值3。

    集合

    Groovy支持最常见的两个java集合:java.util.Collection和java.util.Map。 前面所说的范围实际也是集合的一种(java.util.List)。

    Collection 集合

    groovy:000> c=[1,2,3,4,5,6,7]
    ===> [1, 2, 3, 4, 5, 6, 7]
    groovy:000> c.add(1)  //添加元素
    ===> true
    groovy:000> c
    ===> [1, 2, 3, 4, 5, 6, 7, 1]
    groovy:000> c<<b   //添加其它类型的元素
    Unknown property: b
    groovy:000> c<<6   //添加元素
    ===> [1, 2, 3, 4, 5, 6, 7, 1, 6]
    groovy:000> c+0   //添加元素
    ===> [1, 2, 3, 4, 5, 6, 7, 1, 6, 0]
    groovy:000> c=c-6  //删除所有相同的元素
    ===> [1, 2, 3, 4, 5, 7, 1]
    groovy:000> c=c-c[0..2]  //删除指定范围的元素
    ===> [4, 5, 7]
    groovy:000>
    

    Map集合

    Map是“键-值”对的集合,在groovy中,键不一定是String,可以是任何对象(实际上Groovy中的Map就是java.util.LinkedHashMap)。

    //定义一个Map
    def map=['name':'john','age':14,'sex':'boy']
    map=map+['weight':25]       //添加john的体重
    map.put('length',1.27)      //添加john的身高
    map.father='Keller'         //添加john的父亲
    //可以用两种方式检索值:
    println map['father']       //通过key作为下标索引
    println map.length          //通过key作为成员名索引
    
    //定义一个buildYear
    def buildYear = ['ant':2000,'maven':2004]
    buildYear.gradle = 2008
    
    println buildYear.gradle
    println buildYear['gradle']
    println buildYear.getClass() //class java.util.LinkedHashMap
    

    闭包

    闭包是Groovy中非常重要的一个数据类型或者说一种概念。闭包是一种数据类型,它代表了一段可执行的代码,一般被当作参数来使用。

    // (1)有参数:
    def 闭包名={
    	parameters->code
    }
    //(2)无参数(不需要->符号)
    def 闭包名={code}
    //如果闭包没有定义参数的话,则隐含有一个参数,这个参数名字叫it,和this的作用类似。it代表闭包的参数
    def 闭包名={
    	it->code
    }
    //方法调用:1)闭包名.call(参数)
    (2)闭包名(参数)
    

    闭包中最常见的应用是对集合进行迭代,下面定义了3个闭包对map进行了迭代:

    def map=['name':'john','age':14,'sex':'boy']
    map.each({key,value->    //key,value两个参数用于接受每个元素的键/值
        println "$key:$value"
    })
    map.each{println it}     //it是一个关键字,代表map集合的每个元素
    map.each({ 
    	println it.getKey()+"-->"+it.getValue()
    })
    
    //定义一个包含参数的闭包
    def c1 = { //闭包是一个代码块
    	v->println v
    }
    //定义一个不包含参数的闭包
    def c2 = {
      println 'hello'
    }
    
    //定义两个个方法使用闭包作为参数传递,并调用
    def method1(Closure closure){ //记住这里不导入包
    	closure('param')
    }
    
    def method2(Closure closure){
    	closure()
    }
    
    //执行方法
    method1(c1)  //param
    method2(c2)  //hello
    

    Groovy类和java类一样,你完全可以用标准java bean的语法定义一个groovy 类。
    但作为另一种语言,我们可以使用更groovy的方式定义和使用类,这样的好处是,你可以少写一半以上的javabean代码:

    • 不需要public修饰符
      如前面所言,groovy的默认访问修饰符就是public,如果你的groovy类成员需要public修饰,则你根本不用写它。
    • 不需要类型说明
      同样前面也说过,groovy也不关心变量和方法参数的具体类型。
    • 不需要getter/setter方法
      不要奇怪,在很多ide(如eclipse)早就可以为序员自动产生getter/setter方法了。在groovy中,则彻底不需要getter/setter方法——所有类成员(如果是默认的public)根本不用通过getter/setter方法引用它们(当然,如果你一定要通过get/set方法访问成员属性,groovy也提供了它们)。
    • 不需要构造函数
      不在需要程序员声明任何构造函数,因为groovy自动提供了足够你使用的构造函数。不用担心构造函数不够多,因为实际上只需要两个构造函数(1个不带参数的默认构造函数,1个只带一个map参数的构造函数—由于是map类型,通过这个参数你可以在构造对象时任意初始化它的成员变量)。
    • 不需要return
      Groovy中,方法不需要return来返回值吗?这个似乎很难理解。看后面的代码吧。
      因此,groovy风格的类是这样的:
    • 不需要()号
      Groovy中方法调用可以省略()号(构造函数除外),也就是说下面两句是等同的:
    person1.setName 'kk' 
    person1.setName('kk')
    
    //下面看一个完整类定义的例子:
    class Person {
     def name
     def age
     String toString(){//注意方法的类型String,因为我们要覆盖的方法为String类型
         "$name,$age"
     }
    //如果你使用javabean风格来做同样的事,起码代码量要增加1倍以上。
    //我们可以使用默认构造方法实例化Person类:
    def person1=new Person()
    person1.name='kk'
    person1.age=20
    println person1
    
    //也可以用groovy的风格做同样的事:
    def person2=new Person(['name':'gg','age':22]) //[]号可以省略
    println person2
    

    这样需要注意我们覆盖了Object的toString方法,因为我们想通过println person1这样的方法简单地打印对象的属性值。
    然而toString 方法中并没有return 一个String,但不用担心,Groovy 默认返回方法的最后一行的值。

    断言(assert)

    	def version = 1
    	println(version) 
    	println version  //括号可选
    	assert version == 2  //和junit中的测试一制,给一个期待值和真实值比较
    

    构建脚本(build.gradle 重要)

    //构建脚本中默认都是有一个Project实例的  
    plugins {//声明一个应用插件
        id 'java'   
    }
    
    group 'cn.itcast.gradle'
    version '1.0-SNAPSHOT'
    
    sourceCompatibility = 1.8   //源码编译器版本
    
    repositories {  //指定仓库地址,是一个方法,使用闭包作为参数,调用了一个方法
        mavenCentral()
    }
    
    dependencies {  //依赖版本信息 --> 坐标地址
        testCompile group: 'junit', name: 'junit', version: '4.12'
        //compile  runtime testCompile testRuntime
    }
    
    def createDir = {  //创建一个执行方法
        path->
            File dir = new File(path)
            if(!dir.exists()){
                dir.mkdirs()
            }
    }
    
    //////////////自定义任务动作交给构建工具去完成/////////////////////////////
    task makeJavaDir(){  //创建一个任务
        def paths = ['src/main/java','src/main/resources','src/test/java','src/test/resources']
        doFirst { //开始处添加一个动作
            paths.forEach(createDir)
        }
    }
    
    task markeWebJavaDir(){
        dependsOn 'makeJavaDir' //添加依赖动作
        def paths = ['src/main/webapp','src/test/webapp'];
        doLast {  //结尾处添加一个动作
            paths.forEach(createDir)
        }
    }
    

    在这里插入图片描述

    展开全文
  • groovy教程

    2020-10-07 13:26:10
    视频链接:https://www.bilibili.com/video/BV1qJ411n71M/?spm_id_from=333.788.videocard.0 关于环境:https://www.jianshu.com/p/cb92567adda1 ... IDEA创建groovy:https://blog.csdn.net/zknxx/article/details/5

    视频链接:https://www.bilibili.com/video/BV1qJ411n71M/?spm_id_from=333.788.videocard.0

    关于环境:https://www.jianshu.com/p/cb92567adda1

    关于环境:https://blog.csdn.net/weixin_37625173/article/details/100529803

    IDEA创建groovy:https://blog.csdn.net/zknxx/article/details/52123519

    新建groovy项目:https://www.cnblogs.com/dalianpai/p/12803715.html

    如何安装环境:

     

    代码:

    第一个知识点:

    第二,三个知识点:

    第四个知识点:

    第五个知识点:

    第六个知识点:

    第七个知识点:

    第八个知识点:

    第九个知识点:

    第十个知识点:

    第十一个知识点:

    ---1---

    groovy自带的集合的方法。

    第一个方法:

    第二个方法:

    第三个方法:

    第四个方法:

    第五个方法:

    第六套方法:

    第七个知识点:

    举例:

    第八个知识点:

    第九个知识点(文件):

    也可以是字节码的:

    读取:

    第十个知识点:

    文件:

    第十一个知识点:

    第十二个知识点:

    第十三个知识点:极简的URL

    第十四个知识点:

    输出:

    第十五个知识点:

    https://www.cnblogs.com/baxianhua/p/13300056.html

    第十六个知识点:

    第十七个知识点:

    ---2---

    第五章:

    第一个方法:

    第二个方法:

    加注解之后:

    第三个方法:

    第四个知识点:

    第五个知识点:

    第六个知识点:正则表达式

    分组:

    第七个知识点,泛型:

    第八个知识点:

    第九个知识点:

    第十个知识点:

    ---3---

    设计模式:

    第一个:

    策略:

    改为:

    第二个:

    第三个:

    ---4---

    另一个:

    第四个:

    ...

    例子:

    ---

    ---5---

    第一个知识点:

    第二个知识点:常见的集合操作函数:

    第三个知识点:

    第四个知识点:

    第五个知识点:

    第六个知识点:

    第七个知识点:

    第八个知识点:

    ---6---

    w3c:https://www.w3cschool.cn/groovy/groovy_regular_expressions.html

    展开全文
  • Groovy教程

    2019-01-11 00:07:14
    https://www.w3cschool.cn/groovy/groovy_overview.html
    展开全文
  • TutorialsPoint Groovy 教程.epub
  • 简易groovy教程

    2009-06-29 21:54:39
    初级GROOVY教程,方面初学者掌握GROOVY语法
  • groovy教程入门

    2021-07-16 12:27:17
    groovy入门groovy文件编译运行groovy的基础类型floatString常规StringGStringImpl正则表达式ListMapGroovy语法Closures with {}Closures 2Method方法带默认值map作为参数Class 最近在udemy上学习gradle,中间穿插了...


    最近在udemy上学习gradle,中间穿插了groovy的内容,本文主要介绍groovy的基础数据类型以及语法,如果本文对您有帮助,请不要吝啬您的点赞,谢谢~

    groovy文件编译运行

    • 创建文件 Start.groovy ,并写上:println("hello"), 利用groovy命令行编译运行:groovy src/com/xj/groovy/Hello/Start.groovy, 得到如下结果:
      groovy编译运行成功

    groovy的基础类型

    float

    a = 10.24F
    println a
    println a.class
    

    输出:
    groovy float

    可以看见groovy里面的float类型就是Java里面的Float类型

    String

    常规String

    • 单引号或者双引号
    s = 'Hello' // "Hello"
    println s
    println s.class
    

    输出:
    groovy String类型

    • 可以换行的
    s = '''
            All the power is with in you.
            You can do anything and everything
            '''
    println(s)
    println(s.class)
    

    输出
    带换行的String

    GStringImpl

    name = "friend"
    s = "hello ${name}"
    println s
    println s.class
    

    输出:
    Groovy GStringImpl

    正则表达式

    emailPattern = /([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,5})/
    println emailPattern.getClass()
    println "test@gmail.com" ==~ emailPattern
    println "testgmail.com" ==~ emailPattern
    

    输出:
    Groovy 正则表达式

    List

    LinkedList l = [1, 2, 3]
    println l         // [1, 2, 3]
    println l.class   // class java.util.LinkedList
    
    l << 4
    println l         // [1, 2, 3, 4]
    
    l = l + [5, 6, 7]
    println l         // [1, 2, 3, 4, 5, 6, 7]
    
    println l - [3, 5] // [1, 2, 4, 6, 7]
    
    l.each {println it}  // 1 2...
    l.reverseEach {println it}  // 7 6 ..
    l.eachPermutation {println it}  // 排列组合
    

    Map

    
    m = [:]
    println(m)             // [:]
    println(m.getClass())  // class java.util.LinkedHashMap
    
    m = [courseName: 'Gradle', rating: 5, price: 20]
    println(m)            // [courseName:Gradle, rating:5, price:20]
    
    m.each {
        k, v ->
            println k
            println v
    }
    println m.courseName          // Gradle
    println m['courseName']       // Gradle
    println m.get('courseName')   // Gradle
    

    Groovy语法

    Closures with {}

    c = {
        n = 2 -> println(n%2 == 0 ? "even": "odd")
    }
    c.call() // even
    c.call(1) // odd
    

    Closures 2

    4.times {n->print(n)}
    println()
    4.times {print(it)}
    println()
    

    输出:
    groovy closures times

    Method

    方法

    int product(int x, int y) {
        return x*y
    }
    println product(10, 5)   // 50
    result = product 10, 5
    println(result)           // 50
    

    带默认值

    int product(int x = 3, int y) {
        return x*y
    }
    result = product 5
    println(result)           // 15
    

    map作为参数

    void display(Map productDetails) {
        println productDetails.name
        println productDetails.price
    }
    
    display([name: 'IPhone', price: 1000])
    

    Class

    class Patient {
        def firstName, lastName, age
        static hospitalCode = "huoshan"
    
        void setLastName(lastName) {
            if (lastName == null) {
                throw new IllegalArgumentException("Last name can not be null");
            }
            this.lastName = lastName
        }
        static void display() {
            println hospitalCode
        }
    }
    
    p = new Patient(firstName: 'jhon', age: 40, lastName: 'jack')
    p.setLastName("buffer")
    println p.firstName + " " + p.lastName + " " + p.age  // jhon buffer 40
    Patient.display()            // "huoshan"
    
    展开全文
  • Groovy教程.7z

    2020-05-20 15:18:09
    Groovy 是一种基于Java平台的面向对象语言。Groovy 的语法和 Java 非常的相似,可以使用现有的 Java 库来进行 Groovy 开发。可以将它想像成 Java 语言的一种更加简单、表达能力更强的变体。
  • Groovy 的语法和 Java 非常的相似,可以使用现有的 Java 库来进行 Groovy 开发。可以将它想像成 Java 语言的一种更加简单、表达能力更强的变体。 用 Groovy 编写的任何内容都可以编译成标准的 Java 类文件并在 Java ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,291
精华内容 3,316
关键字:

groovy教程