苏州其然软件开发培训

我们是谁？Who we are?

其然IT教育集团是广州腾科网络技术有限公司旗下运营的网站平台。其然IT 教育集团是一家以提供新型、**的IT技术培训（教育）解决方案为主要经营目标的专业公司，是中国高端IT培训的**品牌。联合思科(Cisco)、甲 骨文(Oracle)、红帽(Red Hat)、华为(Huawei)、微软（Microsoft)、美国计算机行业协会（CompTIA）等国际知名IT厂商以 及国内300多家高等院校， 开展IT认证技能培训和IT职业课程教育，培养新型IT高级人才，是Pearson VUE国际电子考试中心和Prometric(普尔文)授权考试中心，并是达索 （solidworks）、安氏（LinkTrust）的授权经销商。

其然IT教育集团下辖上海分公司、深圳分公司、武汉分公司、杭州分公司等 8个分支机构。以及30多个培训网点，业务涵盖全国主要大、中型城市。

java入门要注意什么

学习java就像是一个种花的过程，不断地为其施肥浇水，它才会茁壮成长。 而我们学习java，就要不断的充实自己、提升自己，才能获得更多机会。很多开始学习java编程的小白，经常就会被概念、定义什么的搞糊涂。当分类 、对象、接口、构造函数等等各种专业名词出现的时候，你一定是脑子里好像一片空白，根本就搞不懂这些字眼的意思和关系，而且，这种情况下，很 容易导致你丧失自信心，开始逃避、拒绝，这些小白经常遇到的情况在我刚接触java的时候也遇见了，但是好在我足够幸运，遇见了诚筑说。我现在已 经是公司的项目经理了，今天，我为大家来总结了一些经验和建议，希望能够帮助到大家。

一点：熟练基本的j2seAPI

除去java语言本身的语法之外呢，要懂得并且熟练j2seAPI的API也是非常有 必要的，在这里，就建议大家首先去掌握字符串的处理、异常的处理、容器、输入输出、线程等，这些相对来说较为重要的。还有就是API的内容是非 常庞大的，关于API，一定要懂得查询API的文件说明，在了解了其作用用途或者目的才能够进行相对于的程序。

二点：稳固java的语法基础

学习java一定要学会使用java的程序语言，用来编写程序，但是学习程序语 言就要熟悉语法是怎么使用的。程序语言其实也是一种语言，不过跟人类的语言不同，这种语言是要和计算机沟通交流，那怎么做才能熟悉这种语言呢 ，我给出的建议是多看别人写的程序，了解人家是怎么用java来解决问题的。然后再找类似的程序去练习了，这样就能够从实际操作中检验自己是否真 的知道该怎么去解决问题了。

三点：加入贴吧论坛多参与讨论

根据我当时的经验，在大家学习的过程中，如果有人可以参与话题，共同讨 论的话，会加快你学习的速度。所以大家可以和我一样，找一个技术讨论的地方，贴吧啊，论坛啊都可以，在这里进行讨论，毕竟大家有着共同的目标 和理想，有着共同的话题可聊，这样的话，又大大节省了学习的时间。

学完基本的java语法呢，现在就该用java来进行实际的编程了，假如你需要 编写窗口程序，那就学Swing窗口设计；假如你要编写数据库什么的，那就学JDBC等等。

Java课程介绍 ：

Java企 业级应用

“就业班”

一阶段 Java语言核心

第二阶段 数据库及Web前端技术

第三阶段 Java Web开发及服务端 框架

第四阶段 综合项目实践

Java课程介绍 

Java企业级应用

“就业班”

一阶段 Java语言核心

二阶段 数据库及Web前端技术

三阶段 Java Web开发及服务端框架

四阶段 综合项目实践

Java互联网开发

“培优班”

一阶段 Java语言核心

二阶段 Java Web服务端技术

三阶段 Java Web框架及互联网架构

四阶段 Java互联网架构

职场华丽转身

“才高班”

大数据 互联网大牛班

6大实训项目

“爱逛网”电商后端数据平台

培训经验=就业经验

>Java互联网开发

“培优班”

一阶段 Java语言核心

第二阶段 Java Web服务端技术

第三阶段 Java Web框架及互联网架构

第四阶段 Java互联网架构

职场华丽转身

“才高班”

大数据 互联网大牛班

6大实训项目

“爱逛网”电商后端数据平台

培训经验=就业经验

Groovy 快速入门

---

>

