一篇文章让你学会简单使用kotlin

封装

public：希望外部能够使用的属性或者方法（共有的 开放的 可以在整个包里面调用的）一般默认public
private：不希望外部使用的属性或者方法（私有的 只能在这个类里面调用的）如果外部想要调用和给他赋值，就必须写一个get set函数，将其作为一个功能让外部调用和对其赋值。

fun showAll(){}//默认public
private fun find(){}

属性

如何定义属性

1. 如果需要外部创建的同时就给这个属性赋值，需要在构造函数里面声明
   a.仅是接收外部的一个数据用于初始化的时候操作，是一个临时的
   b.让这个变量变成属性
2. 直接在类里面声明，需要赋初值（为了安全访问）
   a.知道这个属性的初始值
   b.需要后面计算才有值，或者没值
   c.延迟初始化，但必须在使用之前赋值
   d.懒加载，先赋值，使用时才被赋值，且赋的值是不能改变的。
   其目的是 节约内存 且只能初始化一次，不能改变。如果使用了一次后要改变变量的值，只能用前面的几种方法

class Player(private val id:Int, private val name:String) //这里就是将属性写在构造函数里面，也就是第一种方法{

//以下就是用的第二种方法
    var chip:Int = 0 //筹码

如何访问属性

通过在对象后面加“.”来访问

    fun winMoney(count: Int){
        chip += count
    }
    fun awardMoney(money:Int){
        player.winMoney(money)//调用winmoney这个函数
    }

如何定义方法

实例方法

1. 普通方法
2. 对象方法：必须创建类的一个对象，用这个类对象调用的方法

静态方法

3. 当类被加载到内存时，这个类的静态属性和静态方法同时被加载，而实例方法在创建类并且创建对象之后才有属性和方法的加载。
4. 类方法（伴生对象）：不需要创建类的对象，直接用类名加点调用

注意：
静态方法不能调用实例方法，而实例方法可以调用静态方法。
因为静态方法的类创建时就已经将静态属性和静态方法加载好了，就可以直接调用，而实例方法需要创建对象之后才有属性和方法的加载，不能直接调用

属性默认提供set和get方法

1. set：提供给外部设置值得一个方法
   get： 提供给外部访问值得方法
2. val声明的变量：只有get方法
   var 声明的变量：两个方法都有
3. 与java不同的是：java中set和get需要自己重写，而kotlin中系统自带这两个方法
4. 但有些时候kotlin中需要重写get和set：获取一个值或者设置值时需要做额外的事。
5. 在写set get时会用到field这个变量，这里解释一下：属性并不是保存数据的地方，数据是储存在一个叫数据域的地方，外部是看不到的。这个数据域就是field。

   set(value) {
        //value：接受外部传递的值
        //将传递过来的值赋值给属性变量
        field = value + 1
        //实现额外的功能
    }
    
    get() = field - 1

函数：一种行为或者功能

类里面不能写具体实现，具体实现只能在函数里面或者代码块里面写
函数和c语言基本一致

为什么要使用函数

1. 代码出现冗余（重复出现）
2. 函数是一个独立的代码块（一个代码块完成一个功能）
3. 实现代码的模块化

如何定义函数

1. 先声明，后使用，再具体实现

   返回值 函数名（函数类型 参数别名）{具体实现}
   

嵌套类和内部类

嵌套类(静态内部类)

1. 这个类和外部类没有任何关系 唯一的关系是在外部类的内部
2. 当外部类被加载的时候就会被加载进来

    class Shape{
    var sideCount = 0
    fun perimeter():Int{
        return 10
    }
    class InClass{
        //普通内部类无法直接访问外部类的普通属性和方法
        sideCount = 20
    }
}

内部类

1. 必须有外部类的一个对象才能来访问外部类的方法
2. 内部类可以访问外部类的属性和方法

class Shape{
    var sideCount = 0
    fun perimeter():Int{
        return 10
    }

    inner class DoSomethingClass{//内部类
        init {
            sideCount = 3
            perimeter()
        }
    }
}

继承

子类继承于父类
a继承于b：a就是子类，b就是父类

1. 类默认不能被继承，只有用open写在父类前才能被继承，同样的只有前面加了open的方法才能被继承
2. 现有父类的对象才能有子类
3. 默认情况下父类的私有属性和私有方法是受保护的，不能被子类继承的
4. 用到继承的情况：自定义控件（一般继承很少用，但阅读源代码时会经常用到）

open class Animal(){
    var color:String = "黑"
    open fun sleep(){
        println("睡")
    }
}

class Car:Animal(){
    override fun sleep(){
        super.sleep()
        println("猫睡")
        color = "bai"
    }
}

重写

子类的实现的功能和父类的实现的功能不相同
当子类的实现需要调用父类的功能就用super调用

open class Animal(){

    open fun sleep(){
        println("睡")
    }
    
}
class Car:Animal(){
    override fun sleep(){
        super.sleep()//调用父类的sleep
        println("猫睡")
    }
}

单例设计模式

程序运行过程中，某个类只有一个对象存在

那如何确保一个类只有一个对象

