第七章、Groovy面向对象

最新推荐文章于 2023-06-17 07:00:00 发布
最新推荐文章于 2023-06-17 07:00:00 发布
阅读量313 收藏
点赞数
分类专栏： Groovy 文章标签： groovy 面向对象 trait bean 入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37355951/article/details/110466656
版权

文章目录

1、定义类和脚本

1.1、定义成员变量和本地变量

  • 定义成员变量, 本地变量

  • /**
 * 声明变量
 * @author liangchen* @date 2020/11/8
 */
class DeclareVariableDemo {

    // 成员变量
    public fieldWithModifier
    String typedField
    def untypeField
    protected field1, field2, field3
    private assignedField = new Date()
    static classField
    public static final String CONSTA = 'a', CONSTB = 'b'

    static void main(String[] args) {
        // ClassCastException 类转换异常
        final String PI = '3.14'
        assert PI.class.name == 'java.lang.String'

        assert PI.size() == 4

        GroovyAssert.shouldFail(ClassCastException) {
            Float areaofCircleRadiusOne = PI
        }
    }

    def someMethods(){
        // 本地变量
        def localUntypedMethodVar = 1

        int localTypedMethodVar = 1

        def localVarWithoutAssigment , andAnotherOne

    }

    def localvar = 1,boundvar1 = 1
    def someMethod(){
        def localMethodVar = 1
        boundvar2 = 1
    }



}

  • 没有字段默认调用方法

  • /**
 * 引用成员变量
 * @author liangchen* @date 2020/11/8
 */
class ReferenceFieldDemo {
    static void main(String[] args) {
        def counter = new Counter()
        counter.count = 1
        assert counter.count == 1

        def fieldName = 'sum'
        counter[fieldName] = 2
        assert counter.sum == 2

        // 没有值，就调用get方法
        def pretender = new PretendFieldCounter()
        assert pretender.isNoField == 'pretend value'

        assert pretender.count == 0
        //调用set方法 count ==1
        pretender.isNoFieldEither = 'just to increase counter'
        // 调用set方法  count==2
        pretender.aaa = 1
        assert pretender.count == 2
    }
}
class Counter{
    public count =0
    public sum = 0
}

class PretendFieldCounter {
    public count = 0

    Object get(String name) {
        return 'pretend value'
    }

    void set(String name, Object value) {
        count++

    }
}

1.2、定义方法和参数

  • 可以是确定类型和不确定类型

  • /**
 * 声明方法 和入参类型
 * @author liangchen* @date 2020/11/8
 */
class ClassWithTypedAndUntypedMethods {

    static void main(args) {
        def some = new ClassWithTypedAndUntypedMethods()
        some.publicVoidMethod()
        assert 'hi' == some.publicUntypedMethod()
        assert 'ho' == some.publicTypeMethod()
        def classWith = new ClassWithTypedAndUntypedMethodParams()
        // 入参类型
        assert 'untyped' == classWith.method(1)
        assert 'typed' == classWith.method('whatever')
        assert  'two args' == classWith.method(1,2)

    }


    /**
     * 没有返回值
     */
    void publicVoidMethod(){}

    /**
     * 没有返回类型方法
     * @return
     */
    def publicUntypedMethod(){
        return 'hi'
    }

    /**
     * 有返回值类型
     * @return
     */
    String publicTypeMethod(){
        return 'ho'
    }
    private static final void combinedMethod(){}
}

class ClassWithTypedAndUntypedMethodParams {
    static void main(args) {

    }

    /**
     * 不确定类型入参
     * @param arg
     * @return
     */
    static method(arg){
        return 'untyped'
    }

    /**
     * 有类型入参
     * @param arg
     * @return
     */
    static method(String arg) {
        return 'typed'
    }

    /**
     * 两个参数
     * @param arg1
     * @param arg2
     * @return
     */
    static method(arg1, Number arg2) {
        return 'two args'
    }
}

  • map, list 数组入参

    • /**
 * list map 入参
 * @author liangchen* @date 2020/11/9
 */
class Summer {

    static void main(String[] args) {
        def summer = new Summer();
        assert  2 == summer.sumWithDefualts(1,1)

        assert 3 == summer.sumWithDefualts(1, 1, 1)

        assert 2 == summer.sumWithList([1,1])
        assert 3 == summer.sumWithList([1,1,1])

        assert 2 == summer.sumWithOptionals(1,1)
        assert 3 == summer.sumWithOptionals(1,1,1)

        assert 2 == summer.sumNamed(a:1, b:1)
        assert 3 == summer.sumNamed(a: 1, b: 1, c: 1)
        assert 1 == summer.sumNamed(c:1)

    }

