小白快速学习 Kotlin 语法基础

Kotlin初体验

关于kotlin从17年到现在听了无数遍了，真正开始学习是在去年同事和朋友疯狂安利 说是第一语言了也要开始学习 在2020年8 9月份简单看了郭老师的《第一行代码（第三版）》，因为书太厚啦 我实在静不下心全部看完
最后在博客上面查看到大佬的总结 一口气将 Kotlin简单语法和其他组件简单学会 、光看不练都是假把戏 确实对于我来说看完有点印象 但是确实也很容易忘记
在今年找工作中发现 kotlin越来越重要了 对于新开发的安卓APP都要求最起码会一点Kotlin 有些甚至要求全部使用kotlin进行开发
所以我重新开始了学习Kotlin
这是大佬总结 郭霖大佬的博客 希望对你也有所帮助
https://blog.csdn.net/weixin_38244174/article/details/105893346?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159739421919725222420156%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159739421919725222420156&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_ecpm_v3~pc_rank_v3-1-105893346.pc_ecpm_v3_pc_rank_v3&utm_term=%E9%83%AD%E9%9C%96%E7%AC%AC%E4%B8%80%E8%A1%8C%E4%BB%A3%E7%A0%81%E7%AC%AC%E4%B8%89%E7%89%88&spm=1018.2118.3001.4187

以下是自己总结 打上的代码

方便学习

在这里插入代码片
package com.lincaiqin.kotlinlearn

import java.io.StringReader
import kotlin.math.ln
import kotlin.math.max

/**
 * Created by Android Studio.
 * User: 林财钦
 * Date: 2021/4/10
 * Time: 23:19
该类用于 测试 kotlin 学习成果
 */
/*
fun main(){
    // 无逗号 一行一句
    val i=10  //val 不可变值 相当于java final修饰
    // 一般设定为val  当val满足不了时可定义为 var
    // （另外 函数定义类型时因不用更改 故也为val）
    var j : Int = 20  //可变值
    // : Int 表示 指明参数类型
    j++
    println("i = "+ i +" \nj = " + j)
   // println(getPrint(j))
    println(getMax(0,100))
    println(getMax_if(2999,3000))
    println(getMax_if2(30,29))

    println(getStu_when("lin"))
    println(getStu_when3("lintongxue"))

    println(getNum_for())
}
*/
/*
   kotlin 皆为函数
   fun 函数名(参数 : 参数类型（Int String） ) : 返回参数类型 ｛

       函数体
   ｝
   无返回类型
    fun 函数名(参数 : 参数类型（Int String） )  ｛

       函数体
   ｝
    */
/**
 * 获取返回值并打印
 */
fun getPrint(num : Int ) : Int {
   // print("num = "+num)
    return num
}
//语法糖  ---->将返回的值 “=” 返回
fun getPrint2(num : Int ) = num
fun getMax(num1 : Int ,num2 : Int) = max(num1,num2)

//三种逻辑语句 顺序 选择（条件） 循环
    //条件语句有 if when
fun getMax_if(num1 : Int ,num2 :Int ): Int {
    var v_max :Int = 0
    if(num1 > num2){
        v_max = num1
    }else{
        v_max = num2
    }
    return v_max
}
//语法糖
fun  getMax_if2(num1: Int,num2: Int) =if(num1 > num2) num1 else num2
//when 相当于 switch 但是可以判定的类型比java中的switch要多 例如字符串
// 判断类型 is 相当于instanceof 类型判定
fun getNumObject_when (num : Number){
    when(num){
        is Int -> 1
        is Double -> 2
        else -> 0
    }
}
fun getStu_when (name :String ) = when (name){
    "lin" -> 88
    "wei" -> 100
    else -> 0 //必须的 未加会报错
}
fun getStu_when2 (name :String ) = when {
    name == "lin" -> 88
    name == "wei" -> 100
    else ->0
}
fun getStu_when3 (name : String )= when{
    name.startsWith("lin") -> 100
    name.endsWith("zhen") -> 101
    else -> 0
}
//--------------------------------------------
/**
 * 循环语句 for while
 *  for ( 参数 in 0..10 )
 *  .. 表示[] 左右闭
 *  until 表示 [) 左闭 右开
 *  step  2 跳跃 2
 *  downTo 倒着
 */
fun getNum_for() {
    for( i in 1.. 10) {// 1-10
        println("i = " + i)
    }
    for(i in 0 until  10 step 2){
        println("i = " + i)
    }
    for(i in 10 downTo 1){
        println("i = " + i)
    }
}
//-------------------------------------------
/**
 * 面对对象   类
 * 抽象类 在类class前面加上 open
 * 用 ： 代表继承
 *
 *
 * */
open class Preson{
    var name =""
    var age =0
    fun eat(){
        println("会吃")
    }
}
class Student :Preson(){
    fun learn(){
        println("学习")
    }
}
/*fun main(){
    *//*val preson =Preson()
    preson.age =20
    preson.name="lin"
    preson.eat()
*//*
    *//*val stu = Student()
    stu.eat()
    stu.learn()
    val stu1 = Student1("lin", 17)
    stu1.eat()*//*

    val student1 = Student2()
    val student2 = Student2("lin",20)
    val student3 = Student2("lin",10,"wei",20)
    val student10 = Student10("lin",100)
    println()
    println(student3.sno)
    println(student10.name)
}*/
/***
 *主构造和次构造
 *1+N模式
 * 主函数用init
 * 次函数用 constructor
 */
