/*
一直在独立开发,也没时间调整自己的知识系统,虽然写代码速度变快了,项目经验很丰富了,但是快2年了。还是
用以前的开发方式。打算从0开始,开始重新架构我最近刚写完的护林系统。后面也打算开源出去。在此自勉吧。
这个项目就是使用kotlin,我就花了几天就入门。比较简单,但是就是写java 习惯了。之前还坚信 koltin不可能
取代java,因为android 底层,还有大量的库类和 思想都是适用于 java的,koltin只是让写代码变得方便了,但是
没有实质改变。但是像 很多android 程序员 都是独立开发项目的,大量的业务逻辑需要去写,真正只写核心代码
的人比较少吧。所以抱着试一试的态度尝试下。
*/
kotlin教程: http://www.runoob.com/kotlin/kotlin-basic-syntax.html
根据这个教程大致讲解下:
1.不需要分号结尾,有也没事
2.导包可以把导入一个文件夹,在导入的包比较多的时候,让代码界面看着舒服。
- kotlin.annotation.*
3.函数定义,给人感觉像人类文字, 直观翻译就是: 方法 sum 传入 ( a (int类型), b(int类型)) 返回 int类型结果
fun sum(a: Int, b: Int): Int { // Int 参数,返回值 Int return a + b }
4. 表达式作为函数体,实际用处不大 。 在 代码太多了,需要简化代码时候可以使用下
表达式作为函数体,返回类型自动推断:
fun sum(a: Int, b: Int) = a + b public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型
5.可变长参数函数 ,java也有但是麻烦, 使用场景很多,比如接口传递参数时候
fun vars(vararg v:Int){ for(vt in v){ print(vt) } } // 测试 fun main(args: Array<String>) { vars(1,2,3,4,5) // 输出12345 }
6.lambda表达式 , 核心了
// 这里举例一个Android中最常见的按钮点击事件的例子 mBtn.setOnClickListener(object : View.OnClickListener{ override fun onClick(v: View?) { Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show() } })
//java 代码为: ,感觉没有变少很多,但是看下面lambda。
et_mima.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show(); } });
使用lambda 变为:
mBtn.setOnClickListener {
Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show()
}
7. 一个是 var ,一个val . 一般写代码的时候都会初始化值的。所以基本都不用生命类型
可变变量定义:var 关键字
var <标识符> : <类型> = <初始化值>
不可变变量定义:val 关键字,只能赋值一次的变量(类似Java中final修饰的变量)
val <标识符> : <类型> = <初始化值>
常量与变量都可以没有初始化值,但是在引用前必须初始化
编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。
val a: Int = 1 val b = 1 // 系统自动推断变量类型为Int val c: Int // 如果不在声明时初始化则必须提供变量类型 c = 1 // 明确赋值 ar x = 5 // 系统自动推断变量类型为Int x += 1 // 变量可修改
8. 取代自己去拼写
$ 表示一个变量名或者变量值
$varName 表示变量值
${varName.fun()} 表示变量的方法返回值:
var a = 1 // 模板中的简单名称: val s1 = "a is $a" a = 2 // 模板中的任意表达式: val s2 = "${s1.replace("is", "was")}, but now is $a"
9. 核心
NULL检查机制
Kotlin的空安全设计对于声明可为空的参数,在使用时要进行空判断处理,有两种处理方式,字段后加!!像Java一样抛出空异常,另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理
//类型后面加?表示可为空 var age: String? = "23" //抛出空指针异常 val ages = age!!.toInt() //不做处理返回 null val ages1 = age?.toInt() //age为空返回-1 val ages2 = age?.toInt() ?: -1
10.
我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。
fun getStringLength(obj: Any): Int? { if (obj is String) { // 做过类型判断以后,obj会被系统自动转换为String类型 return obj.length } //在这里还有一种方法,与Java中instanceof不同,使用!is // if (obj !is String){ // // XXX // } // 这里的obj仍然是Any类型的引用 return null }
11. 简单的循环判断方便的多 step 每几位取值 downTo 去返方向 until排除最后一位
区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。
区间是为任何可比较类型定义的,但对于整型原生类型,它有一个优化的实现。以下是使用区间的一些示例:
print("循环输出:") for (i in 1..4) print(i) // 输出“1234” println("\n----------------") print("设置步长:") for (i in 1..4 step 2) print(i) // 输出“13” println("\n----------------") print("使用 downTo:") for (i in 4 downTo 1 step 2) print(i) // 输出“42” println("\n----------------") print("使用 until:") // 使用 until 函数排除结束元素 for (i in 1 until 4) { // i in [1, 4) 排除了 4 print(i) } println("\n----------------")
12.类型强制转换
toByte(): Byte toShort(): Short toInt(): Int toLong(): Long toFloat(): Float toDouble(): Double toChar(): Char
13.
字符
和 Java 不一样,Kotlin 中的 Char 不能直接和数字操作,Char 必需是单引号 ' 包含起来的。比如普通字符 '0','a'。
fun check(c: Char) { if (c == 1) { // 错误:类型不兼容 // …… } }
字符字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列:\t、 \b、\n、\r、\'、\"、\\ 和 \$。 编码其他字符要用 Unicode 转义序列语法:'\uFF00'。
我们可以显式把字符转换为 Int 数字:
fun decimalDigitValue(c: Char): Int { if (c !in '0'..'9') throw IllegalArgumentException("Out of range") return c.toInt() - '0'.toInt() // 显式转换为数字 }
当需要可空引用时,像数字、字符会被装箱。装箱操作不会保留同一性。
14.
数组
数组用类 Array 实现,并且还有一个 size 属性及 get 和 set 方法,由于使用 [] 重载了 get 和 set 方法,所以我们可以通过下标很方便的获取或者设置数组对应位置的值。
数组的创建两种方式:一种是使用函数arrayOf();另外一种是使用工厂函数。如下所示,我们分别是两种方式创建了两个数组:
//[1,2,3] val a = arrayOf(1, 2, 3) //[0,2,4] val b = Array(3, { i -> (i * 2) }) //读取数组内容 println(a[0]) // 输出结果:1 println(b[1]) // 输出结果:2
除了类Array,还有ByteArray, ShortArray, IntArray,用来表示各个类型的数组,省去了装箱操作,因此效率更高,其用法同Array一样:
val x: IntArray = intArrayOf(1, 2, 3) x[0] = x[1] + x[2]
15. """ 规则比较死板,但是用习惯了就方便了
字符串
和 Java 一样,String 是不可变的。方括号 [] 语法可以很方便的获取字符串中的某个字符,也可以通过 for 循环来遍历:
for (c in str) { println(c) }
Kotlin 支持三个引号 """ 扩起来的字符串,支持多行字符串,比如:
fun main(args: Array<String>) { val text = """ 多行字符串 多行字符串 """ println(text) // 输出有一些前置空格 }
String 可以通过 trimMargin() 方法来删除多余的空白。
fun main(args: Array<String>) { val text = """ |多行字符串 |菜鸟教程 |多行字符串 |Runoob """.trimMargin() println(text) // 前置空格删除了 }
默认 | 用作边界前缀,但你可以选择其他字符并作为参数传入,比如 trimMargin(">")。
16. 优化了下 if与 3元表达式吧
IF 表达式
一个 if 语句包含一个布尔表达式和一条或多条语句。
我们也可以把 IF 表达式的结果赋值给一个变量。
val max = if (a > b) { print("Choose a") a } else { print("Choose b") b }
这也说明我也不需要像Java那种有一个三元操作符,因为我们可以使用它来简单实现:
val c = if (condition) a else b
17.
When 表达式
when 将它的参数和所有的分支条件顺序比较,直到某个分支满足条件。
when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式,符合条件的分支的值就是整个表达式的值,如果当做语句使用, 则忽略个别分支的值。
when 类似其他语言的 switch 操作符。其最简单的形式如下:
when (x) { 1 -> print("x == 1") 2 -> print("x == 2") else -> { // 注意这个块 print("x 不是 1 ,也不是 2") } }
在 when 中,else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。
如果很多分支需要用相同的方式处理,则可以把多个分支条件放在一起,用逗号分隔:
when (x) { 0, 1 -> print("x == 0 or x == 1") else -> print("otherwise") }
when 中使用 in 运算符来判断集合内是否包含某实例:
fun main(args: Array<String>) { val items = setOf("apple", "banana", "kiwi") when { "orange" in items -> println("juicy") "apple" in items -> println("apple is fine too") } }
输出结果:
apple is fine too
18. for 循环,不像java那么死板,固定格式,简化了下。最后一条注意看下,不然有点绕
For 循环
fun main(args: Array<String>) { val items = listOf("apple", "banana", "kiwi") for (item in items) { println(item) } for (index in items.indices) { println("item at $index is ${items[index]}") } }
for 循环可以对任何提供迭代器(iterator)的对象进行遍历,语法如下:
for (item in collection) print(item)
for (i in 1..4) print(i) // 打印结果为: "1234"
19. 成员变量注意 需要声明类型
类的属性
属性定义
类的属性可以用关键字 var 声明为可变的,否则使用只读关键字 val 声明为不可变。
class Runoob { var name: String = …… var url: String = …… var city: String = …… }
20. 调用java get/set 方法 直接用 点 。 但是这里也有一个问题,就是有些set方法 不一样是赋值,
就需要 你取看下 它的代码逻辑,重写了
我们可以像使用普通函数那样使用构造函数创建类实例:
val site = Runoob() // Kotlin 中没有 new 关键字
要使用一个属性,只要用名称引用它即可
site.name // 使用 . 号来引用 site.url
Koltin 中的类可以有一个 主构造器,以及一个或多个次构造器,主构造器是类头部的一部分,位于类名称之后:
class Person constructor(firstName: String) {}
如果主构造器没有任何注解,也没有任何可见度修饰符,那么constructor关键字可以省略。
class Person(firstName: String) { }
getter 和 setter
属性声明的完整语法:
var <propertyName>[: <PropertyType>] [= <property_initializer>] [<getter>] [<setter>]
getter 和 setter 都是可选
如果属性类型可以从初始化语句或者类的成员函数中推断出来,那就可以省去类型,val不允许设置setter函数,因为它是只读的。
var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法 var initialized = 1 // 类型为 Int, 默认实现了 getter 和 setter val simple: Int? // 类型为 Int ,默认实现 getter ,但必须在构造函数中初始化 val inferredType = 1 // 类型为 Int 类型,默认实现 getter
21. 对上面的解析下,不然很难理解
1、field 关键字
其中最关键的一句:Remember in kotlin whenever you write foo.bar = value it will be translated into a setter call instead of a PUTFIELD.
也就是说,在 Kotlin 中,任何时候当你写出“一个变量后边加等于号”这种形式的时候,比如我们定义 var no: Int 变量,当你写出 no = ... 这种形式的时候,这个等于号都会被编译器翻译成调用 setter 方法;而同样,在任何位置引用变量时,只要出现 no 变量的地方都会被编译器翻译成 getter 方法。那么问题就来了,当你在 setter 方法内部写出 no = ... 时,相当于在 setter 方法中调用 setter 方法,形成递归,进而形成死循环,例如文中的例子:
var no: Int = 100 get() = field // 后端变量 set(value) { if (value < 10) { // 如果传入的值小于 10 返回该值 field = value } else { field = -1 // 如果传入的值大于等于 10 返回 -1 } }
这段代码按以上这种写法是正确的,因为使用了 field 关键字,但是如果不用 field 关键字会怎么样呢?例如:
var no: Int = 100 get() = no set(value) { if (value < 10) { // 如果传入的值小于 10 返回该值 no = value } else { no = -1 // 如果传入的值大于等于 10 返回 -1 } }
注意这里我们使用的 Java 的思维写了 getter 和 setter 方法,那么这时,如果将这段代码翻译成 Java 代码会是怎么样呢?如下:
int no = 100; public int getNo() { return getNo();// Kotlin中的get() = no语句中出来了变量no,直接被编译器理解成“调用getter方法” } public void setNo(int value) { if (value < 10) { setNo(value);// Kotlin中出现“no =”这样的字样,直接被编译器理解成“这里要调用setter方法” } else { setNo(-1);// 在setter方法中调用setter方法,这是不正确的 } }
翻译成 Java 代码之后就很直观了,在 getter 方法和 setter 方法中都形成了递归调用,显然是不正确的,最终程序会出现内存溢出而异常终止。