Groovy是一门基于JVM的动态语言，很多语法和java类似。大部分Java代码也同时是合法的Groovy代码。本文是快速入门，所以针对语法并不会做非常详细的介绍。如果需要详细语法，请直接查看Groovy**方文档。另外为了省事，本文中的大部分代码例子直接引用了Groovy文档。

基本内容

注释

单行注释，以//开头。

多行注释，/* */。

GroovyDoc注释，和JavaDoc注释类似。

/** * Creates a greeting method for a certain person. * * @param otherPerson the person to greet * @return a greeting message */

Shebang注释，和linux其他注释类似，用于指定脚本解释器的位置。

#!/usr/bin/env groovy

标识符

大体上，Groovy标识符的命名规则和Java差不多。如果某个标识符在Groovy中合法，在Java中不合法，我们可以使用单引号或双引号将标识符包括起来。

字符串

字符串可以使用单引号 或双引号"包括起来。

def str="1234" def str2= 1234

多行字符串可以使用三个连续的单引号或双引号包括。不论是单行还是多行字符串， 都可以使用反斜杠转义字符。

def multiline="""line1 line2 line3 """

我们还可以将变量直接插入到字符串中，这叫做内插字符串（String interpolation）。语法和EL表达式类似。编译器会把美元和花括号中的内容替换成实际的值，内插字符串中还可以进行表达式计算。

def name = Guillaume // a plain string def greeting = "Hello ${name}"

当内插字符串可以由前后的符号区分出的时候，花括号可以省略。

def person = [name: Guillaume , age: 36] assert "$person.name is $person.age years old" == Guillaume is 36 years old

当使用内插字符串的时候，字符串字面值是Groovy的字符串类型GString。这一点需要注意。普通的Java字符串是不变的，而GString是可变的。另外它们的哈希值也不同。因此在使用Map等数据类型的时候需要格外注意，避免使用GString作为Map的键。

字符

Groovy没有字符字面量。如果需要向Java方法传入单个字符的话，可以使用下面的方法进行转换。

def c2 = B as char assert c2 instanceof Character def c3 = (char) C assert c3 instanceof Character

布尔类型

Groovy的布尔类型和Java类似，也有true和false两个值。不过Groovy的布尔语义更丰富。未到结尾的迭代器、非空对象引用、非零数字都认为是真；空集合、空字符串等认为是假。详情参见Groovy文档 core-semantics#Groovy-Truth

数字类型

Groovy支持byte、char 、short、 int 、long和 BigInteger等几种数字类型。如果使用普通方式声明，它们和Java中的变量很相似。

int i = 4 BigInteger bi = 6

如果使用def关键字声明，那么这些数字会自动选择可以容纳它们的类型。

def a = 1 assert a instanceof Integer // Integer.MAX_VALUE def b = 2147483647 assert b instanceof Integer // Integer.MAX_VALUE 1 def c = 2147483648 assert c instanceof Long // Long.MAX_VALUE def d = 9223372036854775807 assert d instanceof Long // Long.MAX_VALUE 1 def e = 9223372036854775808 assert e instanceof BigInteger

这些整数还可以添加0b、0和0x前缀，分别代表8进制数，8进制数和16进制数。

另外Groovy还支持float、double和BigDecimal三种浮点数类型。原理同上。还可以使用科学计数法1.123E10这样的形式代表浮点数。

Groovy的数字常量同样支持后缀区分字面值类型，这几种类型和Java中的类似。唯一不同的是Groovy还支持G和g后缀，代表BigInteger或BigDecimal类型，根据字面值是否含有小数点来区分。

数学计算

数字的计算结果和Java规则类似：小于int的整数类型会被提升为int类型，计算结果也是int类型；小于long的整数类型和long计算，结果是long类型；BigInteger和其它整数类型计算，结果是BigInteger类型；BigDecimal和其它整数类型计算，结果是BigDecimal类型；BigDecimal和float、double等类型计算，结果是double类型。

列表

Groovy中的列表比较灵活，有点像Python中的列表。使用[....]语法可以声明列表，默认情况下列表是ArrayList实现。我们也可以使用as运算符自己选择合适的列表底层类型。

def arrayList = [1, 2, 3] assert arrayList instanceof java.util.ArrayList def linkedList = [2, 3, 4] as LinkedList assert linkedList instanceof java.util.LinkedList

有了列表之后，就可以使用它了。使用方法和Python差不多。我们使用[索引]引用和修改列表元素。如果索引是负的，则从后往前计数。要在列表末尾添加元素，可以使用左移运算符<<。如果在方括号中指定了多个索引，会返回由这些索引对应元素组成的新列表。使用两个点加首位索引..可以选择一个子列表。

