Kotlin基础知识6

已于 2022-11-08 14:43:13 修改
阅读量2.9k 收藏
点赞数
分类专栏： kotlin 文章标签： kotlin android java
于 2022-03-18 01:44:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36828822/article/details/123304574
版权

泛型与类型约束

open class MyAnyClass(name: String)
opne class PersonClass (name: String): MyAnyClass(name = name)
class StudentClass (name: String): PersonClass(name = name)

class Test<T: PersonClass>(private val inputTypeValue :T,private val isR:Boolean=true){
  fun getObj():T? = inputTypeValue.takeIf{isR}
}

可变参数

fun main() {
    foo("1","2","3")
}

fun foo(vararg args:String){
    println(args::class)
    println(args.contentToString())
    for (i in args.indices){
        println(args[i])
    }
    bar(args)
    bar1(*args)
}

fun bar(args: Array<out String>){
    println(args.contentToString())
}

fun bar1(vararg args:String){
    println(args.contentToString())
}
//output:
class kotlin.Array
[1, 2, 3]
1
2
3
[1, 2, 3]
[1, 2, 3]
//1.可变参数会在函数体中，自动转变为数组类型
//2.数组类型不能作为参数，直接传递给可变参数
//3.在数组类型前面添加*,可以传递给可变参数
//4.java中可变参数与数组可以直接互传

[]操作符与get函数


class test <INPUT> (vararg objects: INPUT, val isR: Boolean = true) {

    // 运算符重载
    operator fun get(index: Int) : INPUT ? = objectArray[index].takeIf { isR }
}
fun main() {

    // 只要有一个元素是null，那么所有的元素都是 String?
    val p1 : test<String?> = test("张三", "李四", "王五", null)

    var r : String? = p1[0]//如果一个自定义类想要使用[]操作符，就必须重载get方法
    val r2 : String ? = p1[3]

    println(r)
    println(p1[1])
    println(p1[2])
    println(r2)
}

out-协变


// 生产者 out T  协变 [out T 此泛型能够被获取 读取 所以是out]
interface Producer<out T> {

    // out T  代表整个生产者类里面  这个T  只能被读取，不能被修改了

    // 不能被修改了 （编译不通过）
    // fun consumer(itme: T)  /*{  消费代码  }*/

    // 只能被读取
    fun producer() : T
}

// 消费者 in T  逆变 [in T 此泛型只能被修改 更新 所以是in]
interface Consumer <in T> {
    // out T  代表整个生产者类里面  这个T  只能被读取，不能被修改了

    // 只能被修改了
    fun consumer(itme : T) /*{  消费代码  }*/

    // 不能被读取 （编译不通过）
    // fun producer() : T
}

// 生产者&消费者 T  默认情况下，是不变
interface ProducerAndConsumer<T> {
    // 能被修改了
    fun consumer(itme : T) /*{  消费代码  }*/

    // 能被读取
    fun producer() : T
}

open class Animal // 动物
open class Humanity : Animal() // 人类
open class Man : Humanity() // 男人
open class WoMan : Humanity() // 女人

// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  只管生产者
class ProducerClass1 : Producer<Animal> {
    override fun producer(): Animal {
        println("生产者 Animal")
        return Animal()
    }
}

class ProducerClass2 : Producer<Humanity> {
    override fun producer(): Humanity {
        println("生产者 Humanity")
        return Humanity()
    }
}

class ProducerClass3 : Producer<Man> {
    override fun producer(): Man {
        println("生产者 Man")
        return Man()
    }
}

class ProducerClass4 : Producer<WoMan> {
    override fun producer(): WoMan {
        println("生产者 WoMan")
        return WoMan()
    }
}

fun main() {
    val p1 : Producer<Animal> = ProducerClass1() // ProducerClass1他本来就是 传递 Animal ，当然是可以的

    val p2 : Producer<Animal> = ProducerClass2() // ProducerClass2他本来就是 传递 Humanity，居然也可以，因为out
    val p3 : Producer<Animal> = ProducerClass3() // ProducerClass3他本来就是 传递 Man，居然也可以，因为out
    val p4 : Producer<Animal> = ProducerClass4() // ProducerClass4他本来就是 传递 WoMan，居然也可以，因为out

    // 泛型默认情况下是：泛型的子类对象 不可以赋值给 泛型的父类对象
    // out: 泛型的子类对象 可以赋值给 泛型的父类对象
    // ? extends T 就相当于 KT里面的out，所以才可以 泛型子类对象 赋值给 泛型父类对象
    //java中
    List<? extends CharSequence> list2 = new ArrayList<String>();//可以
    //         List<CharSequence> list1 = new ArrayList<String>();//报错
}

