val和var

• val(来自value)——不可变引用。使用val使用val声明的变量不能在初始化之后再次赋值。它对应的是Java的final变量。

  定义只读局部变量使用关键字val定义，只能为其赋值一次。——来自Kotlin官方文档

  val a: Int = 1  // 立即赋值
  val b = 2   // 自动推断出 `Int` 类型
  val c: Int  // 如果没有初始值类型不能省略
  c = 3       // 明确赋值
  

• var(来自variable)——可变引用。这种变量的值可以被改变。这种声明对应的是普通(非final)的Java变量。

  可重复赋值的变量使用var关键字。——来自Kotlin官方文档

  var x = 5 // 自动推断出 `Int` 类型
  x += 1
  

?和!!

• "?."是安全调用运算符，它允许你把一次null检测和一次方法调用合并成一次操作。foo?.bar()相当于 if (foo != null) foo.bar() else null

  "?"表示当前对象可以为空。如果"?"加在变量后，系统任何时候都不会包他的空指针异常。f : foo?

  当某个变量可以为空的时候，必须在声明的类型后面加上"!"来标识该引用可为空。——来自Kotlin官方文档

  //如果str的内容不是数字返回null
  fun parseInt(str: String): Int? {
      // ……
  }
  

• "!!"是非空断言，可以把任何值转换为非空类型。如果对null值做非空断言。则会抛出异常。foo!!相当于if (foo != null) foo else NullPointerExperience

  "!!"表示当前对象不为空的时候执行后面语句，为空则抛出异常。加在变量后，如果对象为null，那么系统一定会报异常。

类

• 抽象函数

  abstract fun Fly()
  

  <u>抽象函数不用手动添加open，默认被open</u>

  抽象函数必须用abstract关键字修饰
  抽象函数没有具体实现
  含有抽象函数的类是抽象类，必须用abstract关键字修饰

• 抽象类、接口

  在抽象类中，类以及其中的某些成员可以声明为 abstract。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用 open 标注一个抽象类或者函数——来自Kotlin官方文档。

  open class Base {
      open fun f() {}
  }
  abstract class Derived : Base() {
      override abstract fun f()
  }
  

  Kotlin 的接口与 Java 8 类似，既包含抽象方法的声明，也包含实现。与抽象类不同的是，接口无法保存状态。它可以有属性但必须声明为抽象或提供访问器实现。

  使用关键字 interface 来定义接口

  interface Action {
      fun eat()
      fun sleep() {
        // 可选的方法体
      }
  }
  

• 单例类

  饿汉式

  //Java实现
  public class Singleton {
      private static Singleton instance=new Singleton();
      private Singleton(){
  
      }
      public static Singleton getInstance(){
          return instance;
      }
  }
  

  //Kotlin实现
  object Singleton
  

  懒汉式

  //Java实现
  public class Singleton {
      private static Singleton instance;
      private Singleton(){}
      public static Singleton getInstance(){
          if(instance==null){
              instance=new Singleton();
          }
          return instance;
      }
  }
  

  //Kotlin实现
  class Singleton private constructor() {
      companion object {
          private var instance: Singleton? = null
              get() {
                  if (field == null) {
                      field = Singleton()
                  }
                  return field
              }
              fun get(): Singleton{//不需要再用getInstance作方法名，
              //在伴生对象声明时，内部已有getInstance方法。
               return instance!!
              }
      }
  }
  

• 嵌套类、内部类、匿名类

  嵌套类：不能访问外部类的实例，嵌套类不持有外部类的引用，而外部类持有。(相当于Java中静态内部类)在Kotlin中，默认是嵌套类。

  类可以嵌套在其他类中——来自Kotlin官方文档

  class Outer {
      private val bar: Int = 1
      class Nested {
          fun foo() = 2
      }
  }
  val demo = Outer.Nested().foo() // == 2
  

  内部类：能访问外部类的实例，内部类持有外部类的引用。(相当于Java中内部类)

  类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用——来自Kotlin官方文档

  class Outer {
      private val bar: Int = 1
      inner class Inner {
          fun foo() = bar
      }
  }
  val demo = Outer().Inner().foo() // == 1
  

  类A在另一个类B中声明	在Java中	在Kotlin中
  嵌套类(不储存外部类的引用，相当于Java中静态内部类)	static class A	class A
  内部类(储存外部类的引用，相当于Java中内部类)	class A	inner class A

  匿名类：

  使用对象表达式创建匿名内部类实例

  window.addMouseListener(object: MouseAdapter() {
      override fun mouseClicked(e: MouseEvent) { …… }
      override fun mouseEntered(e: MouseEvent) { …… }
  })
  

  如果对象是函数式 Java 接口（即具有单个抽象方法的 Java 接口）的实例， 你可以使用带接口类型前缀的lambda表达式创建它

  val listener = ActionListener { println("clicked") }
  

• 伴生类

  伴生对象：Kotlin允许在类中使用companion object创建伴生对象，用伴生对象的成员来代替静态成员。

  class Person(val name:String){
      companion object {
          val kotPerson=Person("kot")
          fun sayHello(){
              println("Hello")
          }
      }
      var age=0
      fun sayName(){
          println("My name is $name")
      }
  }
  

函数

• 可变参数

  可变长参数函数：函数的变长参数可以用 vararg 关键字进行标识

  fun vars(vararg v:Int){
      for(vt in v){
          print(vt)
      }
  }
  fun main(args: Array<String>) {
      vars(1,2,3,4,5)  // 输出12345
  }
  

  代码实现实现	在Java中	在Kotlin中
  可变参数	int ... v	vararg v : Int

• let、run、also、apply

  let：调用某对象的let函数，则该对象为函数的参数。在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定return表达式。

  val a = "string".let {
      println(it)
      3
  }
  println(a)
  //运行结果
  string
  3
  

  一般和安全调用运算符处理可空参函数，并且在非空参函数中使用let函数时，只有在表达式不为bull时执行lambda，为空时什么都不发生。let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空，返回一个Unit类型的默认值。

  //一个不可空参函数
  fun sendEmailTo(email : String)
  
  //Kotlin检测传来参数不为null
  email?.let{ //表示email不为空才会去执行函数体
      email -> sendEmailTo(email)
  }
  //相当于Java中
  if(email != null) sendEmailTo(email)
  

  run：

  调用某对象的run函数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式。

  val a = run {
      println("run")
      return@run 1
  }
  println(a)
  //输出
  run
  3
  

  调用某对象的run函数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式。

  val a = "string".run {
      println(this)
      1
  }
  println(a)
  //输出
  string
  3
  

  also：调用某对象的also函数，则该对象为函数的参数。在函数块内可以通过 it 指代该对象。返回值为该对象自己。

  val a = "string".also {
      println(it)
  }
  println(a)
  //输出
  string
  string
  

  apply：调用某对象的apply函数，在函数范围内，可以任意调用该对象的任意方法，并且返回该对象。

  新的TextView实例创建之后立即被传给apply，在传给apply的lambda中，TextView 的实例变成了(lambda的)接收者，可以调用它的方法并设置它的属性。lambda执行之后。apply返回已经初始化过的接收者实例，它变成createViewWithCustomAttributes函数的结果。

  //使用apply初始化一个TextView
  fun createViewWithCustomAttributes(context: Context){
      TextView(context).apply{
          text = "Sample Text"
          textSize = 20.0
          setPadding(10,0,0,0)
      }
  }