    def sumWithDefualts(a, b, c = 0) {
        return a + b + c

    }

    def sumWithList(List args) {
        return args.inject (0){sum, i -> sum +=i}
    }

    def sumWithOptionals(a, b, Object[] optionals) {
        return a + b + sumWithList(optionals.toList())
    }
/**
 * 入参为map
 * @param args
 * @return
 */

    def sumNamed(Map args) {
        // 不存在设置0
        ['a','b','c'].each {args.get(it, 0)}
        return args.a + args.b + args.c
    }
}

1.3、?. 判断是否连续为空 （短路运算符）

  • 避免连续判空

    • /**
 * ?. 避免空指针,连续判空
 * @author liangchen* @date 2020/11/9
 */
class ProtectionNPEs {

    static void main(String[] args) {
        def map = [a: [b: [c: 1]]]
        assert  map.a.b.c ==1

        if (map && map.a && map.a.x) {
            assert map.a.x.c == null
        }

        try {
            assert map.a.x.c == null
        } catch (NullPointerException ignore) {

        }
        assert map?.a?.x?.c==null
    }

}

1.4、构造器

  • 指定成员变量名和其他方式

    • /**
 * @author liangchen* @date 2020/11/9
 */
class CallConstructorDemo {
    String name, product

    CallConstructorDemo(name, product) {
        this.name = name
        this.product = product
    }

    // Java 的方式
    def first = new CallConstructorDemo('Canoo', "ULC")

    // as 语法
    def second = ['Canoo','ULC'] as CallConstructorDemo

    // 自己数组元素
    CallConstructorDemo third = ['Canoo', 'ULC']
}


class CallConstructorNameDemo{
    String name, product

    public static void main(String[] args) {
        // 可以指定成员变量名
        new CallConstructorNameDemo()
        new CallConstructorNameDemo(name: 'Canoo')
        new CallConstructorNameDemo(product:'ULC')
        new CallConstructorNameDemo(name: 'Canoo', product: 'ULC')
        
    }
}

2、组织类和脚本

2.1、文件与类关系

  • 一个文件有多个类

    • /**
 * 一个groovy 有两个类
 * @author liangchen* @date 2020/11/9
 */
class MultipleClassDemo {
    static void main(String[] args) {
        def canoo = new Vendor()
        canoo.name = 'jack'
        canoo.product='apple'
        canoo.address.street = '天顶乡'
        canoo.address.zip = 1121
        canoo.address.town = '岳麓区'
        canoo.address.state = '长沙'
        // 查找匹配字符
        assert canoo.dump() =~ /apple/
        // 查找匹配字符
        assert canoo.address.dump() =~/1121/
        println canoo.address.dump()
    }
}
class Vendor {
    public String name
    public String product

    public Address address =new Address();
}
class Address{
    public String  street, town , state
    public int zip
}

2.2、在包组织类

  • 跟java类似

  • 默认导入语句

    • import java.lang.*

import java.util.*

import java.io.*

import java.net.*

import groovy.lang.*

import groovy.util.*

import java.math.BigInteger

import java.math.BigDecimal

  • 导入设置别名 ( 避免相同类名，不同包下，识别更快)

    • 需要继承类

    • package com.jack.groovy.ch7.thirdparty

/**
 * @author liangchen* @date 2020/11/10
 */
class MathLib {

    Integer twice(Integer value) {
        return value * 3

    }

    Integer half(Integer value) {
        return value / 2

    }
}

    • 继承类

      • package com.jack.groovy.ch7

// 这里使用 as 为这个导入设置别名
import com.jack.groovy.ch7.thirdparty.MathLib as TypeMathLib
/**
 * @author liangchen* @date 2020/11/10
 */
class MathLib extends TypeMathLib  {

    /**
     * 订正 2倍
     * @param value
     * @return
     */
    Integer twice(Integer value) {
        return value * 2

    }

    static void main(String[] args) {
        def mathlib = new MathLib()
        assert 10 == mathlib.twice(5)
        assert  2 == mathlib.half(5)
    }

}

2.3、考虑更深classpath(类路径)

3、面向对象的高级特性

3.1、使用继承

  • 类似java

3.2、使用接口

  • 类似java

