【Kotlin】十分钟入门简单教程-最好学习过java语言

Kotlin简单入门

背景

主要知道该语言是jetBrains也就是出开发神器IDEA的公司推出的编程语言就行。因为被Google推荐在android上进行开发，所以该语言也是android开发的所要学习的一门关键语言。

语法特性简单概括（语法糖）

1. kotlin是没有分号作为结束的
2. 变量类型是强推导类型的

采用类似JavaScript的变量关键词 var和val

3. 推荐采用lambda编程，简化

正式认识

变量和函数

• var 和 val:一般情况下推荐使用val;这相当于java中的final变量，安全性会提高不少。

println("Hello My First Kotlin File")
    var a = 10
    println(a+2)
    //Kotlin 是不需要加上分号的;var和val是不一样的概念
    val num : Int = 1340 // 显性对象，和java中的基础数据不一样，在kotlin中是大写的，以对象进行应用的；必须！

• 函数方法；主要的编写要点就是给参和返参
  如下的代码：可以使用lambda编程——这个东西有很多的介绍，我个人理解就是讲一大段代码作为某个方法的参数进行使用即可，千万不要迷糊！这东西的出现就为了提高效率，少敲一些代码

/**
 * Function 方法和函数的使用
 */
fun whichIsBigger(a: Int, num: Int): Int  = max(a, num)//简化写法，语法糖

fun chooseLargeNumber(a: Int, num: Int) : Int{
    return max(a,num)
}

逻辑控制

• if 在kotlin是可以有返回值

**
 * if逻辑操作
 */
fun findBigNumberUseIf(a: Int, num: Int): Int {
//在kotlin中if是可以有返回值的
    val i = if (a > num) a else num
    return i
    //甚至可以直接return if的值
//    return if (a > num) a else num
}

//采用if逻辑操作
fun findBigNumber(a: Int, num: Int): Int {
    if(a > num){
        return a
    }else{
        return num
    }
}

• when 相当于java 中的switch不过不需要break（每次都很容易忘记break，导致各种各样的突发情况！【囧】这也体现kotlin对于这种问题处理的优越）

/**
 *when的使用
 */
// 学生成绩的简单方法
fun getStudentScore(s: String): Int {
    when(s) {
        "Tom" ->  return 89
        "Marry" -> return 100
        "Jerry" ->return 67
        "Chris" -> return 99
    }
    return -1
}
// 关键词is的应用，相当于instanceOf

fun  checkNumberType(num : Number) {
    when (num){
        is Int -> println("Number is Int")
        is Long -> println("Number is Long")
        is Double -> println("Number is Double")
        else -> println("Number is Unsupported")
    }
}

• while和for 使用关键词 in来达到循环的目的。

/**
 * 学习使用循环逻辑，其中的While使用和java的基本一致;
 * for的使用就比较大的区别
 */
//使用循环,这里和Java语言的区别就在于可以使用..代表闭区间；
fun printfOneToTen(){
    for ( i in 1..10){
        print(i)
    }
    println()
}
//单端闭区间 需要使用关键词 until
fun printfOneToNineUseTheKeyWordUntil(){
    for( i in 1 until 10){
        print(i)
    }
    println()
}
// 使用关键词step，类似java中的i++
fun useKeyWordStepToPrint(){
    for( i in 0 until 10 step 2){
        print(i)
    }
    println();
}
//也可降序，采用关键词downTo
fun useKeyWordDownToPrint(){
    for( i in 10 downTo 1 step 3){
        print(i)
    }
    println()
}

面向对象编程

kotlin自然也是像java一样都是面向对象编程语言

• 对象和类

//kotlin将构造函数分为了主次构造函数两种
/**
 * 在kotlin中继承是采用冒号来代替extends；
 * 在person类后面加上括号——主要就是涉及主次构造函数两种构造函数；只能有一个主构造函数，但是却可以多个次构造函数
 * 1. 主构造函数的特点就是没有函数体，在主构造函数上采用init{}来代替函数体
 * 2. 继承对象中括号就是指定父类的构造函数,若父类指定参数进行构造函数那么
 */

