kotlin入门手册

一、基础语法

  • var、val

    var m : Int = 10
    val n : Int = 30
    var j = 50
    
  • 函数

    fun add(m:Int,n:Int):Int{
      return m + n
    }
    
  • 空类型Unit

    fun proccess(m:Int):Unit{
      println(Int)
    }
    
  • Double 8
    Float 4
    Long 8
    Int 4
    Short 2
    Byte 1

    类型转换

    toByte()、toInt()

  • 123L、123.1F、0x1F、0b100101、123_456_789

  • 字符不能直接作为数值使用,可以用toInt转换成Int

  • 数组

    val arr1 = arrayOf(1,2,3,"a")
    var arr2 = arrayOfNulls<Int>(10)
    arr2.size
    val arr3 = Array(10,{i -> (i*i).toString() })
    var arr4:IntArray = intArrayOf(20,10,30)
    
  • 字符串

    1. 双引号包裹可写转义字符
    2. 三引号包裹保留原格式字符串,不能写转义字符
  • 字符串模板

    var i = 10
    val s1 = "i = $i"
    val s2 = "abc"
    val str = "$s2的长度为:${s2.length}"
    
  • 包package

  • 引入包import

    import a.b.*
    import a.b.func as f																																								
    
  • kotlin中if是表达式,有返回值。

    val max = if (a>b) a else b
    val min = if(a>b){
      print("choose a")
      a//返回值
    }else{
      print("choose b")
      b
    }
    
  • when语句,也可以作为表达式返回值,而且不需要每个分支加上break,分支条件可以用逗号分割多个条件,还能是表达式

    var x = 1
    when(x)
    {
      1->{}
      2,3->{}
      else->{}
    }
    
  • in关键词

    var n = 25
    when(n)
    {
      in 1..10->{}
      !in 30..60->{}
      else->{}
    }
    
  • for循环

    var arr = intArrayOf(2,4,5,6)
    for(item:Int in arr){
      println(item)
    }
    for(i in arr.indices){
      println("arr[$i] = " + arr[i])
    }
    for((index,value) in arr.withIndex){
      println("arr[$i] = " + value)
    }
    
  • While\doWhile

    二、类和接口

  • 在kotlin中,类允许定义一个柱构造器和若干个第二构造器。柱构造器是类头的一部分,紧跟在类名后面,用constructor关键词修饰,可以省略。构造参数是可选的。主构造器需要在init块中进行初始化。

    class Person constructor(firstName:String){
      init{
        
      }
    }
    
  • 第二构造器constructor关键词不能省略。类声明了主构造器,所有第二构造器都要在声明后面调用主构造器,或通过另外一个第二构造器间接调用主构造。

    class QACommunity(val url:String){
      init{
        
      }
      constructor(value:Int):this("baidu.com"){
        
      }
      constructor(description:String,url:String):this(20){
        
      }
    }
    
  • kotlin类不支持静态属性和方法,但支持全局函数和变量,如果全局函数要使用类内部资源,要使用Objects

    class Singleton private constructor()
    {
      public var value:Singleton? = null
      private object mHodler {val INSTANCE = Singleton()}
      companion object Factory{
        fun getInstance(): Singleton{
          return mHolder.INSTANCE;
        }
      }
    }
    var obj1 = Singleton.getInstance()
    var obj2 = Singleton.getInstance()
    
  • kotlin构造支持默认参数

  • kotlin不用new关键词创建类的实例

  • kotlin从语法上支持属性

    class Custom
    {
      val name:String
      	get() = "Bill"
      var v:Int = 20
      var value:Int
      	get() = v
      	set(value)
        {
    			v = value //v来保存属性值
        }
      var value2:Int = 0
      	get() = field //从field中读取属性值,field是关键词
      	set(value2)
      	{
          field = value //field来保存属性值
        }
    }
    
  • 函数可定义在类内部和外部,定义在类外部是全局函数,定义规则一样。函数支持默认参数,但需要是最后几个参数。使用vararg关键词声明可变参数。

    fun add(varargs a:Int)
    
  • 函数只有一行代码,可以用等号直接跟代码,可以省略函数返回值类型。

    fun getName() = mName
    fun getName():String
    {
      return mName
    }
    
  • 本地函数即函数内部的函数,作用域在包含本地函数的函数体。

  • 嵌套类用inner关键词声明,可用外部类的实例调用。

  • kotlin有四个修饰符:private、protected、internal、public

  • kotlin类默认是不可继承的,即final。可以用open关键词声明允许集成类

  • kotlin类方法默认不可继承,即final。用open声明可以继承,子类中用override关键词重写类方法。

  • kotlin属性默认不可被重写,使用open和override进行继承重写。val属性可被重写为var属性,反过来不行。

  • interface声明接口,接口方法可以有默认方法体,该默认方法不要求重写。接口中的属性和方法都是open的。

  • abstract声明抽象类

    三、枚举类、扩展

  • 枚举类

    enum class Direction
    {
    NORTH,SOUTH,WEST,EAST
    }
    var direction1: Direction
    var direction2: Direction = Direction.EAST
    
    
    enum class Direction private constructor(val d:Int)
    {
      NORTH(1),SOUTH(2),WEST(3),EAST(4)
    }
    Direction.valueOf("WEST") //输出3
    for(d in Direction.values())
    {
      println(d)
    }
    
  • 扩展原生API

    fun MutableList<Int>.swap(index1:Int,index2:Int)
    {
      val tmp = this[index1]
      this[index1] = this[index2]
      this[index2] = tmp
    }
    val mutableList = mutableListOf(1,2,3)
    mutableList.swap(0,2)
    
  • 扩展自定义类。扩展无法覆盖内部成员函数,内部优先级高。

    open class Parent(val value1:Int,val value2:Int)
    {
      
    }
    fun Parent.printResult()
    {
      
    }
    
  • 扩展属性需要实现setter才能为扩展属性初始化。

    var MyClass.value:Int
    	get() = mValue
    	set(value)
    	{
        mValue = value
      }
    
  • 扩展伴随对象(类似静态成员)

    class MyClass
    {
      companion object{}
    }
    fun MyClass.Companion.test()
    {
      
    }
    fun main()
    {
      MyClass.test()
    }
    
  • 可以在类中扩展顶层类。

    class D 
    {
      override fun toString():String
      {
        return "D"
      }
    }
    class C
    {
      fun D.foo()
      {
        println(toString)
        println(this@C.toString())
      }
      fun proccess(d:D)
      {
        d.foo()
      }
      override fun toString():String
      {
        return "C"
      }
    }
    fun main()
    {
      C().proccess(D())
    }
    //D().foo()不能写在顶层
    
  • 顶层扩展的方法不能使用open关键字,顶层扩展成员不能被继承。在类中对一个类扩展,加上open,可以被继承。

    四、数据类、封闭类、泛型

    五、对象和委托

    六、高阶函数、Lambda

    七、函数

    八、其他kotlin技术

展开阅读全文
©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读