1.1.1 前言

这几天快速学习了一下Groovy语言，现在还没有学习完。先进行记录，后续可以看看以前学习的资料。

首先还是需要有JAVA的基础，否则入门这方面没有那么简单。

还有不会去写Java的对比代码，太浪费时间，你们大概看下吧 。

还有我学的知识也是看到那写到哪，没有大概的标准。

举出的例子，也是我不熟悉，或者我不知道的知识点。因为明年要出去换公司，所以这也相当于在复习以前的知识。

安装groovy的环境自行百度吧。

1.1.2 基本语法

见面还是老规矩，你好！groovy。

  1. class test {
  2.     static void main(String[] args) {
  3.         println("hello groovy!");
  4.     }
  5. }

1.2.1 关键字解释

  • def ：相当于Object，所用定义方法名，定义字段名，定义数组名，定义Bean都可以使用def声明。需要避免和基本类型重合定义，例如：def String user
  • assert ：断言，判断传入的参数是否合法，根据异常会直接终止程序，还有减少使用这个关键字，会造成大量性能的浪费。

    1.2.2 基础

    1.2.2_a 范围运算符

    ```groovy // 范围 def range = 5..10; println(range); println(range.get(3));

// 结果 5..10 8

  1. <a name="lizUI"></a>
  2. ## 1.2.2_b 赋值运算符
  3. ```groovy
  4.  // 除余
  5.  int a = 5;
  6.  int b = 2;
  7.  def x = a %= b;
  8.  println(x);
  9.  if ((a %= b) == 1) {
  10.      println(true);
  11.  } else {
  12.      println(false);
  13.  }
  15. //结果
  16. 1
  17. true

1.2.2_c 循环（for-in语句）

  1.   // for-in语句 
  2.   def range = 5..10;
  4.   for (int r in range) {
  5.       print(r + ",");
  6.   }
  7.    // 结果
  8.    5,6,7,8,9,10,
  9. --------分割线-------------   
  11.   int[] arr = [0, 1, 2, 3, 4];
  12.   for (int i in arr) {
  13.        println(i);
  14.   }
  15.   // 结果
  16.   0
  17.   1
  18.   2
  19.   3
  20.   4

1.2.2_d 可以直接声明键值对

  1.      def employee = ["key": 1, "name": "Jokn", "Age": 30];
  2.      // 不需要声明属性类型，def可以忽略
  3.      for (emp in employee) {
  4.           println(emp);
  5.      }
  7.     //结果
  8.     key=1
  9.     name=Jokn
  10.     Age=30

1.2.2_e 方法（默认参数）

  1.    // 可以直接在参数里赋值
  2.     static def someMethod(int a, int c = 1) {
  3.         int d = a + c;
  4.         return d;
  5.     }
  7.     static void main(String[] args){
  8.         // 调用的时候，分两种方式
  9.         int result = someMethod(2);
  10.         println(result);
  11.         // 可以直接传入新参数，进行计算
  12.         int result2 = someMethod(5, 5);
  13.         println(result2);
  14.     }
  16.     // 结果
  17.     3
  18.     10

1.2.2_f 对象的使用

  1. class User implements Serializable {
  3.     private String name;
  4.     private String age;
  5.     private String sex;
  7.     /**
  8.      * 可以忽略get/set
  9.      * @return
  10.      */
  11.     String getName() {
  12.         return this.name;
  13.     }
  15.     void setName(String name) {
  16.         this.name = name;
  17.     }
  19.     /**
  20.      *  构造器，避免使用def
  21.      */
  22.     User() {}
  24. }

1.2.2_g get/set的使用

  1.   def user = new User();
  2.   // with：可以忽略大量的前缀，例如user.setName()
  3.   user.with {
  4.        name = 'Tom'
  5.        age = 50
  6.        sex = '男'
  7.   }
  8.   // set/get可以直接调用
  9.   user.sex = "女"
  10.   user.name = "something"
  12.   println "name=${user.name} age=${user.age} sex=${user.sex}"
  15.   // 结果
  16.   name=something age=50 sex=女
  17. ------------------分割线----------------------------
  19.   // 第二种直接声明，构造器都不需要
  20.   def user2 = new User(name: "huanfeng", age: 22, sex: "男")
  21.   // 输出的时候，需要双引号，否则会直接报错
  22.   println "${user2.name} ${user2.age} ${user2.sex}"
  24.   // 结果
  25.   huanfeng 22 男

1.2.2_h 分行打印快捷方式

  1.   // 可以忽略括号，但是有的方法需要
  2.   // “\”这个符号并没有换行，只有相当于tab键的空格
  3.   // 自动换行，使用三个多个双引号或单引号
  4.   println("1111111111111111111111111111111111111 1\
  5.         2 \
  6.         3")
  7.    // 结果
  8. 1111111111111111111111111111111111111 1        2         3
  10.   // 三个双引号框起后，里面的空格也会直接输出，并不会换行处理
  11.   println("""111111111111111111
  12. 222222222222222222
  13. 333333333333333333""")
  15.   // 结果
  16. 111111111111111111
  17. 222222222222222222
  18. 333333333333333333

1.2.2_i 三元运算符的使用

  1.     /**
  2.      * 三元运算的简写只能用来判断非空
  3.      * @param name
  4.      * @return
  5.      */
  6.     static def check(String name) {
  7.         assert name
  8.         def result = name ?: "Unknown"
  9.         // 可以省略return
  10.         result
  11.     }
  13.     /**
  14.      * 三元运算还是需要按照以前Java的格式
  15.      * @param str
  16.      * @return
  17.      */
  18.     static def checkNum(String str) {
  19.         def reulst = str.length() > 3 ? str : "xiaoyu"
  20.         reulst
  21.     }