使用Tap方法轻松创建对象 Groovy 2.5.0将tap方法添加到所有对象并更改with方法的方法签名。 在上一篇文章 中，我们已经了解了with方法。...在Groovy 2.5.0中，我们可以为with方法添加一个额外的boolean参数。 如果值为false（默认值），则with方法必须返回与闭包调用返回的值相同的值。...如果值为true，则返回调用with方法的对象实例。 新的tap方法是with(true)的别名，所以它总是返回对象实例。...在第一个例子中，我们使用tap方法创建一个新的Sample对象并设置属性值并调用Sampleclass的方法： /** * Sample class with some properties * and...在下一个例子中，我们使用来自Sample对象的值来创建一个新的String： /** * Sample class with some properties * and a method. */
文章目录 一、使用 对象名.@成员名 访问 Groovy 对象成员 二、完整代码示例 一、使用 对象名....@成员名 访问 Groovy 对象成员 ---- 针对 Groovy 中的类 , class Student { def name def age } 创建 Student 对象 , 如果使用...对象名.成员名 访问该对象中的成员 , 其本质上是调用 Student 对象的 getter 和 setter 方法 ; // 实例化 Student 类 def student = new Student...@age 打印结果为 : Jim 58 二、完整代码示例 ---- 完整代码示例 : /** * 创建 Groovy 类 * 在其中定义 2 个成员 */ class Student {...使用 对象名.成员名 访问对象成员 // 对 对象名.成员名 赋值 , 相当于执行 setter 方法 student.name = "Jerry" student.age = 16 // 使用
文章目录 一、Groovy 类中调用 Groovy 脚本 1、参考 Script#evaluate 方法分析 Groovy 类中调用 Groovy 脚本 2、创建 Binding 对象并设置 args...类的 evaluate 方法 , 通过 GroovyShell 在类方法中调用 Groovy 脚本 ; 在 evaluate 方法中 , 首先创建 GroovyShell 实例对象 , 然后执行该实例对象的...{ /** * 一个助手方法，允许使用此脚本绑定作为变量范围动态计算groovy表达式 * * @param file 要执行的 Groovy 脚本文件...Binding 对象并设置 args 参数 此处创建 GroovyShell 实例对象 涉及到传入 Binding 类型的参数 , 这个参数是 绑定作用域 变量 参数 ; 在 Groovy 脚本中...脚本的执行参数 ; 首先 , 要在 Groovy 类方法中 , 创建 Binding 对象 , // 注意这里创建 groovy.lang.Binding def binding
文章目录 一、Groovy 类中调用 Groovy 脚本 1、创建 GroovyShell 对象并执行 Groovy 脚本 2、代码示例 二、完整代码示例 1、调用者 Groovy 脚本的类 2、被调用者...Groovy 脚本 3、执行结果 一、Groovy 类中调用 Groovy 脚本 ---- 1、创建 GroovyShell 对象并执行 Groovy 脚本 首先 , 创建 GroovyShell 对象...设置要调用的 Groovy 脚本对应的 File 文件对象 ; def file = new File("Script.groovy") 最后 , 调用 GroovyShell 对象的 evaluate...方法 , 执行 Groovy 脚本 ; shell.evaluate(file) 2、代码示例 代码示例 : class Test { void startScript() {...// 注意这里创建 groovy.lang.Binding def binding = new Binding() // 设置 args 参数到 Binding 中的 variable
文章目录 一、使用 对象名.成员名 访问 Groovy 类的成员 二、使用 对象名.'...成员名' 访问 Groovy 类的成员 三、使用 对象名['成员名'] 访问 Groovy 类的成员 四、完整代码示例 一、使用 对象名.成员名 访问 Groovy 类的成员 ---- 对 对象名.成员名...赋值 , 相当于执行 setter 方法 ; /** * 创建 Groovy 类 * 在其中定义 2 个成员 */ class Student { def name def age...; 在 Java 中如果要根据字符串决定要访问哪个成员 , 只能通过反射进行访问 ; 代码示例 : /** * 创建 Groovy 类 * 在其中定义 2 个成员 */ class Student...age' 执行结果 : Han 32 三、使用 对象名[‘成员名’] 访问 Groovy 类的成员 ---- 使用 对象名[‘成员名’] 访问 Groovy 类的成员 , 相当于调用类的 getAt 方法
文章目录 一、使用闭包创建接口对象 ( 接口中有一个函数 ) 二、使用闭包创建接口对象 ( 接口中有多个函数 ) 三、完整代码示例 一、使用闭包创建接口对象 ( 接口中有一个函数 ) ---- 在 Groovy...中 , 声明一个接口 , 接口中定义了 1 个抽象函数 , interface OnClickListener { void onClick() } 传统创建接口的方法如下 , 创建一个匿名内部类..., 也可以创建上述接口对象 , 闭包中的内容就是唯一的抽象函数内容 ; // 使用闭包创建接口对象 OnClickListener listener = { println "OnClickListener..., 在闭包后面添加 as 接口名 代码 , 如下 : // 使用闭包创建接口对象 OnClickListener2 listener2 = { println "OnClickListener2..." } as OnClickListener2 上述方法会默认将接口的多个方法都设置为上述闭包方法 ; 执行接口对象的 onClick 和 onLongClick 方法 , 执行的都是相同的闭包方法 ;
文章目录 一、使用 MetaClass 进行方法拦截 1、使用 MetaClass 在单个对象上进行方法拦截 2、使用 MetaClass 在类上进行方法拦截 二、完整代码示例 1、对象方法拦截 2...、类方法拦截 一、使用 MetaClass 进行方法拦截 ---- MetaClass 可以定义类的行为 , 可以利用 MetaClass 进行方法拦截 ; Groovy 对象 和 类 都可以获取 MetaClass..."Hello ${name}" } } def student = new Student(name: "Tom") 1、使用 MetaClass 在单个对象上进行方法拦截 在 Groovy..., 执行的是闭包的内容 , 不再是原来的 hello 方法内容 ; 2、使用 MetaClass 在类上进行方法拦截 在 Groovy 类上获取的元类对象 , Student.metaClass 拦截...二、完整代码示例 ---- 1、对象方法拦截 创建 2 个 Student 对象 , 使用 MetaClass 在其中一个对象上拦截 hello 方法 , 执行两个对象的 hello 方法 , 只有前者的
文章目录 一、闭包中调用 Groovy 脚本中的方法 二、owner 与 delegate 区别 三、闭包中调用 Groovy 对象中的方法 一、闭包中调用 Groovy 脚本中的方法 ---- 在 Groovy...fun() } closure() 执行上述 Groovy 脚本结果如下 : fun 二、owner 与 delegate 区别 ---- 在 Closure 闭包中 , 其 owner 就是创建闭包时所在的环境..., 这是无法改变的 ; 但是 Closure 闭包对象的 delegate 成员是可以修改的 ; 三、闭包中调用 Groovy 对象中的方法 ---- 在闭包中 , 可以直接调用 Groovy 脚本中定义的方法...; 但是如果想要在闭包中 , 调用实例对象的方法 , 就必须设置闭包的 delegate 成员 ; 如下代码中 , 想要在闭包中 , 调用 Test 对象的 fun 方法 , 在执行闭包之前 , 必须将...闭包的 delegate 设置为 Test 实例对象 ; closure.delegate = new Test() 之后使用 closure() 调用闭包 , 在闭包中执行 fun 方法 , 就会在代理
java中几种创建对象的方式 在java程序中,对象可以被显式地或者隐式地创建....如果找不到该类 Object类的clone()方法 protected Object clone() throws CloneNotSupportedException 创建并返回此对象的一个副本...这通常意味着要复制包含正在被克隆对象的内部“深层结构”的所有可变对象，并使用对副本的引用替换对这些对象的引用。...如果一个类只包含基本字段或对不变对象的引用，那么通常不需要修改 super.clone 返回的对象中的字段。 Object 类的 clone 方法执行特定的克隆操作。...否则，此方法会创建此对象的类的一个新实例，并像通过分配那样，严格使用此对象相应字段的内容初始化该对象的所有字段；这些字段的内容没有被自我克隆。
文章目录 一、基础示例 二、根据字符串动态获取 MetaClass 中的方法 二、使用 evaluate 执行字符串形式的 Groovy 脚本 二、完整代码示例 一、基础示例 ---- 定义类 Student..., 并执行 Student 对象的 hello 方法 , def student = new Student(name: "Tom", age: 18) // 第一次调用 hello 方法 student.hello...() 执行结果如下 : Hello , my name is Tom, 18 years old 二、根据字符串动态获取 MetaClass 中的方法 ---- 进行动态函数拦截时 , 事先不知道要要拦截的方法名..., 这里声明一个药拦截的方法名变量 ; // 要拦截的方法名 def interceptMethodName = "hello" 使用如下代码操作 , 即可获取 MetaClass 中的方法 ; //...${interceptMethodName}" 二、使用 evaluate 执行字符串形式的 Groovy 脚本 ---- 动态函数拦截时 , 也不知道拦截后要执行哪些操作 , 使用 evaluate
文章目录 一、使用 ExpandoMetaClass 进行方法注入 三、完整代码示例 一、使用 ExpandoMetaClass 进行方法注入 ---- 在 【Groovy】MOP 元对象协议与元编程...( 方法注入 | 同时注入普通方法、静态方法、构造方法 ) 博客中 , 使用 MetaClass 注入 普通方法、静态方法、构造方法 , 其底层原理就是通过 ExpandoMetaClass 进行方法注入...; 我们也可以自己手动实现 ExpandoMetaClass 方法注入过程 ; 如为下面的 Student 类注入方法 ; class Student { def name; } 首先 , 创建...ExpandoMetaClass 实例对象 ; def expandoMetaClass = new ExpandoMetaClass(Student) 然后 , 为其注入方法 , 可以注入 普通方法...; // 初始化注入方法 expandoMetaClass.initialize() 最后 , 使用初始化后的 ExpandoMetaClass 对象 , 为 // 替换 Student.metaClass
一、使用 new Object 创建对象 1、使用 new Object 创建对象语法 使用 new Object 创建对象语法如下 : var obj = new Object(); 创建后的对象 是一个空对象... 执行结果 : 二、使用 构造函数 创建对象 1、字面量 和 new Object 创建对象的方法弊端 在 JavaScript 中 , 使用 字面量 和 new Object...- 使用 " 构造函数 " 方式 创建对象 ; 2、构造函数引入 创建对象时 , 属性和方法的结构都是相同的 , 只是 属性值 不同 , 这里就可以通过 构造函数 只设置 不同的 属性值 , 就可以...的 函数体 中 ; 3、构造函数语法 在 JavaScript 中 , 可以使用 " 构造函数 " 来创建对象 , 构造函数 本质上是一个普通的函数 , 通常情况下 将 构造函数 函数名 的首字母大写...使用 new 关键字调用构造函数，创建对象 var person = new Person('Tom', 18); 访问对象的属性和方法 : // 4.
文章目录 一、方法注入 二、使用 Category 分类注入方法 三、完整代码示例 一、方法注入 ---- 在之前的博客中 , 主要是使用 Groovy 元编程 拦截方法 , 改变方法的实现 ; 使用元编程还可以为...Groovy 类 注入一个新的方法 , 方法注入 ; Groovy 方法注入的 3 种方式 : Category 分类注入 MetaClass 账户入 Mixin 注入 上述注入都是通过 运行时元编程...进行方法注入 , 编译时元编程 也可以进行方法注入 ; 二、使用 Category 分类注入方法 ---- 定义 Student 类 , class Student { def name; }...Hello) { new Student(name: "Tom").hello() } use 表示要使用 Hello 类中的注入方法 , 为 Student 类注入 Hello 类中的 hello...方法 , 在下图中可以看到 , 在 use 代码块中 , 可以提示出要注入的方法 ; 三、完整代码示例 ---- 完整代码示例 : class Student { def name; }
文章目录 一、使用 MetaClass 注入构造方法 二、完整代码示例 一、使用 MetaClass 注入构造方法 ---- 使用 MetaClass 注入构造方法 , 代码格式为 : 被注入构造方法的类...Student.metaClass.constructor = { String str -> new Student(name: str) } 注意 , 构造函数的返回值必须是 Student 对象...; 这里在注入的构造函数闭包中 , 可以设置若干构造函数参数 , 上述代码中 , 就为构造函数设置了 String 类型参数 ; 使用上述注入的构造函数 , 实例化 Student 对象 , 调用 hello...方法 , 可以成功打印出构造函数中传入的 “Tom” 参数 ; // 使用注入的构造方法初始化 Student 类 def student = new Student("Tom") student.hello...constructor Student.metaClass.constructor = { String str -> new Student(name: str) } // 使用注入的构造方法初始化
在实现 AJAX 的过程中，创建一个 XMLHttpRequest 对象是必不可少的。...创建 XMLHttpRequest 对象要创建一个 XMLHttpRequest 对象，可以使用如下代码：var xhr = new XMLHttpRequest();上述代码会创建一个新的 XMLHttpRequest...readyState：表示 XMLHttpRequest 对象的请求状态，其值为整数。0：未初始化。XMLHttpRequest 对象已创建但尚未调用 open() 方法。1：已打开。...XMLHttpRequest 对象，并使用 open() 方法初始化一个 GET 请求。...但要注意，同步请求可能导致页面卡顿和响应时间延长，因此建议谨慎使用。总结通过本文，我们详细介绍了 AJAX 中创建 XMLHttpRequest 对象的方法和常用属性、方法。
文章目录 一、使用 MetaClass 进行方法注入 二、完整代码示例 一、使用 MetaClass 进行方法注入 ---- 定义 Student 类 , class Student { def..., 即可注入方法 , 在闭包中 , delegate 就是 Student 对象 ; // 向 Student 类注入 hello 方法 Student.metaClass.hello << {...println delegate println "Hello ${delegate.name}" } 创建 Student 实例对象 , 调用为 Student 类注入的 hello 方法 ,...delegate 代理对象 ; 此处注意 , 注入方法使用 << 运算符 , 替换 / 拦截方法 使用 = 运算符 ; 方法注入后 , 在 类 的 metaClass 中注入的方法 , 在任何 Student...对象中 , 都可以调用被注入的 hello 方法 ; 但是在 对象 的 metaClass 中注入的方法 , 只有该 Student 对象才能调用被注入的 hello 方法 , 其它对象不能调用该注入的方法
文章目录 一、使用 @Delegate 注解进行方法委托 二、完整代码示例 一、使用 @Delegate 注解进行方法委托 ---- 在博客 【Groovy】MOP 元对象协议与元编程 ( 方法委托 |...正常方法调用 | 方法委托实现 | 代码示例 ) 【Groovy】MOP 元对象协议与元编程 ( 方法委托 | 批量方法委托 ) 中 , 都是通过手动方式实现了方法委托 , Groovy 中提供了 @...") public @interface Delegate { } 在被委托对象上 , 直接使用 @Delegate 注解 , 就可以实现方法委托 ; class Student1{ def hello1...hello1 方法时 , 其没有实现 hello1 方法 , 但是被 @Delegate 注解修饰的 Student1 student1 对象中定义了 hello1 方法 , 此时就会自动进行方法委托..., 直接通过 StudentManager 对象调用 Student1 中的方法 sm.hello1() // 方法委托, 直接通过 StudentManager 对象调用 Student2 中的方法
文章目录 一、使用 Mixin 混合进行方法注入 二、完整代码示例 一、使用 Mixin 混合进行方法注入 ---- 使用 Mixin 混合进行方法注入 , 为下面的 Student 类注入方法 ; class...Student { def name } 首先 , 定义被注入的方法 , 定义一个类 , 在类中定义被注入的方法 , 这里需要注意 , 被注入的方法没有 self 参数 , 不能访问其本身对象..., 也可以像 Student.metaClass 中混合 , 二者效果相同 ; // 将 Hello 类中的方法注入到 Student 类中 Student.mixin(Hello) 最后 , 直接调用被注入的方法..., 这里要注意 , 使用 Student 对象调用 hello 方法时 , 同时需要在参数中 , 也传递一个该对象 ; // 创建 Student 对象 def student = new Student...}" } } // 将 Hello 类中的方法注入到 Student 类中 Student.mixin(Hello) // 创建 Student 对象 def student = new Student
文章目录 一、使用 MetaClass 注入静态方法 二、完整代码示例 一、使用 MetaClass 注入静态方法 ---- 使用 MetaClass 注入静态方法 , 可以使用如下代码实现 : 类名....static'.hello = { println "Hello Student ${delegate.name}" } 注意这里在 被注入的 hello 静态方法中 , 使用了 delegate..., 如果使用 Student 类调用 hello 方法 , 则 delegate 就是 Student 类 ; // 通过 Student 类调用静态方法 Student.hello() 如果使用 Student...对象调用 hello 方法 , 则 delegate 就是 Student 对象 ; // 通过 Student 对象调用静态方法 def student = new Student(name: "Tom...() // 通过 Student 对象调用静态方法 def student = new Student(name: "Tom") student.hello() 执行结果 : Hello Student
一、GroovyInterceptable 接口简介 ---- 定义 Groovy 类时 , 令该类实现 GroovyInterceptable 接口 , 该 GroovyInterceptable...GroovyInterceptable{ def name; def hello() { println "Hello ${name}" } } 那么调用 Student 对象的任何方法...result of invoking the method */ Object invokeMethod(String name, Object args); } 重写 Student 类中的...: 不会触发 invokeMethod 方法 ; 通过 invokeMethod 调用方法 : 会触发 invokeMethod 方法 ; 调用不存在的方法 : 会报错 ; 实现了 GroovyInterceptable...接口 : 直接调用方法 : 会触发 invokeMethod 方法 ; 通过 invokeMethod 调用方法 : 会触发 invokeMethod 方法 ; 调用不存在的方法 : 不会报错 ;
领取专属 10元无门槛券
手把手带您无忧上云
云服务器
即时通信 IM
ICP备案
对象存储
实时音视频
