Kotlin学习 6

最新推荐文章于 2024-03-14 22:23:38 发布
最新推荐文章于 2024-03-14 22:23:38 发布
阅读量724 收藏 9
点赞数 10
分类专栏： Kotlin 文章标签： kotlin 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53374893/article/details/136199220
版权

1.接口

interface Movable {
    var maxSpeed: Int
    var wheels: Int

    fun move(movable: Movable): String

}

class Car(var name: String, override var wheels: Int = 4, _maxSpeed: Int) : Movable {

    override var maxSpeed: Int = _maxSpeed
        get() = field
        set(value) {
            field = value
        }

    override fun move(movable: Movable): String {
        TODO("Not yet implemented")
    }

}

fun main() {
    val car = Car("1",4,8)

    println(car.maxSpeed)
}

1.1 接口属性默认实现

interface Movable {
    val maxSpeed: Int
       get() = (1..500).shuffled().first()//相当于给这个属性赋值  每次不一样但他不是修改它 只是修改了它的get方法 所有只读变量不可赋值

    var wheels: Int

    fun move(movable: Movable): String

}

class Car(var name: String, override var wheels: Int = 4) : Movable {

    override val maxSpeed: Int
        get() = super.maxSpeed


    override fun move(movable: Movable): String {
        TODO("Not yet implemented")
    }

}

fun main() {
    val car = Car("1",4)

    println(car.maxSpeed)
    println(car.maxSpeed)
    println(car.maxSpeed)
    println(car.maxSpeed)
}

 2.抽象类

abstract class Gun(val  range:Int){
    abstract fun pullTrigger():String
}


abstract class Gun1(val  a:Int){
    abstract fun pullTrigger():String
}
class AK47(val price:Int):Gun(range = 80),Movable{
    override fun pullTrigger(): String {
        return "AK47 shooting"
    }

    override var wheels: Int
        get() = TODO("Not yet implemented")
        set(value) {}


}

3.泛型

class MagicBox<T> (item:T){
     var subject:T = item


}

class Boy(val name:String,val age:Int)

class Dog(val weight:Int)

fun main() {

    val magicBox1 = MagicBox(Boy("Jack", 20))
    val magicBox2 = MagicBox(Dog( 20))
    println(magicBox1.subject is Boy)
    println(magicBox2.subject is Dog)

}

4.泛型函数

class MagicBox<T> (item:T){
     var subject:T = item

    var available = false

    fun fetch():T?{
        return subject.takeIf { available } //true返回 this false返回null
    }

}

class Boy(val name:String,val age:Int)

class Dog(val weight:Int)

fun main() {

    val magicBox1 = MagicBox(Boy("Jack", 20))
    val magicBox2 = MagicBox(Dog( 20))
    magicBox1.available =true
    println(magicBox1.fetch())
   magicBox2.available=true
    println(magicBox2.fetch())
    magicBox2.fetch()?.run {
        println("you find $weight")
    }
}

 5.多泛型参数

class MagicBox<T>(item: T) {
    var subject: T = item

    var available = false

    fun fetch(): T? {
        return subject.takeIf { available } //true返回 this false返回null
    }

    //return -> R
    fun <R> fetch(subjectModFunction: (T) -> R): R? {
        return subjectModFunction(subject).takeIf { available }
    }
}

class Boy(val name: String, val age: Int)

class Dog(val weight: Int)

fun main() {

    val magicBox1 = MagicBox(Boy("Jack", 20))

    magicBox1.available =true
    val fetch = magicBox1.fetch {
        Boy("男人", 30)
    }
    println(fetch)
    println(fetch?.name)
    println(fetch?.age)
}

6.泛型类型的约束

7. vararg关键字与get函数

vararg相当于Java的可变参数  Int ... age 类似效果

class MagicBox<T:Human>( vararg item: T) {
    var subject: Array<out T> = item

    var available = false

    fun fetch(index:Int): T? {

        return subject[index].takeIf { available } //true返回 this false返回null
    }

    //return -> R
    fun <R> fetch(index: Int,subjectModFunction: (T) -> R): R? {

        return subjectModFunction(subject[index]).takeIf { available }

    }
}
open class  Human(val age:Int)

class Boy(val name: String, age: Int):Human(age)

class Dog(val weight: Int)

fun main() {

    val magicBox1 = MagicBox(Boy("Jack0", 20),Boy("Jack1", 20),Boy("Jack2", 20),Boy("Jack3", 20))

    magicBox1.available =true
    val fetch = magicBox1.fetch(3) {
        it
    }
    println(fetch)
    println(fetch?.name)
    println(fetch?.age)
}

