Kotlin 笔记（一）
2017-06-14 本文已影响168人
周南城
这几天花了点时间看了下kotlin，对我来说还是有一定难度的，慢慢填坑吧，以下是一部分笔记
有点乱，先凑合吧，没有太多写博客经验，整体过一遍后，再统一整理
Kotlin是面向表达式语言
1. 密封类
使用密封类的最主要的的好处体现在你使用 when 表达式。可以确保声明可以覆盖到所有的情形，不需要再使用 else 情形
2.伴随对象
你可以在你的类中声明一个伴随对象，这样你就可以像 java 那样把它当做静态方法调用，只需要它的类名做一个识别就好了
- 伴生对象可以用于让一个类即拥有实例化方法又有静态方法。
- 伴生对象必须声明在类中，且使用 companion object 关键字进行声明。
- 伴生对象与类可以互相访问各自的私有成员。
class TestCompanion{
companion object{
private val CODE="12123"
val URL="http://www.baidu.com"
}
val config ="$CODE , $URL"//伴生对象与类可以互相访问各自的私有成员
}
fun main(args: Array<String>) {
println("${TestCompanion().config}")
}
3.对象创建
可以用对象表达式创建匿名内部类，对于函数式java接口，可以使用带接口类型前缀的lambda表达式创建它
4.main方法创建
快捷键：psvm或者main
5.扩展函数
Kotlin的扩展函数功能使得我们可以为现有的类添加新的函数，而不用修改原来的类。例如，我们可以为一个activity添加一个新函数，用于显示一个toast
fun Activity.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT){
Toast.makeText(this, message, duration).show()
}
我们可以在任何地方声明这个函数（例如在一个utils文件中），然后像使用普通函数一样在这个activity中使用它：
override fun onCreate(savedInstanceState: Bundle?) {
super<BaseActivity>.onCreate(savedInstanceState)
toast("This is onCreate!!")
}
声明一个扩展函数很简单，只需要在函数名之前添加指定的类名即可。在调用时，该函数会以导入的方式添加到这个类中。
//扩展类
//class C {
// fun foo() { println("number") }
//}
//
//fun C.foo(i:Int) { println("extention") }
//
//fun main(args: Array<String>) {
// C().foo()
// C().foo(1)
//}
//扩展类
//fun Context.showToast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {
// Toast.makeText(this, message, duration).show()
//}
//扩展行为
//val Int.isOdd: Boolean
// get() = this and 1 == 1
class MyClass {
companion object {
val txt1="111"
}
}
//val MyClass.Companion.txt2 ="222"//不能这么写，没有扩展成员属性，扩展成员属性是扩展方法的变体，要改成下面的写法
//扩展类的成员
val MyClass.Companion.txt3: String
get() = "222"
fun main(args: Array<String>) {
println(MyClass.txt1)
println(MyClass.txt3)
}
6.函数式接口
lambda表达式需要“函数式接口”的支持
函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，可以用注解@FunctionalInterface修饰。可以检查是否是函数式接口。
比如：
public interface OnClickListener {
void onClick(View v);
}
实现接口：
public interface OnClickListener {
void onClick(View v);
}
这种只有一个抽象方法的接口，就是函数式接口，如果主体只有一条语句，可省略{}、return、语句后面的;
view.setOnClickListener { toast("Click") }
7.我们同样可以用 <TypeName>::<FunctionName> 的方式来引用类成员方法
8.高阶函数，标准库函数
let：主要用于处理可null对象（一般用于 变量?.let{ 语句块 } 里作为安全调用的一种方法），比如
if (forecast != null) {
dataMapper.convertDayToDomain(forecast)
}else {
null
}
类似于
forecast?.let {
dataMapper.convertDayToDomain(it)
}
在forecaset对象不为null的情况下，将forecast作为参数，传给convertDayToDomain方法，在只有一个参数的情况下，缺省为it
with：
val br = BufferedReader(FileReader("hello.txt"))
with(br){
var line: String?
while (true){
line = readLine()?: break
}
close()
}
其中的close和readline方法可以直接调用
而不用with的情况下为：
val br = BufferedReader(FileReader("hello.txt"))
var line: String?
while (true){
line = br.readLine()?: break
}
br.close()
apply：
它看起来于 with 很相似，但是是有点不同之处。 apply 可以避免创建builder的
方式来使用
比如：
class Options{
var scale: Float = 1f
var offsetX: Double = 0.0
var offsetY: Double = 0.0
var rotationX: Float = 0f
var rotationY: Float = 0f
}
假设我们有这么一个类，我们在操作一个地图变换的时候需要传入这个东西，告诉地图该怎么变换。只需要修改部分属性即可
mapView.animateChange(Options().apply {
//Options 的作用域
scale = 2f
rotationX = 180f
})
9.解构声明（多重声明）
所谓的解构声明就是将一个对象解构(destructure)为多个变量，也就是意味着一个解构声明会一次性创建多个变量.简单的来说，一个解构声明有两个动作：
声明了多个变量
将对象的属性值赋值给相应的变量
比如下面的例子：
其实际意义是创建了三个变量name和age，sex，然后将person的属性值”Jane”和20及"female"分别赋值给name和age,sex
在数据类中，不需要重新定义componentN()方法和加上operator关键字
data class TestComponentN(val name: String, val age: Int,val sex:String) {
}
fun main(args: Array<String>) {
val(name,age,sex)=TestComponentN("Jane", 20,"female")
println("$name,$age,$sex")
}
或者实现多重声明只要在任意类内部定义了 componentN() 方法（N 为任意自然数）即可并加上 operator 关键字即可
class TestComponentN(val name: String, val age: Int,val sex:String) {
operator fun component1(): String {
return name
}
operator fun component2(): Int {
return age
}
operator fun component3():String{
return sex
}
}
fun main(args: Array<String>) {
val person = TestComponentN("Jane", 20,"female")
val (name, age) = person // 多重声明
val pName = person.component1()
val pAge = person.component2()
val pSex =person.component3()
println("$pName,$pAge,$pSex")
println(person)
}
10.构造函数
- 构造器分为主构造器和辅助构造器
- 默认一个类总会有一个无参的主构造器
辅助构造器
辅助构造器名为 constructor
辅助构造器可以通过 this() 调用其它的辅助构造器，但是任何一个辅助构造器必须调用主构造器
//调用主构造器
constructor(name: String) : this(name, 0) {
}
constructor(age: Int) : this("Default Name", age) {
}
constructor() : this("Default Name") {
主构造器
主构造器直接定义在类名后
class Man(val name: String, val age: Int, private var from: String = "USA", description: String = "none") {
init {
println("sentences in primary constructor")
}
}
- 主构造器会执行类中 init 代码块中得所有语句，所以每实例化一个对象，上述例子都会打印一条语句
- 主构造器中可以使用默认参数，如上述的 from
- 主构造器中定义的参数可以是 val 也可以是 var，定义的参数会自动转换为该类的成员属性
- 主构造器中的参数也可以不加 var 或 val，此时如果类中的方法有用到该参数，则此参数转换为成员属性，否则会被忽略
- 主构造器也可以被声明为 private，这样就只能通过辅助构造器来实例化该对象
私有主构造器
class Woman private constructor(val name: String, val age: Int) {
constructor(name: String) : this(name, 0) {
}
}
11.多重实现
- 定义带有相同方法的一个open类和一个接口，都带有实现
open class TestSuperClass {
open fun onShow(){}
}
interface TestSuperInterface {
fun onShow(){}
}
一个子类去继承他们
class ShowTest: TestSuperClass(),TestSuperInterface{
override fun onShow() {
super<TestSuperClass>.onShow()
super<TestSuperInterface>.onShow()
}
}
- 定义带有相同方法的一个open类和一个接口，open类实现，接口不实现
open class TestSuperClass {
open fun onShow(){}
}
interface TestSuperInterface {
fun onShow()
}
一个子类去继承他们
class ShowTest: TestSuperClass(),TestSuperInterface{
override fun onShow() {
super<TestSuperClass>.onShow()
}
}
- 定义带有相同方法的一个抽象类和一个接口，接口实现和不实现都是如下
abstract class TestSuperClass {
abstract fun onShow()
}
interface TestSuperInterface {
fun onShow()
}
一个子类去继承他们
class ShowTest: TestSuperClass(),TestSuperInterface{
override fun onShow() {
}
}
总结：继承的父类和实现的接口有相同的方法的，带有实现的情况下，要在子类重写的方法里使用super<Base>来表示，如果都没有实现，则可以不用写super<Base>
- 复写规则
在 kotlin 中，实现继承通常遵循如下规则：如果一个类从它的直接父类继承了同一个成员的多个实现，那么它必须复写这个成员并且提供自己的实现(或许只是直接用了继承来的实现)。为表示使用父类中提供的方法我们用 super<Base>表示:
open class A {
open fun f () { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } // 接口的成员变量默认是 open 的
fun b() { print("b") }
}
class C() : A() , B {
// 编译器会要求复写f()
override fun f() {
super<A>.f() // 调用 A.f()
super<B>.f() // 调用 B.f()
}
}
可以同时从 A 和 B 中继承方法，而且 C 继承 a() 或 b() 的实现没有任何问题，因为它们都只有一个实现。但是 f() 有俩个实现，因此我们在 C 中必须复写 f() 并且提供自己的实现来消除歧义。
12.when
when的分支，可以判断：表达式，值，类型，范围
fun main(args: Array<String>) {
//in 是闭合的，比如 in 10..20，会包含10和20
//when每个分支执行完后，会跳出，不会继续执行判断下一个分支
//匹配值和范围
val x = 10
val y = when (x) {
1 -> 2
3 -> 4
// 3, 10 -> 30
in 10..20 -> 20
!in 20..30 -> 40
else -> 0
}
println("$y")
////匹配类型
// val x = 10
// when (x) {
// is Int -> println("long")
// else -> println("else")
// }
// //匹配参数
// fun add(x: Int): Int {
// return x + 1
// }
//
// val x = 10
// when (x) {
// add(x) -> println("x=" + x)
// else -> println("else")
// }
}
13.If
条件表达式
if/else 结构与 Java 类型，不过由于 Kotlin 面向表达式，所以可以直接将表达式赋给一个变量。
val s = if (x > 0) 1 else -1
这种方式可以给常量赋值，有点类似 Java 中的三元操作符，此时 s 的类型为 Int
如果是下面这种混合型的，s 的类型就为 Any
val s = if (x > 0) "a" else 65
因为 Kotlin 中表达式都必须有值，所以如果没有 else 的话，需要引入 Unit 类
val s3: Any = if (x > 0) 1 else Unit
Kotlin 在 if 语句块的最后可以自动返回最后一行表达式的值，而不需要写 return 语句
//如果是表达式，则需要有一个else分支
val max = if (1 < 2) {
println("a")
2
} else {
println("b")
1
}
如果不是表达式则不需要else分支
if (a > b) {
println("Choose a")
a
}
14.Ranges
range 表达式是通过 rangeTo 函数形成的。rangeTo 函数拥有形如 .. 的操作符，该操作符是用 in 和 !in 实现的。 Range 可以对任何可比较的类型做操作，但对整数基本类型是优化过的。下面是些例子：
if (i in 1..10) {
println(i)
}
if (x !in 1.0..3.0) println(x)
if (str in "island".."isle") println(str)
数字的范围有个附加的特性：它们可以迭代。编译器会把它转成类似于 java 的 for 循环的形式，且不用担心越界：
for (i in 1..4) print(i) // prints "1234"
for (i in 4..1) print(i) // prints nothing
for (x in 1.0..2.0) print("$x ") // prints "1.0 2.0 "
如果你想迭代数字并想反过来，这个相当简单，你可以使用 downTo() 函数
for (i in 4 downTo 1) print(i)
也可以使用指定步数的迭代，这个用到 step()
for (i in 1..4 step 2) print(i) // prints "13"
for (i in 4 downTo 1 step 2) print(i) // prints "42"
for (i in 1.0..2.0 step 0.3) print("$i ") // prints "1.0 1.3 1.6 1.9 "
例子：
// Checking if value of comparable is in range. Optimized for number primitives.
if (i in 1..10) println(i)
if (x in 1.0..3.0) println(x)
if (str in "island".."isle") println(str)
// Iterating over arithmetical progression of numbers. Optimized for number primitives (as indexed for-loop in Java).
for (i in 1..4) print(i) // prints "1234"
for (i in 4..1) print(i) // prints nothing
for (i in 4 downTo 1) print(i) // prints "4321"
for (i in 1..4 step 2) print(i) // prints "13"
for (i in (1..4).reversed()) print(i) // prints "4321"
for (i in (1..4).reversed() step 2) print(i) // prints "42"
for (i in 4 downTo 1 step 2) print(i) // prints "42"
for (x in 1.0..2.0) print("$x ") // prints "1.0 2.0 "
for (x in 1.0..2.0 step 0.3) print("$x ") // prints "1.0 1.3 1.6 1.9 "
for (x in 2.0 downTo 1.0 step 0.3) print("$x ") // prints "2.0 1.7 1.4 1.1 "
for (str in "island".."isle") println(str) // error: string range cannot be iterated over
