kotlin学习第二天：类，扩展方法，高阶函数初步学习

1.类和接口

1.类

1.kotlin中使用constructor作为构造方法；java中则用类名相同来实现构造方法
2.kotlin定义变量时需要赋初始值；但是Java不需要，默认赋值。
3.用fun 名称()来定义函数，关于函数的详细知识可以看我的kotlin的上一篇文章。
4.类默认为public属性
类定义代码：

class SimpleClass1
{
    var y:Int=0
    var x:Int=0
    constructor(x:Int)
    {
        this.x=x;
    }
    fun simple(){}
}

类的调用

val simpleClass1=SimpleClass1(8);
println(simpleClass1.x)

类的另外一种定义

//类的定义
class SimpleClass(var x:Int,val y:String)
{
    fun y(){}
}

//类的调用
val simpleClass=SimpleClass(9,"Hello")
println(simpleClass.x)

2.接口

//接口的定义
interface SimpleInf{
    fun simpleMethod()
}
//1.Java中使用implement来声明接口，但是Kotlin中使用":"来声明接口
//2.Java中override可省略，但是Kotlin中override是强制要写
class SimpleClass2(var x:Int):SimpleInf{
    override fun simpleMethod() {
        TODO("Not yet implemented")
    }
}

3.抽象类

强调一个不同的地方：
就是关于open fun overridable(){}方法中的open的使用，因为kotlin中所有方法默认为final修饰的，不能被重写。所有open方法的作用就是类可以被继承，方法可以被重写

abstract class AbsClass
{
    abstract fun absMethod()
    //下面两个方法默认不能被继承
    open fun overridable(){}
    fun nonOverridable(){}
}

class SimpleClass3(var x:Int): AbsClass()
{
    override fun absMethod() {
        TODO("Not yet implemented")
    }

    override fun overridable() {
        println("123")
    }
}

2.扩展方法

具体地址：https://www.runoob.com/kotlin/kotlin-extensions.html

1.若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数
2.扩展函数是静态解析的，并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

class User(var name:String)

fun User.Print(){
    println("用户名 $name")
}

3.空类型安全

1.?=赋空值

=是？=的一个子类
这种情况是不能赋值空值。

需要加上一个问号才可以赋值为空值

var nonNull:String?="Hello"
nonNull=null

2.!!.实现强制不为空类型

强制length不为空

var nonNull:String?="Hello"
val length=nonNull!!.length

下面这种方法可以实现当length为NULL时，赋值为0，其他?.来进行一次null检查。

val length:Int?=nonNull?.length?:0

3.安全转换 as?

as？把值转换为指定的类型，失败返回null。

4.分支表达式

1.if

if的使用和Java还是比较相似的，不做过多解释

fun main()
{
    var a:Int=3
    var c:Int=0

    c = if (a==3) {
        4
    }else{
        5
    }
    println(c)
}

kotlin中是没有三元运算符，直接用if…else来表示

2.when

第一种表示方法：

//when和Java中的Switch相似，下面代码的意思是当a=0时，c=5;a=1时，c=100;a=其他时，c=20
fun main()
{
    var a:Int=3
    var c:Int=0
    c=when(a){
        0->5
        1->100
        else ->20
    }

    println(c)
}

第二种表示方法：
Any:Any 类型是 Kotlin 中 所有非空类型 （ex: String, Int) 的根类型
is: is 运算符类似于Java中的 instanceof 关键字的用法,用来判断x是否是String型。

var x:Any="hello"
c=when{
    x is String -> x.length
    x==1->100
    else ->20
}
println(c)

值从键盘输入的方法：
从键盘输入值，获取其长度。

c=when(val input= readLine()){
        null->0
        else ->input.length
    }
    println(c)

3.try…catch

和Java中差不多

var b:Int=1
c=try{
    a/b
}catch (e:Exception){
    e.printStackTrace()
    0
}
println(c)

5.Lambda表达式

https://www.cnblogs.com/Jetictors/p/8647888.html
https://blog.csdn.net/achenyuan/article/details/81565565

匿名函数

val f1={
     age:Int,name:String->
     println(age)
     println(name)
     "HelloWorld"
 }

 println(f1(20,"小明"))

6.高阶函数

高阶函数：参数类型包含函数类型或返回值类型为函数类型的函数。

代码解释：
用高阶函数来实现斐波拉契函数，以及所用时间：

//参数类型为函数的高阶函数
fun cost(block:()->Unit)
{
    val start=System.currentTimeMillis()
    block()
    println("输出:${System.currentTimeMillis()-start}")
}

//返回值为函数的高阶函数
fun fibonacci(): () -> Long
{
    var first=1L
    var second=1L
    return {
        val next=first+second
        val current=first
        first=second
        second=next
        current
    }
}

函数调用：

cost{
     val fibonacciNext= fibonacci()
     for(i in 0..10){
         println(fibonacciNext())
     }
 }

7.内联函数

1.inline

https://juejin.cn/post/7011780736109789215#heading-18
每调用一次Lambda都会创建一个新的匿名类实例，会造成额外的内存和性能开销。由此Kotlin提供了内联函数功能。

fun main()
{
    cost1{
        println("Hello")
    }
}

inline fun cost1(block: ()->Unit)
{
    val start=System.currentTimeMillis()
    block()
    println(System.currentTimeMillis()-start)
}

上方代码加上内联函数inline之后，等价于下面：
这样避免了cost1方法的内存消耗

val start=System.currentTimeMillis()
println("Hello")
println(System.currentTimeMillis()-start)

2.noinline

如果一个内联高阶函数中含有多个函数类型参数，其中有一个函数类型参数不想内联，可在该参数前加上noinline关键字

3.crossinline

1.kotlin只允许内联函数的函数参数内部有return，普通函数的函数参数内部不能有return
2.crossinline让编译器帮我们检查函数参数内部是不是带有return，有的话直接在IDE提醒我们不能写(还是为了满足结论1，禁止函数参数写return)