3.3、多方法（重载）

  • 方法名一样，入参不一样

  • /**
 * 方法重载
 * @author liangchen* @date 2020/11/10
 */
class Multimethod {

    def oracle(Object o) {
        return 'object'
    }

    def oracle(String o) {
        return 'string'
    }

    static void main(String[] args) {
       def multi =  new Multimethod()
        Object x =1
        Object y = 'foo'

        assert 'object' == multi.oracle(x)

        assert 'string' == multi.oracle(y)

    }

}

3.4、使用trait

  • trait 关键字

  • /**
 * trait 有点类似 接口，只不过他有一些方法和属性， 应该说是抽象类和接口结合体
 * @author liangchen* @date 2020/11/10
 */
class TraitDemo {

    trait HashId{
        long id
    }

    trait HasVersion{
        long version
    }
    trait Persistent{
        boolean save(){
            println "saving ${this.dump()}"
        }
    }

    trait  Entity implements Persistent ,HashId, HasVersion{
        boolean save(){
            version++
            Persistent.super.save()
        }
    }
    class Publication implements  Entity{
        String title
    }

    class Book extends  Publication{
        String isbn
    }

    static void main(String[] args) {
        Entity gina = new Book(id:1,version: 1,title: 'gina', isbn: "11111")
        gina.save()
        assert gina.version == 2
    }
}

4、GroovyBeans使用

4.1、声明bean

  • /**
 * groovy bean 定义
 * @author liangchen* @date 2020/11/10
 */
class MyBeanDeom {

    static class MyBean implements Serializable{
        String myprop
				//没有定义类型
        def untyped
      	//定义类型
        String typed
				
        def item1, item2
				//赋值初始值
        def assigned = 'default value'
    }

    static void main(String[] args) {
      MyBean myBean =  new MyBean()
       assert 'default value' == myBean.getAssigned()
        myBean.setUntyped('some value')
        assert 'some value' == myBean.getUntyped()
        
    }
}

4.2、beans运行特征

  • 获取field（成员变量）和方法

    • /**
 * 调用groovy方法
 * @author liangchen* @date 2020/11/10
 */
class CallGroovyWayDemo {

   static class MrBean {
        String firstname, lastname
        String getName (){
            return "$firstname $lastname"
        }
    }

     static void main(String[] args) {
         def bean = new MrBean(firstname: 'Rowan')
         bean.lastname = 'Jack'
         // 自动调用name --> getName 方法
         assert 'Rowan Jack' == bean.name

         //获取成员变量，使用.@
         def beanss = new DoublerBean(value: 100)
         assert 200 == beanss.value
         assert 100 == beanss.@value

     }

    /**
     * 获取成员变量，使用.@
     *
     */

    static  class DoublerBean {
        public value

        void setValue(value) {
            this.value = value
        }

        def getValue() {
            value * 2
        }
    }
}

4.3、在任何类中使用bean 的方法

  • 获取def 修饰的field 字段

    • /**
 * 获取bean的属性
 * 获取def 修饰的变量
 * @author liangchen* @date 2020/11/10
 */
class GDKBeanProperties {

    static class ClassWithProperties{
        def someProperty
        public someField
        private somePrivateField
    }

    static void main(String[] args) {
       def obj = new ClassWithProperties()
        def store = []
        obj.properties.each { property ->
            store += property.key
            store += property.value
        }
        assert store.contains('someProperty')
        assert store.contains('someField')  == false
        assert store.contains('somePrivateField') == false
        assert store.contains('class')

        assert obj.properties.size() == 2
    }

}

4.4、Field、accessors、maps and Expando

  • Expando

    • /**
 * 动态扩展属性和方法 Expando
 * @author liangchen* @date 2020/11/10
 */
class ExpandoDemo {

    static void main(String[] args) {
        def boxer = new Expando()
        assert null == boxer.takeThis
        // 赋值 takeThis 不存在的值
        boxer.takeThis = 'jack'
        assert 'jack' == boxer.takeThis
        // 定义方法
        boxer.fightBack = {times -> delegate.takeThis * times}
        assert  'jackjack' == boxer.fightBack(2)
    }
}

5、使用高级语法特性

5.1、使用GPaths查询对象

  • /**
 *  GPath 解析
 * @author liangchen* @date 2020/11/10
 */
class GPathInvoiceDemo {

    static class Invoice{
        List items
        Date date
    }

    static class LineItem{
        Product product
        int count
        int total(){
            return product.dollar * count
        }
    }

    static class Product {
        String name
        def dollar
    }