in-逆变


// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  只管消费者
class ConsumerClass1 : Consumer<Animal> {
    override fun consumer(item: Animal) {
        println("消费者 Animal")
    }
}

class ConsumerClass2 : Consumer<Humanity> {
    override fun consumer(item: Humanity) {
        println("消费者 Humanity")
    }
}

class ConsumerClass3 : Consumer<Man> {
    override fun consumer(item: Man) {
        println("消费者 Man")
    }
}

class ConsumerrClass4 : Consumer<WoMan> {
    override fun consumer(item: WoMan) {
        println("消费者 WoMan")
    }
}

fun main() {
    val p1 : Consumer<Man> = ConsumerClass1() // ConsumerClass1他本来就是 传递 Animal
    val p2 : Consumer<WoMan> = ConsumerClass2() // ConsumerClass1他本来就是 传递 Humanity，居然也可以，因为in

    // 默认情况下： 泛型具体出的父类  是不可以赋值给  泛型声明处的子类的
    // in：泛型具体出的父类  是可以赋值给  泛型声明处的子类的
    
    //JAVA中
    //List<String> list1 = new ArrayList<CharSequence>();//报错
     List<? super String> list2 = new ArrayList<CharSequence>();//可以
    // ? super T 就相当于 KT里面的in，所以才可以 泛型父类对象 赋值给 泛型子类对象
}

in和out的综合运用


// 整个 SetClass 里面的所有成员 泛型相关，只能修改 更改，
//                                    不能获取人家 读取人家的
// 小结：当我们 对这个整个类里面的泛型，只能修改 ，不能让外界读取时，可以声明 in T 逆变
class SetClass<in T>() {

    // 200个函数 这200个函数 对T只能修改，不能给外界读取
    // ...

    fun set1(item: T) {
        println("set1 你要设置的item是:$item")
    }

    fun set2(item: T) {
        println("set2 你要设置的item是:$item")
    }

    fun set3(item: T) {
        println("set3 你要设置的item是:$item")
    }

    // ...

    // 不能给外界读取 (增加in后，不能给外界读取，所以编译不通过)
    /*fun get1() : T? {
        return null
    }

    fun get2() : T? {
        return null
    }

    fun get3() : T? {
        return null
    }*/

    // ...
}


// 整个 GetClass 里面的所有成员 泛型相关，不能修改 更改，
//                                    只能获取人家 读取人家的
// 小结：当我们 对这个整个类里面的泛型，只能给读取 ，不能修改 更改，可以声明 out T 协变
class GetClass<out T>(_item: T) {

    val item: T = _item

    // 200个函数 这200个函数 对T只能读取，不能给外界修改 更改
    // ...

    // 不能给外界修改 更改 (增加out后，不能给外界修改 更改，所以编译不通过)
    /*fun set1(item : T) {
        println("set1 你要设置的item是:$item")
    }

    fun set2(item : T) {
        println("set2 你要设置的item是:$item")
    }

    fun set3(item : T) {
        println("set3 你要设置的item是:$item")
    }*/

    // ...


    fun get1(): T {
        return item
    }

    fun get2(): T {
        return item
    }

    fun get3(): T? {
        return item
    }

    // ...
}

fun main() {
    // 逆变 in T  SetClass 只能修改 更改 不能给外界读取
    val p1 = SetClass<String>()
    p1.set1("Derry")
    p1.set2("Kevin")

    println()

    // 协变 out T GetClass 只能读取，不能修改 更改
    val p2 = GetClass("李四")
    println(p2.get1())
    val p3 = GetClass("王五")
    println(p3.get3())
}

reified关键字

//如果is关键字作用域泛型，则必须在方法中添加reified关键字，并且必须是inline函数
//reified 关键字使用就可以在泛型函数中获取到反射类型的Class对象
inline fun<reified T> randomOrDefault() :T? {
        val objList : List<Any> = listOf(ObjectClass1("obj1 李四", 22, "学习C"),
            ObjectClass2("obj2 王五", 23, "学习C++"),
            ObjectClass3("obj3 赵六", 24, "学习C#"))

        val randomObj : Any? = objList.shuffled().first()

        println("您随机产生的对象 幸运儿是:$randomObj")
        return randomObj.takeIf { it is T } as T?  
    }

定义扩展函数

导入扩展文件 在工作中非常有用，可以把很多的扩展操作，写到某一个地方，到时候引入过来用，比较独立化。

class Test (val name: String, val age: Int, val sex: Char)

// 增加扩展函数
fun Test.show() {
    println("我是show函数, name:${name}, age:$age, sex:$sex")
}

