Kotlin的简单语法

点击查查参考文章

一、方法的固定写法

二、Kotlin的变量与输出
kotlin中常见的数据类型

隐式指定变量的数据类型

var name = "张三";

如果隐式声明一个变量，一定要给变量赋值（因为隐式声明一个变量，编辑器需要通过“=”后面的值判定数据类型，所以一定要赋值）
错误写法： var i；会报错
正确写法： var i = 1；不会报错

显式指定变量的数据类型

var i:Int = 1;
var i:String = "djff";
var i:Long= 10000;

显式的声明一个变量可以赋值也可以不赋值
var i:Int ; 不会报错
var i:String = "djff"; 不会报错

常量的写法（需要用val 修饰变量）

val num = “dsfsdf“

Boolean运算

      代码实现上图
        var num5 = Math.sqrt(5.0)
        var num4 = Math.sqrt(4.0)
        var num3 = Math.sqrt(3.0)
        var num2 = Math.sqrt(2.0)
        
        println((num5-num4)>(num3-num2))

        代码实现上图
        var num7 = Math.pow(2.0,100.0);
        var num8 = Math.pow(3.0,75.0);

        println(num7>num8)

kotlin函数编写规则

    有多个参数，且有返回值（两个参数的类型都是int，返回值也是int）
    
    fun  test(a:Int,b:Int):Int{
        return  a+b;
    }

字符串模板（拼接字符串）

    fun test1(str: String):String{
     //需要注意的是：使用${ } 对字符串进行拼接
        var string:String = "" 金婷婷姐就是垃圾分开了的实际付款${str}${str.length}了圣诞节疯狂  ""
        return string;
         }
   
   调用这个方法并传值
   test1("十九大开了房");

条件控制语句
if else

        if(num7>0){
            println(num5)
        }else{
            println(num4)
        }
       
        //简写(去除{ })
        if(num7>0)
            println(num5)
        else
            println(num4)

字符串的比较

使用“==”或者equals 进行比较的效果是一样的，比较的是两个变量的值是否相等，而不是内存地址是否相等

        var str1 = "张三"
        var str2 = "张三"

        println(str1==str2)
        println(str1.equals(str2))

       var str1 = "abc"
       var str2 = "ABC"

        println(str1.equals(str2,true))//第二个参数true代表忽略大小写，两个参数是相等的
        println(str1.equals(str2,false))//第二个参数是false代表不忽略大小写，两个参数不相等

kotlin空值处理

 //参数后面加一个？ 意思是：在调用这个方法的时候允许传递的参数是null
    fun test2(str: String?):String{
        return "1";
    }
    
    //调用这个方法，如果不加？，调用这个方法的时候如果传递null值，不用运行程序直接会用提示报错
   test2(null);

when表达式

    //10分 满分，9分 干的不错，8分 还可以,其他情况： 还需要加油

    fun getScore(score:Int){
        when(score){
            10-> println("满分")
            9-> println("干的不错")
            8-> println("还可以")
            else ->println("还需要加油")
        }
    }

kotlin的for循环的使用

     //求1-100的和
    fun test2(int:Int){
        var nums = 1..100;//定义一个1-100的数组
        var result :Int = 0;
        for (num in nums){
            println(num)
         result = result + num;
        }

        println("1-100的和${result}")
    }

    //使用step
    fun test4(int:Int){
        var nums = 1..10;//定义一个1-10的数组

        for (num in nums step 2){//2的倍数的数字不打印
            println(num)
        }
        //    打印结果是：1 3 5 7 9


        var nums2 = nums.reversed();
        //讲nums倒叙打印出来  打印结果是： 10 9 8 7 6 5 4 3 2 1
        

        nums2.count();//计算出nums2中有多少个数字
    }

kotlin中的list和map

fun listDemo(list:Array<String>){
    //定义一个list
    var lists = listOf("1","22","33","44")
    //讲list遍历输出
    for(list in lists){
        println(list)
    }

    for((i,e) in lists.withIndex()){
        println("$i  $e")//$i代表下标  $e代表内容
    }
    //输出结果
    0  1
    1  22
    3  33
    4  44 
}

  fun mapDemo(list:Array<String>){
       //定义一个map
        var map = TreeMap<String,String>();

        //往map里面存值
        map["hh"] = "1"
        map["jj"] = "2"
        map["kk"] = "3"

        //通过key取值并输出
        println(map["hh"])
        println(map["jj"])
        println(map["kk"])

   }

kotlin函数和函数表达式

    fun add(x:Int,y:Int):Int{
        return x+y
    }
    
    //上面的代码可以简写为下面的形式
    fun add2(x:Int,y:Int):Int = x+y

   //此时i就相当于是一个函数，可以在另一个函数中调用i函数
    var i = {a:Int,b:Int ->a+b}

     fun add(x:Int,y:Int):Int{
        //调用i函数
        var result = i(5,10)
        println(result)
        return result 
      }

   另外一种写法
   var test5:(Int,Int) ->Int = {x,y ->x+y}
    
    //调用test5
    fun test6(x:Int,y:Int):String{
        var result = test5(5,10);
        println(result)
    }

