Groovy面向对象

类型

原始类型

整数类型

1. byte：8位
2. short：16位
3. int：32位
4. long：64位

浮点型

1. float：32位
2. double：64位

布尔型

1. true
2. false

char

char ：16位

包装类型

1. Boolean
2. Character
3. Short
4. Long
5. Integer
6. Float
7. Double

当原始类型调用.toString()或者 .equals(other)可以进行自动包装和展开

继承

使用extends关键字，Groovy同样也不支持多重继承，可以继承类或者接口（类继承类，接口继承接口）

class Test3 extends Test2{
	...
}
1
2
3

//虽然不报错，但在运行是就会有报错
class Test3 extends Test2,Test4{} 
1
2

泛型

Groovy 在泛型方面与 Java 具有相同的概念。 定义类和方法时，可以使用类型参数并创建 泛型类、接口、方法或构造函数。

泛型类和方法的使用，无论它们是否在 Java 中定义 或 Groovy，可能涉及提供类型参数。

我们可以声明一个 “字符串列表” 如下所示：

List<String> roles = ['Trinity', 'Morpheus']
1

Class类

使用class关键字声明
类和类成员可以具有与 Java 中相同的修饰符（public、protected、private、static 等）

Groovy 类与其 Java 对应类之间的主要区别是：

1. 没有可见性修饰符的类或方法自动成为公共的（可以使用特殊的注释来实现包私有的可见性）。
2. 没有可见性修饰符的字段会自动转换为属性，从而减少冗长的代码， 因为不需要显式的 getter 和 setter 方法。 更多关于这方面的内容将在 字段和属性部分 。
3. 类不需要与其源文件定义具有相同的基本名称，但在大多数情况下强烈建议使用（另请参阅关于脚本的下一点）。
4. 一个源文件可能包含一个或多个类（但如果文件包含任何不在类中的代码，则将其视为脚本）。 脚本只是一些类 特殊约定，并且将与其源文件同名（因此不要在与脚本源文件同名的脚本中包含类定义）。

以下代码提供了一个示例类。

class Test1 {
    def username;
    def password;
    
    def getAll(){
        username = "wangwu"
        password = "123321"
        username + password
    }
}

1
2
3
4
5
6
7
8
9
10
11

内部类

package cn.test

class Test1 {
    def username;
    def password;

    def showInner(){
        def inner = new Inner()
        inner.show()
    }

    class Inner{
        def show(){
            println("inner ...")
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

匿名内部类

class Outer3 {
    private String privateStr = 'some string'

    def startThread() {
        new Thread(new Runnable() {      
            void run() {
                println "${privateStr}."
            }
        }).start()                       
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

静态内部类

使用static关键字进行声明

class Test7 {
    static class InnerTest7{
        
    }
}
1
2
3
4
5

抽象类

使用abstract关键字设置位抽象类，方法也必须用abstract关键字声明，否则认为是带有方法体的方法

abstract class Test2 {
   abstract def show();
    
    def show2(){
        println("show2")
    }
}
1
2
3
4
5
6
7

接口

使用interface关键字声明

interface Test5 {
    def showTest5()
}
1
2
3

实现

使用implements关键字进行实现

class Test6 implements Test5{
  
}

1
2
3
4

闭包（lambda表达式）

闭包是一个开放的、匿名的代码块，它可以接受参数、也可以有返回值
闭包可以引用周围作用域中声明的变量（lambda表达式）
虽然我在这里这样将闭包称为lambda但实际上闭包不等于lambda，至于区别大家可以去看一下相关文章

语法

闭包：

{...}
1

如

def bi(a){
    println(a)
}
1
2
3

lambda

()->{...}
1

如：

def lam = ()->{
    println("this is lam")
}

1
2
3
4

调用

1. 直接使用名字调用
2. 使用call方法调用

lam()

lam.call()
1
2
3