Groovy之面向对象

/**
 * Groovy 默认都是public
 */
class Person {
    String name
    Integer age
 
    def increase(Integer year){
        this.name += year
    }
}
/**
 * 无论是通过.调用还是直接get/set方法都是最终调用get/set方法
 */
def person = new Person(name: 'yif',age: 25)
//println "this name is ${person.name},this age is ${person.age}"
println "this name is ${person.getName()},this age is ${person.getAge()}"
println person.increase(100)

interface Action {
    void eat();
    void drink();
 
}
class Person implements Action{
    String name
    Integer age
 
    def increase(Integer year){
        this.name += year
    }
 
    @Override
    void eat() {
 
    }
 
    @Override
    void drink() {
 
    }
}

/**
 * Trait 是一个可以重用的方法字段，一个类可以有多个trait，避免了多重继承问题，类使用implements进行实现，新的trait使用extends继承原来的trait
 */
 
trait SwimActive{
    def swim(){
        println 'swimming...'
    }
}
 
trait FlyActive{
    def fly(){
        println 'flying...'
    }
}
 
/**
 * 可以通过this 直接访问trait 关键字中的实例
 */
trait EatActive{
    def eat(){
        println "${this.class.name} is eating..."
    }
}
 
class Duck implements SwimActive,FlyActive,EatActive{}
 
def duck = new Duck()
duck.swim()
duck.fly()
duck.eat()

 
/**
 * Trait 支持方法的覆盖
 */
trait Dealer {
    def getProfit() {
 
    }
    def deal() {
        println 'hello dealer'
    }
}
 
//CarDealer继承了Dealer，同时也覆盖了Dealer中的deal方法
trait CarDealer extends Dealer {
    def deal() {
        println 'hello car dealer'
    }
}
 
//Car 实现了CarDealer接口，同时也覆盖率deal方法
class Car implements CarDealer{
    def deal(){
        println 'hello car'
    }
}
def car = new Car()
car.deal()
 
/**
 * 一个类实现多个trait，有可能产生冲突，因为使用了多个方法签名
 */
trait Bus{
    def drive(){
        println 'bus drive'
    }
}
 
trait Bike{
    def drive(){
        println 'bike drive'
    }
}
 
//这里只有后一个trait类生效，也就是Bike有效
class TestTrait implements Bus,Bike{}
def test = new TestTrait()
test.drive()

trait DefaultAction {
    //是抽象类型方法需要加一个abstract
    abstract void eat()
    //不是抽象方法需要加一个空实现
    void play(){
        println 'i can play'
    }
}
class Person implements DefaultAction{
    String name
    Integer age
 
    def increase(Integer year){
        this.name += year
    }
 
    @Override
    void eat() {
 
    }
}

//通过metaClass 为类添加其他属性
Person.metaClass.sex = 'male'
def persiontwo = new Person(name: 'ztz',age: 34)
println persiontwo.sex
 
//还可以进行修改属性的值
persiontwo.sex = 'female'
println persiontwo.sex
//为类进行动态添加方法，将性别进行大写转换
Person.metaClass.sexUpperCase = { -> sex.toUpperCase()}
println persiontwo.sexUpperCase()
/**
 * 为类动态添加静态方法，在开源库中，可以不修改代码，不继承类，通过groovy自带的metaClass类进行动态修改源码，添加方法属性扩展原有的类
person构造方法必须传入name 与age这两个key进行赋值，否则报错
 */
Person.metaClass.static.createStaticPerson = {String name,int age -> new Person(name: name,age: age)}
//createStaticPerson只是一个方法无需再传入name与age这两个key进行赋值
def person3 = Person.createStaticPerson('yif',44)
println person3.name + " and "+person3.age

class Entry {
    static void main(def args){
        println '应用程序正在启动...'
        ApplicationManager.init()
 
        println '应用程序启动完成'
 
        def person = PersonManager.createPerson('ztz',34)
        println person.name + " and " +person.age
    }
}
/**
 * 模拟应用管理类
 */
class ApplicationManager {
    static void init(){
        //将外部注入的属性与方法设置为全局可用
        ExpandoMetaClass.enableGlobally()
        //为第三方类进行添加方法
        Person.metaClass.static.createPerson = {String name,int age ->
            new Person(name:name,age: age)
        }
    }
}
/**
 * person 类型管理器
 */
class PersonManager {
    static Person createPerson(String name,int age){
        return Person.createPerson(name,age)
    }
}

//methodMissing的优先级高于invokeMethod方法，会首先被调用
def methodMissing(String name,Object args){
    return "the method $name is missing"
}

//如果重写了invokeMethod方法，方法没有定义，就会调用该方法
def invokeMethod(String name,Object args){
    return "the method is $name,the params is $args"
}