kotlin默认参数和具名参数

 //设置默认值
    var num = 2;
    fun test7(a:Int = num ,b:Int):Int{//设置a的默认值2
        return  a + b
    }

//调用test7,（因为已经给参数a设置了默认值，所以只需要传递b的值就可以）
var result = test7(b = 5);
println(result );

kotlin 字符串和数字之间的转换

    fun test7(int:Int){
        var  a = "123"
        var  b = 123

        //将int 转成string 类型
        b.toString()

        //将string 转成 int 类型
         a.toInt()
    }

kotlin人机交互

   fun test8(int: Int) {
        println("请输入第一个数字")
        var num1Str = readLine()//返回值是一个stirng
        println("请输入第二个数字")
        var num2Str = readLine();//返回值是一个stirng

        //将string 转成 int
        var num1 = num1Str!!.toInt() //!!的作用是确保num1Str的值不为null
        var num2 = num2Str!!.toInt()

        println("${num1} + ${num2}  = ${num1+num2}" )
    }

kotlin异常处理（使用try catch）

   fun test9(int: Int) {
       println("请输入第一个数字")
       var num1Str = readLine()//返回值是一个stirng
       println("请输入第二个数字")
       var num2Str = readLine();//返回值是一个stirng

       //将string 转成 int
       try {
           var num1 = num1Str!!.toInt()//!!的作用是确保num1Str的值不为null
           var num2 = num2Str!!.toInt()
           
       }catch (e:Exception){
           e.printStackTrace()
           println("内容有错")
       }finally {
           println("内容有错")
       }

kotlin递归 (计算数字的阶乘)

   fun ceshi(num: Int):Int {
        if (num == 1){
            return  1
        }else{
           return num*ceshi(num-1)
        }
    }

kotlin尾递归优化（tailrec ），解决堆栈溢出异常

// (计算数字1 - 100的和)
    // var num = 0
    tailrec fun ceshi1(num: Int, result: Int): Int {
        println("打印结果${result}")
        if (num == 0) {
            return 1
        } else {
            return ceshi1(num - 1, result + num)
        }
    }

kotlin继承

父类需要用open关键字修改，才可以被子类继承
open class Father {
    var chartor:String = "性格内向"
    fun action(){
        println("公共场合大声喧哗")
    }
}


子类继承父类
class Son:Father() {
}


实例化子类，并调用相关的属性和方法
 var son1 = Son()
 println("儿子的性格${son1.chartor}")
 son1.action()

kotlin重写父类方法

父类需要用open关键字修改，才可以被子类继承
open class Father {
    var chartor:String = "性格内向"
    //如果子类想要重写父类的方法，方法名必须使用open修饰
    fun action(){
        println("公共场合大声喧哗")
    }
}


子类继承父类
class Son:Father() {
//重写父类的方法要用修饰
  override  fun  action(){
        println("儿子性格很内容，在公共场合很有礼貌")
    }
}

实例化子类，并调用相关的属性和方法
 var son1 = Son()
 println("儿子的性格${son1.chartor}")
 son1.action()

kotlin接口

定义一个接口
interface  IMan {
    fun xiaodidi()
}


//定义一个类，实现接口
class Man1 : IMan {
//重写接口里面的方法，要用override关键字修饰
    override fun xiaodidi() {
        println("18cm厘米")
    }
}


实例化Man1,并调用里面的函数
 var man = Man1()
 man.xiaodidi();

kotlin抽象类

定义一个抽象类
abstract Man {
  abstract  fun xiaodidi()
}

继承抽象类,并同时重写抽象类里面的方法
class Test: Man(){
  override fun xiaodidi() {
        println("18cm厘米")
    }
}

一个类继承一个抽象类，同时重写一个接口

定义一个接口
interface  IMan {
    fun xiao()
}

定义一个抽象类
abstract Man {
  abstract  fun xiaodidi()
}

继承抽象类并同时实现接口,并同时重写抽象类和接口里面的方法
class  Test:Man(),IMan{
  override fun xiao() {
        println("30cm厘米")
    }
    
  override fun xiaodidi() {
        println("18cm厘米")
    }
}

kotlin枚举

enum class MeiJu {
    周一, 周二, 周三, 周四, 周五, 周六, 周日
}

调用枚举中的数据
 println(MeiJu.周一.ordinal)//ordinal代表数据的下表索引

kotlin sealed类

Test5被sealed 修饰
sealed class Test5 {
    fun sayHello() {
        println("大家好")
    }

    class Test1 : Test5()
    class Test2 : Test5()
}

实例化Test1和Test2
var test:Test5 = Test5.Test1()
test.sayHello()

kotlin单例模式

类被object修饰，该类只能被实例化一次
object singinstance {
    fun test(){
        println("单例测试")
    }
}