println(“this is my first kotlin.”)
/*
- val:常量; var:变量
*/
val name = “Jack”
// name = “Rose” //报错
var age = 18
age = 20;
//也可明确类型
var count: Int = 100
/*
- 换行: 1. \n; 2. “”" +|
*/
val line = “here is one line\nthis is another line”
println(line)
val newLine = “”"here is one newLine
|here is another newLine"“”.trimMargin()
println(newLine)
/*
- 字符串模板、占位符:$
*/
var template = “this is a template string called $name and length is ${name.length}”
println(template)
/*
- null: ? ?. ?: !!
*/
var nullableString1: String? = “abc” //?可为空, 不加?则不能为空
var nullableString2: String? = null
println(nullableString1?.length)//?.如果为空则返回null, 不为空则返回实际值
println(nullableString2?.length)
println(nullableString2?.length ?: “i am null”)//?:如果为空则用:后面的赋值
// println(nullableString2!!.length)//!!如果为空则强制抛异常
var nameNullable: String? = null
var len = nameNullable?.length
println(len == null)
/*
- 延迟初始化: lateinit var, by lazy
*/
lateinit var lateInitByLateinit: String//lateinit var只能用来修饰类属性, 不能用来修饰局部变量和基本类型
fun testLateInit() {
lateInitByLateinit = “this is a lateinit string”
}
testLateInit()
println(lateInitByLateinit)
//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<String, Int>(“a” to 1, “b” to 2)
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 <T, R> T.let(f: (T) -> R): R { f(this)}
“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 <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
with(ArrayList()) {
add(“withTest”)
println(“this = $this, size = $size”)
}.let { println(it) }
}
withTest()
//run -> run只接收一个lambda函数为参数; 返回值是函数最后一行, 或者return语句
fun runTest() {
// fun <T, R> T.run(f: T.() -> R): R = f()
“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) {
}
=============================================================================
fun main(args: Array) {
/*
- lambda表达式
*/
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
最后
我这里整理了一份完整的学习思维以及Android开发知识大全PDF。
当然实践出真知，即使有了学习线路也要注重实践，学习过的内容只有结合实操才算是真正的掌握。
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
ng>) {
/*
- lambda表达式
*/
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-iEsjjzTv-1712707271908)]
[外链图片转存中…(img-0vAqsfbH-1712707271909)]
[外链图片转存中…(img-pGNuMyQY-1712707271910)]
[外链图片转存中…(img-vya6AyA6-1712707271910)]
[外链图片转存中…(img-chtTULFa-1712707271910)]
[外链图片转存中…(img-IhmP3wny-1712707271911)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-X5A2xwOb-1712707271911)]
最后
我这里整理了一份完整的学习思维以及Android开发知识大全PDF。
[外链图片转存中…(img-al6xUETu-1712707271912)]
当然实践出真知，即使有了学习线路也要注重实践，学习过的内容只有结合实操才算是真正的掌握。
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-1C3enH6v-1712707271912)]
874
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
