全网最全面的由浅到深的Kotlin基础教程（五）

最新推荐文章于 2024-06-14 14:00:44 发布
最新推荐文章于 2024-06-14 14:00:44 发布
阅读量800 收藏 12
点赞数 12
分类专栏： Kotlin 文章标签： kotlin 继承 数据类 接口 抽象类 运算符重载 out 协变 in逆变
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34720818/article/details/139042968
版权

全网最全面的由浅到深的Kotlin基础教程（五）

前言

本篇文章接着上一篇文章全网最全面的由浅到深的Kotlin基础教程（四）继续进阶学习kotlin，建议看完上一篇文章，再来看本篇文章。前面4篇文章都是kotlin的基础知识，本篇文章开始进入深水区，主要讲解kotlin语言中类的继承，数据类，枚举类，接口类，抽象类，密封类，泛型，运算符重载，out协变，in逆变等等。

1. 继承与重载的open关键字

kotlin需要使用open关键字使得类可以被继承，使得类中的方法可以被重写。示例代码如下：

open class Person(val name:String){
    //默认都是final方法，无法继承，需要用open关键字去除final
    open fun show() = println("人类name=$name")
}

class Student(name: String):Person(name){
    override fun show() {
        println("学生name=$name")
    }
}
fun main() {
    var person:Person = Student("MEKEATER")
    person.show()
}

运行结果如下：
在这里插入图片描述

2. 类型转换 is + as 配合类型转换

is用户判断是否为指定类型，as用于类型转换，示例代码如下：

fun main() {
    //Student类继承自Person
    var p: Person = Student("mekeater")
    if (p is Student) {
        (p as Student).show()
    }
}

4. Any超类学习

kotlin任何类默认都继承了Any类

class Test04:Any() //任何类默认都继承了Any类
fun main() {
    println(Test04().toString())
}

5. 对象声明：实现单例实例

kotlin通过object关键字生命的类，就是实现一个单例对象,可以反编译查看java代码的实现。通过这种方式实现java的单例模式，示例代码如下：

//object 就是实现一个单例对象。可以反编译查看java代码的实现。
object Test5{
    //因为是单例，主构造函数用不到了，所以，init实际写在静态代码块了，可以反编译查看
    init {
        println("Test5 init")
    }

    fun show() = println("show函数")
}
fun main() {
    //都是同一个实例
    println(Test5)
    println(Test5)
}

运行结果如下：
在这里插入图片描述

6. object :对象表达式

kotlin通过object : 对象表达式匿名实现接口或者继承类，示例代码如下：

open class Test06{
    open fun show(info:String) = println("[$info]")
}
fun main() {
    //匿名对象 表达式，即匿名实现类对象
    var test06 = object : Test06() {
        override fun show(info: String) {
            println("匿名对象实现【$info】")
        }
    }
    test06.show("mekeater")

    //对接口，用对象表达式（匿名对象）实现
    var run = object : Runnable {
        override fun run() {
            println("通过对象表达式，匿名实现接口")
        }
    }
    run.run()
}

7. 伴生对象companion object

kotlin通过companion object关键字实现静态变量和静态方法，示例代码如下：

class Test07{
    companion object{
        val info = "mekeater"
        fun show() = println("info=$info")
    }
}
fun main() {
    Test07.show()
}

8. 嵌套类与内部类

在类中再定义一个类，如果不加inner关键字，则为嵌套类，否则为内部类，内部类可以访问外层类的变量，嵌套类不可以。示例代码如下：

class Test08{
    val info = "mekeater"
    //不加inner默认是嵌套类，必须加inner使得嵌套的类成为内部类，而内部类才能访问外部类的成员变量
    inner class Test1{
        fun show() = println("info=$info")
    }
}
fun main() {
    Test08().Test1().show()
}

9. 数据类

kotlin通过data关键字声明的类称为数据类，数据类会自动生成toString hashCode equals 解构操作，这点可以通过反编译为java代码证明。数据类适用于类似javaBean的场景，示例代码如下：

//可以通过反编译为java代码比较普通类和数据类的区别。
//普通类只有get set和构造函数，而数据类相对于普通类，会再自动生成toString hashCode equals 解构操作
class Test09(var name:String)
data class Test091(var name: String)
fun main() {
    println(Test09("mekeater"))
    println(Test091("mekeater")) //因为数据类自动重写了toString,所以，输出结果与普通类不一样
}

