groovy基础语法学习，2024年最新kotlin实现接口

• 闭包

*/

def clouser = { println “Hello groovy” }

clouser.call()

clouser()

/**

• 闭包传参

*/

def clouser1 = { String name, int age -> println “Hello ${name},age is ${age}” }

clouser1.call(“huang”, 18)

clouser1(“groovy”, 99)

/**

• 闭包传参(默认，隐式参数)

*/

def clouser2 = { println “Hello ${it}” }

clouser2.call(“huang”)

clouser2(“groovy”)

/**

• 返回值

*/

def clouser3 = { String name -> return “Hello ${name}” }

def result = clouser3(“huangxiaoguo”)

println result

println “------------------------------------------------闭包在基本数据类型中使用-----------------------------------------”

/**

• 用来求指定number的阶乘

• @param number

• @return

*/

int fab(int number) {

int result = 1

1.upto(number, { num -> result *= num })

return result

}

int fab2(int number) {

int result = 1

number.downto(1) {

//在groovy中可以把Closure放到括号外面，效果一样

num -> result *= num

}

return result

}

//int x = fab(5);

int x = fab2(5);

println x

/**

• 求和，（注意times的起始值一直是0，因此不能用作阶乘等其他操作）

• @param number

• @return

*/

int cal(int number) {

int result;

number.times {

num -> result += num

}

return result

}

int x1 = cal(101);

println x1

/**

• 绝对值

• @param number

• @return

*/

int abs(int number) {

return number.abs()

}

int x2 = abs(-101);

println x2

println “---------------------------------------------字符串和闭包结合使用-----------------------------------------------”

String str = “love and 2 to be 1 love all 8 happiness”

/**

• each的遍历

*/

str.each {

// String temp ->print temp.multiply(2)

String temp -> print temp

}

println()

/**

• find来查找符合条件的第一个

*/

println str.find {

String s -> s.isNumber()

} //2

/**

• findAll来查找符合条件的集合

*/

def list = str.findAll { String s -> s.isNumber() }

println list.toListString()//[2, 1, 8]

/**

• 只要满足就是true

*/

println str.any {

s -> s.isNumber()

}

/**

• 要全部满足才返回true

*/

println str.every {

s -> s.isNumber()

}

/**

• 遍历所有字母

*/

def list2 = str.collect {

it.toUpperCase()

}

println list2.toListString()//[L, O, V, E, , A, N, D, , 2, , T, O, , B, E, , 1, , L, O, V, E, , A, L, L, , 8, , H, A, P, P, I, N, E, S, S]

println “-------------------------------------闭包的三个重要变量：this,owner,delegate-----------------------------------”

def scriptClouser={

println “scriptClouser this:”+this//代表闭包定义处的类

println “scriptClouser owner:”+owner//代表闭包定义处的类或者对象

println “scriptClouser delegate:”+delegate//代表任意对象,默认与owner一致

}

scriptClouser.call()

/**

• 定义了一个内部类

*/

class Person{

def static classClouser={

println “scriptClouser this:”+this

println “scriptClouser owner:”+owner

println “scriptClouser delegate:”+delegate

}

def static say(){

def classClouser={

println “methodScriptClouser this:”+this

println “methodScriptClouser owner:”+owner

println “methodScriptClouser delegate:”+delegate

}

classClouser.call()

}

}

Person.classClouser.call()

Person.say()

println “-------------------------------------”

/**

• 闭包中定义一个闭包

*/

def nesrClouser={

def innerClouser={

println “innerClouser this:”+this

println “innerClouser owner:”+owner//与this不一样,variable.clouserstudy$_run_closure12@1500b2f3

println “innerClouser delegate:”+delegate //默认和owner一样

}

innerClouser.delegate=Person //修改默认的delegate, delegate:class variable.Person

innerClouser.call()

}

nesrClouser.call()

println “------------------------------------------------闭包的委托策略-------------------------------------------------”

class Student{

String name;

def pretty ={

“My name is ${name}”

}

String toString(){

pretty.call()

}

}

class Teacher{

String name

}

def stu = new Student(name:“Student”)

def tea = new Teacher(name: ‘Teacher’)