// 增加扩展函数
fun Test.getInfo() = "我是getInfo函数, name:${name}, age:$age, sex:$sex"

fun String.addExtAction(number: Int) =  this + "@".repeat(number)

fun String.showStr() = println(this)

/* 增加扩展函数后 的 背后代码

    public final class Test {

        public static final void show(Test $this$show) {
            System.out.println("我是show函数, name:" + $this$show.name + ", age:" + $this$show.age, sex:" + $this$show.sex);
        }

        public static final void getInfo(Test $this$getInfo) {
            return "我是getInfo函数, name:" + $this$show.name + ", age:" + $this$show.age, sex:" + $this$show.sex;
        }

        public static final void showStr(String $this$showStr) {
            System.out.println($this$showStr);
        }

        public static final String addExtAction(String $this$addExtAction) {
           return $this$addExtAction + StringsKt.repeat((CharSequence)"@", number);
        }

        public static void main(String [] args) {
            main();
        }

        public static void main() {
            // ...
        }
    }
 */

// Test.xxx  xxx函数里面会持有this == Test对象本身
fun main() {
    val p = Test("张三", 28, '男')
    p.show()
    println(p.getInfo())

    println("Derry".addExtAction(8))
    println("Kevin".addExtAction(3))

    "这个是我的日志信息".showStr()
    "Beyond".showStr()
}

//还可以对超类进行扩展，这样所有的子类都可以用
fun Any.showPrintlnContent() = println("当前内容是:$this")

//注意：
// 第一点：如果我们自己写了两个一样的扩展函数，编译不通过
// 第二点：KT内置的扩展函数，被我们重复定义，属于覆盖，而且优先使用我们自己定义的扩展函数
public fun File.readLines(charset: Charset = Charsets.UTF_8): List<String> {
    val result = ArrayList<String>()
    forEachLine(charset) { result.add(it); }
    return result
}

/*output:
我是show函数, name:张三, age:28, sex:男
我是getInfo函数, name:张三, age:28, sex:男
Derry@@@@@@@@
Kevin@@@
这个是我的日志信息
Beyond
*/

扩展属性

// 你必须把前面的普通方式学会：
val myStr : String = "AAA"
/* 背后代码：
   public final class KtBase117Kt {

       @NotNull
       private static final String myStr = "AAA";

       @NotNull
       public static final String getMyStr() {
            return myStr;
       }
   }
 */

// 扩展属性：只能是val，无法定义var
val String.myInfo: String
    get() = "Derry"
   // set(value)="123" 无法使用

/* 背后代码：

   public final class KtBase117Kt {

       真实情况：
       @NotNull
       public static final String getMyInfo(@NotNull String $this$myInfo) {
          Intrinsics.checkParameterIsNotNull($this$myInfo, "$this$myInfo");
          return "Derry";
       }
   }

 */

// 打印输出 并且 链式调用 (只有String有资格这样)
fun String.showPrintln() : String {
    println("打印输出 并且 链式调用 (只有String有资格这样)：内容$this")
    return this
}

val String.stringAllInfoValueVal
    get() = "当前${System.currentTimeMillis()}这个时间点被调用了一次，当前的值是:$this，当前字符串长度是:$length"

fun main() {
    val str : String = "ABC"
    println(str.myInfo)

    str.showPrintln().showPrintln().showPrintln().showPrintln()

    str.myInfo.showPrintln().showPrintln().showPrintln()

    "Derry".stringAllInfoValueVal // 扩展属性
        .showPrintln().showPrintln().showPrintln().showPrintln() // 扩展函数

}

泛型扩展函数

fun main() {
    val r: Char = "Derry".mLet {
        it
        true
        "OK"
        'A'
    }

    123.mLet {
        it
    }

    'C'.mLet {
        it
    }

    // 万能类型，任何类型，所有类型，都可以使用我的 mLet
    val r2 : String = "Derry2".let {
        it
        34543.45f
        "Derry"
    }
}
// I.mLet 对I输入Input进行函数扩展，扩展函数的名称是 mLet，意味着，所有的类型，万能类型，都可以用 xxx.mLet
// lambda : (I) -> O   (I输入参数) -> O输出
//  : O  会根据用户的返回类型，变化而变化
// lambda(this) I进行函数扩展，在整个扩展函数里面，this == I本身
private inline fun<I, O> I.mLet(lambda : (I) -> O) : O = lambda(this)

可空类型扩展函数


// 对 String?==可空类型的 进行函数扩展，并且有备用值
fun String?.outputStringValueFun(defalutValue : String) = println(this ?: defalutValue)

