2024年安卓最新深入学习-Gradle-自动化构建技术（二）Groovy-筑基，2024年最新海尔技术面试

文末

好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，可以来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。

这里放上一部分我工作以来以及参与过的大大小小的面试收集总结出来的相关的几十套腾讯、头条、阿里、美团等公司21年的面试专题，其中把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分免费分享给大家，主要还是希望大家在如今大环境不好的情况下面试能够顺利一点，希望可以帮助到大家~

还有 高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料 帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。

【Android核心高级技术PDF文档，BAT大厂面试真题解析】

【延伸Android必备知识点】

这里只是整理出来的部分面试题，后续会持续更新，希望通过这些高级面试题能够降低面试Android岗位的门槛，让更多的Android工程师理解Android系统，掌握Android系统。喜欢的话麻烦点击一个喜欢在关注一下~

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

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

• 1）、解决特定领域的专有问题。
• 2）、它与系统编程语言走的是两个极端，系统编程语言是希望解决所有的问题，比如 Java 语言希望能做 Android 开发，又希望能做服务器开发，它具有横向扩展的特性。而 DSL 具有纵向深入解决特定领域专有问题的特性。

总的来说，DSL 的 核心思想 就是：“求专不求全，解决特定领域的问题”。

二、Groovy 初识

1、Groovy 的特点

Groovy 的特点具有如下 三点：

• 1）、Groovy 是一种基于 JVM 的敏捷开发语言。
• 2）、Groovy 结合了 Python、Ruby 和 Smalltalk 众多脚本语言的许多强大的特性。
• 3）、Groovy 可以与 Java 完美结合，而且可以使用 Java 所有的库。

那么，在已经有了其它脚本语言的前提下，为什么还要制造出 Grvooy 语言呢？

因为 Groovy 语言相较其它编程语言而言，其 入门的学习成本是非常低的，因为它的语法就是对 Java 的扩展，所以，我们可以用学习 Java 的方式去学习 Groovy。

2、Groovy 语言本身的特性

其特性主要有如下 三种：

• 1）、语法上支持动态类型，闭包等新一代语言特性。并且，Groovy 语言的闭包比其它所有语言类型的闭包都要强大。
• 2）、它可以无缝集成所有已经存在的 Java 类库，因为它是基于 JVM 的。
• 3）、它即可以支持面向对象编程（基于 Java 的扩展），也可以支持面向过程编程（基于众多脚本语言的结合）。

需要注意的是，在我们使用 Groovy 进行 Gradle 脚本编写的时候，都是使用的面向过程进行编程的。

3、Groovy 的优势

Groovy 的优势有如下 四种：

• 1）、它是一种更加敏捷的编程语言：在语法上构建除了非常多的语法糖，许多在 Java 层需要写的代码，在 Groovy 中是可以省略的。因此，我们可以用更少的代码实现更多的功能。
• 2）、入门简单，但功能非常强大。
• 3）、既可以作为编程语言也可以作为脚本语言
• 4）、熟悉掌握 Java 的同学会非常容易掌握 Groovy。

4、Groovy 包的结构

Groovy 官方网址

从官网下载好 Groovy 文件之后,我们就可以看到 Groovy 的目录结构，其中我们需要 重点关注 bin 和 doc 这个两个文件夹。

bin 文件夹

bin 文件夹的内容如下所示：

这里我们了解下三个重要的可执行命令文件，如下所示：

• 1）、groovy 命令类似于 Java 中的 java 命令，用于执行 groovy Class 字节码文件。
• 2）、groovyc 命令类似于 Java 中的 javac 命令，用于将 groovy 源文件编译成 groovy 字节码文件。
• 3）、groovysh 命令是用来解释执行 groovy 脚本文件的。

doc 文件夹

在 doc 文件夹的下面有一个 html 文件，其中的内容如下所示：

这里的 api 和 documentation 是我们需要重点关注的，其作用分别如下所示：

• api：groovy 中为我们提供的一系列 API 及其 说明文档。
• documentation：groovy 官方为我们提供的一些教程。

5、Groovy 中的关键字

下面是 Groovy 中所有的关键字，命名时尤其需要注意，如下所示：

as、assert、break、case、catch、class、const、continue、def、default、
do、else、enum、extends、false、finally、for、goto、if、implements、
import、in、instanceof、interface、new、null、package、return、super、
switch、this、throw、throws、trait、true、try、while

