Groovy -＞ Groovy类和对象

类

Groovy脚本可以同时写class类和def定义变量，Groovy脚本中可以同时包含类和脚本(class类外边还可以写代码)

class Yang {
    // 属性声明
    def name = "Yang"

    // 方法声明 return 可以省略
    def sayHello() {
        name + " say hello!"
    }
}

• 属性赋值

def yang = new Yang()
// 属性赋值，第一种方式
yang.name = "Guo"
println yang.sayHello()

// 属性赋值，第二种方式
yang["name"] = "Never"
println yang.sayHello()

// 属性赋值，第三种方式
yang.setName("Give Up")
println yang.sayHello()

// 属性赋值，第四种方式
def guo = new Yang(name : "Guo")
println guo.sayHello()

// log
Yang say hello!
Guo say hello!
Never say hello!
Give Up say hello!
Guo say hello!

• 读取属性

// 获取属性，第一种方式
println yang.name

// 获取属性，第二种方式
println yang["name"]

// 获取属性，第三种方式
println yang.getName()

// log
Give Up
Give Up
Give Up

抽象类

abstract class Animal {
    String name

    // 抽象方法
    abstract def makeSound()

    def sayName() {
        println "My name is $name."
    }
}

class Dog extends Animal {
    def makeSound() {
        println "Woof"
    }
}

// 创建对象
def dog = new Dog(name: "Buddy")
dog.sayName()
dog.makeSound()

// log
My name is Buddy.
Woof

接口

// 接口
interface Greeter {
    def greet()
}

class Person implements Greeter {
    String name

    def greet() {
        println "Hello, my name is $name."
    }
}

// 创建对象
def person = new Person(name: "Alice")
person.greet()

内部类

• 非静态内部类

// 内部类->非静态内部类，需要通过外部类实例来创建内部类实例
class Outer {
    String outerField = "Outer Field"

    class Inner {
        String innerField = "Inner Field"

        def display() {
            // 访问外部类的成员
            println "Accessing from Inner Class: $outerField"
            println "Inner Field: $innerField"
        }
    }

    def createInner() {
        return new Inner()
    }
}

// 创建外部类实例
def outer = new Outer()

// 通过外部类实例创建内部类实例
def inner = outer.createInner()

// 使用内部类
inner.display()

// log
Accessing from Inner Class: Outer Field
Inner Field: Inner Field

• 静态内部类

// 内部类->静态内部类，静态内部类不依赖于外部类的实例，可以直接通过外部类来创建静态内部类的实例
class Outer1 {
    static String outerStaticField = "Outer Static Field"

    static class StaticInner {
        String innerField = "Inner Field"

        def display() {
            // 访问外部类的静态成员
            println "Accessing from Static Inner Class: $outerStaticField"
            println "Inner Field: $innerField"
        }
    }
}

// 直接创建静态内部类实例
def staticInner = new Outer1.StaticInner()

// 使用静态内部类
staticInner.display()

// log
Accessing from Static Inner Class: Outer Static Field
Inner Field: Inner Field

• 匿名内部类

// 内部类->匿名内部类
interface Greeter1 {
    def greet()
}

def greeter = new Greeter1() {
    def greet() {
        println "Hello from anonymous inner class"
    }
}

// 使用匿名内部类
greeter.greet()

// log
Hello from anonymous inner class