    static void main(String[] args) {
        def ulcDate = Date.parse('yyyy-MM-dd', '2015-01-01')
        def otherDate = Date.parse('yyy-MM-dd', '2015-02-02')
        def ulc = new Product(dollar: 1499, name: 'ULC')
        def ve = new Product(dollar: 499, name: 'Visual Editor')

        def invoices = [
                new Invoice(date: ulcDate, items: [
                        new LineItem(count: 5, product: ulc),
                        new LineItem(count: 1, product: ve)
                ]),
                new Invoice(date: otherDate, items: [
                        new LineItem(count: 4, product: ve)
                ])
        ]
        // lineItem 平铺，拆开
        def allItems = invoices.items.flatten()

        // 循环调用 total方法
        assert [5*1499, 499, 4*499] == allItems*.total()

        // 查询 数量大于 7000的
        assert ['ULC'] == allItems.grep{it.total() > 7000}.product.name

        // product == ulc , date日期变成字符串
        def searchDates = invoices.grep { it.items.any{it.product == ulc}}.date*.toString()
        assert [ulcDate.toString()] == searchDates
    }
}

5.2、注入*操作

  • /**
 *    * 号操作
 * @author liangchen* @date 2020/11/10
 */
class SpreadDemo {

    def getList(){
        return [1,2,3]
    }

    def sum(a, b, c) {
        return a + b + c
    }

    static void main(String[] args) {
       def spread =  new SpreadDemo()
        // 直接调用getList 方法获取到值作为sum的参数
        assert 6 == spread.sum(*spread.list)

        // 直接使用*变量数组
        def range = (1..3)
        assert [0,1,2,3] == [0, *range]

        // 或者map 或者map *:map
        def map = [a:1, b:2]
        assert [a:1, b:2, c:3] == [c:3, *:map]
    }

}

5.3、利用命令链来使用精确语法

6、总结

  1. 方法、成员变量、局部变量定义（对比java来说的）
  2. groovybean定义