println stu.toString()//My name is Student

stu.pretty.delegate=tea

//修改委托策略（DELEGATE_FIRST,DELEGATE_ONLY…）

stu.pretty.resolveStrategy=Closure.DELEGATE_FIRST//有限寻找tea，找不到再找stu

println stu.toString()//My name is Teacher

• 面向对象

创建接口

/**

• 接口中不允许定义非public的方法

*/

interface Action {

void eat()

void drink()

void play()

}

创建抽象接口

/**

• 类似于interface ，但是trait可以进行方法的实现（类似java中的abstract）

*/

trait DefaultAction {

abstract void eat();

void play1(){

println ‘DefaultAction’

}

}

构建对象

/**

• 1.groovy中默认都是public类型

*/

class Persion implements Action, DefaultAction {

String name

Integer age

def increaseAge(Integer years) {

this.age = years

}

@Override

void eat() {

}

@Override

void drink() {

}

@Override

void play() {

}

/**

• 一个方法找不到时，调用它代替

• @param name

• @param args

• @return

*/

def invokeMethod(String name, Object args) {

return “name=>$name,args=>${args}”

}

def methodMissing(String name, Object args){

return “the method ${name} is missing”

}

}

具体操作

/**

• 2无论你是直接，还是调用get/set最终都是调用get/set

*/

def persion = new Persion(name: ‘android’, age: 26)

println " name is ${persion.name},age is ${persion.getAge()}"// name is android,age is 26

persion.increaseAge(20)

println " name is ${persion.name},age is ${persion.getAge()}"// name is android,age is 20

persion.play1() //DefaultAction

//the method cry is missing

println persion.cry()//没有cry这个方法时，默认调用methodMissing方法->没有的话->invokeMethod方法

/**

• 为类动态的添加一个属性

*/

Persion.metaClass.sex = ‘我是动态添加的属性’

Persion.metaClass.nameMethod = { -> name.toUpperCase() }

Persion.metaClass.static.createPerson={

String name, int age->new Persion(name: name,age: age)

}

def person = new Persion(name: ‘android’, age: 26)

println person.sex //我是动态添加的属性

person.sex = ‘修改属性’

println person.sex //修改属性

println person.nameMethod() //ANDROID

def person1 = Persion.createPerson(“dongtai”, 99)

println person1.name+“,”+person1.age //dongtai,99

• groovy 运行时时序表

• json操作

/**

• 1.groovy中默认都是public类型

*/

class Person implements Serializable {

String name

Integer age

String getName() {

return name

}

void setName(String name) {

this.name = name

}

Integer getAge() {

return age

}

void setAge(Integer age) {

this.age = age

}

}

import groovy.json.JsonOutput

import groovy.json.JsonSlurper

import objectorention.Persion

def list=[new Persion(name: ‘huangxiaoguo1’,age: 25),

new Persion(name: ‘huangxiaoguo2’,age: 26),

new Persion(name: ‘huangxiaoguo3’,age: 27),

new Persion(name: ‘huangxiaoguo4’,age: 28)]

/**

• 将对象转换为json

*/

println JsonOutput.toJson(list)

/**

• 打印格式化的json串

*/

def json = JsonOutput.toJson(list)

println JsonOutput.prettyPrint(json)

/**

• 将json串转换为实体对象

*/

def jsonSlpuer=new JsonSlurper()

def parse = jsonSlpuer.parseText(json)

println parse.toString()

println “--------------------------------groovy中进行网络请求---------------------------------------------”

def getNetworkData(String url){

//发送http请求

def connection=new URL(url).openConnection()

connection.setRequestMethod(‘GET’)

connection.connect()

def request = connection.content.text

//将json转换为实体对象

def jsonSlpuer=new JsonSlurper()

return jsonSlpuer.parseText(request)

}