8.get函数

也就是运算符重载

class MagicBox<T:Human>( vararg item: T) {
    var subject: Array<out T> = item

    var available = false

    fun fetch(index:Int): T? {

        return subject[index].takeIf { available } //true返回 this false返回null
    }

    //return -> R
    fun <R> fetch(index: Int,subjectModFunction: (T) -> R): R? {

        return subjectModFunction(subject[index]).takeIf { available }

    }

    operator fun get(index: Int):T?{
        return subject[index]
    }

}
open class  Human(val age:Int)

class Boy(val name: String, age: Int):Human(age)

class Dog(val weight: Int)

fun main() {

    val magicBox1 = MagicBox(Boy("Jack0", 20),Boy("Jack1", 20),Boy("Jack2", 20),Boy("Jack3", 20))

    magicBox1.available =true
    val fetch = magicBox1.fetch(3) {
        it
    }
    println(fetch)
    println(fetch?.name)
    println(fetch?.age)

    println(magicBox1[3]?.name)
}

9. out 协变 in 逆变 invariant(不变)

 

//out
interface Production<out T> {
    fun product(): T
}

//in
interface Consumer<in T> {
    fun consume(item: T)
}

//不变
interface ProductionConsumer<T> {
    fun product(): T
    fun consume(item: T)
}


open class Food

open class FastFood : Food()

class Burger : FastFood()

//汉堡生产者
//食品商店
class FoodStore : Production<Food> {
    override fun product(): Food {
        println("Product Food")
        return Food()
    }

}


class FastFoodStore : Production<FastFood> {
    override fun product(): FastFood {
        println("Product FastFood")
        return FastFood()
    }

}

class BurgerStore : Production<Burger> {
    override fun product(): Burger {
        println("Product Burger")
        return Burger()
    }

}

//消费者
class EveryBody : Consumer<Food> {
    override fun consume(item: Food) {
        println("consume food")
    }

}

class ModernPeople : Consumer<FastFood> {
    override fun consume(item: FastFood) {
        println(item is Burger)
        println("consume FastFood")
    }

}

class AmericanPeople : Consumer<Burger> {
    override fun consume(item: Burger) {
        println("consume Burger")
    }

}

fun main() {
    //赋值
    val production1: Production<Food> = FoodStore()

    val product = production1.product()
    //用了Out关键字   子类转父类泛型         泛型可以协变和逆变
    val production2: Production<Food> = FastFoodStore()
    val production3: Production<Food> = BurgerStore()


    //in  父类转子类泛型
    val consumer1: Consumer<Burger> = EveryBody()
    val consumer2: Consumer<Burger> = ModernPeople()
    consumer2.consume(Burger())
    val consumer3: Consumer<Burger> = AmericanPeople()


}

10. reified关键字

 reified 和 inline 关键字配合使用能够实现泛型类型判断。因为匿名函数会被优化到这个随机类型函数中，那么就能够知道具体类型是啥了

这个函数的返回类型由backup函数的返回类型决定 和类定义的泛型无关 也就是类的泛型没有起到任何约束作用  你写一个String都可以

class MagicBox<T : Human>() {

    //产生一个指定类型的对象，如果不是指定类型的对象，就通过backup函数生成一个指定类型的对象
//    fun <T> randomOrBackUp(backup: () -> T): T {
//        val items:List<out Human>  = listOf(
//            Boy("Jack", 20),
//            Man("John", 35)
//        )
//        val random:Human =items.shuffled().first()
//        return if (random is T){  //T会被擦除
//            random
//        }else{
//            backup()
//        }
//
//    }
    inline fun <reified T> randomOrBackUp(backup: () -> T): T { //内联函数它就会被替换，泛型擦除从而解决 类型将会保留下来

        val items:List<Human>  = listOf(
            Boy("Jack", 20),
            Man("John", 35)
        )
        val random:Human =items.shuffled().first()
        return if (random is T){  //T会被擦除
            random
        }else{
            backup()
        }

    }

}

open class Human(val age: Int)

class Boy(val name: String, age: Int) : Human(age){

}

class Man(val name: String, age: Int) : Human(age){
    override fun toString(): String {
        return "Man(name='$name' age ='$age')"
    }
}