往前的
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Groovy中的面向对象
weixin_30689307的博客
08-05 110
Groovy中的面向对象 前面说到groovy支持脚本和类，前面一节已将简单说了脚本和类之间的关系，这一节主要介绍一下groovy中类的相关知识，即面向对象相关知识。 1.类型 1.1 原始类型 groovy中支持的原始数据类型与java相同，分别是boolean，char，short，int，long，float，double。 1.2 类 groovy中的类与java中很相似，但有以下几点是g...
Groovy~Groovy的面向对象
feizuiku0116的博客
01-25 675
Groovy类是数据的集合和对该数据进行操作的方法 Groovy中的类声明了该类定义的对象的状态（数据）和行为 class Student { int StudentID String StudentName static void main(String[] args) { Student st = new Student() st.StudentID = 1 st.StudentName = "Joe" } } 二、.
Groovy---动态面向对象
CS
04-15 1114
变量声明 定位字段两种方式 方法声明 方法返回值声明 方法参数声明 高级方法参数使用 构造函数 位置参数 命名参数 隐式构造函数 接口与集成与Java一样 GroovyBeans---groovy方式非常简便 其中旧版的Groovy使用@Property语法，现在
groovy简明教程（六）面向对象
iteye_6700的博客
09-03 203
8. groovy的面向对象 groovy来自java，当然是含有面向对象的基因。 8.1 属性和本地变量 groovy有private，protected，public等访问修饰符，但据groovy 2.0.7测试的结果，这些修饰符都是没有起作用，都是public的访问权限，这似乎是一个bug，但是尚未修复，http://jira.codehaus.org/browse/GROOVY-...
Groovy面向对象五
荣耀之路
05-29 290
注解
groovy-doc-cn:groovy中文文档
06-29
1. **基础语法**：Groovy的语法简洁且直观，它支持面向对象编程、函数式编程和命令式编程等多种编程范式。例如，它使用闭包（closures）作为第一级公民，并提供了灵活的语法糖，如方法调用的点号操作符和链式调用。 ...
Groovy in Action源代码
02-22
Groovy是一种面向对象的、动态的、强大的脚本语言，它是Java平台上的一个组件，可以无缝地与Java代码集成。Groovy结合了Java的类型安全性和脚本语言的灵活性，使得开发者能够以更简洁、高效的代码实现复杂的任务。...
apache-groovy-sdk-2.5.2.zip
08-17
Apache Groovy SDK 2.5.2 是一个用于开发Groovy程序的重要软件开发工具包，它包含了一系列必要的组件，使得开发者能够充分利用Groovy这门动态、面向对象的编程语言进行开发工作。Groovy是一种JVM（Java Virtual ...
groovy http请求
11-26
Groovy是一种基于Java平台的、动态的、面向对象的编程语言，它被广泛用于脚本编写、自动化任务、测试等领域。在Groovy中发送HTTP请求是开发者经常需要进行的操作，尤其是在进行API测试或者集成第三方服务时。下面...
通过groovy自定义函数实现提取明细表字段至主表字段.rar
08-14
在自定义函数中，我们可以利用Groovy的面向对象特性，定义类和方法来处理明细表和主表的数据交互。 2. **数据访问**：Groovy可以方便地与数据库进行交互，通过JDBC API或者ORM框架（如Hibernate）来查询明细表和主...
Groovy语言规范中文版之面向对象
dabaoonline的专栏
01-13 1173
面向对象官方文档:Object orientation1.数据类型 Types1.1基本数据类型 Primitive typesGroovy支持Java语言规范中定义的所有的基本数据类型: 整数类型:byte(8 bit),short(16 bit),int(32 bit)和long(64 bit) 浮点型: float(32 bit)和double(64 bit) boolean型(true 或f
Groovy面向对象二
荣耀之路
05-21 414
构造函数
Groovy之面向对象
hdbdhdbh的博客
06-17 261
trait是一组可重用的方法和字段，可以将它们混入到一个或多个类中。一个类可以同时拥有多个trait而不需要使用多重继承 可以通过this 直接访问trait 关键字中的实例。Groovy中的类与Java类似，不同的是它可以通过对象实例化名字直接调用属性值，不需要通过get进行获取值。：将外部注入的属性与方法设置为全局可以使用。的优先级最高，会首先判断类对象是否通过。trait 覆盖，扩展与冲突。如果没有则进行判断是否重写了。方法，都没有则进行异常抛出。方法则进行判断是否重写了。进行添加方法或者属性。
groovy 面向对象
我是一只小菜鸟，飞丫飞丫飞~~~
05-15 1712
1. groovy中类，接口等的定义和使用 1.1 类 右键->New->Groovy Class创建一个groovy类，名字是Person。groovy默认所有的类都是public，所以创建完成的class前面没有public进行修饰。 /** * 1.groovy中默认都是public * 2.所有的groovy类都默认集成了一个GroovyObject类 * 这是g...
Groovy调用另一个.groovy作为对象使用
vampiwolf的博客
10-16 3281
第一步：新建dog.groovy，编辑内容如下： package animal class Dog{ public def name; def bark(){ println("barking"); } def say(){ println("My name is " + name); } } 第二步：确认电脑已经安装gr...
Groovy 入门
qq_28323343的博客
05-05 219
初次学习Groovy，欢迎互相学习和请教
丢弃重口味的xml配置--spring4用groovy配置bean
热门推荐
kiwi_coder
12-21 3万+
spring4之前，bean的配置可以主要分为两种方式，一种是使用基于xml，个人非常讨厌这种方式，因为明明一件很简单的事，放在xml中就会多了不少繁杂的信息。另一种方式是基于java的配置。在几天前release的spring4中，我们可以用groovy作为spring的配置文件啦！比起最早的基于xml配置，使用groovy会更加灵活，而且干扰信息会更少。
Groovy(七)GroovyBean
wzj_110的博客
03-20 276
Java和Groovy的区别 一权限修饰符回顾 强调： groovy中'不指定修饰符'默认的修饰符就是'public';而'java'不指定修饰符,默认是'default' 1）验证方式：通过编译的'class字节码文件'来验证 核心： public static void main -->'psvm'了解各个位置 二 类和对象 ++++++++++++++++'回顾Java特性'++++++++++++++++ 1）类和对象-->理解：抽象模板和具体实例 2...
groovy 显示对象类型
最新发布
05-25
在Java和Groovy中，您可以使用getClass()方法来显示对象的类型，该方法返回一个Class对象，该对象包含有关该对象表示的类的信息。以下是一些不同方式显示对象类型的示例： 在Java中，您可以使用getClass()方法： ``` Object obj = new String("Hello"); Class<? extends Object> objClass = obj.getClass(); System.out.println(objClass.getName()); ``` 在Groovy中，您可以直接使用对象的class属性： ``` def obj = "Hello" println obj.class.name ``` 这些代码将打印出 “java.lang.String”，显示了对象的类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值