6、Groovy && Java 差异学习

1）、getter / setter

对于每一个 field，Groovy 都会⾃动创建其与之对应的 getter 与 setter 方法，从外部可以直接调用它，并且 在使⽤ object.fieldA 来获取值或者使用 object.fieldA = value 来赋值的时候，实际上会自动转而调⽤ object.getFieldA() 和 object.setFieldA(value) 方法。

如果我们不想调用这个特殊的 getter 方法时则可以使用 .@ 直接域访问操作符。

2）、除了每行代码不用加分号外，Groovy 中函数调用的时候还可以不加括号。

需要注意的是，我们在使用的时候，如果当前这个函数是 Groovy API 或者 Gradle API 中比较常用的，比如 println，就可以不带括号。否则还是带括号。不然，Groovy 可能会把属性和函数调用混淆。

3）、Groovy 语句可以不用分号结尾。

4）、函数定义时，参数的类型也可以不指定。

5）、Groovy 中函数的返回值也可以是无类型的，并且无返回类型的函数，其内部都是按返回 Object 类型来处理的。

6）、当前函数如果没有使用 return 关键字返回值，则会默认返回 null，但此时必须使用 def 关键字。

7）、在 Groovy 中，所有的 Class 类型，都可以省略 .class。

8）、在 Groovy 中，== 相当于 Java 的 equals，，如果需要比较两个对象是否是同一个，需要使用 .is()。

9）、Groovy 非运算符如下：

assert (!“android”) == false

10）、Groovy 支持 ** 次方运算符，代码如下所示：

assert 2 ** 3 == 8

11）、判断是否为真可以更简洁：

if (android) {}

12）、三元表达式可以更加简洁：

// 省略了name
def result = name ?: “Unknown”

13）、简洁的非空判断

println order?.customer?.address

14）、使用 assert 来设置断言，当断言的条件为 false 时，程序将会抛出异常。

15）、可以使用 Number 类去替代 float、double 等类型，省去考虑精度的麻烦。

16）、switch 方法可以同时支持更多的参数类型。

注意，swctch 可以匹配列表当中任一元素，示例代码如下所示：

// 输出 ok
def num = 5.21
switch (num) {
case [5.21, 4, “list”]:
return “ok”
break
default:
break
}

三、Groovy 基础语法

Groovy 的基础语法主要可以分为以下 四个部分：

• 1）、Groovy 核心基础语法。
• 2）、Groovy 闭包。
• 3）、Groovy 数据结构。
• 4）、Groovy 面向对象

1、Groovy 核心基础语法

Groovy 中的变量

变量类型

Groovy 中的类型同 Java 一样，也是分为如下 两种：

• 1）、基本类型。
• 2）、对象类型。

但是，其实 Groovy 中并没有基本类型，Groovy 作为动态语言， 在它的世界中，所有事物都是对象，就如 Python、Kotlin 一样：所有的基本类型都是属于对象类型。为了验证这个 Case，我们可以新建一个 groovy 文件，创建一个 int 类型的变量并输出它，结果如下图所示：

可以看到，上面的输出结果为 ‘class java.lang.Integer’，因此可以验证我们的想法是正确的。实际上，Groovy 的编译器会将所有的基本类型都包装成对象类型。

变量定义

groovy 变量的定义与 Java 中的方式有比较大的差异，对于 groovy 来说，它有 两种定义方式，如下所示：

• 1）、强类型定义方式：groovy 像 Java 一样，可以进行强类型的定义，比如上面直接定义的 int 类型的 x，这种方式就称为强类型定义方式，即在声明变量的时候定义它的类型。
• 2）、弱类型定义方式：不需要像强类型定义方式一样需要提前指定类型，而是通过 def 关键字来定义我们任何的变量，因为编译器会根据值的类型来为它进行自动的赋值。

下面，我们就使用 def 关键字来定义一系列的变量，并输出它们的类型，来看看是否编译器会识别出对应的类型，其结果如下图所示：

可以看到，编译器的确会自动自动推断对应的类型。

那么，这两种方式应该分别在什么样的场景中使用呢？

如果这个变量就是用于当前类或文件，而不会用于其它类或应用模块，那么，建议使用 def 类型，因为在这种场景下弱类型就足够了。

