kotlin

2024-04-08  本文已影响0人  书虫大王X
高阶函数：
fun outerFunction(): () -> Unit {
    var count = 0
    return {
        count++
        println("Count: $count")
    }
}

fun testFun(string1: String, string2: String, method: (String, String) -> String) {
    println(method(string1, string2))
}

方法一：
testFun("你好啊", " hello") { string1: String, string2: String ->
    "$string1 ++ $string2"
}
方法二
    val stringFun = fun(string1: String, string2: String): String {
        return "$string1  ++  $string2"
    }
    testFun("你好啊", " hello", stringFun)
定义lambda表达式：
    val sum1: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
    val sum2 = { x: Int, y: Int -> x + y }
    val sum3 = fun(x: Int, y: Int): Int = x + y

    sum1(1,2)
    sum2(1,2)
    sum3(1,2)

    val sum3 = fun(x: Int, y: Int): Int = x + y
 
    sum3(1,2)
内联函数：
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) { …… }
局部函数：
fun calculateArea(radius: Double): Double {
    fun calculateCircleArea(r: Double): Double {
        return Math.PI * r * r
    }
    
    // 调用局部函数
    return calculateCircleArea(radius)
}
递归函数：
tailrec fun findFixPoint(x: Double = 1.0): Double =
    if (Math.abs(x - Math.cos(x)) < eps) x else findFixPoint(Math.cos(x))
中坠函数（infix）
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)
val result = point1 to point2
kotlin 扩展为什么优于继承

1、无需修改源代码： 扩展函数和属性可以在不修改原始类代码的情况下为现有类添加新功能。这对于无法访问源码或者源码受限的情况非常有用。
2、避免类的继承链过深
3、灵活性和可扩展性： 扩展函数使得你可以轻松地向任何类添加新的功能，而无需考虑类的层次结构或修改大量代码。这使得你的代码更具扩展性和灵活性，可以适应未来需求的变化。
4、代码组织和可读性： 使用扩展函数可以更清晰地组织代码，使得类的功能分散在不同的文件中，而不会使类的定义变得冗长。这有助于提高代码的可读性和可维护性。

kotlin的拓展方法
class User(var name:String) {
    companion object { }  // 将被称为 "Companion"
}

// 给user类增加方法
fun User.Print(){
    print("用户名 $name")
}

// 伴生对象的扩展
User.Companion.foo() {
    println("伴随对象的扩展函数")
}

// 扩展属性，检查年龄是否大于等于 18
val User: Boolean
    get() = age >= 18

//调用
fun main(arg:Array<String>){
    var user = User("Runoob")
    user.Print()
}
Java中，一个对象在内存中的标识主要涉及以下几个方面的信息：
19、组合（引用）跟继承的使用场景区别：
// 定义一个 Car 类，它包含 Engine 和 Wheels 实例作为其成员变量
class Car(private val engine: Engine, private val wheels: Wheels) {
    fun start() {
        engine.start()
        println("Car is running on ${wheels.count} wheels")
    }
}

// 定义 Engine 类
class Engine {
    fun start() {
        println("Engine started")
    }
}

// 定义 Wheels 类
class Wheels(val count: Int)
  • 继承的优点：
    代码重用、快速开发
    抽象和多态
    扩展性
    维护性
    统一接口
  • 继承的缺点：
    1、紧耦合（Tight Coupling）： 继承会在父类和子类之间创建一种紧密的关联关系，使得子类依赖于父类的实现细节。如果父类的实现发生变化，可能会影响到所有的子类，导致系统的脆弱性增加。
    2、单继承限制（Single Inheritance Restriction）： 在很多面向对象编程语言中，类只能继承自一个父类，这被称为单继承。这限制了一个类同时从多个源继承行为，而有时候多重继承可能更为自然或更符合问题领域的模型。
    3、层次结构复杂性（Hierarchy Complexity）： 随着继承层次的增加，系统的类层次结构可能会变得非常复杂。这会增加理解和维护代码的难度，尤其是在大型项目中。
    4、父类变更困难性（Difficulty in Modifying the Parent Class）： 如果父类发生变更，可能需要修改所有的子类。这样的修改可能会导致不稳定性和破坏性的变化，特别是在没有适当测试的情况下。
    5、过度继承（Overuse of Inheritance）： 有时候开发者可能过度使用继承，导致一个庞大的类层次结构，其中很多类之间的关系不是很清晰。这样的过度继承可能会导致代码难以理解和维护。
什么情况下使用继承，什么情况下使用组合
操作符
foo as? Type -> foo is  Type  retrun (foo as Type)
             -> foo !is Type  return null
 
//as?和?:联合使用
object as? Person ?: "not human"
object as? Person ?: return false

(Boolean).yes {
  // dosomething
}

TODO("提示内容")

for (i in array.indices) {
    println(array[I])
}

for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}
伴生对象：
kotlin转java

密封类的每个子类可以有多个对象，枚举常量就是枚举类型的一个对象
密封类子类可以持有其他引用数据，枚举常量只能持有枚举类构造方法传入的值
密封类可以自定义方法，枚举常量只能重写枚举类的方法

Kotlin 的优点：
Kotlin 的缺点：
Java 的优点：
Java 的缺点：

1、Kotlin中init代码块和构造方法以及伴生对象中代码的调用时机及执行顺序

2、kotlin的主构造函数和次构造函数：

class Person (name: String){
        init {
            println(name)
        }
        // 次构造器(通过this直接调用主构造器)
        constructor(age: Int): this("HAHA"){
            println(age)
        }
    } 

class Student(sno: String, grade: Int, name: String, age: Int) : People(name, age) {
}
推荐使用 Kotlin 关键字 Reified - 简书 (jianshu.com)
  1. 方法名相同，参数类型相同
  2. 子类返回类型小于等于父类方法返回类型
  3. 子类抛出异常小于等于父类方法抛出异常
  4. 子类访问权限大于等于父类方法访问权限：子类不能将父类中的方法、属性的作用域变小，因为可能会造成方法的“失传”
上一篇 下一篇

猜你喜欢

热点阅读