fun main() {
      val box1:MagicBox<Boy> = MagicBox()
    val subject:Man = box1.randomOrBackUp {
        Man("Jimmy", 36)
    }
    println(subject)
}

11.定义扩展函数


//给字符串追加若干个感叹号
fun String.addExt(amount:Int =1 ):String{
    return this + "!".repeat(amount)
}

fun main() {
    println("abc".addExt(3))
}

//给字符串追加若干个感叹号
fun String.addExt(amount:Int =1 ):String{
    return this + "!".repeat(amount)
}

fun Any.easyPring(){
    println(this)
}
fun Any.easyPring1(){
    println(this.toString()+1)
}

fun main() {
    println("abc".addExt(3))

    "abc".easyPring()
}

可以用private修饰符，只能在此文件下使用

12.泛型扩展函数


//给字符串追加若干个感叹号
fun String.addExt(amount:Int =1 ):String{
    return this + "!".repeat(amount)
}

private fun <T> T.easyPring():T{
    println(this)
    return this;
}
fun Any.easyPring1(){
    println(this.toString()+1)
}

fun main() {
    println("abc".addExt(3))

     "abc".easyPring().addExt(3).easyPring()
}

 13.扩展属性


val String.numVowels
        get() = count{ "aeiou".contains(it) }//true 计数器加1 

fun <T> T.easyPrint():T{
    println(this)
    return this
}

fun main() {
    "The people's Republic of China".numVowels.easyPrint()
    val count = "the".count()
    println(count)

}

 14. 可空类型扩展函数


fun String?.printWithDefault (default:String) = print(this ?: default)//如果为null就为default


fun main() {
    val  nullableString :String?  = "asdas";
    nullableString.printWithDefault("jmj")
}

15. infix关键字


 infix fun String?.printWithDefault (default:String) = print(this ?: default)//infix 对一个参数的函数 可以简化写法，去掉调用的点和括号


fun main() {
    val  nullableString :String?  = "asdas";
    nullableString printWithDefault "jmj" 
}

 16.定义扩展文件

package com.jason.kotlin.extension

fun <T> Iterable<T>.randomTask():T = this.shuffled().first()
import com.jason.kotlin.extension.randomTask

fun main() {
    val randomTask = listOf<String>("jmj", "sada", "asd").randomTask()
    println(randomTask)
}