但是，如果你这个类或变量要用于其它模块的，建议不要使用 def，还是应该使用 Java 中的那种强类型定义方式，因为使用强类型的定义方式，它不能动态转换为其它类型，它能够保证外界传递进来的值一定是正确的。如果你这个变量要被外界使用，而你却使用了 def 类型来定义它，那外界需要传递给你什么才是正确的呢？这样会使调用方很疑惑。

如果此时我们在后面的代码中改变上图中 x1 的值为 String 类型，那么 x1 又会被编译器推断为 String 类型，如下图所示：

于是我们可以猜测到，其实使用 def 关键字定义出来的变量就是 Obejct 类型。

Groovy 中的字符串

Groovy 中的字符串与 Java 中的字符串有比较大的不同，所以这里我们需要着重了解一下。

Groovy 中的字符串除了继承了 Java 中传统 String 的使用方式之前，还 新增 了一个 GString 类型，它的使用方式至少有七、八种，但是常用的有三种定义方式。此外，在 GString 中新增了一系列的操作符，这能够让我们对 String 类型的变量有 更便捷的操作。最后，在 GString 中还 新增 了一系列好用的 API，我们也需要着重学习一下。

Groovy 中常用的三种字符串定义方式

在 Groovy 中有 三种常用 的字符串定义方式，如下所示：

• 1）、单引号 ‘’ 定义的字符串
• 2）、双引号 “” 定义的字符串
• 3）、三引号 ‘“”’ 定义的字符串

首先，需要说明的是，‘不管是单引号、双引号还是三引号，它们的类型都是 java.lang.String’。

那么，单引号与三引号的区别是什么呢？

既生瑜何生亮，其实不然。当我们编写的单引号字符串中有转义字符的时候，需要添加 ‘’，并且，当字符串需要具备多行格式的时候，强行将单引号字符串分成多行格式会变成由 ‘+’ 号组成的字符串拼接格式。

那么，双引号定义的变量又与单引号、三引号有什么区别呢？

双引号不同与单、三引号，它定义的是一个可扩展的变量。这里我们先看看两种双引号的使用方式，如下图所示：

在上图中，第一个定义的 author 字符串就是常规的 String 类型的字符串，而下面定义的 study 字符串就是可扩展的字符串，因为它里面使用了 ‘${author}’ 的方式引用了 author 变量的内容。而且，从其最后的类型输出可以看到，可扩展的类型就是 ‘org.codehaus.groovy.runtime.GStringImpl’ 类型的。

需要注意的是，可扩展的字符串是可以扩展成为任意的表达式，例如数学运算，如下图所示：

有了 Groovy 的这种可扩展的字符串，我们就可以 避免 Java 中字符串的拼接操作,提升 Java 程序运行时的性能。

那么，既然有 String 和 GString 两种类型的字符串，它们在相互赋值的场景下需要不需要先强转再赋值呢？

这里，我们可以写一个 小栗子来看看实际的情况，如下图所示：

可以看到，我们将 success 字符串传入了 come 方法，但是最终得到的类型为 result，所以，可以说明 编译器可以帮我们自动在 String 和 GString 之间相互转换，我们在编写的时候并不需要太过关注它们的区别。

2、Groovy 闭包（Closure）

闭包的本质其实就是一个代码块，闭包的核心内容可以归结为如下三点：

• 1)、闭包概念

• 定义

• 闭包的调用

• 2)、闭包参数

• 普通参数

• 隐式参数

• 3)、闭包返回值

• 总是有返回值

闭包的调用

clouser.call()
clouser()
def xxx = { paramters -> code }
def xxx = { 纯 code }

从 C/C++ 语言的角度看，闭包和函数指针很像，闭包可以通过 .call 方法来调用，也可以直接调用其构造函数，代码如下所示：

闭包对象.call(参数)
闭包对象(参数)

如果闭包没定义参数的话，则隐含有一个参数，这个参数名字叫 it，和 this 的作用类 似。it 代表闭包的参数。表示闭包中没有参数的示例代码：

def noParamClosure = { -> true }

注意点：省略圆括号

函数最后一个参数都是一个闭包，类似于回调函数的用法，代码如下所示：

task JsonChao {
doLast ({
println “love is peace~”
}
})

// 似乎好像doLast会立即执行一样
task JsonChao {
doLast {
println “love is peace~”
}
}