运行结果如下：
在这里插入图片描述
上面代码反编译为java的部分代码如下，可以明显看出加了data关键字的Test091类，自动生成了component1解构函数，copy函数，toString函数，hashCode函数，equals函数，但是，可以看出这些操作只是处理主构造的参数，所以，次构造的内容会丢失，这点需要注意！

public final class Test09 {
   @NotNull
   private String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.name = var1;
   }

   public Test09(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      super();
      this.name = name;
   }
}

public final class Test091 {
   @NotNull
   private String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.name = var1;
   }

   public Test091(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      super();
      this.name = name;
   }

   @NotNull
   public final String component1() {
      return this.name;
   }
   
   @NotNull
   public final Test091 copy(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      return new Test091(name);
   }

   // $FF: synthetic method
   public static Test091 copy$default(Test091 var0, String var1, int var2, Object var3) {
      if ((var2 & 1) != 0) {
         var1 = var0.name;
      }

      return var0.copy(var1);
   }

   @NotNull
   public String toString() {
      return "Test091(name=" + this.name + ")";
   }

   public int hashCode() {
      String var10000 = this.name;
      return var10000 != null ? var10000.hashCode() : 0;
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof Test091) {
            Test091 var2 = (Test091)var1;
            if (Intrinsics.areEqual(this.name, var2.name)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}

10. 类实现解构声明

kotlin通过component加数字实现为类添加解构功能，至于解构是什么东西，直接看如下代码示例，相信一看就懂了。

//普通类，声明解构函数，使其具备解构能力，但一般没必要，需要解构，就定义数据类就行了
class Test11(var name:String, var age:Int){
    //函数名必须为component1 component2 ...
    operator fun component1() = name
    operator fun component2() = age
}

//数据类，上面也提到过，默认已经实现了解构
data class Test11_1(var name:String, var age:Int)

fun main() {
    var test11 = Test11("mekeater", 18)
    val (name,age) = test11
    println("name=$name,age=$age")
    // 下划线代表不接收某个解构数据，可以看反编译java源码，理解实现方式
    val (name1, _) = Test11_1("sun", 18)
    println("name=$name1")
}

代码运行结果如下：
在这里插入图片描述

11. 运算符重载

kotlin通过operator关键字及指定的函数名称实现重载运算符，如实现+运算符重载示例代码如下：

data class Add(var num1:Int, var num2:Int){
    //实现 + 运算符重载
    operator fun plus(p1:Add): Int {
        return (num1+p1.num1) + (num2+p1.num2)
    }
}
fun main() {
    println(Add(1,2) + Add(3,4))
}

运行结果如下：
在这里插入图片描述
其它一些运算符名称如下：
在这里插入图片描述
在这里插入图片描述

12. 枚举类

12.1 枚举类定义

通过enum关键字声明的类为枚举类，示例代码如下：

enum class Week{
    星期一,
    星期二
}
fun main() {
    println(Week.星期一)
    println(Week.星期二 is Week)
}

运行结果如下：
在这里插入图片描述

12.2 定义主构造函数带参数的枚举类

枚举类和普通类一样，也有主构造函数，定义主构造函数带参数的枚举类，示例代码如下：

//一般枚举类的参数都要私有化，因为参数值是在内部枚举值中传入的，不需要外部传入
enum class Info(private var status:String){
    START("开始"), //因为枚举类主构造函数带参数，因此枚举值需要传入值
    STOP("停止"); //枚举后面如果有函数，需要有结束符
    fun show() = println("status = $status")
    fun update(s:String){
        this.status = s
    }
}
fun main() {
    Info.START.show()
    Info.STOP.show()

    Info.START.update("启动")
    Info.START.show()
}

运行结果如下：
在这里插入图片描述

13. 代数数据类型

代数数据类型，其实就是把枚举类和when结合使用的场景，示例代码如下：

enum class Score{
    A,
    B,
    C,
    D
}
class Teacher(private val score:Score){
    fun show() = when(score){
        Score.A -> "成绩为A"
        Score.B -> "成绩为B"
        Score.C -> "成绩为C"
        Score.D -> "成绩为D"
    }
}
fun main() {
    println(Teacher(Score.A).show())
}

运行结果如下：
在这里插入图片描述

14. 密封类

密封类就是把一堆类收集在一个由sealed声明的类中，示例代码如下：

sealed class Person1 {
    object Bird:Person1()
    class Student(var name:String):Person1()
}

class Test16(private var person1:Person1){
    fun show() = when(person1){
        is Person1.Student -> "这是一个学生，学生姓名：${(person1 as Person1.Student).name}"
        is Person1.Bird -> "这是一只小鸟"
    }
}
fun main() {
    println(Test16(Person1.Student("mekeater")).show())
    println(Test16(Person1.Bird).show())
}

运行结果如下：
在这里插入图片描述

15. 接口类

kotlin定义接口和java类似，通过interface关键字定义接口，其中接口类中声明的成员变量需要实现类通过构造函数，或者重写成员变量实现，示例代码如下：

interface IUSB{
    //成员变量需要实现类通过构造函数，或者重写成员变量实现
    var usbVersion:String
    var usbInfo:String
    fun show():String
}

//方式一、通过构造函数实现接口中的成员变量
class Mouse(override var usbVersion: String, override var usbInfo: String) :IUSB{
    override fun show(): String {
        return "Mouse usbVersion=$usbVersion,usbInfo=$usbInfo"
    }
}

//方式二、通过重新接口类的成员变量实现
class Keyword():IUSB{
    override var usbVersion: String = ""
    override var usbInfo: String = ""
    override fun show(): String {
        return "Keyword usbVersion=$usbVersion,usbInfo=$usbInfo"
    }
}

fun main() {
    var usb:IUSB = Mouse("3.0", "usb3.0版本")
    println(usb.show())
    usb = Keyword()
    usb.usbVersion="3.1"
    usb.usbInfo="usb3.1"
    println(usb.show())
}

运行结果如下：
在这里插入图片描述

16. 抽象类

kotlin通过abstract关键字定义抽象类，这个和java类似，没啥好说的，直接看示例代码：

abstract class BaseActivity{
    fun onCreate(){
        setContentView(getLayoutID())
        initView()
    }

    private fun setContentView(layoutID:Int) = println("layoutID=$layoutID")

    abstract fun getLayoutID():Int
    abstract fun initView()
}

class MainActivity: BaseActivity() {
    override fun getLayoutID(): Int = 666

    override fun initView() = println("initView finish")
}

fun main() {
    MainActivity().onCreate()
}

运行结果如下：
在这里插入图片描述

17. 泛型学习

17.1 定义泛型类

kotlin定义泛型类与java类似，直接看示例代码：

class Kt19<T>(private val obj:T){
    fun show() = println("obj=$obj")
}
fun main() {
    Kt19<Int>(18).show()
    Kt19("hello").show() //kotlin具有类型推断能力，因此可以省略指定类型
}

运行结果如下：
在这里插入图片描述

17.2 泛型函数

kotlin定义泛型函数与java类似，直接看示例代码：

fun<T> show(info:T){
    info?.also {
        println("info=$it")
    } ?: println("info=null")
}

fun main() {
    show(10)
    show(10.66)
    show("good")
    show(null)
}

运行结果如下：
在这里插入图片描述

17.3 泛型变换

输入一种泛型类型，然后通过lambda表达式实现输出为另一种泛型类型，这种泛型转换写法在kotlin代码中很常见，示例代码如下：

inline fun <I, O> map(input: I, action: (I) -> O) =
        action(input)

fun main() {
    var map = map(123) {
        "[$it]"
    }
    println(map)
}

运行结果如下：
在这里插入图片描述

17.4 泛型类型约束

kotlin泛型类型约束相当于java中T extends ，示例代码如下：

open class Animal()
open class Dog():Animal()
//T:Dog，T必须是Dog或者继承自Dog，相当于java中T extends Dog
class Test22<T:Dog>(private val input:T, private val isT:Boolean = true){
    fun getInput() = input.takeIf { isT }
}

18. vararg关键字（动态参数）

通过vararg关键字实现动态参数，示例代码如下：

class Kt23<T>(vararg var ages: T){
    fun show(index:Int) = println("age=${ages[index]}")

    //运算符重载
    operator fun get(index:Int) = ages[index]
}
fun main() {
    val p1 = Kt23(16,17.7,"sun")
    p1.show(2)
    println(p1[0])
}

运行结果如下：
在这里插入图片描述

19. out-协变和in-逆变

  • 协变 out T具有以下特点
  1. 泛型只能读取，不能修改
  2. 子类泛型可以直接赋值给父类泛型，类似java ? extend T
  • 逆变 in T具有以下特点
  1. 泛型只能修改，不能读取
  2. 父类泛型可以直接赋值给子类泛型，类似java ? super T。父类去转子类，这应该是逆向过程，所以逆变的名称因此而来。

示例代码如下：

//协变
interface Product<out T>{
    //修改操作，无法通过编译
    //fun f1(item:T)
   fun product():T
}
//逆变
interface Consumer<in T>{
    fun consumer(item:T)
    //读取操作，无法通过编译
    //fun f2():T
}

open class Animal1

open class Dog1: Animal1()

class Product0:Product<Animal1>{
    override fun product(): Animal1 {
        println("生产 Animal1")
        return Animal1()
    }
}

class Product1:Product<Dog1>{
    override fun product(): Dog1 {
        println("生产 Dog1")
        return Dog1()
    }
}

class Consumer0:Consumer<Animal1>{
    override fun consumer(item: Animal1) {
        println("消费 Animal1")
    }
}

class Consumer1:Consumer<Dog1>{
    override fun consumer(item: Dog1) {
        println("消费 Dog1")
    }
}

fun main() {
    val p1:Animal1 = Product0().product()
    
    // 子类Dog1可以赋值给父类Animal1,正常子类是不能赋值给父类的，
    // 此处之所以可以，是因为Product中的泛型是采用协变，类似java的 ? extend Animal
    val p2:Animal1 = Product1().product()
    
    //父类泛型Animal1直接赋值给了子类泛型Dog1，原因是in起的作用，类似java中 ? super Dog1
    val p1:Consumer<Dog1> = Consumer0()
    val p2:Consumer<Dog1> = Consumer1()
}

20. reified关键字学习

reified修饰的泛型，才具有泛型类型判断的能力，即 obj is T，示例代码如下：

data class ObjClass1(val name:String)
data class ObjClass2(val name:String)
class Kt27{
    //只有用reified修饰泛型，才有泛型类型判断的能力 it is T。同时只有inline修饰的函数，才能使用reified修饰
    inline fun<reified T> getObj(defaultLambdaAction:()->T):T{
        var listOf = listOf(ObjClass1("obj1"), ObjClass2("obj2"))
        var obj = listOf.shuffled().first()
        println("随机对象：$obj")
        //T? 代表可为null,不然会有null as T转换异常
        return obj.takeIf { it is T} as T? ?: defaultLambdaAction()
    }
}
fun main() {
    Kt27().getObj<ObjClass1> {
        var result = ObjClass1("备用对象")
        println("启用备用对象:$result")
        result
    }
}

示例运行结果：
在这里插入图片描述

Mekeater
关注
  • 12
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
31-协变-逆变-双向协变(赋值操作).ts
03-06
31-协变-逆变-双向协变(赋值操作)
全网最全面的RDMA拥塞控制教程
10-30
全网最全面的RDMA拥塞控制教程，详细介绍了RDMA的基础知识以及一些非常经典的RDMA拥塞控制算法，GitHub格式的MD文件生成的PDF。
全网最全面的由浅到深的Kotlin基础教程（一）
Mekeater的博客
05-19 587
因为kotlin语言是集所有语言之大成，学习完kotlin也一定程度上可以让你加深对其它语言，尤其是java语言的进一步理解。坚持看完本系列文章，你将掌握一门非常灵活的编程语言，相信一定会收获满满。
全网最全面的由浅到深的Kotlin基础教程（七）
Mekeater的博客
05-23 811
本篇对kotlin的一些标准函数和转换函数进行源码解析，以及用kotlin简单实现Rxjava的几个操作符。
全网最全面的由浅到深的Kotlin基础教程（二）
Mekeater的博客
05-20 990
本文是对全网最全面的由浅到深的Kotlin基础教程（一）的进阶教程，通过本文可以熟悉kotlin字符串操作，apply run also等内置函数的使用等
全网最全面的由浅到深的Kotlin基础教程（四）
Mekeater的博客
05-21 577
本篇文章主要学习kotlin类的定义，主次构造函数，初始化代码块等相关的基础语法。
全网最全面的由浅到深的Kotlin基础教程（三）
Mekeater的博客
05-20 485
本文讲解kotlin语言中集合相关的语法
全网最全面的由浅到深的Kotlin基础教程（六）
Mekeater的博客
05-22 971
本篇主要讲解kotlin扩展函数，注解，DSL，kotlin与java的相互调用等相关语法。
kotlin语言！全网最具深度的三次握手、四次挥手讲解，成功入职阿里
fanzhang_vip0723的博客
01-15 97
正文 从我个人的角度写写30多岁码工的感受：的确是受年龄压力开始增大了。比如二十多岁的小年轻，可能什么都懂，对组里的东西很熟悉。有时候我也怀疑自己是不是智商不够，是不是自学能力太差，是不是基础不行，别人是不是都玩命加班，你知道30多岁的人那种危机感。 在这个竞争激烈的行业中，只有优秀的Android工程师才能够生存，需要我们能够为客户提供的最佳技术和资源，需要有优秀的开发工具，保证以最佳质量以及高效时间来构建。 B4A B4A是Android的基础版，这是一种可简化编程的Android的应用程序开发工具。
Android快速转战Kotlin教程，面试必备_会android的学kotl
2401_84103616的博客
04-18 515
只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。自己的知识准备得怎么样，这直接决定了你能否顺利通过一面和二面，所以在面试前来一个知识梳理，看需不需要提升自己的知识储备是很有必要的。现在面对跨平台技术的冲击，原生开发者的现状大家都清楚，我相信大多数面试的朋友都有这种体会，要求越来越高，要学习掌握的技术越来越多！基础对于一个人的成长高度是至关重要的，俗套且形象的可以比作万丈高楼的地基。
vscode全网最详细使用教程附代码
02-15
VSCode 使用教程附代码 VSCode 是一个功能强大且灵活的代码编辑器，它提供了许多实用功能和插件来提高开发效率。在本篇教程中，我们将详细介绍 VSCode 的安装、设置和基本使用方法。 一、安装 VSCode VSCode 的...
DOTNET-C#基础快速入门教程-全网最简单
10-15
DOTNET_C#基础快速入门教程，100多页的pdf文档，包括了常用的基础知识点： 数据类型 类型转换 变量、常量、运算符 字符串 流程控制 数组 结构、枚举 访问修饰符 方法 装箱和拆箱 接口 类和对象 多态 C# 预处理器 ...
机器学习绘图库Python Matplotlib.pyplot全网最全面新手教程
01-06
最近看到一个讲Matplotlib的英文教程写的很高明，兼收并蓄，简单易懂，特意翻译过来，与君共享。原网址在：http://cs231n.github.io/python-numpy-tutorial/#matplotlib 。 Matplotlib（https://matplotlib.org/）...
全网最全Java基础视频教程
01-21
01.01_计算机基础(计算机概述) 01.02_计算机基础(计算机硬件和软件概述) 01.03_计算机基础(软件开发和计算机语言概述) 01.04_计算机基础(人机交互) 01.05_计算机基础(键盘功能键和快捷键) 01.06_计算机基础(如何打开...
hbuilder开发移动app教程，kotlin协程和线程
2401_84412895的博客
04-23 877
其实客户端开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。（以下体系的复习资料是我从各路大佬收集整理好的）《Android开发七大模块核心知识笔记》《960全网最全Android开发笔记》《379页Android开发面试宝典》历时半年，我们整理了这份市面上最全面的安卓面试题解析大全包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。
探索Napier：Kotlin Multiplatform的日志记录库
最新发布
虎哥LoveDroid
06-14 482
Napier是一个多平台日志记录库，旨在为Kotlin Multiplatform项目提供一致的日志记录体验。它允许开发者在通用模块中编写日志代码，并在各个平台上显示相应的日志。Napier允许开发者注入自定义的Antilog，以便在调试和发布版本中切换不同的日志记录策略。Napier作为一个Kotlin Multiplatform日志记录库，为开发者提供了一致且强大的日志记录功能。无论是调试信息还是错误日志，Napier都能帮助你在多个平台上高效记录和管理日志。
kotlin 中的布尔
记录点滴
06-12 383
kotlin中内置的Boolean类型，可以有true与false两个值的布尔对象
Error:Kotlin: Module was compiled with an incompatible version of Kotlin.
weixin_40873693的博客
06-11 467
Windows系统：File -> settings -> Languages & Frameworks -> Kotlin。4.2、点击Check again，然后点击install即可。这个报错大概意思：模块是用不兼容的Kotlin版本编译的。4.1、打开kotlin面板。：安装完成后一定要重启项目。插件版本比pom中的低。把项目里面的版本降一下。4.3等待安装成功即可。
全网最详细的vscode教程
09-03
对于全网最详细的VSCode教程，以下是一个简短的描述： 全网最详细的VSCode教程应该包含以下内容：基本介绍、安装和设置、编辑器布局、常用快捷键、实用插件和扩展、调试功能、版本控制、代码片段等。 在基本介绍...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mekeater

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值