def letters = [ a , b , c , d ] assert letters[0] == a assert letters[1] == b assert letters[-1] == d assert letters[-2] == c letters[2] = C assert letters[2] == C letters << e assert letters[ 4] == e assert letters[-1] == e assert letters[1, 3] == [ b , d ] assert letters[2..4] == [ C , d , e ]

列表还可以组合成复合列表。

def multi = [[0, 1], [2, 3]] assert multi[1][0] == 2

数组

声明数组的方式和列表一样，只不过需要显示指定数组类型。数组的使用方法也和列表类似，只不过由于数组是不可变的，所以不能像数组末尾添加元素。

int[] intArray = [1, 2, 3, 4, 5] def intArray2 = [1, 2, 3, 4, 5, 6] as int[]

Map

创建Map同样使用方括号，不过这次需要同时指定键和值了。Map创建好之后，我们可以使用[键]或.键来访问对应的值。默认情况下创建的Map是java.util.LinkedHashMap，我们可以声明变量类型或者使用as关键字改变Map的实际类型。

def colors = [red: #FF0000 , green: #00FF00 , blue: #0000FF ] assert colors[ red ] == #FF0000 assert colors.green == #00FF00

关于Map有一点需要注意。如果将一个变量直接作为Map的键的话，其实Groovy会用该变量的名称作为键，而不是实际的值。如果需要讲变量的值作为键的话，需要在变量上添加小括号。

def key = name def person = [key: Guillaume ] //键是key而不是name assert !person.containsKey( name ) assert person.containsKey( key ) //这次才正确的将key变量的值作为Map的键 person = [(key): Guillaume ] assert person.containsKey( name ) assert !person.containsKey( key )

运算符

和Java类似的运算符

Groovy的数学运算符和Java类似，只不过多了一个乘方运算**和乘方赋值**=。

Groovy的关系运算符（大于、小于等于这些）和Java类似。

Groovy的逻辑运算符（与或非这些）和Java类似，也支持短路计算。

Groovy的位运算符合Java类似。

Groovy的三元运算符条件?值1:值2和Java类似。

可空运算符

Groovy支持Elvis操作符，当对象非空的时候结果是值1，为空时结果是值2。或者更直接，对象非空是使用对象本身，为空时给另一个值，常用于给定某个可空变量的默认值。

displayName = user.name ? user.name : Anonymous displayName = user.name ?: Anonymous

安全导航运算符

当调用一个对象上的方法或属性时，如果该对象为空，就会抛出空指针异常。这时候可以使用?.运算符，当对象为空时表达式的值也是空，不会抛出空指针异常。

def person = Person.find { it.id == 123 } def name = person?.name assert name == null

字段访问运算符

在Groovy中默认情况下使用点运算符.会引用属性的Getter或Setter。如果希望直接访问字段，需要使用.@运算符。

class User { public final String name User(String name) { this.name = name} String getName() { "Name: $name" } } def user = new User( Bob ) assert user.name == Name: Bob assert user.@name == Bob

方法指针运算符

我们可以将方法赋给变量，这需要使用.&运算符。然后我们就可以像调用方法那样使用变量。方法引用的实际类型是Groovy的闭包Closure。这种运算符可以将方法作为参数，让Groovy语言非常灵活。

def str = example of method reference def fun = str.&toUpperCase def upper = fun() assert upper == str.toUpperCase()

展开运算符

展开运算符*.会调用一个列表上所有元素的相应方法或属性，然后将结果再组合成一个列表。

class Car { String make String model } def cars = [ new Car(make: Peugeot , model: 508 ), new Car(make: Renault , model: Clio )] def makes = cars*.make assert makes == [ Peugeot , Renault ]

展开运算符是空值安全的，如果遇到了null值，不会抛出空指针异常，而是返回空值。

cars = [ new Car(make: Peugeot , model: 508 ), null, new Car(make: Renault , model: Clio )] assert cars*.make == [ Peugeot , null, Renault ] assert null*.make == null

展开运算符还可以用于展开方法参数、列表和Map。

范围运算符

使用..创建范围。默认情况下范围是闭区间，如果需要开闭区间可以在结束范围上添加<符号。范围的类型是groovy.lang.Range，它继承了List接口，也就是说我们可以将范围当做List使用。

def range = 0..5 assert (0..5).collect() == [0, 1, 2, 3, 4, 5] assert (0..<5).collect() == [0, 1, 2, 3, 4] assert (0..5) instanceof List assert (0..5).size() == 6

比较运算符

<=>运算符相当于调用compareTo方法。

assert (1 <=> 1) == 0

成员运算符

成员运算符in相当于调用contains或isCase方法。

def list = [ Grace , Rob , Emmy ] assert ( Emmy in list)

相等运算符

==运算符和Java中的不同。在Groovy中它相当于调用equals方法。如果需要比较引用，使用is。

def list1 = [ Groovy 1.8 , Groovy 2.0 , Groovy 2.3 ] def list2 = [ Groovy 1.8 , Groovy 2.0 , Groovy 2.3 ] assert list1 == list2 //比较内容相等 assert !list1.is(list2) //比较引用相等

转换运算符

我们可以使用Java形式的(String) i来转换类型。但是假如类型不匹配的话，就会抛出ClassCastException。而使用as运算符就会避免这种情况。

Integer x = 123 String s = x as String

如果希望自己的类也支持as运算符的话，需要实现asType方法。

表达式和语句

声明变量

Groovy支持以传统方式使用变量类型 变量名的方式声明变量，也可以使用def关键字声明变量。使用def关键字的时候，变量类型由编译器自动推断，无法推断时就是Object类型。

Groovy可以同时声明多个变量。

def (a, b, c) = [10, 20, foo ]

如果左边的变量数比右面的值多，那么剩余的变量就是null。

def (a, b, c) = [1, 2] assert a == 1 && b == 2 && c == null

如果等号右面比左面多，那么多余的值会被忽略。

def (a, b) = [1, 2, 3] assert a == 1 && b == 2

自定义对象也可以用多重赋值进行对象解构。该对象必须有getAt方法。

class CustomDestruction { int a int b int c //解构需要实现getAt方法 def getAt(int i) { switch (i) { case 0: a; break case 1: b; break case 2: c; break default: throw new IllegalArgumentException() } } static void main(String[] args) { //对象解构 def obj = new CustomDestruction(a: 3, b: 4, c: 5) def (x, y, z) = obj PRintln("x=$x,y=$y,z=$z") } }

条件语句

Groovy的if语句和Java的类似。不过在Groovy中布尔值的真假不仅看条件比较的结果，还可以以其他情况判断。前面已经介绍过了。switch语句同理，真值判断非常自由。详情可参见Groovy文档 真值判断。

循环语句

Groovy支持传统的Java的for(int i=0;i<N;i )和for(int i :array)两种形式。另外还支持for in loop形式，支持迭代范围、列表、Map、数组等多种形式的集合。

// 迭代范围 def x = 0 for ( i in 0..9 ) { x = i } assert x == 45 // 迭代列表 x = 0 for ( i in [0, 1, 2, 3, 4] ) { x = i }

while语句的形式和Java相同。

断言语句

前面我们看到了很多Groovy断言的例子。Groovy断言语句的功能很强大，以至于文档中写的是强力断言（Power assertion）。

Groovy断言的形式如下。Groovy断言和Java断言完全不同。Groovy断言是一项语言功能，一直处于开启状态，和JVM的断言功能-ea完全无关。所以它是我们进行单元测试的首选方式。

assert [left expression] == [right expression] : (optional message)

比如我们要断言1 1=3。结果应该类似这样。越复杂的表达式，断言效果越清晰。有兴趣的同学可以试试。

Caught: Assertion failed: assert 1 1 == 3 | | 2 false

面向对象编程

Groovy的面向对象编程和Java类似，但是提供了一系列功能简化面向对象开发。当然如果你想使用传统的Java语法来声明所有成员也可以，Groovy设计目的之一就是让Java程序员能够以低成本的方式切换到Groovy上。

字段默认是私有的，Groovy会自动实现Getter和Setter方法。 方法和属性默认是公有的。 类不必和文件名相同， 一个文件可以有多个类，如果一个类也没有，该文件就会被看做是脚本。

构造器

Groovy的构造器非常灵活，我们可以使用传统的Java方式声明和使用构造器，也可以完全不声明构造器。有时候不声明反而更简单。如果没有声明构造器的话，我们可以在构造对象的时候使用命名参数方式传递参数，这种方式非常方便，因为我们不需要声明所有参数，只要声明所需的参数即可。

如果希望对构造器进行限制，可以手动声明构造器，这样这种自动构造就不会进行了。

class Product { String name double price String toString() { return "Product(name:$name,price:$price)" } static void main(String[] args) { def product = new Product(name: AMD Ryzen 1700 , price: 2499) println("隐式构造器:$product") } }

方法

Groovy方法和Java方法基本相同。不过Groovy方法更方便：支持命名参数和默认参数。另外Groovy方法可以使用def关键字声明，这时候方法返回类型是Object。在Groovy中方法的返回语句可以省略，这时候编译器会使用方法的**后一个语句的值作为返回值。在前面我们还看到了def关键字定义变量，这时候变量的类型需要从代码中推断。

在使用命名参数的时候需要注意一点，方法参数需要声明为Map类型（不需要详细指定键和值的类型），在调用方法的时候使用命名参数方式传入参数。

def foo(Map args) { "${args.name}: ${args.age}" } //调用方法 foo(name: Marie , age: 1)

另外方法的括号是可选的，我们可以省略括号直接像这样调用方法。

methodWithDefaultParam 555 , 42

字段

Groovy中字段和Java中的概念类似。不过Groovy更加方便：默认情况下字段是私有的，Groovy自动生成字段的Getter和Setter。如果需要更精细的控制，把它当成Java字段用就行了。不过如果自定义字段的话，Groovy不会自动生成对应的属性了。

属性

如果字段上面没有声明访问修饰符（private、public这些），Groovy就会自动生成Gettter和Setter。如果字段是final的，那么只会生成Getter。这就是Groovy方便的属性功能。

当然Groovy的方便不止于此，我们的所有类似Java访问字段的语法，实际上都会调用字段对应的Getter和Setter。这样显著减少了代码量。如果在类内部的话，.字段语法会直接访问字段，这样做是为了防止无限递归调用属性。

下面的例子中，**次调用p.name = Marge 如果在类内部，就直接写入字段，如果调用在类外部，就会使用Setter写入。第二次调用使用了方法语法，直接使用Setter写入，所以不管在类内还是类外，写入的值都是"Wonder$name"。

class Person { String name void name(String name) { this.name = "Wonder$name" } String wonder() { this.name } } def p = new Person() p.name = Marge assert p.name == Marge p.name( Marge ) assert p.wonder() == WonderMarge

特征类

Groovy和Scala一样，支持特征类（trait）。特征类就好像自带实现的接口。在Java中只能继承一个类和多个接口。在Groovy中，我们可以继承多个特征类。特征类和普通的Groovy类一样，可以包括属性、字段、方法等，特征类也可以是抽象的。

使用特征类，我们可以在Groovy中实现类似C 的多重继承。另外，特征类支持运行时动态绑定，在某些情况下非常有用。

trait Readable { void read() { println("read...") } } trait Writable { void write(String text) { println("write $text") } } class Notebook implements Readable, Writable { static void main(String[] args) { //使用特性类 def notebook = new Notebook() notebook.read() notebook.write("something") } }

闭包

闭包是Groovy非常重要的一个功能，也是我们介绍的**后一个功能。要了解闭包，**好先知道Java的Lambda表达式、匿名内部类等概念。Groovy闭包和Lambda表达式概念相近，但是功能更强大。

声明闭包

闭包的形式如下。

{ [closureParameters -> ] statements }

以下都是合法的Groovy闭包。所有闭包都是groovy.lang.Closure类型的实例。闭包的参数类型是可选的。如果闭包只有单个参数，参数名也是可选的。Groovy会隐式指定it作为参数名。Kotlin语言也是类似的做法，有助于我们先出可读性很好的闭包。

{ item } { -> item } { println it } { it -> println it } { name -> println name } { String x, int y -> println "hey ${x} the value is ${y}" } { reader -> def line = reader.readLine() line.trim() }

调用闭包

闭包既可以当做方法来调用，也可以显示调用call方法。

def code = { 123 } assert code() == 123 assert code.call() == 123

调用有参数的闭包也是类似的。

def isOdd = { int i-> i%2 == 1 } assert isOdd(3) == true assert isOdd.call(2) == false

使用闭包

Groovy闭包类似Java的Lambda表达式和匿名内部类，不过使用更方便，能让我们减少不少代码量。闭包还可以作为方法参数传递到其他地方，这让闭包更加灵活。

static void funWithClosure(Closure closure) { closure() } //在其他地方调用该方法 funWithClosure({ println("Hello yitian") }) //括号还可以省略，更加简练 funWithClosure { println("Hello yitian") }

关于闭包，还有几个精彩的例子，就是Gradle脚本和Groovy模板引擎，它们都利用了Groovy强大的闭包功能，构建出简练而强大的DSL，让我们用很少的代码就可以实现强大的功能（虽然学起来稍微复杂点）。

参考资料

Groovy**方文档 语法

相关推荐：

---

南京java培训   南京java培训班   南京java培训机构