// 编译期非常智能：能够监测到你做了if判断（能够对你代码逻辑监测），就知道后续类型
fun String?.outputStringValueFunGet(defaultValue : String) = this ?: defaultValue

// TODO 118-Kotlin语言的可空类型扩展函数
// 如果是null，就输出默认值
fun main() {
    val infoValue : String ? = null // infoValue是可空的类型  String  String?==可空类型的
    infoValue.outputStringValueFun("我是默认值啊1")
    val name = "Derry"
    name.outputStringValueFun("我是默认值啊2")

    // >>>>>>>>>>>>>>
    println(infoValue.outputStringValueFunGet("我是默认值啊3"))
    println(name.outputStringValueFunGet("我是默认值啊4"))
}

infix关键字

// 自定义的中缀表达式 + 扩展函数 一起用的     使用者： "一".gogogo(1)  "一" gogogo 1
// 1.条件一  对第一个参数 C1.gogogo  函数扩展
// 2.条件二  需要在 括号(c2: C2) 参数里面，传递一个参数
private infix fun <C1, C2> C1.gogogo(c2: C2) {
    // 做很多的逻辑
    // ...
    // 省略几万行代码
    println("我们的中缀表达式，对一个参数的内容是:$this")
    println("我们的中缀表达式，对二个参数的内容是:$c2")
}
// infix == 中缀表达式 可以简化我的代码
fun main() {
    // 下面是我们map自带的中缀表达式
    mapOf("零".to(0))

    mapOf("一" to 1)
    mapOf("二" to 2)
    mapOf("三" to 3)

    // 下面是我们自己写的中缀表达式
    123 gogogo '男'
    "Derry".gogogo('M')
    "Derry2" gogogo 'M'
}

map变换函数

fun main() {
    val list = listOf("李元霸", "李连杰", "李小龙")
    // T T T  --->  新的集合(R, R, R)
    // 原理：就是把你 匿名函数 最后一行的返回值 加入一个新的集合，新集合的泛型是R，并且返回新集合
    val list2 : List<Int> = list.map {
        // it = T == 元素 == String
        "【$it】"
        88
    }
    println(list2)

    // 用途： 和 RxJava的思路，一模一样
    val list3 : List<String> = list.map {
        "姓名是:$it"
    }.map {
        "$it，文字的长度是:${it.length}"
    }.map {
        "【$it】"
    }
    for (s in list3) {
        print("$s  ")
    }

    println()

    list.map {
        "姓名是:$it"
    }.map {
        "$it，文字的长度是:${it.length}"
    }.map {
        "【$it】"
    }.map {
        print("$it  ")
    }
}

//output:
//[88, 88, 88]
//【姓名是:李元霸，文字的长度是:7】  【姓名是:李连杰，文字的长度是:7】  【姓名是:李小龙，文字的长度是:7】  
//【姓名是:李元霸，文字的长度是:7】  【姓名是:李连杰，文字的长度是:7】  【姓名是:李小龙，文字的长度是:7】

filter过滤函数

fun main() {
    // println("126-Kotlin语言的过滤函数-filter")

    val nameLists = listOf(
        listOf("黄晓明", "李连杰", "李小龙"),
        listOf("刘军", "李元霸", "刘明"),
        listOf("刘俊", "黄家驹", "黄飞鸿")
    )

    nameLists.map {
        // it ==  nameLists的元素 == listOf("黄晓明", "李连杰", "李小龙"),
        println(it)
    }

    println()

    nameLists.flatMap {
        // it ==  nameLists的元素 == listOf("黄晓明", "李连杰", "李小龙"),
        println(it)

        listOf("")//flatmap一定要返回一个集合
    }

    println()

    nameLists.map {
            it -> it.filter {
        true
    }
    }.map {
        print("$it   ")
    }

    println()
    println()

    nameLists.flatMap {
            it -> it.filter {
        true
    }
    }.map {
        print("$it   ")
    }

    println()
    println()

    // List<T> 返回给 map 后的效果： [黄晓明, 李连杰, 李小龙]   [刘军, 李元霸, 刘明]   [刘俊, 黄家驹, 黄飞鸿]
    // List<T> 返回给 flatMap 效果: 黄晓明   李连杰   李小龙   刘军   李元霸   刘明   刘俊   黄家驹   黄飞鸿

    nameLists.flatMap {
            it -> it.filter {
        it.contains('黄') // 包含 ‘黄’ true，否则是false
    }
    }.map {
        print("$it   ")
    }

}

