一、入门Kotlin

kotlin基础入门，与java对比

学习kotlin最主要的知识点包含变量、函数（实际就是方法）、逻辑控制语句、面向对象编程、Lambda编程、空指针检查机制等

变量

java中如果想要声明一个变量，需要在其前面声明这个变量的类型
kotlin 只有两个字段声明一个变量 val和var

    val a: Int = 10;
    val b = 20L
    var e = "123123123"

区别：
val对应java中的final,常量，初始赋值后不能再被赋值
var用来声明一个可变的变量，可以重复被赋值
使用方式：优先使用val去声明一个变量，而当val不能满足需求的时候，在使用var,这样的程序会更加健壮

java和Kotlin数据类型对照表

java基本数据类型	Kotlin对象数据类型
int	Int
long	Long
short	Short
float	Float
double	Double
boolean	Boolean
char	Char
byte	Byte

函数（方法）

使用fun声明，后面跟函数名，例如：

fun main() {    //main方法
}
//声明一个方法
fun printParmas(i: Int ,str : String = "hello") {
    println("int is $i , str is : $str")
}

逻辑语句

1、if条件语句
java的if判断

  private static int max(int i, int j) {
        int k ;
        if (i>j){
            k = i;
        }else {
            k = j;
        }
        return k ;
    }

Kotlin的if判断

//正常
fun maxNun(a: Int, b: Int): Int {
    var c = 0
    if (a>b){
        c= a
    }else{
        c = b
    }
    return c
}

//简化
fun maxNun(a: Int, b: Int): Int {
    var c = if (a>b){
        a
    }else{
        b
    }
    return c;
}
//精简
fun maxNun(a: Int, b: Int): Int = if (a > b){
   a
}else{
    b
}
//最终版
fun maxNun(a: Int, b: Int): Int = if (a > b) a else b

2、when语句判断
类似java中swich语句，比swich强大，可以传入几乎是任意类型做判断

fun getStore(s: String) : Int = when(s){
    "sdd"->70
    "we"->712
    "qweq"->7023
    else -> 0;
}

when语句允许传入一个任意类型的参数，格式：匹配值 -> {执行逻辑}，如

fun checkNumber(i: Number) {
    when(i){
        is Int -> println("是 int")
        is Double -> println("是 double")
        else -> println("是 m没有")
    }
}

3、循环语句
java中常用循环有while循环和for循环，kotlin也一样，这两种循环都有

		java中循环
        for (int l = 0; l < 1; l++) {
        }
        while (true){
        }
        for (String s: name){
        }

kotlin中循环

	//定义一个0-10的数
    val range = 0..10;  
    //定义一个0-10的数，筛选出3的倍数
    val ranges = 0 until 10 step 3;
    for (i in ranges ){
        println("是  $i")
    }
	//倒序输出从10到4
    for (i in 10 downTo 4){
        println("是  $i")
    }
     while (true){
   }

…和until 区别：
… : 创建两端闭区间的关键字
until ：创建一个左闭右开的区间
step ：跳过一些其中的元素

面向对象

1、类与对象
创建一个对象，java需要声明其参数类型，get 和 set方法，kotlin 不需要，只需要声明对象，设置默认值就可以了。

class Persion {
    var name = "";
    var  age = 0;

    fun eat(){
        println(name +"is eat" + age +"yaer old");
    }
}
//使用
    val  p = Persion();
    p.name = "Tom"
    p.age = 200;
    p.eat()

2、继承
java中继承是需要父类抽象类，才能去实现继承，kotlin中也是，所有非抽象类都不可被继承，如果需要被继承，需要在父类声明open关键字，子类继承父类，只需要在末尾添加 ：父类名，就实现继承了

 open class Persion {
    var name = "";
    var  age = 0;
}
 class Student() : Persion() {
    var num = "";
    var  store = 0;
    }
    //默认初始化赋值
 class Student(var  sno : String , var grade:Int) : Persion() {
    var num = "";
    var  store = 0;
    //次构造函数
	 constructor(): this("",0){

    }
    init {
        println(sno);
        println(grade);
    }
 }

constructor：次要构造函数定义关键字
init:数据结构打印关键字，类似于java的toString

3、接口
kotlin和java接口声明类似，都是用interface修饰类名的，和java一样，可以单继承，多实现
使用方式和继承一样，也是 ： 接口类名

interface Study {
    fun resdBook()
    fun doHomework(){
        println("And is  doHomework")
    }
}
//和继承的区别是，继承后面有括号，接口没有
 class Student(var  sno : String , var grade:Int) : Persion() ,Study{}