荭色海湾
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kotlin学习6—神奇的协程
shu_lance的博客
10-05 288
前言 在Kotlin中，有个非常特色的一项技术，那就是协程 什么是协程呢？协程与线程是有点类似的，可以简单地认为协程就是一种轻量级的线程 在平常开发的时候，线程是最小的执行单位，都知道线程是非常重量级的，需要依靠操作系统的调度才能实现不同线程之间的切换 但是协程不同于线程的一点在于，协程可以仅在编程语言的层面上就可以实现不同协程之间的切换，从而大大提高了并发编程的运行效率 协程允许在单线程模式下模拟多线程编程的效果，代码执行时的挂起与恢复完全是由编程语言来控制的，与操作系统无关 基本用法 由于Kotlin并
kotlin学习kotlin学习
08-16
kotlin学习kotlin学习
kotlin-接口
qq_55888300的博客
05-05 3073
与类的伴生对象类似，接口的伴生对象是该接口的单例实例。在 Kotlin 中，接口（Interface）是定义了一组抽象方法（没有实现体）的类型，这些方法可以被其他类实现。要实现继承了其他接口的接口，可以实现其所有的父接口定义的方法，并在实现类中提供所有继承的属性。在 Kotlin 1.4 及以后的版本中，接口中可以定义默认实现的方法。要实现接口中的默认方法，可以选择覆盖该方法，也可以直接继承该默认实现。要实现接口中的属性，可以在实现类中提供一个属性实现。注意，在实现接口中的方法时，需要使用。
【Kotlin】接口和抽象类 ( 接口属性和方法定义 | 接口默认方法实现 | 抽象类 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-21 5489
一、接口属性和方法定义、 二、接口默认方法实现、 三、抽象类
Android—Kotiln基础教程（五）
qq_30382601的博客
11-12 932
前言 在上一篇中主要讲解了Kotlin关于集合相关的知识点，在本篇中，将会对Kotlin的对象进行详解！ 1. 对象 1.1 示例一(无构造函数) class Player { //分析点1 var name = "abc" get() = field.capitalize() set(value) { field = value.trim() } var age = 10 get() = fiel
Kotlin 接口 interface 默认实现了open。并且可以提供默认实现
丿灬安之若死
04-03 2031
interface Movable { var maxSpeed: Int var wheels: Int fun move(movable: Movable): String } class Car(_name: String, override var wheels: Int = 4) : Movable { override var maxSpeed: Int get() = 1 set(value) {} override.
Kotlin与Java互调-Kotlin接口默认实现问题
KyungLip的博客
07-18 1402
Kotlin与Java互调-Kotlin接口默认实现问题
kotlin学习书籍（中文）
11-14
《Kotlin学习书籍（中文）》是一套专为中文学习者设计的教程，旨在帮助开发者深入理解和掌握Kotlin编程语言，特别是其在Android开发中的应用。这套资源包含了两本PDF电子书：《Kotlin in Chinese》和《Kotlin for ...
kotlin学习demo
08-14
【Kotlin学习Demo详解】 Kotlin，一种由JetBrains公司开发的现代编程语言，自2016年发布以来，已经在Android开发领域取得了显著的地位。它以其简洁、安全和面向表达性的特性，深受开发者喜爱。这个"Kotlin学习demo...
Kotlin学习资料自用
最新发布
06-13
【Kotlin学习资料自用】 Kotlin是一种现代的、面向对象的编程语言，由JetBrains公司开发，主要用于Android应用开发，但也可应用于Web、服务器端和桌面应用等平台。Kotlin的设计目标是提供简洁、安全、可空安全以及...
kotlin学习项目案例
02-23
Kotlin 是一种现代、静态类型的编程语言，由 JetBrains 开发并于 2011 年公开发布。它旨在成为 Java 的替代语言，可以运行于 Java 虚拟机（JVM）上，并与现有的 Java 代码和库完美集成。以下是 Kotlin 的几个关键...
kotlin的接口详解
liulanba的博客
01-08 1257
在 Kotlin 中，接口（Interface）是一种定义了一组方法的抽象类型。与类不同，接口不能包含状态或字段。接口中的方法可以有默认实现，也可以是抽象的需要在实现类中提供具体实现的方法。
Kotlin的接口支持方法默认实现和抽象属性
走一段令人留恋的路，做一个不负自己的人
02-18 6031
Kotlin对于接口的设计和Java并不完全相同，它增强了接口的功能，包括如下两个：接口方法支持默认实现、接口中支持抽象属性。例子如下： interface Flyer { val speed: Int val height get() = 1000 fun kond() fun fly() { println("I can fl...
Kotlin中写 调用接口参数，转lambda表达式的步骤
yihanss的博客
03-14 374
Kotlin中写 调用接口参数，转lambda表达式的步骤
kotlin界面_kotlin界面默认实现如何工作
weixin_26727575的博客
09-24 347
kotlin界面Kotlin Interface supports default implementation. Which implies that we can have a default implementation to all the properties and functions defined in the Interface. Kotlin接口支持默认实现。 这意味着我们可以...
Kotlin基础学习 16
m0_57026595的博客
06-23 401
2.Kotlin语言的infix关键字 3.Kotlin语言的定义扩展文件 4.Kotlin语言的重命名扩展学习 5.Kotlin语言的DSL学习 6.Kotlin语言的变换函数map 7.Kotlin语言的变换函数-flatmap
Kotlin语言类，field关键字，计算属性，防范竟态条件学习
XXX_17的博客
11-07 820
Kotlin语言类，field关键字，计算属性，防范竟态条件学习
Kotlin学习笔记（五）
科科然的博客
11-08 2023
定义类 针对我们定义的每一个属性，Kotlin都会产生一个field、一个getter和setter，field用来存储属性数据，我们不能直接定义field，Kotlin会封装field，保护它里面的数据，只暴露给getter和setter使用。属性的getter方法决定如何读取属性值，每个属性都有它的getter方法，setter方法决定你如何给属性赋值，所以只有可变属性才会有setter方法，尽管Kotlin会自动提供默认的getter和setter，但在需要控制如何读取属性数据时，我们也可以自定义
Kotlin编程之接口和实现接口
热门推荐
HeXinGen的博客
05-31 1万+
Kotlin编程中： 定义接口和实现接口
kotlin学习路线
04-09
6. 深入学习Kotlin的高级特性：一旦掌握了Kotlin的基础知识，可以进一步学习一些高级特性，比如协程、函数式编程、DSL等。这些特性可以提高你的代码质量和开发效率。 7. 参与实际项目：最好的学习方式是通过实践。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值