//by lazy用来修饰val变量, 可以用来修饰局部变量和基本类型，等下一次调用到的时候才会进行初始化
val lazyByLazy: String by lazy {
println(“here is lazy init”)
“Zoo”
}
println(lazyByLazy)//lazyByLazy被调用到了，开始初始化，执行println(“here is lazy init”)，并且赋值"Zoo"
/*
is 判断类型
*/
val isString: String? = “kotlin”
if (isString is String) {
println(“it’s string”)
}
/*
as 类型转换
*/
val y: Int? = 123;
val x: String? = y as? String;
println(x);
/*
方法
*/
//step1: 标准写法
fun method1(name: String): String {
return “hello $name”
}
//step2: 如果返回值类型可以由编译器推断出来，则可以省略返回值类型
fun method2(name: String) = {
“hello $name”
}
//step3: 函数只有单个表达式，则可以省略花括号，直接写在=后
fun method3(name: String) = “hello $name”
//step4: 具有代码块的函数，必须显示指明返回类型
fun method4(): Int {
println(“this is 100”)
return 100
}
println(method1(“kotlin1”))
println(method2(“kotlin2”))
println(method3(“kotlin3”))
println(method4())
//void返回类型
fun testVoid(): Unit {//Unit = java’s void
println(“this is a void fun”)
}
fun testVoidWithoutUnit() {
println(“this is a void fun without unit”)
}
fun methodWithMultipleArgs(vararg name: String) {//多个参数
println(“params size is ${name.size}”)
}
methodWithMultipleArgs(“aaron”)
methodWithMultipleArgs(“aaron”, “beyond”)
fun methodWithOneLine(age: Int): Boolean = age == 20
println(methodWithOneLine(20))
//@JvmStatic and @JvmField
println(JvmClass.name);
//方法入参可以指定默认值
fun sayHello(who: String = “Jerry”, msg: String = “Hello”) {
println(“$who - said - $msg”)
}
sayHello()
/*
9.1 Class
*/
//open表示此类可以被继承, 用在函数上面表示此函数可以被重写
open class KotlinClass(val name: String) {
open fun print(content: String?) {
println(this.name + content)
}
}
val kotlinClass = KotlinClass(“Charles”)
kotlinClass.print(" say: hello")
/*
9.2 Class extends Class and Implements interface
*/
class SubKotlinClass(name: String) : KotlinClass(name), CallBack { //父类构造函数直接赋值, 不再调用super
override fun getName(id: Int) {
println(“id = $id”)
}
override fun print(content: String?) {
println(this.name + content + “!!!”)
}
}
val subKotlinClass = SubKotlinClass(“Sub”)
subKotlinClass.print(" say: hello")
/*
9.3 Class with primary constructor, 主构造器定义在类头部, 因此需要init空间做初始化
*/
class KotlinClassConstructor1 constructor(name: String) {
val name: String
init {
this.name = name
}
}
val kotlinClassConstructor1 = KotlinClassConstructor1(“Jack”)
println(“kotlinClassConstructor:${kotlinClassConstructor1.name}”)
/*
9.4 Class with primary constructor, 主构造器定义在类头部, 也可以在类的属性初始化声明处
*/
class KotlinClassConstructor2 constructor(name: String) {
val prop: String = name.toUpperCase()
}
/*
9.5 Class with primary constructor, 如果主构造函数没有注解或可见性说明，则 constructor 关键字可以省略
*/
class KotlinClassConstructor3(name: String) {
}
/*
9.6 Class with primary constructor, 声明属性并在主构造函数中初始化更简洁的写法
*/
class KotlinClassConstructor4(var name: String) {
}
val kotlinClassConstructor4 = KotlinClassConstructor4(“Jack”)
println(“kotlinClassConstructor:${kotlinClassConstructor4.name}”)
/*
9.7 Class with secondary constructor, 次级构造器, 可以有多个
*/
class KotlinClassSecondaryConstructor {
private var name: String
private var age: Int = 0
private var male: Boolean = false
constructor(name: String) {
this.name = name;
}
constructor(name: String, age: Int) {
this.name = name
this.age = age
}
constructor(name: String, age: Int, male: Boolean) : this(name, age) {
this.name = name
this.age = age
this.male = male
}
fun print() {
println(this.name)
}
}
val kotlinClassSecondaryConstructor1 = KotlinClassSecondaryConstructor(“Michael”)
kotlinClassSecondaryConstructor1.print()
val kotlinClassSecondaryConstructor2 = KotlinClassSecondaryConstructor(“Michael”, 18, true)
kotlinClassSecondaryConstructor2.print()
/*
9.8 class without body
*/
class withoutBody
/*
9.9 DataClass
*/
data class DataClassSample(val x: Int, val y: Int)
val data = DataClassSample(100, 200)
println(data.x + data.y)
/*
10.1 ArrayList and for
*/
val names = arrayListOf(“dog”, “cat”)
for (name in names) {
println(“names contains:$name”)
}
for (i in 0 until names.size) {//从0一直到names.size - 1, 方便数组遍历而设计
println(“[for until]names contans:${names[i]}”)
}
/*
10.2 Map
*/
val ages = mapOf
for ((key, value) in ages) {
println(“$key -> $value”)
}
/*
10.3 可变数组
*/
val bags = mutableListOf(1, 2, 3)
bags.add(4)
println(bags.last())
println(bags[0])
/*
10.4 while
*/
var cnt: Int = 0;
while (cnt < 5) {
println(cnt++)
}
if (cnt == 5)
println(“cnt = 5”)
/*
10.5 when: 等价于switch
*/
var a = 1
val b = 2;
val c = 3
when (b) {
1 -> println(“the result is 1”)
2 -> {
a = 11
println(a)
}
1, 2 -> println(“1 or 2”)
in 1…2 -> println(“in 1 and 2”)
else -> {
println(“nothing”)
}
}
/*
10.6 单例
*/
println(Utils1.label)
println(Utils2.hello())
/*
10.7 static
*/
println(CompanionTest.name)
println(CompanionTest.run())
/*
10.8 getter and setter
*/
val getterAndsetter = KotlinGetterAndSetter()
getterAndsetter.x = 100
println(“getter and setter:” + getterAndsetter.x)
//getter and setter 二次赋值
val person = Person()
println(“name:${person.name}”)
person.name = “hello world”
println(“name:${person.name}”)
person.age = -1
println(“name:${person.age}”)
/* 11. 内联函数
apply let run with also
函数体对象 this it this this it
对象是否可省 可 不可 可 可 不可
返回值 必有,当前对象 最后一行,可有可无 最后一行,可有可无 最后一行,可有可无 必有,当前对象
可否判空 可以 可以 可以 不可以 可以
*/
//let -> 闭包内使用it作为当前这个对象的参数; 返回值是函数最后一行, 或者return语句
fun letTest(): Int {
// fun
“letTest”.let {
println(it)
return 1
}
}
println(letTest())
//apply -> 闭包内可以任意调用此对象; 并且最终也会返回此对象
fun applyTest() {
// fun T.apply(f: T.() -> Unit): T { f(); return this }
ArrayList().apply {
add(“applyTest”)
println(“this = $this, size = $size”)
}.let { println(it) }
}
applyTest()
// apply with null and nonnull
val strJim: String? = null
strJim?.apply {
println(“apply with nonnull”)
} ?: strJim.apply {
println(“apply with null”)
}
//with -> 闭包内可以任意调用此对象; 返回值是函数最后一行, 或者return语句
fun withTest() {
// fun
with(ArrayList()) {
add(“withTest”)
println(“this = $this, size = $size”)
}.let { println(it) }
}
withTest()
//run -> run只接收一个lambda函数为参数; 返回值是函数最后一行, 或者return语句
fun runTest() {
// fun
“runTest”.run {
println("this = " + this)
}.let { println(it) }
}
runTest()
//run用来判空
val s = null
s?.run {
} ?: run {
println(“use run to identify null”)
}
//also
fun alsoTest() {
val car = Car(“Benz”)
car.also {
it.name = “BMW”
}
println(“car’s name is ${car.name}”)
}
alsoTest()
/*
其它
*/
//test anonymous inner class about interface
callback.getName(123)
//@JvmOverloads, 声明多个参数的构造函数
val animal = Animal()
animal.func(“dog”)
animal.func(“dog”, 2)
animal.func(“dog”, 2, “New York”)
//lambda表达式
val lambdaTest1 = LambdaTest1()
lambdaTest1.setTheCallBack(object : CallBack {
override fun getName(id: Int) {
println(“getName”)
}
})
//if the callback defined in java
lambdaTest1.setTheCallBackFromJava(CallBackFromJava {
println(“getName”)
})
val lambdaTest2 = LambdaTest2()
lambdaTest2.setCallBack({ id -> println(“getName”) })
lambdaTest2.setCallBack { id -> println(“getName”) }
lambdaTest2.setCallBack { println(“getName”) }
//lambda使用下划线_, 没有用到的就用_代替
val aa = mapOf(1 to “a”, 2 to “B”)
aa.forEach { (_, value) -> println(“value:$value”) }
// chain use
var list = arrayOf(“java”, “c++”, “Android”, “Kotlin”, “iOS”)
list.map {
“Hello $it”
}.filter {
!it.contains(“c”)
}.forEach {
println(it)
}
}
//new a interface
private val callback = object : CallBack {
override fun getName(id: Int) {
println(“CallBack -> getName”)
}
}
/*
Object: 单例, Object修饰的类为静态类, 里面的方法和变量都是静态的
*/
object Utils1 {
val label: String
get() {
if (true)
return “here is singleton fun”
else
return “”
}
}
object Utils2 {
fun hello() {
println(“here is an object demo”)
}
}
/*
Interface
*/
//interface CallBack {
// fun getName(id: Int)
//}
interface CallBack2 {
fun getName(id: Int)
fun getVersion() = 1 // can offer non-abstract method
}
/*
companion object:伴生对象，相当于java中的static
*/
class CompanionTest {
companion object { //一个类中只能存在一个伴生对象
val name: String = “Vincent”
fun run() {
println(“I am running!”)
}
}
}
/*
getter and setter: 自带, 默认隐藏
*/
class KotlinGetterAndSetter {
var x: Int = 0
set(value) {
field = value
}
get() = field
}
class Person {
var name: String = “Tom”
set(value) {
field = value
}
get() = field.toUpperCase()
var age: Int = 100
set(value) {
if (value < 0) {
field = 0
} else {
field = value
}
}
get() = field
}
/*
@JvmStatic and @JvmField，主要是方便java调用，不用再在java中写.INSTANCE调用kotlin代码
*/
open class JvmClass {
companion object {
@JvmField
val name: String = “jvm test”
@JvmStatic
fun method() {
println(“call method”)
}
}
}
class Animal {
//define multiple constructor
@JvmOverloads
fun func(a: String, b: Int = 0, c: String = “abc”) {
}
}
class Car(var name: String) {
}
class LambdaTest1 {
var callback: CallBack? = null
var callbackfromjava: CallBackFromJava? = null
fun setTheCallBack(callback: CallBack) {
this.callback = callback
}
fun setTheCallBackFromJava(callbackfromjava: CallBackFromJava) {
this.callbackfromjava = callbackfromjava
}
}
class LambdaTest2 {
lateinit var callback: (CallBack) -> Unit
fun setCallBack(callback: (CallBack) -> Unit) {
this.callback = callback
}
}
class User(var name: String, var age: Int) {
}
3. Kotlin Advanced
=============================================================================
fun main(args: Array) {
/*
lambda表达式
*/
//(1) kotlin中lambda表达式定义在{}中
//(2) 其参数(如果存在)在 -> 之前声明(参数类型可以省略)
//(3) 函数体(如果存在)在 -> 后面
//源代码：无参
fun l1() {
println(“无参数”)
}
//lambda表达式: 以值的形式传递
val l1 = { println(“无参数”) }
//调用
l1()
//源代码：有参
fun l2(x: Int, y: String) {
println(y.length + x)
}
//lambda表达式: 以值的形式传递
val l2 = { x: Int, y: String -> println(y.length + x) }
//调用
l2(1, “Mike”)
//lambda表达式可以直接通过run运行
run { l2(1, “tom”) }
//lambda简化过程
val people = listOf(User(“张三”, 18), User(“李四”, 20))
//1.1 函数只有lambda一个实参
//原始完整代码
println(“年纪最大:” + people.maxBy({ user: User -> user.age }))
//step1:如果lambda表达式是函数调用的最后一个实参，它可以放在括号外面
println(“年纪最大:” + people.maxBy() { user: User -> user.age })
//step2： 当lambda是函数唯一的实参时，可以去掉函数调用的括号
println(“年纪最大:” + people.maxBy { user: User -> user.age })
//step3：如果lambda的参数的类型可以推导，那么可以省略参数的类型
println(“年纪最大:” + people.maxBy { user -> user.age })
//step4：对于lambda中一个参数时，可以使用默认参数名称it来代替命名参数，并且lambda的参数列表可以简化，省略参数列表和->
println(“年纪最大:” + people.maxBy { it.age })
//1.2 函数有除了lambda外多个实参
fun lambdaTest1(a: Int, b: (String) -> String) {
println(“$a + ${b(a.toString())}”)
}
fun lambdaTest2(b: (String) -> String, a: Int) {
println(“$a + ${b(a.toString())}”)
}
lambdaTest1(11) {
“hello: $it”
}
lambdaTest2({ “hello: $it” }, 22)
//定义匿名函数，赋值给test变量
var test = fun(x: Int, y: Int): Int {
return x + y
}
//通过test调用匿名函数
println(test(2, 4))
/*
函数作为参数传递, 可以用作回调: T.()->Unit 和 ()->Unit
接受函数作为参数或者返回一个函数的函数就叫做高阶函数
*/
//() -> Unit//表示无参数无返回值的Lambda表达式类型
//(T) -> Unit//表示接收一个T类型参数，无返回值的Lambda表达式类型
//(T) -> R//表示接收一个T类型参数，返回一个R类型值的Lambda表达式类型
//()->Unit
//2.1 不带参数和返回值的函数作为形参
fun action0(method: () -> Unit) {
method()
println(“this is action0”)
}
fun method0() {
println(“this is method0 which is invoked”)
}
action0 {
println(“this is action0”)
}
fun action1(first: Int, method: () -> Unit) {
method()
println(“this is action1”)
}
//format->step1
action1(1, {
println(“第1种写法”)
})
//format->step2
action1(1) {
println(“第2种写法”)
}
val method: () -> Unit = {
println(“第3种写法”)
}
action1(1, method)
//2.2 带参数和返回值的函数作为形参
fun method1(msg1: Int, msg2: Int): Int {
println(“this is method1”)
return msg1 + msg2;
}
fun getResult1(
arg01: Int,
arg02: Int,
method: (arg1: Int, arg2: Int) -> Int
) {
println(“----->msg:before”)
val ret = method(arg01, arg02);
println(“----->msg:after = $ret”)
}
println(getResult1(1, 2, ::method1))
//T.()->Unit
fun getResult3(
method: Test.() -> Unit
) {
println(“----->msg:before”)
val test1 = Test()
test1.apply(method)
println(“----->msg:after ${test1.a}”)
}
println(
getResult3(
{
a = “Tim”
})
)
//2.3 函数作为参数, 指定加载位置和时机
var host = false
fun isHost() = host
suspend fun getFromNet() {
withContext(Dispatchers.IO) {
delay(1000)
host = true
}
}
fun load(checkHost: () -> Boolean) {
GlobalScope.launch() {
getFromNet()
if (checkHost.invoke()) println(“yes, it’s the host”) else print(“no, it’s not the host”)
}
}
load { isHost() }
/*
3.1 类委托
*/
val b = BaseImpl(10)
Derived(b).print() // 输出 10
Derived(b).otherPrint() //输出other
/*
3.2 属性委托
*/
val isLogin: Boolean by DerivedProperty(“tom”)
if (isLogin) {
println(“this is a property when invoked”)
}
/*
协程
*/
// 4.1 RxJava和协程的区别
fun getUser(): Observable {
val random = Random()
return Observable
.create { emitter: ObservableEmitter ->
//模拟网络请求
println("I’m doing network,CurrentThread is " + Thread.currentThread().name + “…”)
Thread.sleep(1000)
if (random.nextBoolean()) {
emitter.onNext(“Jack”)
} else {
emitter.onError(TimeoutException(“Net Error!”))
}
}
.subscribeOn(Schedulers.io())//指定网络请求在IO线程
}
fun rxjava() {
getUser()
.subscribe(object : Observer {
override fun onComplete() {
}
override fun onSubscribe(d: Disposable) {
}
override fun onNext(t: String) {
println(t)
}
override fun onError(e: Throwable) {
}
})
Thread.sleep(2000)//延时2s,避免主线程销毁
}
//run
rxjava()
/* 4.2
可在全局创建协程: launch和runBlocking
(1)launch是非阻塞的;
(2)runBlocking是阻塞的;
可返回结果的协程: withContext和async
(1)withContext与async都可以返回耗时任务的执行结果;
(2)多个withContext任务是串行的, withContext可直接返回耗时任务的结果;
(3)多个async任务是并行的, async返回的是一个Deferred, 需要调用其await()方法获取结果;
*/ 自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
尾声
你不踏出去一步，永远不知道自己潜力有多大，千万别被这个社会套在我们身上的枷锁给捆住了，30岁我不怕，35岁我一样不怕，去做自己想做的事，为自己拼一把吧！不试试怎么知道你不行呢？
改变人生，没有什么捷径可言，这条路需要自己亲自去走一走，只有深入思考，不断反思总结，保持学习的热情，一步一步构建自己完整的知识体系，才是最终的制胜之道，也是程序员应该承担的使命。
附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！
/* 4.2
可在全局创建协程: launch和runBlocking
(1)launch是非阻塞的;
(2)runBlocking是阻塞的;
可返回结果的协程: withContext和async
(1)withContext与async都可以返回耗时任务的执行结果;
(2)多个withContext任务是串行的, withContext可直接返回耗时任务的结果;
(3)多个async任务是并行的, async返回的是一个Deferred, 需要调用其await()方法获取结果;
*/ 自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-JgnQ8J8B-1712377880102)]
[外链图片转存中…(img-YXOy1Nr5-1712377880103)]
[外链图片转存中…(img-PeF3qgUO-1712377880103)]
[外链图片转存中…(img-zexogCRz-1712377880104)]
[外链图片转存中…(img-NOybOQaL-1712377880104)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
尾声
你不踏出去一步，永远不知道自己潜力有多大，千万别被这个社会套在我们身上的枷锁给捆住了，30岁我不怕，35岁我一样不怕，去做自己想做的事，为自己拼一把吧！不试试怎么知道你不行呢？
改变人生，没有什么捷径可言，这条路需要自己亲自去走一走，只有深入思考，不断反思总结，保持学习的热情，一步一步构建自己完整的知识体系，才是最终的制胜之道，也是程序员应该承担的使命。
附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
[外链图片转存中…(img-4ij2V6MF-1712377880105)]
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！
精彩文章
您阅读本篇文章共花了：
发表评论