class Student(name: String, age: Int) : Person(name, age) , Study {
    var sno = ""
    var grade = 0
    override fun readBooks() {
        println("I am going to read books!")
    }

//    override fun writeReports() {
//
//        println("I am going to write reports!")
//    }
}

//显式指明参数,
class Student_Explicit (val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
    //在init方法中进行逻辑输出 主构造函数
    init {
        println("Student sno"+ sno + " grade "+grade)
    }
}

// 多个次构造函数，主要使用构造体constructor
class MultiCreateStudentClass(val sno: String, val grade: Int, name: String, age:Int)  : Person(name, age){
        init{
            println("MultiCreateStudentClass: "+ name + " " + age + " sno " +sno + " grade " + grade)
        }
        //只是指定名字和年龄参数
        constructor(name: String, age: Int) : this("",0,name,age){
            println("MultiCreateStudentClass: "+ name + " " + age)
        }
        //啥都没有,直接调用上面的次构造方法全部采用默认值
        constructor() : this("null",0)
}

//仅有次构造函数的类,不需要在继承的时候写上括号使用关键词 super代替
class OnlySecondaryStudentCreateClass : Person{
    constructor(): super("DefaultName",19)
}

• 接口，kotlin的接口使用和java的基本一致

多了默认实现方法，这个就可以不用override重写

//在kotlin中接口的使用和Java基本一致，接口和继承都是实现多态的方式
/**
 * 学生Student 类就可以实现这个，不过不是像java一样使用implement关键词，
 * 而是使用冒号：然后使用逗号，进行分隔
 */

interface Study {
    //定义几个动作
    fun readBooks()

    //‼️ 在kotlin中 允许对定义的方法进行默认的实现;意味着需要实现这个接口的类可以不用实现这个方法，这个就默认
    fun writeReports() {
        println("StudyFunction : Write Reports")
    }
    /**
     * 函数的可见性修饰符，即public,private,protected,default这些java的修饰，
     * 不过在kotlin将default换成internal内部的意思——代表同一个模块中的类才可见哦！
     */
}

• 数据类（JavaBean）和单例类

关键词data – 数据类
object – 单例模式

//这个是kotlin特有的，数据类，就不用像java中重写hashCode等等方法以充当数据类的
//使用关键词data数据
data class CellPhone(val brand:String,val price :Double){

}


//采用object关键词来实现在java中的单例模式
object SingletonObject {
    fun test(){
        print("It is the Singleton!")
    }
}

lambda编程

这个在kotlin是推荐的一种编程模式！通俗来说：一段代码作为参进行使用

• 通过集合api（kotlin）

 //通过集合的api进行入门lambda
    /**
     * 使用list
     */
    //kotlin中提供一个内置list进行
    val listFruits = listOf<String>("Apple","Orange","Banana","Grape")
    val listFruitsCanBeVarious = mutableListOf("Apple","Orange","Banana","Grape")
    println(listFruits.javaClass)
    for (f in listFruits) {
        print(f)
    }
    listFruitsCanBeVarious.add("Pear")
    for (f in listFruitsCanBeVarious) {
        println(f)
    }
    /**
     * 使用set,mutable是可变的意思
     */
    val setFruits = mutableSetOf("Apple","Orange","Banana","Grape","Apple")
    for(f in setFruits) {
        println(f)
    }
    /**
     * 使用map
     */
    //这里的to不是关键词，是infix函数，后续再深入研究
    val mapFruits = mutableMapOf("Apple" to 1,"Orange" to 2,"Banana" to 3,"Grape" to 4)
    for((key,value) in mapFruits) {
        //这里的for和之前的list以及set就不太一样，需要注意
        println(key +" : "+ value)
    }

---

• lambda的解析

 //集合的函数式api
    /**
     *  求最长单词的水果英文,
     */
    //这个是比较缩减的写法，那么就得一步步溯流回去，为啥可以这样缩写！
    //it是关键字来代表这个String
    println(listFruits.maxByOrNull {
        it.length
    })
    /**回顾lambda的定义：
     * 简单来说就是一段可以作为参数使用的代码片段
     * 可以看到和上面的区别，这里是用一个括号代表参数；
     * 上面的是直接使用花括号进行一个代码
     */
    val lambda = {fruit : String -> fruit.length}
    println(listFruits.maxByOrNull (lambda))
    /**
     * 获取全部都是大写的list
     */
    val listNew = listFruits.mapNotNull{it.uppercase()}
    println(listNew)

    /**
     * 进行过滤操作使用方法filter操作，包含字母a的
     */
    val listIsFiltered = listFruits.filter { it.contains('a') }.map{it.lowercase()}
    println(listIsFiltered)

