Kotlin(一)

一.常量与变量

val（value 的简写）用来声明不可变的变量，类似java中的final，不可重复赋值
val <标识符> : <类型> = <初始值>
var（variable的简写）用来声明可变的变量，可被重新赋值
var <标识符> : <类型> = <初始值>

val a : String = "123"
注：也可直接写成 val a = "123"  这里的a会被自动推导成字符串变量，这是kotlin的类型推导机制
var a : String = "123"
把val 修改成var后，即可修改a的值

二.函数（方法）

函数是用来运行代码的载体
基本用法：
fun 方法名(参数) : 返回值类型{方法体}
fun是定义函数的关键字，无论定义什么函数都需要用fun声明

1.有返回值

   fun domain(param1 : Int,param2 : Int) : Int{
        return max(param1,param2)
   }
   简化写法:
   fun domain(param1 : Int,param2 : Int) : Int = max(param1,param2)

2.无返回值

   fun domain(param1 : Int) : Unit{
         println("$param1")
   }
   注：Unit相当于java中的void，也可以不写
   fun domain(param1 : Int){
         println("$param1")
   }

三.程序的逻辑控制

1.if语句

kotlin中的if语句跟java中的if语句用法基本一样

  写法可不断精简
  fun domain(param1 : Int,param2 : Int) : Int{
        var a = 0
        if (param1>param2){
            a = param1
        }else{
            a = param2
        }
        return a
    }

   fun domain(param1: Int, param2: Int): Int {
        val a = if (param1 > param2) {
                param1
            } else {
                param2
            }
        return a
    }

  fun domain(param1: Int, param2: Int): Int {
        return  if (param1 > param2) {
                param1
            } else {
                param2
            }
    }

  fun domain(param1: Int, param2: Int): Int = if (param1 > param2) {
        param1
    } else {
        param2
    }

  fun domain(param1: Int, param2: Int): Int = if (param1 > param2)
        param1
    else
        param2
    

2.when条件语句

kotlin中的when语句跟java中的switch语句很相似，但却比switch强大很多

例子：有返回参数传入一个分数，返回描述
   fun ScoreDescn(score:Int):String{
        var descn:String;
        when(score){
            10 -> descn = "优"
            9 -> descn = "良"
            8 -> descn = "中"
            7 -> descn = "可"
            else -> descn = "差"
        }
        return descn
    }
    
   运行
   fun main(){
        val a = 10
        ScoreDescn(a)
    }

返回 "优"

无返回参数
   fun ScoreDescn(score:Int){
        when(score){
            10 -> "优"
            9 ->  "良"
            8 ->  "中"
            7 ->  "可"
            else ->  "差"
        }
    }

3.循环语句

for循环 kotlin中把java中的for-i循环直接舍弃，加强了java中的for-each循环，变成了for-in循环

0到10遍历  
..是创建两端闭区间的关键字  数学表达式[0,10]
  for(i in 0..10){
       println(i)
   }
until是左闭右开区间的关键字  数学表达式[0,10)
  for(i in 0 until 10){
      println(i)
   }

四.类

创建一个类
class Car {
}
然后定义一个变量“速度“，并在里面加上两个动作，跑和停止两个函数
class Car {
    var velocity = 0
    fun run(){
        velocity = 10
       println("这辆车的速度达到了"+velocity)
    }
    fun stop(){
        velocity = 0
        println("这辆车的速度达到了"+velocity)
    }
}
然后进行实例化，kotlin中取消了new关键字
fun main(){
        val car = Car()
        car.velocity = 10
        car.run()
        car.velocity = 0
        car.stop()
    }

继承与构造函数

在kotlin中所有任何一个非抽象类默认都是不可以被继承的，相当于java中加了final关键字，如果需要被继承要在类的前面加上open关键字

open class Car {
  .......
}
class bus : Car(){

}

kotlin中将构造函数分成了主构造函数和次构造函数
主构造函数的特点是没有函数体，直接定义在类名后面即可

class Bus(val size : Int) : Car(){

}

val bus = Bus(10)

kotlin提供了一个init结构体，所有主构造函数中的逻辑写在里面

class Bus(val size : Int) : Car(){
  init {
      println(size)
  }
}

任何一个类可以有多个次构造函数，所有次构造函数都必须调用主构造函数(包括间接调用)，次构造函数是通过constructor关键字定义的

class Bus(val size : Int,height : Int) : Car(height){

    constructor(height: Int):this(10,100){

    }
    constructor():this(0){
        
    }
}