闭包的用法

闭包的常见用法有如下 四种：

• 1）、与基本类型的结合使用。
• 2）、与 String 类的结合使用。
• 3）、与数据结构的结合使用。
• 4）、与文件等结合使用。

闭包进阶

• 1）、闭包的关键变量

• this

• owner

• delegate

• 2）、闭包委托策略

闭包的关键变量

this 与 owner、delegate

其差异代码如下代码所示：

def scrpitClouser = {
// 代表闭包定义处的类
printlin “scriptClouser” this:" + this
// 代表闭包定义处的类或者对象
printlin “scriptClouser” this:" + owner
// 代表任意对象，默认与 ownner 一直
printlin “scriptClouser” this:" + delegate
}

// 输出都是 scrpitClouse 对象
scrpitClouser.call()

def nestClouser = {
def innnerClouser = {
// 代表闭包定义处的类
printlin “scriptClouser” this:" + this
// 代表闭包定义处的类或者对象
printlin “scriptClouser” this:" + owner
// 代表任意对象，默认与 ownner 一直
printlin “scriptClouser” this:" + delegate
}
innnerClouser.call()
}

// this 输出的是 nestClouser 对象，而 owner 与 delegate 输出的都是 innnerClouser 对象
nestClouser.call()

可以看到，如果我们直接在类、方法、变量中定义一个闭包，那么这三种关键变量的值都是一样的，但是，如果我们在闭包中又嵌套了一个闭包，那么，this 与 owner、delegate 的值就不再一样了。换言之，this 还会指向我们闭包定义处的类或者实例本身，而 owner、delegate 则会指向离它最近的那个闭包对象。

delegate 与 this、owner 的差异

其差异代码如下代码所示：

def nestClouser = {
def innnerClouser = {
// 代表闭包定义处的类
printlin “scriptClouser” this:" + this
// 代表闭包定义处的类或者对象
printlin “scriptClouser” this:" + owner
// 代表任意对象，默认与 ownner 一致
printlin “scriptClouser” this:" + delegate
}

// 修改默认的 delegate
innnerClouser.delegate = p
innnerClouser.call()
}

nestClouser.call()

可以看到，delegate 的值是可以修改的，并且仅仅当我们修改 delegate 的值时，delegate 的值才会与 ownner 的值不一样。

闭包的委托策略

其示例代码如下所示：

def stu = new Student()
def tea = new Teacher()
stu.pretty.delegate = tea
// 要想使 pretty 闭包的 delegate 修改生效，必须选择其委托策略为 Closure.DELEGATE_ONLY，默认是 Closure.OWNER_FIRST。
stu.pretty.resolveStrategy = Closure.DELEGATE_ONLY
println stu.toString()

需要注意的是，要想使上述 pretty 闭包的 delegate 修改生效，必须选择其委托策略为 Closure.DELEGATE_ONLY，默认是 Closure.OWNER_FIRST 的。

3、Groovy 数据结构

Groovy 常用的数据结构有如下 四种：

• 1）、数组
• 2）、List
• 3）、Map
• 4）、Range

数组的使用和 Java 语言类似，最大的区别可能就是定义方式的扩展，如下代码所示：

// 数组定义
def array = [1, 2, 3, 4, 5] as int[]
int[] array2 = [1, 2, 3, 4, 5]

下面，我们看看其它三种数据结构。

1、List

即链表，其底层对应 Java 中的 List 接口，一般用 ArrayList 作为真正的实现类，List 变量由[]定义，其元素可以是任何对象。

链表中的元素可以通过索引存取，而且 不用担心索引越界。如果索引超过当前链表长度，List 会自动往该索引添加元素。下面，我们看看 Map 最常使用的几个操作。

1）、排序

def test = [100, “hello”, true]
// 左移位表示向List中添加新元素
test << 200
// list 定义
def list = [1, 2, 3, 4, 5]
// 排序
list.sort()
// 使用自己的排序规则
sortList.sort { a, b ->
a == b ？0 :
Math.abs(a) < Math.abs(b) ? 1 : -1
}

2）、添加

// 添加
list.add(6)
list.leftShift(7)
list << 8

3）、删除

// 删除
list.remove(7)
list.removeAt(7)
list.removeElement(6)
list.removeAll { return it % 2 == 0 }

4）、查找