• lambda的应用
  线程启动某方法

//学习使用关键词any和all,这个是判断的，返回的boolean；
    //any是只要有一个满足就返回true，all必须是所有都满足
    val mapInAnyCase = mapFruits.any { it.key.contains('a')}
    println(mapInAnyCase)

    //重头戏：Java函数式的api使用‼️,这里会提示你直接采用lambda的方式进行
    Thread(object : Runnable {
        override fun run() {
            println("Thread is running")
        }
    }).start()
    //省略括号保留花括号
    Thread { println("Thread——2 is running") }.start()

空指针问题

在java中空指针问题是项目崩溃的最高问题！在kotlin中就提供一种机制保护指针，尽可能避免空指针问题出现。

关键操作符号?以及.?,!!.,:?具体的使用详见以下代码：

package com.chris.firstproject
/**
 * 空指针问题是崩溃率最高的问题，
 * 在kotlin中提供一套系统针对空指针问题的方案。
 * 一般情况下，kotlin是不允许传入一个null的对象的
 */
fun main() {
    val computer = Computer("Apple",24324.12)
    readInfoComputer(computer)
    readInfoComputerWhateverNULL(null)
    readInfoComputerFouced(computer)
    readInfoComputerByLetFunction(computer)
}
//当加上一个操作符号? 这样这个参才会被允许传入空，
// 但是这就容易导致空指针问题；要小心
class Computer( val brand : String,  val price : Double){
    fun show(){
        println("$brand :$price")
    }

}

//使用操作符号 ?. 来表示对象不为空的时候正常调用
fun readInfoComputer(computer : Computer?){
    computer?.show()
}


/**
 * 学习使用操作符号 ?: 这个符号有点类似java中的三元表达式
 * 不过这里是操作用于空指针的审查的，不是像三元表达式进行布尔判断的
 */
fun readInfoComputerWhateverNULL(computer : Computer?){
    val computer_2 = computer ?: Computer("Default",0.0)
    computer_2.show()
}

//使用操作符号 !!. 这个意味着不论是否为空都给我用！！存在隐患，不推荐使用该符号
fun readInfoComputerFouced(computer: Computer?){ computer!!.show()
}

//使用let函数，这个可不是关键词也不是操作符号;这个函数会将自身作为参数传入该函数方法中；
//在这段代码中是采用关键词it作为自身对象进行使用
fun readInfoComputerByLetFunction(computer: Computer?){
    //省略写法，这个也是lambda的优势
    computer?.let{
        it.show()
    }
}

小技巧

• 字符串内嵌 这个和javaScript很像，格式为${}
• 参数默认

/**
 * 这一部分的代码主要是学习使用kotlin编程的一些小技巧和特性
 * 1. 字符串内嵌 ${}
 * 2. 参数默认值，这个就可以在进行方法执行的时候默认参数！
 */
fun main(){
    val computer = Computer("XiaoMI",2143.34)
    showStringEmbedded(computer)
    showUserInfoByDefault(computer,"Chris")
    showUserInfoByDefault(computer)
    //特殊情况,使用键值对的方式进行定位
    showUserInfoByDefaultSpecialCase(userName = "Chris")
}

// 如果表达式中仅有一个变量就可以省略花括号
fun showStringEmbedded(computer: Computer) {
    println("${computer.brand} is ${computer.price} ")
}

// 方法参数默认值，这就导致在kotlin比较少用次构造函数
fun showUserInfoByDefault(computer: Computer,userName : String = "Default"){
    print(userName)
    showStringEmbedded(computer)
}
// 特殊情况，第一个参数默认
fun showUserInfoByDefaultSpecialCase(computer: Computer =  Computer("Mac",124124.3),userName : String){
    print(userName)
    show