def reponse = getNetworkData(“http://******/wsd/dictionary/getMapByDicflag?dicFlag=wsd.grade.type”)

println reponse.data

• xml操作

import groovy.xml.MarkupBuilder

final String xml=‘’’

/website/about/index.html

<![CDATA[

]]>

/website/categories/index.html

<![CDATA[]]>

/website/tags/index.html

<![CDATA[]]>

/website/tags2/index.html

<![CDATA[]]>

‘’’

println “------------------------------------------------解析xml-----------------------------------------”

/**

• 开始解析xml数据

*/

def xmlSlurper = new XmlSlurper()

def search = xmlSlurper.parseText(xml)

println search.entry[0].url.text();//打印内容，/website/about/index.html

println search.entry[0].content.@type;//打印属性，html

/**

• 遍历

*/

def list=[]

search.entry.each{ entry->

def title=entry.title.text();

if (title.equals(“标签”)){

list.add(entry.url.text())

}

}

println list.toListString() //[/website/tags/index.html, /website/tags2/index.html]

/**

• 深度遍历xml数据（即使xml多层也可以找到）

*/

def titles= search.depthFirst().findAll {entry->

return entry.title.text()==‘标签’?true:false

}

println titles.toListString() //[/website/tags/index.html标签, /website/tags2/index.html标签]

/**

• 广度遍历xml数据

*/

def urls= search.children().findAll {node->

node.title==‘标签’&&node.@id==‘3’

}.collect{node->

return node.url.text()

}

println urls //[/website/tags/index.html]

println “------------------------------------------------生成xml-----------------------------------------”

/**

16

10

Python

*/

def writer = new StringWriter()

def xmlBuilder = new MarkupBuilder(writer)//用来生成xml数据的核心类

//根节点langs创建

xmlBuilder.langs(type:‘curent’,count:‘3’,mainstream:‘true’){

//创建language结点

language(flavor:‘static’,version:‘1.5’,){

age(16)

}

language(flavor:‘dynamic’,version:‘1.6’,){

age(10)

}

language(flavor:‘dynamic’,version:‘1.7’,‘Python’)

}

println writer

/**

• 动态生成

*/

def writer1 = new StringWriter()

def xmlBuilder1 = new MarkupBuilder(writer1)//用来生成xml数据的核心类

def langs = new Langs();

xmlBuilder1.langs(type:langs.type,count: langs.count,mainstream: langs.mainstream ){

langs.langages.each{lang->

language(flavor:lang.flavor, version:lang.version, value:lang.value)

}

}

class Langs{

String type=‘curent’

int count=3

boolean mainstream=true

def langages=[

new Language(flavor:‘static’,version:‘1.5’,value:“java”),

new Language(flavor:‘dynamic’,version:‘1.6’,value: “H5”),

new Language(flavor:‘dynamic’,version:‘1.7’,value: “java”)

]

}

class Language{

String flavor

String version

String value

}

println writer1

• file操作

/**

• 文件操作

*/

def file = new File(‘…/…/groovy.iml’)

file.eachLine { line ->

println line

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

资源分享

• 最新大厂面试专题

这个题库内容是比较多的，除了一些流行的热门技术面试题，如Kotlin，数据库，Java虚拟机面试题，数组，Framework ，混合跨平台开发，等

• 对应导图的Android高级工程师进阶系统学习视频
  最近热门的，NDK，热修复，MVVM，源码等一系列系统学习视频都有！

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-hTlhFWjZ-1712722427417)]
[外链图片转存中…(img-ubhY86xF-1712722427417)]
[外链图片转存中…(img-AqXL5n0R-1712722427418)]
[外链图片转存中…(img-VVDCTUpF-1712722427418)]
[外链图片转存中…(img-dEIgLLOZ-1712722427419)]
[外链图片转存中…(img-hpSwmofb-1712722427419)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-eEJ1Monb-1712722427420)]

资源分享

• 最新大厂面试专题

这个题库内容是比较多的，除了一些流行的热门技术面试题，如Kotlin，数据库，Java虚拟机面试题，数组，Framework ，混合跨平台开发，等

[外链图片转存中…(img-o22aFC3W-1712722427420)]

• 对应导图的Android高级工程师进阶系统学习视频
  最近热门的，NDK，热修复，MVVM，源码等一系列系统学习视频都有！

[外链图片转存中…(img-Tff22DOE-1712722427421)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-a4IsSv6y-1712722427422)]