open class Preson1(val name :String , val age :Int){

    fun eat(){
        println("会吃")
    }

}
class Student1(val sno :String , val grade :Int):Preson1(sno,grade){
    //主函数逻辑
    init{
        println("sno is"+ sno)
        println("grade is"+grade)
    }
    //次函数
}
class Student2(val sno:String ,val grade : Int ,name :String ,age :Int) : Preson1(name,age){
    //主函数逻辑
    init{
        println("sno is"+ sno)
        println("grade is"+grade)
    }
    //次函数
    //规定若二者都存在 次函数需要调用主函数 间接调用也可
    //调用了主函数
    constructor(name:String ,age :Int ): this ("",0,name ,age)
    //间接调用了主函数  给sno和grade赋值
    constructor():this("",0){}
}
//特殊情况 只有次函数
class Student10 :Preson1{
    constructor(name :String ,age :Int): super(name,age)
}
//--------------------------
/**
 * 关于接口 interface
 * 用：引入

 */


class Workman (name :String ,age :Int):Preson(),Study{

    override fun read() {
        println("会读")
    }

    override fun speck() {
        println("会说")
    }

}
/*fun main(){
  *//*  val workman =Workman("lin",100)
    workman.read()
    workman.speck()*//*
    val stu = stu("lin",20)
    val stu1= stu("wei",20)
    println(stu == stu1)

    work.dowork()

}*/

interface Study1 {
    fun read()
    fun speck(){
        println("可以说话 也可以打印")
    }

}
//------------------
/****
 * 修饰符
 * public  都可见
 * protected  包名可见
 * private  私有
 * internal  彤模块
 */

//数据类型  class 前面+   data
// 和
// 单例类   class 替换   Object
//

data class stu(val name :String, val age :Int)
object work{
    fun dowork(){
        println("打工")
    }
}
//---------------关于集合--------------
/****
 * --list
 * listOf  对于不可变集合
 *  mutableListOf 对于可变的集合
 *
 *  --map
 *  mapOf    不可变
 *  mutablemapOf  可变
 *  to 关联
 */
/*
fun main(){
    val list = listOf("lin","wei","li","qin")
    val list2 = mutableListOf("lin","wei")
    list2.add("可以")
    val lnum = list.get(0)
    println(lnum)

    val map = HashMap<String, Int>()
    map["lin"] =20
    map.put("WEI",19)
    val num= map["lin"]
    println(num)
    val map2 = mapOf("lin" to 2,"weo" to 29)
    val map3 = mutableMapOf("lin" to 20)
    map3.put("weo",20)

    val list5 = listOf("lin", "cai","weio")
    //正则表达式-->Lambda  寻找最长字符串 .maxBy
    val maxLength = list5.maxBy { it.length }
    println(maxLength)
    */
/**
     * 推导
     * ｛参数名1：参数类型，参数名2 ：参数类型 -> 函数体｝
     *//*

    list5.maxBy ({ name:String -> name.length }) //包含一条Lambda
    list5.maxBy {  name:String -> name.length  } //唯一参数可去括号（）  最后参数可写括号外绵
    list5.maxBy { name ->name.length }           //推导机制 不去声明类型也可
    list5.maxBy { it.length }                    // 一个参数可用 it 去声明
    //--------推导结束-----(十分便捷 一行搞定)--

    //-------JAVA函数API调用---
    // （需要提醒的是，Java函数式API的使用仅限于Kotlin调用Java单抽象方法接口必须由Java定义。
    // 因为Kotlin中有专门的高阶函数来实现更加强大的自动定义函数式API功能。）
    // 根据推导得出最便捷的使用方式-
    Thread{
        println("多线程的使用");
    }.start();
    //同理可得 以后 btn.setOnClickListener{//逻辑}

}
*/
//-------空指针------
//kotlin 将空指针异常 提前到 编译时期 非运行时期 ，杜绝了 空指针异常


fun dodo(i : Int?){//若要为空的对象 在:类型 后面加问号?
    println(i)
    i ?. toByte()// 调用方法时 ?. 代表 当对象可为空时 进行方法
    i ?. toString()
    val c1= if(i != null) i else 0
    val c = i ?: 0  // ?: 时代表 不为空 返回左边  ， 空 返回右边
}

fun getTextLength(text : String ?) = text?.length ?: 0
//!! 可加在对象后面强制通过
//let 函数
fun dodo_let(i : Int ?){
    /*i ?. let {i->
        i.toByte()
        i.toString()
    }*/
    //推导 同一个参数用it代替
    i ?.let {
        i.toByte()
        i.toString()
    }
}
//-----------字符串内嵌表达式  ${}  当仅有一变量时 {}可以去掉--
fun main(){
    val str = "--001--"
    println("没啥可以输出$str")

}
//    Kotlin的参数默认值功能能够在很大程度上替代次构造函数的作用

#如若有侵权行为 请联系我
希望对你也有所帮助 请 抓紧 一定要快速行动起来 冲