//output:
/*[黄晓明, 李连杰, 李小龙]
[刘军, 李元霸, 刘明]
[刘俊, 黄家驹, 黄飞鸿]

[黄晓明, 李连杰, 李小龙]
[刘军, 李元霸, 刘明]
[刘俊, 黄家驹, 黄飞鸿]

[黄晓明, 李连杰, 李小龙]   [刘军, 李元霸, 刘明]   [刘俊, 黄家驹, 黄飞鸿]   

黄晓明   李连杰   李小龙   刘军   李元霸   刘明   刘俊   黄家驹   黄飞鸿   

黄晓明   黄家驹   黄飞鸿   */

flatMap变换函数

// map {返回类型：T String Int Boolean Char ...  是把每一个元素（String）加入到新集合，最后返回新集合 List<String>}
// flatMap {返回类型：每一个元素 T 集合1 集合2 集合3 ... 是把每一个元素（集合）加入到新集合，最后返回新集合 List<List<String>> 最终内部会处理成List<String>}

// TODO flatMap 相当于 List<List<String>> 集合的集合，有嵌套关系

fun main() {
    val list : List<String> = listOf("李四", "王五", "赵六", "初七")

    val newList : List<String> = list.map {
        "你的姓名是:$it" // 每次返回一个 String
    }.map {
        "$it, 你文字的长度是:${it.length}" // 每次返回一个 String
    }.flatMap {
        listOf("$it 在学习C++", "$it 在学习Java", "$it 在学习Kotlin") // 每次返回一个集合，四次
    }
    println(newList)

    println()

    /*
    [你的姓名是:李四, 你文字的长度是:8 在学习C++,
     你的姓名是:李四, 你文字的长度是:8 在学习Java,
     你的姓名是:李四, 你文字的长度是:8 在学习Kotlin,

     你的姓名是:王五, 你文字的长度是:8 在学习C++,
     你的姓名是:王五, 你文字的长度是:8 在学习Java,
     你的姓名是:王五, 你文字的长度是:8 在学习Kotlin,

     你的姓名是:赵六, 你文字的长度是:8 在学习C++,
     你的姓名是:赵六, 你文字的长度是:8 在学习Java,
     你的姓名是:赵六, 你文字的长度是:8 在学习Kotlin,

     你的姓名是:初七, 你文字的长度是:8 在学习C++,
     你的姓名是:初七, 你文字的长度是:8 在学习Java,
     你的姓名是:初七, 你文字的长度是:8 在学习Kotlin]
     */

    // 原理：就是把你 匿名函数 最后一行的返回值(又是一个集合listOf(......)) 加入一个新的集合，新集合的泛型是R，并且返回新集合
}

kotlin与java互操作性与可空性

public class KtBase129 {

    public String getInfo1() {
        return "Derry Info1";
    }

    public String getInfo2() {
        return null;
    }
}

fun main() {
    // 下面是 Java 与 KT 交互 ，错误的案例
    println(KtBase129().info1.length)
    // println(KtBase129().info2.length) // 引发空指针异常

    // 下面是 Java 与 KT 交互 ，错误的案例
    // : String! Java 与 KT 交互的时候，Java给KT用的值，都是 : String! 这种类型
    val info1  = KtBase129().info1
    val info2 = KtBase129().info2
    println(info1.length)
    // println(info2.length) // 引发空指针异常


    // 下面是 Java 与 KT 交互 ，正确的案例1
    // : String! Java 与 KT 交互的时候，Java给KT用的值，都是 : String! 这种类型
    // 只要是看到有  String! 的类型，在使用的时候，必须 ?.xxx，这个是规则1 这个规则1不好，如果忘记写，就有风险
    val info1s  = KtBase129().info1
    val info2s = KtBase129().info2
    println(info1s?.length)
    println(info2s?.length)

    // 下面是 Java 与 KT 交互 ，正确的案例2 (推荐)
    // : String! Java 与 KT 交互的时候，Java给KT用的值，都是 : String! 这种类型
    // 只要是看到有  String! 的类型，在使用的时候，必须 : String? 来接收Java值，这个是规则2（直接限定你不会出错了）
    val info1ss : String?  = KtBase129().info1
    val info2ss : String? = KtBase129().info2
    println(info1ss?.length)
    println(info2ss?.length)
}

合并函数-zip

