Kotlinkotlin的基本语法

Posted 2021-08-26 Rose J

本文目录

• kotlin学习-基本语法
• • 1.简介
  • 2.运行
  • 3.逻辑控制
  • • 1.if条件语句
    • 2.when条件语句
    • 循环语句
  • 4.面向对象
  • 5.接口
  • 6.可见修饰符
  • 7.数据类
  • 8.单例类

kotlin学习-基本语法

1.简介

对比java

1.语法简洁，代码量少

2.语法高级

3.语言安全性。杜绝空指针

4.和java100%兼容

2.运行

在线网站：https://play.kotlinlang.org/

val 不可变 =final

var 非final

var a =10

（自动推导类型）

不加分号

变量延迟赋值：

var a：Int a=10

函数

import kotlin.math.max



fun main(){
    var a=10
    var b=12
    var max=largerNumber(a,b)
    println(""+max)
}
fun largerNumber(num1:Int ,num2:Int):Int {
    return max(num1,num2)

}

语法糖

当一个函数只有一行代码时，Kotlin允许我们不必编写函数体，可以直接将唯一的一行代码写在函数定义的尾部，中间用等号连接即可。

fun largerNumber(num1:Int ,num2:Int):Int = max(num1,num2) 自动推导–>简化

fun largerNumber(num1:Int ,num2:Int) = max(num1,num2)

3.逻辑控制

程序的执行语句主要分为3种：顺序语句，条件语句，循环语句

1.if条件语句

fun largerNumber(num1:Int ,num2:Int):Int {
    var value=0
    if(num1>num2){
        value=num1
    }else{
        value=num2
    }
   return value
}

需要重新赋值 所以用var

kotlin if语句有返回值

因此简化

fun largerNumber(num1:Int ,num2:Int):Int {
    val value=if(num1>num2){
        num1
    }else{
        num2
    }
   return value
}

不需要重新赋值，所以用val

再简化 替代value

fun largerNumber(num1:Int ,num2:Int):Int {

   return if(num1>num2){
       num1
    }else{
        num2
    }
}

加上语法糖再简化

fun largerNumber(num1:Int ,num2:Int)=if(num1>num2){
       num1
    }else{
        num2
    }

语法糖结合if语法

fun largerNumber(num1:Int ,num2:Int)=if(num1>num2) num1 else num2

2.when条件语句

类似switch

精准匹配

    fun main(){
    val a="Tom"
    println(""+getScore(a))
}
fun getScore(name:String)=when(name){

   "Tom"->86
   "Jim"->77
   "Jack"->95
   "Lily"->100
    else -> 0
}

类型匹配

Number 类型的参数

像Int，Long，Float，Double等与数字相关的都是他的子类

fun main(){
    val a=98
    println(""+checkNumber(a))
}
fun checkNumber(num:Number)=when(num){

   is Int -> println("number is Int")
   is Double -> println("number is Double")
   else ->println("number not support")
}

不带参数

fun main(){
    val a="Tom"
    println(""+getScore(a))
}
fun getScore(name:String)=when{

   name== "Tom"->86
   name=="Jim"->77
   name=="Jack"->95
   name=="Lily"->100
    else -> 0

}

判断所有以Tom开头的人 用startsWith

fun main(){
    val a="Tomkvj"
    println(""+getScore(a))
}
fun getScore(name:String)=when{

   name.startsWith("Tom") ->86
   name=="Jim"->77
   name=="Jack"->95
   name=="Lily"->100
    else -> 0

}

循环语句

while循环和java一样

for

kotlin中是for-in

..闭区间

fun main(){
    for(i in 1..10){
        println(i)
    }
}

until 左闭右开区间

fun main(){
    for(i in 0 until 9){
        println(i)
    }
}

step 跳过某些数（加法）. i+2 == step 2

fun main(){
    for(i in 0 until 3 step 2){
        println(i)
    }
}

输出

0

2

downto 降序

fun main(){
    for(i in 3  downTo 1){
        println(i)
    }
}

输出

3

2

1

4.面向对象

类与对象

创建实例不需要new

var p=Person()

继承与构造函数

在kotlin中任何一个非抽象类默认都是不可以被继承的

，相当于java中声明了final

(原因：类和变量一样，最好都是不可变的，可变就存在未知的风险)

抽象 关键字 open

继承 ： （java中是extends 在kotlin中继承是 冒号：）父类带括号

主构造函数 和 次构造函数

主构造函数

每个类都有一个默认的不带参数的主构造函数，当然也可以显式的指明参数，主函数的特点是没有函数体，直接定义在类名后面即可

class Stduent(val sno:String,val grade:Int) : Person()  {
}

表明对Student实例化时必须传入要求的参数

init函数体

class Stduent(val sno:String,val grade:Int) : Person()  {
    init {
        println("sno is"+sno)
        println("sno is"+grade)
    }
}

实例化

val stduent=Stduent("123",5)

主构造函数调用父类的构造函数

1.父类无参数

要带括号

2.父类有参数

父类

open class Person(val name:String,val age:Int){
}

子类

class Stduent(val sno:String,val grade:Int,name:String,age: Int) : Person(name,age)  {
    init {
        println("sno is"+sno)
        println("sno is"+grade)
    }
}

在主构造函数中加上参数

实例化

`       val stduent=Stduent("123",5,"123",2)`

次构造函数

ktolin规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)

class Stduent(val sno:String,val grade:Int,name:String,age: Int) : Person(name,age)  {
    constructor(name: String,age: Int):this("",0,name,age){

    }
    constructor():this("",0);
}

次构造函数时通过constructor关键字来定义的，

这里我们定义了两种次构造函数，

1.第一个次构造函数接受name和age参数，然后又通过this关键字调用了主构造函数，并将sno和grade两个参数赋值为初始值

2.第二个函数不接受任何参数，他通过this关键字调用了我们定义的第一个次构造函数并将name和age参数也赋值成初始值，

因为第二个次构造函数间接调用了主构造函数，所以合法

那么就拥有了三种实例化方式

…

kotlin****特殊情况-只有次构造函数，没有主构造函数

class Stduent : Person{
    constructor(name: String,age: Int):super(name,age){

    }

}

次构造函数直接调用父类的构造函数

5.接口

接口类

interface Study {
    fun readBooks()
    fun doHomework()
}

父类

open class Person(val name:String,val age:Int){
}

子类

class Stduent(name: String,age: Int) : Person(name,age),Study{


    override fun readBooks() {
     println(name+"is reading")
    }

    override fun doHomework() {
        println(name+"is donging homework")


    }

}

主函数

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val stduent=Stduent("123",5)
        doStudy(stduent)

    }
    fun doStudy(study: Study){
        study.readBooks()
        study.doHomework()

    }
}

因为子类实现了Study接口，所以可以直接传递Stduent类的实例 —面向接口编程，多态

允许对接口中定义的函数进行默认实现

–也就是可以不实现

6.可见修饰符

区别

protected

当前类和子类可见

java：包内可见

internal：同一模块可见

7.数据类

data关键字

val user1=User("小许",20)
        val user2=User("小许",20)

加data ，对比对象属性，返回ture，不加 返回false

8.单例类

object关键字

object Singleton {
    fun SingletonTest(){
        println("singletonTest is called")
    }
}