4、多态
kotlin也可以使用多态

    val s = Student("123",1)
    s.name = "jery"
    s.age = 10000000
    doStudys(s);
    //多态
	fun doStudys(study: Study) {
	    study.resdBook()
	    study.doHomework()
	}

5、修饰符
java中的修饰符 public private protected default 默认是default
kotlin的修饰符 public private protected internal 默认是public

修饰符	java	Kotlin
public	所有类可见	所有类可见（默认）
private	当前类可见私有	当前类可见私有
protected	当前类，子类，同一包路径下的类可见	当前类子类可见
default	同一包路径下的类可见（默认）
internal		同一模块中的类可见

6、数据类和单例类
在java中，需要做数据排序等操作，通常需要重写equals、toString、hashcode这几个方法：例如

public class CellPhones {
    String brand;
    double price;

    public CellPhones(String brand,double price){
        this.brand = brand;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CellPhones that = (CellPhones) o;
        return Double.compare(that.price, price) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(price);
    }

    @Override
    public String toString() {
        return "CellPhones{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

Konlin中使用数据类模型排序，在数据类前面用data关键字修饰，kotlin会自动生成equals，hashcode,toString 等方法，实现比较大小等功能

data class CellPhone(val Brand:String,val price : Double)

    val phone1 = CellPhone("sanxing",21220.10)
    val phone2 = CellPhone("sanxing",21220.10)
    //创建java数据模型
    val phone3 = CellPhones("sanxing",21220.10)
    val phone4 = CellPhones("sanxing",21220.10)
    println(phone1)	//CellPhone(Brand=sanxing, price=21220.1)
    println(phone1==phone2)	//true
    println(phone3)  //CellPhone(Brand=sanxing, price=21220.1)
    println(phone3==phone4)  //true
    

单例模式：避免创建重复对象
java中常用的单例类一般就是懒汉和饿汉两种，使用synchronized加锁，避免重复创建对象，必要时双重锁定

public class SingleTonjava {
    private  static  SingleTonjava singleTonjava;
    public SingleTonjava(){ }
    public synchronized static SingleTonjava getInstance(){
        if (singleTonjava== null){
            singleTonjava = new SingleTonjava();
        }
        return singleTonjava;
    }
}

Kotlin中单例类直接创建就可以，创建Kotlin.class文件的时候，选择Object.创建的类就是单例类

object Singleton {
    fun SingletonTest(){
        println("SingletonTest  单例模式")
    }
}
	//调用
 Singleton.SingletonTest()

Lambad编程

1、集合
kotlin集合包含List集合和Set集合、Map集合
List—ArrayList LinklistList
Set—HashSet
Map—HashMap

list集合创建
listOf函数创建的是一个不可变的集合，长度是固定的
mutableListOf函数创建的是一个可变的集合，可以往里面添加元素

	//传统创建集合方式，和java类似
    val list  = ArrayList<String>()
    list.add("apple1")
    list.add("apple2")
    list.add("apple3")
    list.add("apple4")
    println(list)

    //创建的是不可变集合
    val list1 = listOf<String>("apple1","apple1","apple1","apple1")
    println(list1)

    //创建可变集合
    val list2 = mutableListOf<String>("app","apple1","apple1","apple1")
    list2.add("123s123d")
    println(list2)

set集合
底层是有hash映射机制来存放数据的，因此，集合中的数据是无序的，去除重复元素
setOf函数创建的是一个不可变的集合，长度是固定的
mutableSetOf函数创建的是一个可变的集合，可以往里面添加元素

 //set集合和list用法一样
    val set  = HashSet<String>()
    set.add("apple1")
    set.add("apple2")
    set.add("apple3")
    set.add("apple4")
    println(set)   .//[apple1, apple2, apple3, apple4]

    //set集合值思唯一的，自动去重
    //创建的是不可变集合
    val set1 = setOf<String>("apple1","apple1","apple1","apple1")
    println(set1) //[apple1]

    //创建可变集合
    val set2 = mutableSetOf<String>("apple1","apple1","apple1","apple1")
    set2.add("123sd")
    println(set2)	//[apple1, 123sd]

Map集合
map集合是键值对形式的数据结构，key唯一，值不唯一,key相同，以后添加的key的value值为准，map集合不建议使用put和get方法添加和获取数据，推荐使用map[kay] = value这种形式，添加数据
mapOf函数创建的是一个不可变的集合，长度是固定的
mutableMapOf函数创建的是一个可变的集合，可以往里面添加元素

val map = HashMap<String,Int>()
    //这种写法不建议
    map.put("apple1",1)
    map.put("apple2",2)
    map.put("apple3",3)
    //建议这种写法
    map["apple3"] = 4
    map["apple5"] = 5
    println(map)		//{apple1=1, apple2=2, apple3=4, apple5=5}
    //获取一条数据
    val  number = map["apple4"]
    println(number)	//null

    //创建map集合简单写法
    //长度不可变
    val map1 = mapOf<String,Int>("apple1" to 1,"apple2" to 2,"apple3" to 4,"apple4" to 4)
    //长度可变
    val map2 = mutableMapOf<String,Int>("apple1" to 1,"apple2" to 2,"apple3" to 4,"apple4" to 4)
    map2["apple5"]=5
    println(map1)	//{apple1=1, apple2=2, apple3=4, apple4=4}
    println(map2)	//{apple1=1, apple2=2, apple3=4, apple4=4, apple5=5}

map集合循环遍历数据

   for ((key , value) in map){
        println("ket is $key  , value is $value")
    }

2、集合的函数API
//如果两个元素比较大小，可以调用MathJVM.kt中的比较方法就可以实现，例如：

fun maxNunOne(a: Int, b: Int): Int = max(a, b)
fun methonName(i: Int, i1: Int): Int {
    return min(i, i1);
}

集合中找最大值，传统写法就是遍历集合，找到其中的最大值

  var maxLearthFruit = "";
    for (fount in list2){
        if (fount.length > maxLearthFruit.length){
            maxLearthFruit = fount;
        }
    }

Kotlin的API有直接取最大值的方法（相关方法在Collection.kt这个类中）

//简写 lambda写法
	var maxLearthFruit1 = list2.maxByOrNull { it.length }   //最大值
	val minNum = list2.minByOrNull { it.length }		//最小值
//正常写法
	var lambda = {list : String -> list.length};
	var max = list.maxByOrNull(lambda);

筛选函数filter ：用来过滤集合中的数据，可以单独使用，也可以配合map一起使用

//筛选长度为6以下的元素，并且这些元素都大写
val list = listOf<String>("apple1","apple2","apple3","apple4","121312")
  val newList = list.filter { it.length<=6 }.map { it.toUpperCase() }
 // [APPLE1, APPLE2, APPLE3, APPLE4]

any 和 all函数
any至少有一个元素满足条件就行
all是所以元素都必须满足条件

	    val list2 = mutableListOf<String>("app","apple1","apple1","apple1")
	    val  anyResult = list2.any { it.length<= 5 }
	    val  allResult = list2.all { it.length<= 5 }
	    println(anyResult)  //true
	    println(allResult)	//false

Kotlin调用java函数API
开启线程：

	//常规写法
   Thread(Runnable {
        println("Thread is run")
    }).start()

    //省略写法
    Thread{
        println("Thread is run two")
    }.start()

空指针

?. ：判空符，可以判断元素空的操作

 doStudy(null);
 fun doStudy(s: Study?) {
    //直接盘空
    if (s != null){
        s.resdBook()
    }
    // ?.操作符
    s?.doHomework()
}

?: ：操作符 类似于三元运算符,做判空操作用的

//一般判空操作
var c = if (a!= null){
        a
    }else{
        b
    }

    //简化
    val  d = a ?: b;

let函数
let函数属于Kotlin中的标准函数，let函数是处理全局变量的判空问题的，而if.判断语句是无法做到这点的

//let相当于整体判断
 doStudy1(null);
 fun doStudy1(s: Study?) {
    s?.let { stu ->
        stu.resdBook()
        stu.doHomework()
    }

    //简化
    s?.let {
        it.resdBook()
        it.doHomework()
    }
}

可空类型系统
kotlin中默认所有的参数和变量都不为空，所以传入的任何参数都不为空，如果一个函数传入一个null，会有报错，提示在函数方法声明类型后面添加**?**

字符串内嵌表达式
$ 操作符：可以直接把变量放在打印字符串里输出，不用频繁的拼接字符串了

 println("int is $i , str is : $str")

函数的参数默认值
函数初始化的时候，可以设置参数默认值

printParmas(123);
fun printParmas(i: Int ,str : String = "hello") {
    println("int is $i , str is : $str")
    //int is 123 , str is : hello
}

参考郭霖老师的第一行代码（第三版），第二章，做的笔记，有兴趣可以查看书籍