1. 私有化构造函数：外部无法通过构造函数来创建这个类的对象
2. 在内部提供一个静态方法来获取对象
   a. 先用一个静态属性保存一个对象
   b. 静态方法返回这个属性的值

   companion object{
    private var instance = StudentManager()//先实例化一个类的对象
    fun shareInstance():StudentManager{
        return instance
    }

对象

一个类中的一个对象的创建顺序

1. 主构造函数
2. 创建属性
3. init代码块
4. 次构造函数

class Dog(var id:Int){//主构造函数

    var age = 10//创建属性
    
    init {//init代码块
        println("init")
        println("${age}")
    }
    constructor(name:String)：this(id:2){//次构造函数
        println("次构造函数")
        println("${age++}")
    }
}

接口

定义一套方法或协议，不需要实现
功能：在一个未知类中添加一些方法，就知道这个类的对象中肯定有这些方法

首先定义一个接口，接口的命名一般用I开头Listener结尾

interface IAnimalListener {
    fun sound(){
    }
}

接下来我们用一个cat类来使用接口，并且重写接口的sound方法

class Cat:Animal {
    override fun sound() {
        println("喵喵")
    }
}

抽象类 abstract

为什么要用抽象类

某个类已经实现，有些功能暂时不能实现，由其他类来实现

到底什么是抽象类

抽象类就是模板，就像我们去下载网上的ppt模板一样，下载模板以后再向里面添加自己需要的内容做成一个完整的ppt，再去给别人看。
其中：
ppt模板指的就是：抽象类
完整的ppt指的就是：用抽象类
写完再给别人看指的就是：完成实例化一个对象

什么时候要写抽象类

当我们需要给出一个功能但不同的对象有不同的实现方法，我们就只写一个框架（模板），好让继承抽象类时 按照抽象类里面的抽象方法具体实现
一般程序架构人员一般才去写这样的抽象类

举个例子

   abstract class oneAnimal {
    //抽象类中也可以有抽象方法
    abstract fun eat()
    
    //也有一般的方法
    fun drink(){
        println("喝水")
    }
}

class Dog: oneAnimal() {
    override fun eat() {
        println("狼吞虎咽")
    }
}

以上的方法中Dog要使用oneAnimal就必须实现其中的抽象方法eat

注意：
1. 抽象类不能被实例化，只有继承之后实现了里面的抽象方法才能被实例化。
2. 一般类里面可以定义的内容，抽象类里面都可以有。
3. 继承一个抽象类，但又不想实现其中的抽象方法，可以把这个类也写成抽象类，但最终还是谁调用谁实现。

扩展函数

什么是扩展函数

在已有的类的基础上添加新的方法或者新的属性
可能有人会问为什么不用继承
因为有一些类比如说String是final的，就是不可以被继承的
所以我们需要扩展函数
我们来看一个简单的例子：

/**
*这里是原函数
*/
fun MyfirstWord(str: String):String{
    val index = str.indexOf(' ')
    return if (index < 0) str else str.substring(0,index)
}

fun String.firstWord():String{
    var index = this.indexOf(' ')
    return if (index < 0) this else this.substring(0,index)
}

异常处理

try：具体可能会出现bug的代码
catch：捕获可能的异常
finally：无论如何都要执行的代码

/**
 *异常处理
 */
fun main() {
    try {
        val num = readLine()?.toInt()//接收一个数字输入
        println(num)
    }catch (e:NumberFormatException){//e：Exception
        println("不能输入除数字外的字符")
    }finally {
        println("处理完毕")
    }
}

Lambda表达式

与函数不同的是:

1. 函数是作为参数的
2. 可以返回多种类型的多个数据
   功能：实现数据回调
   指定某个任务（函数） 执行后需要执行其他某件任务（函数），由调用者来指定，但调用者必须自己去实现这个函数

如果函数的最后一个参数是函数变量，这个具体实现可以放在括号外面

如何表示一个函数变量

//一个参数一个返回值
val f1:(Int) -> Int
//多个参数，一个返回值
val f2:(Int,String) -> String
//一个参数，无返回值
val f3:(float) -> Unit//这里的unit不能省掉！

如何定义一个函数类型的变量

将普通函数的声明换一种方式来表达

fun add(a:Int,b:Int):Int

比如将上面这个一般的函数化为函数变量需要三步

1. 去除fun 和函数名 (a:Int,b:Int):Int
2. 去掉参数里面的变量名 (Int,Int):Int
3. 返回值使用 '->'对应

最后就可以化成

  (Int,Int?)->Int 

如何初始化一个函数变量（函数的具体实现）

1. 将函数变量的具体实现和函数中的具体实现一样
2. 如果只有一个参数，可以不给这个变量命名，默认使用it表示这个参数
3. 如果有两个及以上的参数，必须给每个参数依次取变量名，结尾使用 ->

如何调用一个函数变量

变量名(值)

val result = add(1,2)

泛型

泛指任意类型
修饰函数：泛型函数
修饰类：泛型类

in和out用于修饰类

1. 使用out修饰的集合，只能接收指定类型的子类组成的集合
   只能用get 不能用set
   out修饰的集合对象只能取不能存

2. 使用in修饰的集合，只能接收指定类型的父类组成的集合
   只能用set 不能用get
   in修饰的集合对象只能存不能取

open class Old
open class Father:Old()
class Child:Father()

val childArrayList:ArrayList<Old> = arrayListOf(Old(),Old(),Old())
val fatherArrayList:ArrayList<in Father> =  childArrayList

val childArrayList:ArrayList<Child> = arrayListOf()
val fatherArrayList:ArrayList<out Father> =  childArrayList