fun main() {
    val names = listOf("张三", "李四", "王五")
    val ages = listOf(20, 21, 22)

    // RxJava zip 合并操作符
    // KT 自带就有zip 合并操作

    // 原理：就是把 第一个集合 和 第二个集合 合并起来，创建新的集合，并返回
    //      创建新的集合(元素，元素，元素) 元素Pair(K, V)  K代替第一个集合的元素   V代替第二个集合的元素
    val zip : List<Pair<String, Int>> = names.zip(ages)
    println(zip)
    println(zip.toMap())
    println(zip.toMutableSet())
    println(zip.toMutableList())

    println()

    // 遍历
    zip.forEach {
        // it == Pair<String, Int>
        println("姓名是:${it.first}, 年龄是:${it.second}")
    }

    println()

    // map 普通方式
    zip.toMap().forEach { k, v ->
        println("姓名是:${k}, 年龄是:${v}")
    }

    println()

    // map 解构的方式
    zip.toMap().forEach { (k, v) ->
        println("姓名是:${k}, 年龄是:${v}")
    }

    println()

    zip.toMap().forEach {
        // it == Map的元素 每一个元素 有K和V，  Map.Entry<String, Int>
        // it == Pair<String, Int>
        println("姓名是:${it.key}, 年龄是:${it.value}")
    }
}

接口定义与默认实现

// 1.接口里面的所有成员 和 接口本身 都是 public open 的，所以不需要open，这个是接口的特殊
// 2.接口不能有主构造，反正就是没有构造
// 3.实现类不仅仅要重写接口的函数，也要重写 接口的成员变量
// 4.接口实现代码区域，全部都要增加 override 关键字来修饰

interface IUSB {
    val usbVersionInfo: String // USB版本相关的信息
    get() = "IUSB"//如果给接口成员赋予默认实现，必须是val修饰，但是一般不建议接口加入默认实现

    var usbInsertDevice: String // USB插入的设备信息

    fun insertUBS() : String
	fun insertUBS2() : String{//默认实现
        return ""
    }
}

class Mouse : IUSB{
    override var usbVersionInfo: String ="MouseInfo"
    override var usbInsertDevice: String = "MouseDevice"

    override fun insertUBS(): String {
        return "Mouse ${usbVersionInfo} ,${usbInsertDevice}"
    }

}

//这种实现接口的方式与上面的效果一样
class Mouse2(override var usbVersionInfo: String, override var usbInsertDevice: String) : IUSB{
    override fun insertUBS(): String {
        return "Mouse ${usbVersionInfo} ,${usbInsertDevice}"
    }

}

class Mouse1 : IUSB{
    override var usbInsertDevice: String=""

    override fun insertUBS(): String {
        return "Mouse ${usbVersionInfo} ,${usbInsertDevice}"
    }

}

fun main() {
    var mouse = Mouse()
    println(mouse.insertUBS())
    var mouse1 = Mouse1()
    println(mouse1.insertUBS())
}

注解@JvmName

//Kt文件
@file:JvmName("Stu") // 就是在编译器环节，修改我们的类的名字，让Java端调用更简洁

package aaa.test

// @file:JvmName("Stu") 注意：必须写在 包名的外面

fun getStudentNameValueInfo(str : String) = println(str)

fun main() {}

/* 背后生成的代码：

    public final class TestKt {

        public static final void getStudentNameValueInfo(@NotNull String str) {
            System.out.println(str);
        }

        public static final void main() {
        }

        public static void main(String[] args) {
            main();
        }
    }


    @file:JvmName("Stu") 背后的原理
    public final class Stu {

        public static final void getStudentNameValueInfo(@NotNull String str) {
            System.out.println(str);
        }

        public static final void main() {
        }

        public static void main(String[] args) {
            main();
        }
    }
 */
//=====================
//java文件
//import aaa.test.Stu;
import aaa.test.TestKt;

public class test {

    public static void main(String[] args) {
//        Stu.getStudentNameValueInfo("aaaaa");
        TestKt.getStudentNameValueInfo("aaaa");
    }
}

注解@JvmField

class Person {
    @JvmField
    val names = listOf("Zhangsan", "Lisi", "Wangwu")
}

/* 背后的原理代码：

    public final class Person{

        @NotNull
        private final List names = CollectionsKt.listOf(new String[]{"Zhangsan", "Lisi", "Wangwu"});

        // val 只读的，只有 getNames
        public final List getNames() {
            return this.names;
        }
    }
    @JvmField 背后会剔除私有代码 成员
    public final class Person {
       @JvmField
       @NotNull
       public final List names = CollectionsKt.listOf(new String[]{"Zhangsan", "Lisi", "Wangwu"});
    }
 */


public class test {

    public static void main(String[] args) {
        Person person = new Person();
        for (String name : person.names) {
            System.out.println(name);
        }
    }
}

注解@JvmOverloads

// 默认参数
fun show( name : String, age : Int = 20, sex : Char = 'M') {
    println("name:$name, age:$age, sex:$sex")
}