// 查找
int result = findList.find { return it % 2 == 0 }
def result2 = findList.findAll { return it % 2 != 0 }
def result3 = findList.any { return it % 2 != 0 }
def result4 = findList.every { return it % 2 == 0 }

5）、获取最小值、最大值

// 最小值、最大值
list.min()
list.max(return Math.abs(it))

6）、统计满足条件的数量

// 统计满足条件的数量
def num = findList.count { return it >= 2 }

Map

表示键-值表，其 底层对应 Java 中的 LinkedHashMap。

Map 变量由[:]定义，冒号左边是 key，右边是 Value。key 必须是字符串，value 可以是任何对象。另外，key 可以用 ‘’ 或 “” 包起来，也可以不用引号包起来。下面，我们看看 Map 最常使用的几个操作。

1）、存取

其示例代码如下所示：

aMap.keyName
aMap[‘keyName’]
aMap.anotherkey = “i am map”
aMap.anotherkey = [a: 1, b: 2]

2）、each 方法

如果我们传递的闭包是一个参数，那么它就把 entry 作为参数。如果我们传递的闭包是 2 个参数，那么它就把 key 和 value 作为参数。

def result = “”
[a:1, b:2].each { key, value ->
result += “$key$value”
}

assert result == “a1b2”

def socre = “”
[a:1, b:2].each { entry ->
result += entry
}

assert result == “a=1b=2”

3）、eachWithIndex 方法

如果闭包采用两个参数，则将传递 Map.Entry 和项目的索引（从零开始的计数器）；否则，如果闭包采用三个参数，则将传递键，值和索引。

def result = “”
[a:1, b:3].eachWithIndex { key, value, index -> result += “$index($key$value)” }
assert result == “0(a1)1(b3)”

def result = “”
[a:1, b:3].eachWithIndex { entry, index -> result += “$index($entry)” }
assert result == “0(a=1)1(b=3)”

4）、groupBy 方法

按照闭包的条件进行分组，代码如下所示：

def group = students.groupBy { def student ->
return student.value.score >= 60 ? ‘及格’ : ‘不及格’
}

5）、findAll 方法

它有两个参数，findAll 会将 Key 和 Value 分别传进 去。并且，如果 Closure 返回 true，表示该元素是自己想要的，如果返回 false 则表示该元素不是自己要找的。

Range

表示范围，它其实是 List 的一种拓展。其由 begin 值 + 两个点 + end 值表示。如果不想包含最后一个元素，则 begin 值 + 两个点 + < + end 表示。我们可以通过 aRange.from 与 aRange.to 来获对应的边界元素。

如果需要了解更多的数据结构操作方法，我们可以直接查 Groovy API 详细文档 即可。

4、Groovy 面向对象

如果不声明 public/private 等访问权限的话，Groovy 中类及其变量默认都是 public 的。

1）、元编程（Groovy 运行时)

Groovy 运行时的逻辑处理流程图如下所示:

为了更好的讲解元编程的用法，我们先创建一个 Person 类并调用它的 cry 方法，代码如下所示：

// 第一个 groovy 文件中
def person = new Person(name: ‘Qndroid’, age: 26)
println person.cry()

// 第二个 groovy 文件中
class Person implements Serializable {

String name

Integer age

def increaseAge(Integer years) {
this.age += years
}

/**

• 一个方法找不到时，调用它代替
• @param name
• @param args
• @return
  */
  def invokeMethod(String name, Object args) {

return “the method is ${name}, the params is ${args}”
}

def methodMissing(String name, Object args) {

return “the method ${name} is missing”
}

总结

最后小编想说：不论以后选择什么方向发展，目前重要的是把Android方面的技术学好，毕竟其实对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！

这里附上我整理的几十套腾讯、字节跳动，京东，小米，头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

由于篇幅有限，这里以图片的形式给大家展示一小部分。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

技术进阶之路很漫长，一起共勉吧~

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

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

总结

最后小编想说：不论以后选择什么方向发展，目前重要的是把Android方面的技术学好，毕竟其实对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！

这里附上我整理的几十套腾讯、字节跳动，京东，小米，头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

由于篇幅有限，这里以图片的形式给大家展示一小部分。

[外链图片转存中…(img-aBxlIHsy-1715107822137)]

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

技术进阶之路很漫长，一起共勉吧~

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

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