精华内容
下载资源
问答
  • 1、写作背景 目前在进行开源项目学习中,有一些项目时用gradle...IDEA创建一个groovy工程如下: 创建一个groovy class 创建一个最简单的hello world(语法略有不同) class HelloWorld { sta...

    1、写作背景

    目前在进行开源项目学习中,有一些项目时用gradle进行版本控制的,所以在此记录


    2、参考网址


    3、工程创建

    • IDEA创建一个groovy工程如下:
    1096351-74c957c523ac8aa7.png
    • 创建一个groovy class
    1096351-228bfbb638f4882d.png
    • 创建一个最简单的hello world(语法略有不同)
    class HelloWorld {
        static void main(argus){
            // 1、原版Java代码
            String helloString  = "hello, world"
            System.out.println("---Java:"+helloString)
            // 2、groovy代码
            def var = "hello, world"
            println "---Groovy:"+var
        }
    }
    
    
    1096351-ca2c5e949219adc6.png

    • 上诉依然不能解释groovy的简洁性语法(这一次连类都不写,直接打印)
    1096351-55059ff894c9d110.png
    • 执行结果如下:
    1096351-ec3cacace953dddc.png
    展开全文
  • Groovy

    2018-09-21 10:14:00
    Groovy种基于Java平台的面向对象语言。 Groovy 1.0于2007年1月2日发布,其中Groovy 2.4是当前的主要版本。 Groovy通过Apache License v 2.0发布。 Groovy的特点 Groovy中有以下特点: 同时支持静态和动态类型。...



    Groovy 概述

    由 lichiabor 创建,youj 最后一次修改 2016-12-12

    Groovy是一种基于Java平台的面向对象语言。 Groovy 1.0于2007年1月2日发布,其中Groovy 2.4是当前的主要版本。 Groovy通过Apache License v 2.0发布。

    Groovy的特点

    Groovy中有以下特点:

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

    Groovy的官方网站是http://www.groovy-lang.org/

    Groovy的官方网站











    Groovy 环境

    由 lichiabor 创建,Alma 最后一次修改 2016-12-12

    有多种方式来获得的Groovy环境设置。

    下载和安装 -进入该链接www.groovy-lang.org/download.html获得Windows安装程序部分。

    Groovy的环境设置

    启动Groovy安装程序,然后请执行以下完成安装步骤。

    第1步 -选择语言安装程序。

    语言安装

    第2步 -点击下一步按钮。

    Groovy的2.4.5安装

    第3步 -点击“我同意”按钮。

    许可协议

    第4步 -接受默认组件,然后单击下一步按钮。

    选择组件

    第5步 -选择适当的目标文件夹,然后单击下一步按钮。

    安装位置

    第6步 -点击安装按钮开始安装。

    开始菜单文件夹

    第7步 -一旦安装完成后,单击下一步按钮开始配置。

    安装完成

    第8步 -选择默认选项,并单击下一步按钮。

    环境变量

    第9步 -接受默认的文件关联,然后单击下一步按钮。

    文件关联

    第10步 -单击Finish按钮完成安装。

    Finish按钮

    一旦上述步骤之后,你就可以开始使用Groovy shell,有助于测试我们的Groovy,而不需要为Groovy提供一个完整的集成开发环境。可以通过在命令提示符下命令groovysh来完成。

    运行命令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 基本语法

    由 lichiabor 创建,Alma 最后一次修改 2016-12-12


    为了了解Groovy的基本语法,让我们先看看一个简单的Hello World程序。

    创建你的第一个Hello World程序

    创建Hello World程序,你只要输入以下几行简单的代码就可实现 -

    class Example {
       static void main(String[] args) {
          // Using a simple println statement to print output to the console
          println('Hello World');
       }
    }
    

    当我们运行上面的程序,我们会得到以下结果 -

    Hello World
    

    在Groovy中导入语句

    import语句可以用来导入,可以在你的代码可以使用其他库的功能。这是通过使用在 Import 关键字完成。

    下面的示例演示了如何使用MarkupBuilder的类,它可能是最常用的创建HTML或XML标记的类之一。

    import groovy.xml.MarkupBuilder 
    def xml = new MarkupBuilder() 
    

    默认情况下,Groovy在代码中包括以下库,因此您不需要显式导入它们。

    import java.lang.* 
    import java.util.* 
    import java.io.* 
    import java.net.* 
    
    import groovy.lang.* 
    import groovy.util.* 
    
    import java.math.BigInteger 
    import java.math.BigDecimal
    

    Groovy令牌

    令牌可以是一个关键字,一个标识符,常量,字符串文字或符号。

    println(“Hello World”);
    

    在上面的代码行中,有两个令牌,首先是关键词的println而接下来就是字符串的“Hello World”。

    Groovy评论

    在您的代码中使用注释。Groovy的注释可以是单行或多行。

    单行注释使用//在该行的任何位置来识别。一个例子如下所示 -

    class Example {
       static void main(String[] args) {
          // Using a simple println statement to print output to the console
          println('Hello World');
       }
    }
    

    多行注释标识与在开始/ *和* /识别多行注释的末尾。

    class Example {
       static void main(String[] args) {
          /* This program is the first program
          This program shows how to display hello world */
          println('Hello World');
       }
    }
    

    分号

    就像Java编程语言,它需要具有分号在Groovy定义多个语句之间进行区分。

    class Example {
       static void main(String[] args) {
          // One can see the use of a semi-colon after each statement
          def x = 5;
          println('Hello World');  
       }
    }
    

    上述例子示出了分号使用了不同行的代码语句之间进行区分。

    身份标识

    标识符被用来定义变量,函数或其他用户定义的变量。标识符以字母开头,美元或下划线。他们不能以数字开头。以下是有效标识符的一些例子

    def employeename 
    def student1 
    def student_name
    

    其中,DEF是在Groovy用来定义标识符的关键字。

    下面是一个如何在我们的Hello World程序中使用标识符的代码示例。

    class Example {
       static void main(String[] args) {
          // One can see the use of a semi-colon after each statement
          def x = 5;
          println('Hello World'); 
       }
    }
    

    在上述的例子中,变量x被用作标识符。

    关键词


    关键字作为名称建议是在Groovy编程语言中保留的特殊字。 下表列出了在Groovy中定义的关键字。

    asassertbreakcase
    catchclassconstcontinue
    defdefaultdoelse
    enumextendsfalseFinally
    forgotoifimplements
    importininstanceofinterface
    newpullpackagereturn
    superswitchthisthrow
    throwstraittruetry
    while   

    空白

    空白是在编程语言如Java和Groovy用来形容空格,制表符,换行符和注释术语。空格分隔从另一个声明的一部分,使编译器,其中一个元素标识的声明。

    例如,在下面的代码示例,存在关键字def和变量x之间的空白。这是为了让编译器知道DEF是需要被使用,并且是x应该是需要被定义的变量名的关键字。

    def x = 5;
    


    文字


    文字是在groovy中表示固定值的符号。Groovy语言有符号整数,浮点数,字符和字符串。下面是一些在Groovy编程语言文字的例子 -

    12 
    1.45 
    ‘a’ 
    “aa”

    Groovy 数据类型

    由 lichiabor 创建,Alma 最后一次修改 2016-12-12

    在任何编程语言中,需要使用各种变量来存储各种类型的信息。变量只是保留值的存储位置,这意味着,当你创建一个变量,你保留在内存中的一些空间来存储与变量相关的值。

    您可能喜欢存储各种数据类型的信息,如字符串,字符,宽字符,整数,浮点数,布尔值等。基于变量的数据类型,操作系统分配内存并决定什么可以存储在保留的存储器中。

    内置数据类型

    Groovy提供多种内置数据类型。以下是在Groovy中定义的数据类型的列表 - 

    • byte -这是用来表示字节值。例如2。

    • short -这是用来表示一个短整型。例如10。

    • int -这是用来表示整数。例如1234。

    • long -这是用来表示一个长整型。例如10000090。

    • float -这是用来表示32位浮点数。例如12.34。

    • double -这是用来表示64位浮点数,这些数字是有时可能需要的更长的十进制数表示。例如12.3456565。

    • char -这定义了单个字符文字。例如“A”。

    • Boolean -这表示一个布尔值,可以是true或false。

    • String -这些是以字符串的形式表示的文本。例如,“Hello World”的。

    绑定值

    下表显示了数字和小数点文字中的最大允许值。

    byte-128到127
    short-32,768到32,767
    int2,147,483,648 到,147,483,647
    long-9,223,372,036,854,775,808到+9,223,372,036,854,775,807
    float1.40129846432481707e-45到3.40282346638528860e + 38
    double4.94065645841246544e-324d 到1.79769313486231570e + 308d

    数字类

    类型除了基本类型,还允许以下对象类型(有时称为包装器类型)-

    • java.lang.Byte
    • java.lang.Short
    • java.lang.Integer
    • java.lang.Long
    • java.lang.Float
    • java.lang.Double

    此外,以下类可用于支持高精度计算 -

    名称描述例如
    java.math.BigInteger不可变的任意精度的有符号整数数字30克
    java.math.BigDecimal不可变的任意精度的有符号十进制数3.5克

    以下代码示例说明如何使用不同的内置数据类型 - 

    class Example { 
       static void main(String[] args) { 
          //Example of a int datatype 
          int x = 5; 
    		
          //Example of a long datatype 
          long y = 100L; 
    		
          //Example of a floating point datatype 
          float a = 10.56f; 
    		
          //Example of a double datatype 
          double b = 10.5e40; 
    		
          //Example of a BigInteger datatype 
          BigInteger bi = 30g; 
    		
          //Example of a BigDecimal datatype 
          BigDecimal bd = 3.5g; 
    		
          println(x); 
          println(y); 
          println(a); 
          println(b); 
          println(bi); 
          println(bd); 
       } 
    }
    

    当我们运行上面的程序,我们会得到以下结果 -

    5 
    100 
    10.56 
    1.05E41 
    30 
    3.5

    Groovy 变量

    由 lichiabor 创建,Alma 最后一次修改 2016-12-12

    Groovy中的变量可以通过两种方式定义 - 使用数据类型的本地语法,或者使用def关键字。对于变量定义,必须明确提供类型名称或在替换中使用“def”。这是Groovy解析器需要的。

    Groovy中有以下基本类型的变量,如上一章所述 -

    • byte - 这用于表示字节值。例如2。

    • short - 用于表示一个短数。例如10。

    • int - 这用于表示整数。 例如1234。

    • long - 这用于表示一个长数。例如10000090。

    • float - 用于表示32位浮点数。例如12.34。

    • double - 这用于表示64位浮点数。例如12.3456565。

    • char - 这定义了单个字符文字。例如'a'。

    • Boolean - 这表示一个布尔值,可以是true或false。

    • String - 这是以字符串形式表示的文本。 例如“Hello World”。

    Groovy还允许其他类型的变量,如数组,结构和类,我们将在后续章节中看到。

    变量声明

    变量声明告诉编译器为变量创建存储的位置和大小。

    下面是一个变量声明的例子 -

    class Example { 
       static void main(String[] args) { 
          // x is defined as a variable 
          String x = "Hello";
    		
          // The value of the variable is printed to the console 
          println(x);
       }
    }
    

    当我们运行上面的程序,我们会得到以下结果 -

    Hello
    

    变量命名

    变量的名称可以由字母,数字和下划线字符组成。 它必须以字母或下划线开头。 大写和小写字母是不同的,因为Groovy,就像Java是一种区分大小写的编程语言。

    class Example { 
       static void main(String[] args) { 
          // Defining a variable in lowercase  
          int x = 5;
    	  
          // Defining a variable in uppercase  
          int X = 6; 
    	  
          // Defining a variable with the underscore in it's name 
          def _Name = "Joe"; 
    		
          println(x); 
          println(X); 
          println(_Name); 
       } 
    }
    

    当我们运行上面的程序,我们会得到以下结果 -

    5 
    6 
    Joe 
    

    我们可以看到x和X是两个不同的变量,因为区分大小写,在第三种情况下,我们可以看到_Name以下划线开头。

    打印变量

    您可以使用println函数打印变量的当前值。下面的示例显示了如何实现这一点。

    class Example { 
       static void main(String[] args) { 
          //Initializing 2 variables 
          int x = 5; 
          int X = 6; 
    	  
          //Printing the value of the variables to the console 
          println("The value of x is " + x + "The value of X is " + X);  
       }
    }
    

    当我们运行上面的程序,我们会得到以下结果 -

    The value of x is 5 The value of X is 6 


    Groovy 运算符

    由 lichiabor 创建,Alma 最后一次修改 2016-12-12

    运算符是一个符号,通知编译器执行特定的数学或逻辑操作。

    Groovy中有以下类型的运算符 -

    • 算术运算符
    • 关系运算符
    • 逻辑运算符
    • 位运算符
    • 赋值运算符

    算术运算符

    Groovy语言支持正常的算术运算符任何语言。以下是在Groovy中可用的算术运算符 -

    显示示例

    运算符描述例子
    +两个操作数的加法1 + 2 将得到 3
    -第一第二操作数相减
    2 - 1 将得到 1
    *两个操作数的乘法2 * 2 将得到4
    /两个操作数的除法3/2 将得到 1.5
    取模运算3%2 将得到 1
    ++自增运算,在自身值的基础上加1

    INT X = 5;

    X ++;

    X 将得到 6

    --自减运算,在自身值的基础上减1

    INT X = 5;

    X - -;

    X 将得到 4


    关系运算符

    关系运算符允许对象的比较。以下是在Groovy中可用的关系运算符 -

    显示示例

    运算符描述例子
    ==测试两个对象之间是否相等2 == 2 将得到 true
    !=测试两个对象之间是否不等3 != 2 将得到 true
    <检查是否左边的对象是小于右边的对象。2 < 3 将得到 true
    <=检查是否向左对象是小于或等于右边的对象2 <= 3 将得到 true
    >检查是否左边的对象比右边的对象大。3 > 2 将得到 true
    >=检查是否向左对象大于或等于右边的对象。3>= 2 将得到 true

    逻辑运算符

    逻辑运算符用于计算布尔表达式。以下是在Groovy中提供的逻辑运算符 -

    显示示例

    运算符描述例子
    &&这是逻辑“与”运算true && true 得到 true
    ||这是逻辑“或”运算true || true 得到 true
    这是逻辑“非”运算!true 得到 false

    位运算符

    Groovy中提供了四个位运算符。以下是在Groovy中可用的位运算符 -

    显示示例

    运算符描述
    这是位“与”运算
    |这是按位“或”运算
    ^这是按位“异或”或异或运算符
    这是按位反运算符

    这里是显示这些运算符的真值表。

    pqp&Qp | qp ^ Q
    00000
    01011
    11110
    10011

    赋值运算符

    Groovy语言也提供了赋值操作符。以下是在Groovy提供的赋值运算符 -

    显示示例

    运算符描述例子
    +=A += B 等价于 A = A+B

    DEF A = 5

    A += 3

    输出将是8

    -=A -= B 等价于 A = A-B

    DEF A = 5

    A -= 3

    输出将是2

    *=A *= B 等价于 A= A*B

    DEF A = 5

    A *= 3

    输出将是15

    /=A /= B 等价于 A = A/B

    DEF A = 6

    A /= 3

    输出将是2

    (%)=A (%)= B 等价于 A = A % B

    DEF A = 5

    A %= 3

    输出将是2

    范围运算符

    Groovy支持范围的概念,并在..符号的帮助下提供范围运算符的符号。下面给出了范围运算符的一个简单示例。

    def range = 0..5 
    

    这只是定义了一个简单的整数范围,存储到一个局部变量称为范围内的下限为0和上限为5。

    以下代码段显示了如何使用各种运算符。

    class Example { 
       static void main(String[] args) { 
          def range = 5..10; 
          println(range); 
          println(range.get(2)); 
       } 
    }
    

    当我们运行上面的程序,我们会得到以下结果 -

    从println语句中,可以看到显示在range语句中定义的整个数字范围。

    get语句用于从定义的范围中获取一个对象,它将索引值作为参数。

    [5, 6, 7, 8, 9, 10] 
    7
    

    运算符优先级

    下表按优先级顺序列出了所有groovy运算符

    运算符名称
    ++ - + -预增/减,一元加,一元减
    * / %乘法,除法,取模
    + -加法,减法
    ==!= <=>等于,不等于,比较
    二进制/位运算符与
    ^二进制/位异或
    |二进制/按位或
    &&逻辑和
    ||逻辑或
    = ** = * = / =%= + = - = << = >> = >>> = = ^ = | =各种赋值运算符



    Groovy 循环

    由 lichiabor 创建,youj 最后一次修改 2016-12-12

    到目前为止,我们已经看到已经按顺序方式一个接一个执行的语句。此外,在Groovy中提供了语句来改变程序逻辑中的控制流。然后将它们分类为我们将详细看到的控制语句的流程。

    序号语句和描述
    1while语句

    while语句首先通过计算条件表达式(布尔值)来执行,如果结果为真,则执行while循环中的语句。

    2for语句

    for语句用于遍历一组值。

    3for-in语句

    for-in语句用于遍历一组值。

    循环控制语句

    序号语句和描述
    1break语句

    break语句用于改变循环和switch语句内的控制流。

    2continue语句

    continue语句补充了break语句。它的使用仅限于while和for循环。

    Groovy If语句

    由 yuleiming 创建,小路依依 最后一次修改 2016-12-29

    第一个决策语句是 if 语句。这种说法的一般形式是 -

    if(condition) { 
       statement #1 
       statement #2 
       ... 
    }
    

    这个语句的一般工作是首先在 if 语句中评估一个条件。如果条件为真,它然后执行语句。下图显示了 if 语句的流程。

    If Statement

    下面是一个if / else语句的例子 -

    class Example { 
       static void main(String[] args) { 
          // Initializing a local variable 
          int a = 2 
    		
          //Check for the boolean condition 
          if (a<100) { 
             //If the condition is true print the following statement 
             println("The value is less than 100"); 
          } 
       } 
    }
    

    在上面的例子中,我们首先将一个变量初始化为值2.然后我们评估变量的值,然后决定是否应该执行 println 语句。上面的代码的输出将是 -

    The value is less than 100


    Groovy If/Else语句

    由 yuleiming 创建,小路依依 最后一次修改 2016-12-29

    我们将看到的下一个决策语句是 if / else 语句。这种说法的一般形式是 -

    if(condition) { 
       statement #1 
       statement #2 
       ... 
    } else{ 
       statement #3 
       statement #4  
    }
    

    这个语句的一般工作是首先在 if 语句中评估一个条件。如果条件为真,则其后执行语句,并在else条件之前停止并退出循环。如果条件为假,则执行else语句块中的语句,然后退出循环。下图显示了 if 语句的流程。

    If Statements

    下面是一个if / else语句的例子 -

    class Example { 
       static void main(String[] args) { 
          // Initializing a local variable 
          int a = 2
    		
          //Check for the boolean condition 
          if (a<100) { 
             //If the condition is true print the following statement 
             println("The value is less than 100"); 
          } else { 
             //If the condition is false print the following statement 
             println("The value is greater than 100"); 
          } 
       } 
    }
    

    在上面的例子中,我们首先将一个变量初始化为值2.然后我们评估变量的值,然后决定应该执行哪个 println 语句。上面的代码的输出将是

    The value is less than 100.


    Groovy 嵌套If语句

    由 yuleiming 创建,youj 最后一次修改 2016-12-29

    有时需要有多个if语句嵌入在彼此内部。

    这种说法的一般形式是 -

    if(condition) { 
       statement #1 
       statement #2 
       ... 
    } else if(condition) { 
       statement #3 
       statement #4 
    } else { 
       statement #5 
       statement #6 
    }
    

    以下是嵌套if / else语句的示例 -

    class Example { 
       static void main(String[] args) { 
          // Initializing a local variable 
          int a = 12 
    		
          //Check for the boolean condition 
          if (a>100) {
             //If the condition is true print the following statement 
             println("The value is less than 100"); 
          } else 
             // Check if the value of a is greater than 5 
    			
          if (a>5) { 
             //If the condition is true print the following statement 
             println("The value is greater than 5 and greater than 100"); 
          } else { 
             //If the condition is false print the following statement 
             println("The value of a is less than 5"); 
          }  
       } 
    }	     
    

    在上面的例子中,我们首先将一个变量初始化为值12.在第一个 if 语句中,我们看到 a 的值是否大于100。如果没有,那么我们进入第二个for循环,看看 a 的值是否大于5或小于5.上面的代码的输出将是 -

    The value is greater than 5 and greater than 100

    Groovy Switch语句

    由 yuleiming 创建,youj 最后一次修改 2016-12-29

    有时,嵌套的if-else语句是如此常见,并且经常使用,以便设计一个更容易的语句,称为 switch 语句。

    switch(expression) { 
       case expression #1: 
       statement #1 
       ... 
       case expression #2: 
       statement #2 
       ... 
       case expression #N: 
       statement #N 
       ... 
       default:
       statement #Default 
       ... 
    } 
    

    本声明的一般工作如下 -

    • 要评估的表达式放在switch语句中。

    • 将有多个case表达式被定义以基于表达式的计算来决定应该执行哪一组语句。

    • 在结尾处的语句的每个案例段中添加一个 break 语句。这是为了确保在执行相关语句集时立即退出循环。

    • 还有一个默认case 语句,如果没有任何前面的情况表达式求值为true,则执行。

    下图显示了 switch-case 语句的流程。

    Switch Statements

    以下是switch语句的示例 -

    class Example { 
       static void main(String[] args) { 
          //initializing a local variable 
          int a = 2
    		
          //Evaluating the expression value 
          switch(a) {            
             //There is case statement defined for 4 cases 
             // Each case statement section has a break condition to exit the loop 
    			
             case 1: 
                println("The value of a is One"); 
                break; 
             case 2: 
                println("The value of a is Two"); 
                break; 
             case 3: 
                println("The value of a is Three"); 
                break; 
             case 4: 
                println("The value of a is Four"); 
                break; 
             default: 
                println("The value is unknown"); 
                break; 
          }
       }
    }
    

    在上面的例子中,我们首先将一个变量初始化为值2.然后我们有一个switch语句,它计算变量a的值。 基于变量的值,它将执行语句的相关案例集。上面的代码的输出将是 -

    The value of a is Two

    Groovy 嵌套Switch语句

    由 yuleiming 创建,youj 最后一次修改 2016-12-29

    它也可以有一个嵌套的 switch 语句。语句的一般形式如下所示 -

    switch(expression) { 
       case expression #1: 
       statement #1 
       ... 
       case expression #2: 
       statement #2
       ... 
       case expression #N: 
       statement #N 
       ... 
       default: 
       statement #Default 
       ... 
    }
    

    下面是嵌套switch语句的一个示例 -

    class Example { 
       static void main(String[] args) { 
          //Initializing 2 variables i and j 
          int i = 0; 
          int j = 1; 
    		
          // First evaluating the value of variable i 
          switch(i) { 
             case 0: 
                // Next evaluating the value of variable j 
                switch(j) { 
                   case 0: 
                      println("i is 0, j is 0"); 
                      break; 
                   case 1: 
                      println("i is 0, j is 1"); 
                      break; 
                   
                   // The default condition for the inner switch statement 
                   default: 
                   println("nested default case!!"); 
                } 
             break; 
    			
             // The default condition for the outer switch statement 
             default: 
                println("No matching case found!!"); 
          }
       }
    }
    

    在上面的例子中,我们首先将a的变量初始化为a的值为2.然后我们有一个 switch 语句,它计算变量 a 的值。 基于变量的值,它将执行语句的相关案例集。上面的代码的输出将是 -

    i is 0, j is 1



    Groovy 方法

    由 lichiabor 创建,小路依依 最后一次修改 2016-12-12

    Groovy中的方法是使用返回类型或使用def关键字定义的。方法可以接收任意数量的参数。定义参数时,不必显式定义类型。可以添加修饰符,如public,private和protected。默认情况下,如果未提供可见性修饰符,则该方法为public。

    最简单的方法是没有参数的方法,如下所示:

    def methodName() { 
       //Method code 
    }
    

    下面是一个简单方法的例子

    class Example {
       static def DisplayName() {
          println("This is how methods work in groovy");
          println("This is an example of a simple method");
       } 
    	
       static void main(String[] args) {
          DisplayName();
       } 
    }
    

    在上面的例子中,DisplayName是一个简单的方法,它由两个println语句组成,用于向控制台输出一些文本。在我们的静态main方法中,我们只是调用DisplayName方法。上述方法的输出将是 - 

    This is how methods work in groovy 
    This is an example of a simple method
    

    方法参数

    如果一个方法的行为由一个或多个参数的值确定,则它通常是有用的。我们可以使用方法参数将值传递给被调用的方法。请注意,参数名称必须彼此不同。

    使用参数的最简单的方法类型,如下所示 −

    def methodName(parameter1, parameter2, parameter3) { 
       // Method code goes here 
    }
    

    以下是使用参数的简单方法的示例

    class Example {
       static void sum(int a,int b) {
          int c = a+b;
          println(c);
       }  
    	
       static void main(String[] args) {
          sum(10,5);
       } 
    }
    

    在这个例子中,我们创建一个带有2个参数a和b的sum方法。两个参数都是int类型。然后我们从我们的main方法中调用sum方法,并将值传递给变量a和b。

    然后我们从我们的main方法中调用sum方法,并将值传递给变量a和b。

    上述方法的输出将是值15。

    默认参数

    Groovy中还有一个规定来指定方法中的参数的默认值。 如果没有值传递给参数的方法,则使用缺省值。 如果使用非默认和默认参数,则必须注意,默认参数应在参数列表的末尾定义。

    以下是使用参数的简单方法的示例 -

    def someMethod(parameter1, parameter2 = 0, parameter3 = 0) { 
       // Method code goes here 
    } 
    

    让我们看看我们之前看到的添加两个数字的相同示例,并创建一个具有一个默认和另一个非默认参数的方法 - 

    class Example { 
       static void sum(int a,int b = 5) { 
          int c = a+b; 
          println(c); 
       } 
    	
       static void main(String[] args) {
          sum(6); 
       } 
    }
    

    在这个例子中,我们创建一个具有两个参数a和b的sum方法。两个参数都是int类型。此示例和上一个示例的区别在于,在这种情况下,我们将b的默认值指定为5。
    因此,当我们从main方法中调用sum方法时,我们可以选择只传递一个值为6的值,并将其分配给sum方法中的参数a。

    上述方法的输出将为值11。

    class Example {
       static void sum(int a,int b = 5) {
          int c = a+b;
          println(c);
       } 
    	
       static void main(String[] args) {
          sum(6,6);
       } 
    }
    

    我们也可以通过传递2个值来调用sum方法,在上面的例子中,我们传递2个值6.第二个值6实际上将替换分配给参数b的默认值。

    上述方法的输出将是值12。

    方法返回值

    方法也可以将值返回到调用程序。 这在现在编程语言中是必需的,其中方法执行某种计算,然后将所需值返回到调用方法。

    下面是一个带有返回值的简单方法的例子。

    class Example {
       static void sum(int a,int b = 5) {
          int c = a+b;
          return c;
       } 
    	
       static void main(String[] args) {
          println(sum(6));
       } 
    }
    

    在我们上面的例子中,注意这次我们为我们的方法sum指定一个类型为int的返回类型。 在方法中,我们使用return语句将sum值发送到调用主程序。 由于方法的值现在可用于main方法,因此我们使用println函数在控制台中显示该值。 在前面的例子中,我们将我们的方法定义为静态方法,这意味着我们可以直接从类中访问这些方法。方法的下一个示例是实例方法,其中通过创建类的对象来访问方法。我们将在后面的章节中看到类,现在我们将演示如何使用方法。

    上述方法的输出将为值11。

    实例方法

    方法通常在Groovy中的类中实现,就像Java语言一样。类只是一个蓝图或模板,用于创建定义其属性和行为的不同对象。类对象显示由其类定义的属性和行为。因此,通过在类中创建方法来定义行为。

    我们将在后面的章节中更详细地看到类,下面是类中方法实现的例子。

    以下是如何实现方法的示例。

    class Example { 
       int x; 
    	
       public int getX() { 
          return x; 
       } 
    	
       public void setX(int pX) { 
          x = pX; 
       } 
    	
       static void main(String[] args) { 
          Example ex = new Example(); 
          ex.setX(100); 
          println(ex.getX()); 
       } 
    }
    

    在我们上面的例子中,这次我们没有为类方法指定静态属性。在我们的main函数中,我们实际上创建了一个Example类的实例,然后调用'ex'对象的方法。

    上述方法的输出将是值100。

    本地和外部参数名称

    Groovy提供的设施就像java一样具有本地和全局参数。在下面的示例中,lx是一个局部参数,它只具有getX()函数内的作用域,x是一个全局属性,可以在整个Example类中访问。如果我们尝试访问getX()函数之外的变量lx,我们将得到一个错误。

    class Example { 
       static int x = 100; 
    	
       public static int getX() { 
          int lx = 200; 
          println(lx); 
          return x; 
       } 
    	
       static void main(String[] args) { 
          println getX() 
       }  
    }
    

    当我们运行上面的程序,我们会得到以下结果。

    200 
    100
    

    方法属性

    就像在Java中一样,groovy可以使用this关键字访问它的实例成员。以下示例显示了当我们使用语句this.x时,它引用其实例并相应地设置x的值。

    class Example { 
       int x = 100; 
    	
       public int getX() { 
          this.x = 200; 
          return x; 
       } 
    	
       static void main(String[] args) {
          Example ex = new Example(); 
          println(ex.getX());
       }
    }
    

    当我们运行上面的程序,我们将得到200的结果打印在控制台上。


    Groovy 文件I/O

    由 lichiabor 创建,Alma 最后一次修改 2016-12-12

    Groovy在使用I / O时提供了许多辅助方法,Groovy提供了更简单的类来为文件提供以下功能。

    • 读取文件
    • 写入文件
    • 遍历文件树
    • 读取和写入数据对象到文件

    除此之外,您始终可以使用下面列出的用于文件I / O操作的标准Java类。

    • java.io.File
    • java.io.InputStream
    • java.io.OutputStream
    • java.io.Reader
    • java.io.Writer

    读取文件

    以下示例将输出Groovy中的文本文件的所有行。方法eachLine内置在Groovy中的File类中,目的是确保文本文件的每一行都被读取。

    import java.io.File 
    class Example { 
       static void main(String[] args) { 
          new File("E:/Example.txt").eachLine {  
             line -> println "line : $line"; 
          } 
       } 
    }
    

    File类用于实例化以文件名作为参数的新对象。 然后它接受eachLine的函数,将它放到一个line的变量并相应地打印它。

    如果文件包含以下行,它们将被打印。

    line : Example1
    line : Example2
    

    读取文件的内容到字符串

    如果要将文件的整个内容作为字符串获取,可以使用文件类的text属性。以下示例显示如何完成此操作。

    class Example { 
       static void main(String[] args) { 
          File file = new File("E:/Example.txt") 
          println file.text 
       } 
    }
    

    如果该文件包含以下行,它们将被打印出来。

    line : Example1 
    line : Example2
    

    写入文件

    如果你想写入文件,你需要使用作家类输出文本到一个文件中。下面的例子说明了如何可以做到这一点。

    import java.io.File 
    class Example { 
       static void main(String[] args) { 
          new File('E:/','Example.txt').withWriter('utf-8') { 
             writer -> writer.writeLine 'Hello World' 
          }  
       } 
    }
    

    如果你打开文件example.txt文件,您将看到文本中打印了“Hello World”这个词。

    获取文件的大小

    如果要获取文件的大小,可以使用文件类的length属性来获取,以下示例显示如何完成此操作。

    class Example {
       static void main(String[] args) {
          File file = new File("E:/Example.txt")
          println "The file ${file.absolutePath} has ${file.length()} bytes"
       } 
    }
    

    上面的代码将显示文件的大小(以字节为单位)。

    测试文件是否是目录

    如果要查看路径是文件还是目录,可以使用File类的isFile和isDirectory选项。以下示例显示如何完成此操作。

    class Example { 
       static void main(String[] args) { 
          def file = new File('E:/') 
          println "File? ${file.isFile()}" 
          println "Directory? ${file.isDirectory()}" 
       } 
    }
    

    上面的代码将显示以下输出 - 

    File? false 
    Directory? True
    

    创建目录

    如果要创建一个新目录,可以使用File类的mkdir函数。以下示例显示如何完成此操作。

    class Example {
       static void main(String[] args) {
          def file = new File('E:/Directory')
          file.mkdir()
       } 
    }
    

    如果目录E:\ Directory不存在,将创建它。

    删除文件

    如果要删除文件,可以使用File类的delete功能。以下示例显示如何完成此操作。

    class Example {
       static void main(String[] args) {
          def file = new File('E:/Example.txt')
          file.delete()
       } 
    }
    

    如果存在该文件将被删除。

    复制文件

    Groovy还提供将内容从一个文件复制到另一个文件的功能。以下示例显示如何完成此操作。

    class Example {
       static void main(String[] args) {
          def src = new File("E:/Example.txt")
          def dst = new File("E:/Example1.txt")
          dst << src.text
       } 
    }
    

    将创建文件Example1.txt,并将文件Example.txt的所有内容复制到此文件。

    获取目录内容

    Groovy还提供了列出驱动器中的驱动器和文件的功能。

    以下示例显示如何使用File类的listRoots函数显示机器上的驱动器。

    class Example { 
       static void main(String[] args) { 
          def rootFiles = new File("test").listRoots() 
          rootFiles.each { 
             file -> println file.absolutePath 
          }
       }
    }
    

    根据机器上可用的驱动器,输出可能会有所不同。在标准机器上的输出将类似于下面的一个 - 

    C:\
    D:\
    

    以下示例显示如何使用File类的eachFile函数列出特定目录中的文件。

    class Example {
       static void main(String[] args) {
          new File("E:/Temp").eachFile() {  
             file->println file.getAbsolutePath()
          }
       } 
    }
    

    输出将显示目录E:\ Temp中的所有文件

    如果要递归显示目录及其子目录中的所有文件,则可以使用File类的eachFileRecurse函数。以下示例显示如何完成此操作。

    class Example { 
       static void main(String[] args) {
          new File("E:/temp").eachFileRecurse() {
             file -> println file.getAbsolutePath()
          }
       }
    } 
    

    输出将显示目录E:\ Temp中的所有文件及其子目录(如果存在)。



    Groovy 可选

    由 lichiabor 创建,小路依依 最后一次修改 2016-12-12

    Groovy是一个“可选”类型的语言,当理解语言的基本原理时,这种区别是一个重要的语言。与Java相比,Java是一种“强”类型的语言,由此编译器知道每个变量的所有类型,并且可以在编译时理解和尊重合同。这意味着方法调用能够在编译时确定。

    当在Groovy中编写代码时,开发人员可以灵活地提供类型或不是类型。这可以提供一些简单的实现,并且当正确利用时,可以以强大和动态的方式为您的应用程序提供服务。

    在Groovy中,可选的键入是通过'def'关键字完成的。下面是一个使用def方法的例子 - 

    class Example { 
       static void main(String[] args) { 
          // Example of an Integer using def 
          def a = 100; 
          println(a); 
    		
          // Example of an float using def 
          def b = 100.10; 
          println(b); 
    		
          // Example of an Double using def 
          def c = 100.101; 
          println(c);
    		
          // Example of an String using def 
          def d = "HelloWorld"; 
          println(d); 
       } 
    } 
    

    从上面的程序,我们可以看到,我们没有声明单个变量为Integer,float,double或string,即使它们包含这些类型的值。

    当我们运行上面的程序,我们将得到以下结果 - 

    100 
    100.10 
    100.101
    HelloWorld
    

    可选的打字在开发期间可以是一个强大的实用程序,但是当代码变得太大和复杂时,可能导致在后期开发阶段的可维护性问题。

    要了解如何使用Groovy中的可选输入,而不让代码库陷入无法维护的混乱,最好在应用程序中采用“鸭式输入”的理念。

    如果我们使用鸭式重写上面的代码,它将看起来像下面给出的。变量名称的名称比它们代表的类型更多,这使得代码更容易理解。

    class Example { 
       static void main(String[] args) { 
          // Example of an Integer using def 
          def aint = 100; 
          println(aint); 
    		
          // Example of an float using def 
          def bfloat = 100.10; 
          println(bfloat); 
    		
          // Example of an Double using def 
          def cDouble = 100.101; 
          println(cDouble);
    		
          // Example of an String using def 
          def dString = "HelloWorld"; 
          println(dString); 
       } 
    }

    Groovy 数字

    由 lichiabor 创建,小路依依 最后一次修改 2016-12-12

    在Groovy中,数字实际上表示为对象,它们都是类Integer的一个实例。要使对象做某事,我们需要调用在其类中声明的一个方法。

    Groovy支持整数和浮点数。

    • 整数是不包含分数的值。
    • 浮点数是包含小数部分的十进制值。

    Groovy中的数字示例如下所示 - 

    Integer x = 5; 
    Float y = 1.25; 
    

    其中x是整数类型,y是浮点数。

    groovy中的数字被定义为对象的原因通常是因为存在对数字执行操作的要求。在原始类型上提供类的概念被称为包装类。

    默认情况下,Groovy中提供了以下包装程序类。

    包装类

    包装类的对象包含或包装其各自的基本数据类型。将原始数据类型转换为对象的过程称为装箱,这由编译器负责。将对象转换回其对应的基本类型的过程称为取消装箱。

    例子

    以下是装箱和拆箱的例子 -

    class Example { 
       static void main(String[] args) {
          Integer x = 5,y = 10,z = 0; 
    		
          // The the values of 5,10 and 0 are boxed into Integer types 
          // The values of x and y are unboxed and the addition is performed 
          z = x+y; 
          println(z);
       }
    }
    

    上述程序的输出将为5.在上述示例中,5,10和0的值相应地首先嵌入到整数变量x,y和z中。上述程序的输出将是5。然后,当执行x和y的添加时,值从其整数类型取消装箱。

    数字方法

    由于Groovy中的Numbers表示为类,以下是可用的方法列表。

    序号方法和描述
    1xxxValue()

    此方法接受Number作为参数,并基于调用的方法返回基本类型。

    2compareTo()

    compareTo方法是使用比较一个数字与另一个数字。如果要比较数字的值,这是有用的。

    3equals()

    该方法确定调用方法的Number对象是否等于作为参数传递的对象。

    4valueOf()

    valueOf方法返回保存所传递的参数的值的相关Number对象。

    5toString()

    该方法用于获取表示Number对象的值的String对象。

    6parseInt()

    此方法用于获取某个String的原始数据类型。 parseXxx()是一个静态方法,可以有一个参数或两个参数。

    7abs()

    该方法给出了参数的绝对值。参数可以是int,float,long,double,short,byte。

    8ceil()

    方法ceil给出大于或等于参数的最小整数。

    9floor()

    方法floor给出小于或等于参数的最大整数。

    10rint()

    方法rint返回值最接近参数的整数。

    11round()

    方法round返回最接近的long或int,由方法返回类型给出。

    12min()

    该方法给出两个参数中较小的一个。参数可以是int,float,long,double。

    13max()

    该方法给出了两个参数的最大值。参数可以是int,float,long,double。

    14exp()

    该方法返回自然对数e的底数为参数的幂。

    15log()

    该方法返回参数的自然对数。

    16pow()

    该方法返回第一个参数的值增加到第二个参数的幂。

    17sqrt()

    该方法返回参数的平方根。

    18sin()

    该方法返回指定double值的正弦值。

    19cos()

    该方法返回指定double值的余弦值。

    20tan()

    该方法返回指定double值的正切值。

    21asin()

    该方法返回指定double值的反正弦值。

    22acos()

    该方法返回指定double值的反余弦值。

    23atan()

    该方法返回指定double值的反正切。

    24atan2()

    该方法将直角坐标(x,y)转换为极坐标(r,theta),并返回theta。

    25parseInt()

    该方法将参数值转换为度。

    26radian()

    该方法将参数值转换为弧度。

    27random()

    该方法用于生成介于0.0和1.0之间的随机数。范围是:0.0 = <Math.random <1.0。通过使用算术可以实现不同的范围。


    Groovy xxxValue()方法

    由 yuleiming 创建,youj 最后一次修改 2016-12-29

    此方法接受Number作为参数,并基于调用的方法返回基本类型。 以下是可用的方法列表 -

    byte byteValue() 
    short shortValue() 
    int intValue() 
    long longValue() 
    float floatValue() 
    double doubleValue()
    

    参数 - 无需参数。

    返回值 - 返回值是根据调用的值函数返回的原始类型。

    例子

    以下是方法值的用法示例。

    class Example { 
       static void main(String[] args) {  
          Integer x = 5; 
    		
          // Converting the number to double primitive type
          println(x.doubleValue()); 
    		
          // Converting the number to byte primitive type 
          println(x.byteValue()); 
    		
          // Converting the number to float primitive type 
          println(x.floatValue());
    		
          // Converting the number to long primitive type 
          println(x.longValue()); 
    		
          // Converting the number to short primitive type 
          println(x.shortValue()); 
    		
          // Converting the number to int primitive type 
          println(x.intValue());  
       } 
    }
    

    当我们运行上面的程序,我们将得到以下结果 -

    5.0 
    5 
    5.0 
    5 
    5 
    5 


    Groovy compareTo()方法

    由 yuleiming 创建,youj 最后一次修改 2016-12-29

    compareTo方法是使用比较一个数字与另一个数字。如果要比较数字的值,这是有用的。

    句法

    public int compareTo( NumberSubClass referenceName ) 
    

    参数

    referenceName - 这可以是字节,双精度,整数,浮点型,长整型或短整型。

    返回值

    • 如果整数等于参数,则返回0。
    • 如果整数小于参数,则返回-1。
    • 如果整数大于参数,则返回1。

    例子

    下面是一个使用这个方法的例子 -

    class Example { 
       static void main(String[] args) { 
          Integer x = 5;
    		
          //Comparison against a Integer of lower value 
          System.out.println(x.compareTo(3));
    		
          //Comparison against a Integer of equal value 
          System.out.println(x.compareTo(5)); 
    		
          //Comparison against a Integer of higher value 
          System.out.println(x.compareTo(8)); 
       } 
    } 
    

    当我们运行上面的程序,我们将得到以下结果 -

    1 
    0 
    -1 


    Groovy equals()方法

    由 yuleiming 创建,youj 最后一次修改 2016-12-29

    该方法确定调用方法的Number对象是否等于作为参数传递的对象。

    句法

    public boolean equals(Object o)
    

    参数

    o - 任何对象。

    返回值

    如果参数不为空,并且是同一类型且具有相同数值的对象,则方法返回True。

    例子

    下面是一个使用这个方法的例子 -

    class Example { 
       static void main(String[] args) { 
          Integer x = 5; 
          Integer y = 10; 
          Integer z = 5; 
    		
          //Comparison against an Integer of different value 
          System.out.println(x.equals(y));
    		
          //Comparison against an Integer of same value 
          System.out.println(x.equals(z));  
       } 
    }
    

    当我们运行上面的程序,我们将得到以下结果 -

    false 
    true









    --------------------------------------------------------------------------



    展开全文
  • 一个非常轻巧的基于Groovy的Web应用程序项目模板 您可能听说过该项目Grails是Ruby on Rails之Groovy版本的框架,该框架使您可以通过动态脚本更轻松地创建Web应用程序。 尽管Grails提供了所有功能,但如果您仔细...

    groovy 模板

    一个非常轻巧的基于Groovy的Web应用程序项目模板

    您可能听说过该项目Grails是Ruby on Rails之类的Groovy版本的框架,该框架使您可以通过动态脚本更轻松地创建Web应用程序。 尽管Grails提供了所有功能,但如果您仔细观察引擎盖,它并不是“轻巧”的。 我并不是说Grails不好或什么。 使用Grails编写Web应用程序实际上非常酷。 但是我发现自己经常想要更轻的东西,但仍然想用Groovy做原型。 因此,在这里,我将向您展示一个maven-groovy-webapp项目模板,该模板用于开始任何Web应用程序开发。 它非常简单,轻巧,但是却非常时髦。

    如何开始

    解压缩上面的maven-webapp-groovy.zip文件,您应该看到以下几个文件:

    bash> cd maven-webapp-groovy
    bash> find .
    bash> ./pom.xml
    bash> ./README.txt
    bash> ./src
    bash> ./src/main
    bash> ./src/main/java
    bash> ./src/main/java/deng
    bash> ./src/main/java/deng/GroovyContextListener.java
    bash> ./src/main/resources
    bash> ./src/main/resources/log4j.properties
    bash> ./src/main/webapp
    bash> ./src/main/webapp/console.gt
    bash> ./src/main/webapp/health.gt
    bash> ./src/main/webapp/home.gt
    bash> ./src/main/webapp/WEB-INF
    bash> ./src/main/webapp/WEB-INF/classes
    bash> ./src/main/webapp/WEB-INF/classes/.keep
    bash> ./src/main/webapp/WEB-INF/groovy
    bash> ./src/main/webapp/WEB-INF/groovy/console.groovy
    bash> ./src/main/webapp/WEB-INF/groovy/health.groovy
    bash> ./src/main/webapp/WEB-INF/groovy/home.groovy
    bash> ./src/main/webapp/WEB-INF/groovy/init.groovy
    bash> ./src/main/webapp/WEB-INF/groovy/destroy.groovy
    bash> ./src/main/webapp/WEB-INF/web.xml

    如您所见,它是一个基于Maven的应用程序,并且我已经配置了tomcat插件,因此您可以这样运行它:

    bash> mvn tomcat7:run
    bash> open http://localhost:8080/maven-webapp-groovy/home.groovy

    当然,使用maven,运行程序包阶段可以让您在准备就绪时将其部署到任何实际的应用程序服务器中。

    bash> mvn package
    bash> cp target/maven-webapp-groovy.war $APP_SERVER_HOME/autodeploy

    里面是什么

    您应该在web.xml文件中检出主要配置,然后您会看到有一些内置的Groovy servlet和一个自定义侦听器。

    <?xml version="1.0"?>
    <web-app xmlns="http://java.sun.com/xml/ns/javaee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
            version="2.5">
    
        <description>Groovy Web Application</description>
        <welcome-file-list>
            <welcome-file>home.groovy</welcome-file>
        </welcome-file-list>
    
        <servlet>
            <servlet-name>GroovyServlet</servlet-name>
            <servlet-class>groovy.servlet.GroovyServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>GroovyServlet</servlet-name>
            <url-pattern>*.groovy</url-pattern>
        </servlet-mapping>
    
        <servlet>
            <servlet-name>TemplateServlet</servlet-name>
            <servlet-class>groovy.servlet.TemplateServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>TemplateServlet</servlet-name>
            <url-pattern>*.gt</url-pattern>
        </servlet-mapping>
    
        <listener>
            <listener-class>deng.GroovyContextListener</listener-class>
        </listener>
        <context-param>  
           <param-name>initScripts</param-name>
           <param-value>/WEB-INF/groovy/init.groovy</param-value>
        </context-param>
        <context-param>    
           <param-name>destroyScripts</param-name>
           <param-value>/WEB-INF/groovy/destroy.groovy</param-value>
        </context-param>
    
    </web-app>

    我选择将GroovyServlet用作控制器(它是Groovy附带的),这使您可以使用/WEB-INF/groovy目录中的任何脚本。 就是这样,无需进一步设置。 这是启动Groovy Webapp所需的唯一条件! 请参阅console.groovy作为示例及其工作方式。 这是此JVM控制台的常规版本

    现在,您可以使用Groovy处理任何逻辑,甚至可以根据需要生成HTML输出,但是我发现使用TemplateServlet更容易。 这样就可以将Groovy模板文件用作视图。 它非常类似于JSP,但是它使用Groovy代替! 而且我们知道Groovy语法要短得多! 请参阅console.gt作为示例及其工作方式。

    GroovyContextListener是我写的东西,它是可选的。 这使您可以在webapp启动或关闭状态下运行任何脚本。 我创建了一个空的init.groovydestroy.groovy占位符。 因此,现在您拥有了几乎所需的任何Web应用程序原型所需的所有功能。

    简单胜出

    此设置只是加载了Groovy的普通Java Servlet。 我经常认为,越简单,错误越少,代码编写速度就越快。 没有沉重的框架,没有额外的学习曲线(除了基本的Servlet API和Groovy / Java的课程知识),然后就可以使用了。
    使用此Groovy Webapp模板玩得开心! 并且让我知道您在玩过这个游戏后是否有炫酷的原型可以炫耀。

    参考:来自A程序员杂志博客的JCG合作伙伴 Zemian Deng提供的基于Groovy的非常轻量的Web应用程序项目模板

    翻译自: https://www.javacodegeeks.com/2012/12/a-very-light-groovy-based-web-application-project-template.html

    groovy 模板

    展开全文
  • 02Groovy语法()

    2017-06-04 11:35:47
    Groovy语法直接来源于java的语法特性。 比如: 关键字和语句都是和java类似。... Groovy也是使用new来创建对象的。 Groovy也会自动的导入许多包: groovy.lang.* groovy.util.* java.lang.*

    Groovy语法直接来源于java的语法特性。
    比如:
    关键字和语句都是和java类似。
    类,接口,属性,方法的定义。
    Groovy也是使用new来创建对象的。
    Groovy也会自动的导入许多包:
    groovy.lang.*
    groovy.util.*
    java.lang.*
    java.util.*
    java.util.regex.*
    java.net.*
    java.io.*

    异常处理也是try/catch/finally机制
    运算符,表达式,赋值
    控制结构
    代码注释
    等等这些都是和java语法类似的。

    数值与表达式

    数值

    Groovy中所以东西都是对象。整数(-1,200,20)都是Integer类的对象。

    定义变量(动态类型):def price = 100

    等同于:Integer price = new Integer(100);
    groovy语句可以不使用逗号结尾。

    也是支持自动的拆箱和装箱。
    3.times{println “Hello”}:打印三次。这个在Java中无法实现的。(把3看做一个对象;所以对象.方法是正常的)
    浮点数:1.5,-3.14都是BigDecimal类的对象。
    数值类型:
    Integer 15 Long 100L,100l
    Float 1.23F Double 1.25D
    java.math.BigInteger 123g,456G(无小数点)
    java.math.BigDecimal 1.23g,1.23G(有小数点)

    GDK中的数值方法:

    def store = ''
    10.times{store += 'X'}:执行10次。
    1.upto(5){number -> store += number}:数字从1,到5(这里是一个闭包:number作为参数)
    2.downto(-2){number -> store+= number+''}:从大到小。
    0.step(0.5,0.1){number -> store += nubmer + ''}:从0开始,一直长到0.5,每次长0.1。后面又是一个闭包。
    

    运算符

    基于方法的运算符。
    a==b 等价于 java中的 a.equals(b)
    Groovy中的===就是java中的==
    Groovy支持操作符重载,重载运算符对应的方法就是操作符重载。(实际上就是方法的重载)
    <<操作符被重载,以支持向集合中添加项。
    ?=安全引用操作符(防止空指针异常),在方法调用前添加一?就相当于在调用前面放了一个条件,可以防止在null对象上调用方法。?操作符非常有用,可以极大减少条件语句。
    基于方法的运算符:
    这里写图片描述
    注意最后三个比较方法,大于返回1,等于返回0,小于返回-1.

    这些方法可以到GroovyConsole中去验证:Ctrl+Enter执行。(断言成功返回null)

    字符串简介

    字符串GString简介

    def str = “hello”;print str//同行中多个语句,‘;’不能少哦
    def name = ‘xiaoxiao’
    print “${name}“:引用name变量的值
    Groovy中字符串可以使用单引号或双引号括起来(可以在其内部加入\n等转义字符),但是java中不行,java中单引号用来包含单个字符,双引号才能包含字符串。
    原格式输出:三个单引号。不用像java中使用+号来连接字符串。

    print  ''' 
        aaa
        bbb
    '''
    

    三个双引号:内部就可以使用${}来获取变量的值。

    print """
        \taaa
        ${name}
        \nbbb
    """
    

    Groovy中的方法

    Groovy中可以直接使用java方法。
    变量作用域与java方法类似。
    可以使用动态类型或静态类型:
    安全引用时使用静态类型。OR映射时使用静态类型,指定变量类型与数据库列匹配。

    可以省略return,默认返回最后语句的值

    定义方法

    def fun(name){
        println "Hello ${name}"//默认返回最后一句值,没有使用return语句。
    }
    

    执行方法

    fun(“小名”)

    Groovy方法的默认参数

    这个在java中也是不被支持的。
    def fun(name,welcomeStr=’Hello’){
    print “ welcomeStr {name}”
    }
    func(“小明”)//输出 Hello 小明
    func(“小明”,”翻译”)//输出:翻译 小明

    调用方法时,优先选择匹配参数个数的方法。

    例如上面的第一个定义的fun()和第二个定义的fun();当只传入一参数是就是调用第一fun()。
    也可以通过指定具体参数的类型,来进行匹配。

    Groovy方法的参数:值传递还是引用传递?

    def printName(name){
    println “before namename=printlnafter {name}”
    }

    def name = “SS”
    printName(name)
    输出:before SS
    after “小明”
    println “${name}”:输出:SS

    可见Groovy方法参数是值传递。

    控制流程

    循环

    def count = 1;def limit = 5
    while(count <= limit){
        println "count: ${count}"
        count++
    }
    for(i = 0;i<5;i++){pirntln "hello"}
    for(i in [1,2,3,4,5]){//可以用在范围或映射或GSting上
        print i
    }
    breakcontinue与java一样。

    判断

    • if(1){println “Goog”}//输出:Goog

    • def a
      if(a){println “good”}
      else{print ‘null’}

    • def b = []
      if(b){println “good”}
      else{print ‘null’}

    • def c = [1:”FF”,2:”DD”]
      if(c){println “good”}
      else{print ‘null’}

    结论:if的条件除了是布尔值外,可以可以是对象,空表示FALSE,否则为TRUE

    switch语句

    A:java类似的

    switch(4){
    case 1: pirntln "One" ;break
    case 2: println "Two" ; break
    .....
    default: println "Default"
    }
    

    B:Groovy特性

    def var = 0
    switch(var){
    case 0:    println "One"
    case 11..20:     println "Two"//var 值在11-20范围之间
    case '10':  println "Three"
    case [1,2,3]:  println "Four"//一个列表中的元素。
    case Float:    println "Five"//1.5F满足float类型
    case {it % 3 == 0}: println "Six"//满足闭包条件
    case ~'[0-9]{3}': println "Seven"//正则
    default : println "default"
    }
    

    控制台输入与输出

    读取标准输入:

    def name = new BufferedReader(new InputStreamReader(System.in)).readLine()
    println “your name is :${name}”
    System.in.readLine()已经被废除了,在Groovy中使用会出错。

    标准输出:

    print 不换行
    println 换行
    

    格式化输出 :printf

    printf(“%d-%f-\n[%s][%10s][%-10s]”,[5,5.2,’sdfs’,’sdfsd’])
    %d:按整型数据
    %f:按浮点类型输出
    %-10s:宽度10,左侧输出字符串

    我们可以通过GroovyConsole小工具来验证代码片段

    注意:Groovy编程,可以是脚本,也可以重构为Groovy类。
    Groovy中==与java中的不同

    展开全文
  • 一个非常轻巧的基于Groovy的Web应用程序项目模板 您可能听说过该项目Grails是Ruby on Rails之Groovy版本的框架,该框架使您可以通过动态脚本轻松地创建Web应用程序。 尽管Grails提供了所有功能,但如果您仔细...
  • Groovy语言学习

    2019-07-04 14:39:44
    Groovy是什么 Groovy是在Java平台上,具有像Python,Ruby,SmallTalk 语言特性的灵活动态语言。Groovy保证这些特性像Java语法...Groovy仅仅是创建Java种新的途径(运行时创建Groovy的语法与Java相似。 G...
  • Groovy思考 第三章 Groovy开发环境

    千次阅读 2013-04-06 10:17:08
    Groovy思考 第三章 Groovy开发环境作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs本章将继续...你将学会使用Groovy语言来建立域对象、控制器和服务。而且使用Groovy的方法并非只有种。另外,对
  • 、变量 1、类型 对象类型、基本类型(本质是对象类型) int x = 0 println x.class double y = 3.14 println y.class 输出: class java.lang.Integer class java.lang.Double 结论: 从log输出可以得出,groovy...
  • Groovy 1.5

    2008-10-16 10:22:54
    Groovy 1.5的新特性 作者 Guillaume Laforge译者 曹云飞 发布于 2008年1月15日 下午...在2007年1月成功地发布了Groovy 1.0之后,下一个主要的里程碑1.5版已经发布。在1.5版中有一些有趣而新颖的地方,我们会在这篇文...
  • Groovy秘诀

    2018-10-24 11:32:00
    Groovy秘诀 听说java世界里有个Groovy大神!java...
  • groovy 学习

    2020-02-05 14:44:05
    groovy 的环境安装 centos下的安装 $ curl -s get.sdkman.io | bash $ source "$HOME/.sdkman/bin/sdkman-init.sh" $ sdk install groovy $ groovy -version windows下的安装 官网下载安装包后解压,配置...
  • 创建一个xml文件 /** * * @author liangchen* @date 2020/11/20 */ // 11.3 def builder = new groovy.xml.MarkupBuilder() builder.numbers { //文本 description 'Square and factors of 10..15' for (i ...
  • Groovy简介与使用

    万次阅读 多人点赞 2018-11-04 16:59:17
    简介 使用 应用 Groovy语法特性(相比于Java) Groovy与Java项目集成使用 GroovyShell GroovyClassLoader GroovyScriptEngine ...对于仅有一个类 对于多个 对于有定义的脚本 Spring对Groo...
  • groovy_流利的Groovy

    2020-07-03 08:23:58
    Groovy而不是替换Java,而是对其进行了补充,提供了种更简单,更流畅的语法,其中类型检查在运行时动态完成。 您可以使用Groovy即时编写Java应用程序,将Java模块粘合在一起,甚至扩展现有的Java应用程序,甚至.....
  • groovy安装

    2017-11-08 10:28:29
    Groovy是依赖于Java的,所以首先要配置好JDK。 Step2:下载Groovy 下载地址,下载下来解压即可。 Step3:配置Groovy环境变量 vim ~/.bash_profile 输入 # groovy export PATH=$PATH:/Users/xuhongchuan/...
  • Groovy培训

    2018-03-15 20:09:25
    概念Groovy种动态语言,它和Java类似(算是Java的升级版,但是又具备脚本语言的特点),都在Java虚拟机中运行。//区别1.在Groovy可以用def定义无类型的变量,和返回值为无类型的方法,而在Java中没有def2. Java...
  • 你将学会使用Groovy语言来建立域对象、控制器和服务。而且使用Groovy的方法并非只有种。另外,对于建立,可以使用Groovy作为脚本语言。例1:简单的Groovy脚本Hello.groovyprintln "Hello ${arg...
  • Groovy学习

    2013-08-27 20:56:56
    Groovy 代码通常要比 Java 代码更容易编写,而且编写起来也更快,这使得它有足够的资格成为开发工作包中的一个附件。在另一方面,正如我在这个系列中反复强调的那样,Groovy 并不是 —— 而且也不打算成为 —— Java...
  • Groovy基础篇

    2017-06-07 16:12:10
    Groovy基础学习首先,了解一下什么是Groovy: ·它是种像Java一样运行在JVM上,但更加敏捷的动态语言。 ·它的语法理念源于Python,Ruby和Smalltalk,但它的语法与Java语言的语法很是相似。 ·相比于Java,大大减少...
  • Groovy 进行 JDBC 编程

    千次阅读 2008-12-14 10:24:00
    在 实战 Groovy 系列的前几期中,您已经了解了 Groovy 的一些非常优美的特性。在 第 1 期 中,学习了如何用 Groovy 对普通的 Java™ 代码进行更简单、更...这一次您会发现 Groovy 的另一个实际应用,即如何用它迅速地构
  • groovy语法

    千次阅读 2014-08-20 10:27:52
    过去半年都在写Groovy,基本都是在实战中学习,从java转过来,也还没什么问题,毕竟基础,架构都没变。 Groovy的强大特性中,Closure,MetaClass都...MetaClass就有专门为一个模块做了些MetaClass,和GORM差不多的,
  • Groovy 快速入门

    千次阅读 2017-03-04 16:30:31
    Groovy是一门基于JVM的动态语言,很多语法和Java类似。大部分Java代码也同时是合法的Groovy代码。本文是快速入门,所以针对语法并不会做非常详细的介绍。如果需要详细语法,请直接查看Groovy官方文档。另外为了省事...
  • Groovy种可以用于构建的DSL,基于Jvm支持所有的Java语法,同时又对Java进行了扩展,提供了大量的语法糖去简化我们的代码。在开发中既能像Java一样用面向对象的方式编写,也能像脚本一样用面向过程的方式编写。而...
  • groovy_Groovy的无痛AOP

    2020-07-06 00:12:55
    groovy Cedric Beust将面向方面的编程(AOP)描述为“一个好主意,它将保留一些专家开发人员的特权” 。 对于某些人来说,即使使用Spring和JBoss,进入门槛仍然很高。 幸运的是,这是动态语言可以提供帮助的领域。 ...
  • 实战 Groovy: 用 Groovy 进行 JDBC 编程 用 GroovySql 构建下一个报告应用程序 ...
  • Groovy 语言基础

    2021-03-02 20:44:23
    Gradle 是一个构建工具,它的构建脚本是基于 Groovy 或是 Kotlin 语言编写的。 今天我们就来看下 Groovy 的基础语法。Groovy结合了 Java、Python、Ruby 等当下几大流行语言的优点。它可以说是从 Java 中衍生出来的...
  • Java调用Groovy的方法总结

    万次阅读 2013-09-10 22:17:18
    很多情况下,Groovy是执行某一类任务的理想工具,如快速原型开发设计(rapid prototyping)或创建可由宏指令(macros)或插件(plug-ins)扩展的模块应用。这些扩展可以用Groovy实现,而不需冗长乏味的开发部署周期...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,903
精华内容 4,761
关键字:

groovy创建一个控制类