// 默认参数
@JvmOverloads // 原理：编译器环节 专门重载一个函数，专门给 Java用
fun toast( name : String, sex : Char = 'M') {
    println("name:$name, sex:$sex")
}
fun main() {
    // KT端
    show("张三")
    toast("李四")
}

public class test {

    public static void main(String[] args) {
        // Java端
        // TestKt.show("张三") // Java无法享用 KT的默认参数

        TestKt.toast("张三"); // 相当于 Java 享用 KT的默认参数
    }
}

注解@JvmStatic

class MyObject {

    companion object {

        @JvmField
        val TARGET = "黄石公园"

        @JvmStatic
        fun showAction(name: String) = println("$name 要去 $TARGET 玩")
    }
}

fun main() {
    // KT 端
    MyObject.TARGET

    MyObject.showAction("Derry")
}

public class test {

    public static void main(String[] args) {
        // Java 端
        System.out.println(MyObject.TARGET);

        MyObject.showAction("Kevin");
    }
}

注意

使用kotlin改造java项目的时候，特别注意方法中参数的类型需要加“?“，因为如果是Java方法调用kotlin方法，参数是null的话会崩溃。

hzulwy
关注
专栏目录
《Kotlin从小白到大牛》第22章：Kotlin I/O与文件管理
weixin_38072116的博客
06-11 460
第22章 Kotlin I/O与文件管理 Kotlin I/O（输入与输出）是基于Java I/O流技术，但是Java I/O流技术使用起来比较繁琐，Kotlin提供了很多扩展，使代码变得简洁。本章介绍Kotlin I/O流和文件管理相关知识。 22.1 Java I/O流概述 Kotlin I/O流技术主要来自于Java I/O流技术，因此有必要先介绍一下Java I/O流技术。Java将数据的输入流和输出操作当作“流”来处理，“流”是一组有序的数据序列。“流”分为两种形式：输入流和输出流，从数据源中读取
android开发中使用okhttp出现的kotlin.text.Charsets异常
anod的专栏
09-24 2136
用的okhttp 3.11.0和okio2.1.0（okhttp依赖于okio） 运行时出现异常： java.lang.ClassNotFoundException: Didn't find class "kotlin.text.Charsets" 就是有一个类找不到，看起来是kotlin的核心库里的。 另外，网上另一哥们儿说也遇到这个问题，换用了较低版本的okio就解决了。但没有明说有问...
kotlin.text.charsets
Super_Jadroid的博客
08-28 1892
java.lang.NoClassDefFoundError:   didn't find class kotlin.text.charsets   Android studio项目中引入了自己下载的两个jar  3.10版本的okhttp和2.0版本的okio   结果apk安装好就闪退 日志显示buffer中的使用的kotlin.text.charsets找不到 网上找了好多没找到原因...
Kotlin编码规范
hqyhqyhq的专栏
02-17 1055
编码规范 本页包含当前 Kotlin 语言的编码风格。 源代码组织 命名规则 格式化 文档注释 避免重复结构 语言特性的惯用法 库的编码规范 应用风格指南 如需根据本风格指南配置 IntelliJ 格式化程序，请安装 Kotlin 插件 1.2.20 或更高版本，转到Settings | Editor | Code Style | Kotlin，点击右上角的Set from…链接，并从菜单中选择Kotlin style guide。 如需验证代码已按风格指南格式化，请转到Set...
【2023】Kotlin教程 第一篇 Kotlin基础 第6章 字符串 6.2 不可变字符串
谢谢你们的关注
03-31 366
【2023】Kotlin教程 第一篇 Kotlin基础 第6章 字符串 6.2 不可变字符串
Kotlin基础知识
02-12
Kotlin基础知识 参加课程和Google 训练营后，初步了解Kotlin的发展。 目录 主要景点 内置空安全性。 一流的协程支持。 不鼓励继承以支持合成。 允许您为Web +移动应用程序和微服务使用相同的语言。 JetBrains...
Kotlin基础知识及案例.zip
02-26
本压缩包"Kotlin基础知识及案例.zip"包含了一些关于Kotlin语言的基本概念、语法特性以及实战案例，旨在帮助初学者快速掌握这门语言。 1. **基础语法**： - **变量声明**：Kotlin支持var（可变变量）和val（不可变...
Kotlin基础知识和代码1
08-04
【Kotlin基础知识与代码解析】 Kotlin是一种现代的、面向对象的编程语言，它被设计为简洁、安全和富有表现力。在这个基础教程中，我们将深入理解Kotlin的关键概念，包括变量声明、类型系统、关键字以及二进制和十六...
Kotlin开发基础知识总结文档
最新发布
05-27
Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结Kotlin开发基础知识总结...
kotlin基础--快速上手kotlin语言开发
weixin_46039528的博客
06-14 2658
java是要写在类中，在java中调用kotlin文件中的代码，UtilsK后缀要加Kt，kotlin文件中都会被编译为public static变量，所以在java的main函数中可以直接文件名.函数名调用。下面演示调用kotlin的class，如果是kotlin类的class，需要KClass这样声明，KotlinMain::class调用的时候直接调用，后缀不用加上.java因为是kotlin类的class。变量名写在前面，类型写在后面，编译器如果能推断出你的类型，那么类型是不用声明的。
Kotlin基础学习第3章—内置类型
qq_27494201的博客
05-29 427
文章目录一丶基本类型二丶数组三丶区间四丶集合框架五丶函数六丶案例：四则计算器七丶本章小结 一丶基本类型 二丶数组 package com.wangrui.kotlin fun main(){ 方式一：创建一个可变长度的整型数组 val c0 = intArrayOf(1,2,3,4,5) 方式二：创建整型数组并且按照每个下标（0~4）依次+1 赋值给数组 c1 val c1 = IntArray(5){it + 1} println(c1.contentToSt
【Kotlin】Kotlin学习一-基本类型
珍心
09-06 187
【Kotlin】基本类型数字整数Byte Short Int Long浮点数字面常量表达方式第一组实验（Int?1000 和Int? 100）第二组实验（Int 1000 和Int 100）第三组实验（缓存）同一性和相等性显示转换位运算字符布尔数组原生类型数组字符串 学而不思则罔，思而不学则殆 数字 整数Byte Short Int Long 类型 大小 最大值 最小值 Byte 8 27-1 (127) -27(-128) Short 16 215-1(32767) -215(-3
kotlin 基础语法-02-函数-高阶函数
samuelnotes的专栏
03-03 444
kotlin 基础语法-02-函数-高阶函数 本篇文章 主要介绍kotlin 中的函数、嵌套函数、扩展函数、 lambda 语法 、 高阶函数、内联函数 体会函数式编程的能力。 1.函数 我们已经很熟悉函数的声明了、 基本函数的声明语法如下： fun funName(arg1:String="默认值"):返回值类型{ /// 函数体 } 其中参数后边的默认值是可以省略的、 如果...
[Charset]UTF-8, UTF-16, UTF-16LE, UTF-16BE的区别
伊苏
01-29 439
[Charset]UTF-8, UTF-16, UTF-16LE, UTF-16BE的区别 最近遇到的麻烦事 charset里的问题, 一般我们都用unicode来作为统一编码, 但unicode也有多种表现形式 首先, 我们说的unicode, 其实就是utf-16, 但最通用的却是utf-8, 原因: 我猜大概是英文占的比例比较大, 这样utf-8的存储优势比较明显, 因为ut...
Kotlin之实现随机生成汉字
Zachary的基地
11-05 2494
关于编码介绍在Java之将GB2312编码转化为汉字有提。GBK编码，是对GB2312编码的扩展，因此完全兼容GB2312-80标准。GBK编码依然采用双字节编码方案，其编码范围：8140－FEFE，剔除xx7F码位，共23940个码位。共收录汉字和图形符号21886个，其中汉字（包括部首和构件）21003个，图形符号883个。 private fun getChineseWord(): String { val encodelist = arrayOf( ...
Kotlin学习笔记——Kotlin基础
川峰的博客
12-11 5440
Kotlin学习手记——基本类型、变量、集合、数组、区间、函数声明
kotlin 集合操作之 joinToString
热门推荐
火星男孩的分享空间
01-02 1万+
public fun <T> Iterable<T>.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequ...
Android OkHttp4 RequestBody.create()过时解决办法 kotlin、java版本
syfyyds12138的博客
10-04 2237
前段时间，OKhttp3已升级到Okhttp4 ，编写语言由java过渡到，而以前okhttp3经常用到的post提交数据的：已过时，并且换成了kotlin的新特性写法！
Kotlin偏函数
向小凯同学学习
04-03 976
一、通过偏函数与柯里化函数的结合，来聊一聊偏函数到底是什么，怎么实现 看一个例子，main方法中就是偏函数的调用 package net.println.kotlin.chapter5.currying import java.io.OutputStream import java.nio.charset.Charset /** * @author:wangdong * @descri...
Kotlin基础知识开场白
05-12
Kotlin 是一种现代化的静态类型编程语言，它最初由 JetBrains 开发，目前已经成为 Android 开发中的主要语言之一。Kotlin 具有许多优秀的...本次对话中，我可以为你提供 Kotlin 基础知识的相关问题解答和学习资源推荐。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值