Kotlin 笔记（一）

这几天花了点时间看了下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) {
    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.onCreate(savedInstanceState)
    toast("This is onCreate!!")
}

声明一个扩展函数很简单，只需要在函数名之前添加指定的类名即可。在调用时，该函数会以导入的方式添加到这个类中。

//扩展类
//class C {
//    fun foo() { println("number") }
//}
//
//fun C.foo(i:Int) { println("extention") }
//
//fun main(args: Array) {
//    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) {
    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.我们同样可以用 :: 的方式来引用类成员方法

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) {
    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) {
    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.onShow()
        super.onShow()
    }
}

定义带有相同方法的一个open类和一个接口，open类实现，接口不实现

open class TestSuperClass {
    open fun onShow(){}
}

interface TestSuperInterface {
    fun onShow()
}

一个子类去继承他们

class ShowTest: TestSuperClass(),TestSuperInterface{
    override fun onShow() {
        super.onShow()
    }
}

定义带有相同方法的一个抽象类和一个接口，接口实现和不实现都是如下

abstract class TestSuperClass {
    abstract fun onShow()
}

interface TestSuperInterface {
    fun onShow()
}

一个子类去继承他们

class ShowTest: TestSuperClass(),TestSuperInterface{
    override fun onShow() {
    }
}

总结：继承的父类和实现的接口有相同的方法的，带有实现的情况下，要在子类重写的方法里使用super来表示，如果都没有实现，则可以不用写super

复写规则

在 kotlin 中，实现继承通常遵循如下规则：如果一个类从它的直接父类继承了同一个成员的多个实现，那么它必须复写这个成员并且提供自己的实现(或许只是直接用了继承来的实现)。为表示使用父类中提供的方法我们用 super表示:

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.f() // 调用 A.f()
        super.f() // 调用 B.f()
    }
}

Kotlin 笔记（一）

1. 密封类

2.伴随对象

3.对象创建

4.main方法创建

5.扩展函数

6.函数式接口

7.我们同样可以用 :: 的方式来引用类成员方法

8.高阶函数，标准库函数

9.解构声明（多重声明）

10.构造函数

11.多重实现

12.when

13.If

14.Ranges

你可能感兴趣的:(Kotlin 笔记（一）)