zoukankan      html  css  js  c++  java
  • Kotlin——初级篇(五):操作符与操作符重载一

    本篇文章为大家详细的介绍Koltin特有的操作符重载。或许对于有编程经验的朋友来说,操作符这个词绝对不陌生,就算没有任何编辑基础的朋友,数学中的算数运算符也绝不陌生。例如(+、-、*、/、>、<、>=、<=)等。而算数运算符是编程语言中的一种操作符而已。就算你没有任何基础,也请你详细的看完这篇文章,我相信你会很有收获的。

    目录

    一、约定

    所谓预定:即指Kotlin允许我们为自己的类型提供预定义的一组操作符的实现。这些操作符具有固定的符号表示(如 +*)和固定的优先级。为实现这样的操作符,我们为相应的操作类型提供了一个固定名字的函数。这样的技术,称为约定

    因为由类实现的接口集是固定的,而Kotlin不能为了实现其他接口而修改现有的类,因此一般通过扩展函数的机制来实现为现有的类增添新的约定方法,从而适应任何现有的Java类。

    二、操作符与操作符重载

    根据操作数据个数的不同,分为两种操作类型:

    1. 一元操作:即指操作数只有一个的情况
    2. 二元操作:即指操作数存在二两或多个的情况。特别说明:在存在多个操作数的情况下,会用复合运算或拆分为多个运算。

    2.1、一元操作

    一元操作:即指一个操作数的情况,

    2.1.1、简单的一元操作运算

    这里分为三种情况有三种一元操作:

    • + 表示为操作数实现一个正号的意思,其操作数为数值型
    • - 表示为操作数实现一个负号的意思,其操作数为数值型
    • ! 表示取反的意思,其操作数为boolean类型

    提供一个表格直观的展示:

    操作符 重载
    +a a.unaryPlus()
    -a a.unaryMinus()
    !a a.not()

    例:

    var a = 1
    var b = -2
    var c = true
    var d = false
    
    // 操作符实现
    println("+a = ${+a}	 -a = ${-a}	 !c = ${!c}")
    println("+b = ${+b}	 -b = ${-b}	 !d = ${!d}")
    
    // 操作符重载实现
    println("+a = ${a.unaryPlus()}	 -a = ${a.unaryMinus()}	 !c = ${c.not()}")
    println("+b = ${b.unaryPlus()}	 -b = ${b.unaryMinus()}	 !d = ${d.not()}")
    

    输出结果为:

    +a = 1	 -a = -1	 !c = false
    +b = -2	 -b = 2	 !d = true
    +a = 1	 -a = -1	 !c = false
    +b = -2	 -b = 2	 !d = true
    
    2.1.2、复杂的一元操作

    复杂的一元操作符即指,对操作数进行自增、自减操作。和Java是一样的

    这里主要有4种情况:

    • 后缀自增:表示为操作数进行自增操作,其操作数为数值型。例如:a++
    • 后缀自减:表示为操作数进行自减操作,其操作数为数值型。例如:a--
    • 前缀自增:表示为操作数进行自增操作,其操作数为数值型。例如:++a
    • 前缀自减:表示为操作数进行自增操作,其操作数为数值型。例如:--a

    提供一个表格直观的展示:

    操作符 重载 表示
    a++ a.inc() a = a.also{ a.inc() }
    a-- a.dec() a = a.also{ a.dec() }
    ++a a.inc() a = a.inc().also{ a = it }
    --a a.dec() a = a.dec().also{ a = it }

    解释:操作符++的重载为inc(),操作符--的重载为dec()。但是前缀操作和后缀操作是有着明显的区别的:

    • 后缀操作是第一次调用的时候不执行自身。在第二次开始进行自增或自减操作。
    • 前缀操作是第一次调用的时候就执行自增或自减操作

    实例:

    var a = 10
    var b = 10
    var c = 10
    var d = 10
    
    // 操作符实现
    println("a++ = ${a++} 	 b-- = ${b--} 	 ++c = ${++c} 	 --d = ${--d}")
    
    // 操作符重载方式实现,或许你看不明白上表中代码,不过这没关系,你只要记住上面前缀与后缀操作的区别就行
    a.also { a.inc() }
    b.also { b.dec() }
    c.inc().also { c = it }
    d.dec().also { d = it }
    println("a = $a 	 b = $b 	 c = $c 	 d = $d")
    

    输出结果为:

    a++ = 10 	 b-- = 10 	 ++c = 11 	 --d = 9
    a = 10 	 b = 10 	 c = 11 	 d = 9
    

    2.2 二元操作

    二元操作:即指操作数存在二两或多个的情况。

    2.2.1、简单的二元操作

    简单的二元操作有:

    • a + b,表示两个操作数相加,值得注意的是若某一个操作数为String类型时。其返回值为String类型,当且仅当两个操作数都为数值型时,其返回值才会数值型。
    • a - b,表示两个操作数相减,返回值为数值型
    • a * b,表示两个操作数相乘,返回值为数值型
    • a / b,表示两个操作数相除,返回值为数值型
    • a % b,表示两个操作数相除后的余数,官方称之为,即a模以b 。返回值为Int
    • a .. b,表示范围(区间),这里不详细说明,在下面一点的区间操作符一起讲解。

    这里提供一个表格直观的展示:

    操作符 重载
    a + b a.plus(b)
    a - b a.minus(b)
    a * b a.tiems(b)
    a / b a.div(b)
    a % b a.rem(b) 或 a.mod(b)
    a .. b a.rangTo(b)

    这里值得注意的是:a % b的重载为a.rem()a.mod()。不过a.mod()Koltin1.0版本的重载方法,现在已经弃用了,Koltin1.1以及以上版本使用a.rem()重载方法

    // 简单的二元操作
    val a = 10
    val b = 2
    val c = "2"
    val d = "Kotlin"
    
    // 操作符实现
    println("a + d = " + a + d)
    println("c + d = " + c + d)
    println("a + b = ${a + b} 	 a - b = ${a - b} 	 a * b = ${a * b} 	 a / b = ${a / b} 	 a % b = ${a % b}")
    
    // 操作符重载实现
    // println("a + d = ${a + d}") 错误:字符串模板限制只能为数值型
    println("a + b = ${a.plus(b)} 	 a - b = ${a.minus(b)} 	 a * b = ${a.times(b)} 	 a / b = ${a.div(b)} 	 a % b = ${a.rem(b)}")
    // println(a.plus(d))  错误:因为第一个操作数`a`限制了其plus()方法的参数,
    // println(d.plus(a))  正确:因为plus()方法的参数为超(Any)类型
    

    输出结果为:

    a + d = 10Kotlin
    c + d = 2Kotlin
    a + b = 12 	 a - b = 8 	 a * b = 20 	 a / b = 5 	 a % b = 0
    a + b = 12 	 a - b = 8 	 a * b = 20 	 a / b = 5 	 a % b = 0
    

    2.2.2、复合二元操作

    复合的二元操作有:

    • a += b,表示第一个操作数的的值为第一个操作数加上第二个操作数,值得注意的是若某一个操作数为String类型时。其返回值为String类型,当且仅当两个操作数都为数值型时,其返回值才会数值型。
    • a -= b,表示第一个操作数的的值为第一个操作数减去第二个操作数,返回值为数值型
    • a *= b,表示第一个操作数的的值为第一个操作数乘以第二个操作数,返回值为数值型
    • a /= b,表示第一个操作数的的值为第一个操作数除以第二个操作数,返回值为数值型
    • a %= b,表示第一个操作数的的值为第一个操作数模以第二个操作数 。返回值为Int

    这里提供一个表格直观的展示:

    操作符 表示 重载
    a += b a = a + b a = a.plus(b)
    a -= b a = a - b a = a.minus(b)
    a *= b a = a * b a = a.tiems(b)
    a /= b a = a / b a = a.div(b)
    a %= b a = a % b a = a.rem(b)

    例: 操作符实现

    var b = 2
    var a = 10
    var c = "Kotlin"
    
    // 主要演示字符串的+=
    c += a                          等价于  c = c.plus(a)
    print("c = $c 	")
    
    a += b                          等价于  a = a.plus(b)
    print("a = $a 	")
    
    a = 10
    a -= b                          等价于  a = a.minus(b)
    print("a = $a 	")
    
    a = 10
    a *= b                          等价于  a = a.tiems(b)
    print("a = $a 	")
    
    a = 10
    a /= b                          等价于  a = a.div(b)
    print("a = $a 	")
    
    a = 10
    a % b                          等价于  a = a.rem(b)
    print("a = $a 	")
    

    输出结果为:

    c = Kotlin10 	a = 12 	a = 8 	a = 20 	a = 5 	a = 0 	
    

    或许你会说这里为什么没有Kotlin的版本呢?你在看官方文档或者其他人一些博客文章的时候可能有这样a += b <=> a.plusAssign()的操作。但是我告诉你a.plusAssign()不是这样用的,你可以看源码知道primitives.kt文件中肯本就不存在plusAssign()这个方法。因为Koltin赋值不是表达式。即 a += b <=> a = a + bKotlin中是a = a.plus(b)。不过数组与集合是同时存在plus()plusAssign()这两个函数的。

    还有一点就是:如果我的第一个操作数定义为val(不可变)类型时,a += b这个表达式会编译出错。

    上面说到了在源码primitievs.kt文件中不存在plusAssign()minusAssign()timesAssign()divAssign()remAssign()这些方法。那为什么官方文档上会存在呢?这里这里不做详解,但是我会在自定义重载操作符方法的时候给大家说明,请大家详细的往下看,一些更高级的操作

    2.3、位运算操作

    位运算操作:即对一个数进行位移运算。关于这个操作符的重载函数,我在前面讲解数据类型章节的时候已经讲解过,这里就不多做累述了。没有看过的朋友请参见Kotlin——初级篇(三):数据类型详解

    2.4、区间操作

    区间操作符:即是符号..。值得注意的是这个操作符在Java中是不存在的,且两个操作数都是整型

    操作符 表示 重载
    a .. b a 到 b 中间的值 a.rangeTo(b)

    这个操作符一般用于for循环中,在条件判断中偶尔也会用到。

    例:

    val a = 1
    val b = 5
    
    // 操作符实现
    val s = 3 in a .. b     // true,因为3在区间[1,5]之内
    println("s = $s")
    for (index in a .. b){
        print("index = $index 	")
    }
    
    // 操作符重载方式实现
    val t = 3 in a.rangeTo(b)
    println("t = $t")
    for (index in a.rangeTo(b)){
        print("index = $index 	")
    }
    

    输出结果为:

    s = true
    index = 1 	index = 2 	index = 3 	index = 4 	index = 5 	
    t = true
    index = 1 	index = 2 	index = 3 	index = 4 	index = 5 
    

    当然了,这些实例都是极其简单的。我在Kotlin——初级篇(四):控制语句讲解这篇文章也是讲到过的。

    总结

    关于操作符重载,这里由于篇幅过长的原因,后面的比较操作符,以及inis、以及自定义操作符等都会在下一章讲解。敬请期待...

    这篇文章,主要讲解了Kotlin中常用的操作符以及重载方法。其中的第一部分只是介绍了其概念,在第二节在才开始讲解了其用法及实例说明。重点在于二元操作中的复合运算一节,千万不要被别人的博客和翻译文档所误导。上面的实例都是我一个一个实验过后才写出来的。实践出真理,不然我也不知道这个a += b等所
    对应的a.plusAssign(b)等会这么坑。

    参考

    这里参考了别人翻译的官方文档
    以及另外一篇很好的博文

    源代码

    如果各位大佬看了之后感觉还阔以,就请各位大佬随便star一下,您的关注是我最大的动力。
    我的个人博客Jetictors
    我的githubJetictors
    我的掘金Jetictors

    欢迎各位大佬进群共同研究、探索

    QQ群号:497071402

  • 相关阅读:
    4月份学习计划
    windows下下载安装python、 pip、nose
    Windows下怎么搭建Python+Selenium的自动化环境
    pthon之异常、文件练习题
    python 元组 字符串 字典 列表嵌套练习题1
    硬件访问服务AIDL JNI 方式
    Android 加载图片优化(二) LruCache DiskLruCache
    Android 加载图片优化(一)
    ubuntu 下 4412烧写SuperBoot
    metro WCF
  • 原文地址:https://www.cnblogs.com/Jetictors/p/8241212.html
Copyright © 2011-2022 走看看