三、表达式

一. 常量和变量

  1. 变量
var a = 2

val b = 2 // 只读变量
  1. 常量
    使用 const 关键字修饰,只能定义在全局范围,只能修饰基本类型,必须立即用字面量初始化
const val b = 3 // 等同于 Java 中 static final int b = 3;
  1. 常量引用
val person = Person(18, "Andy") // person是堆上创建对象
person.age = 19 // 对象改变但引用没变
  1. 编译期和运行时常量
const val b = 3

编译时即可确定常量的值,并用值替换调用处

val c: Int

运行时才能确定值,调用处通过引用获取值

二. 分支表达式

  1. if ... else ..
    和 Java 的 if 语句一样,只是在 kotlin 中叫表达式

  2. when
    等同于 Java 中的 switch

// java
switch (a) {
  case 0: 
    c = 5;
  break
  default:
    c = 20;
}

// kotlin
when(a) {
  0 -> c = 5
  else -> c= 20
}
// 改善成:
c = when(a) {
  0 -> 5
  else -> 20
}
  1. Java 中的 when 在 kotlin 中
var x: Any = ...
c = when {
  x is String -> x.length
  x == 1 -> 100
  else -> 20
}
c = when(val input = readLine()) {
  null -> 0
  else -> input.length
}
  1. try ... catch
try {
  c = a / b
} catch (e : Exception){
  e.printStackTrace()
  c = 0
}

三. 运算符与中缀表达式

  1. 运算符
    (1)kotlin 支持运算符重载
    (2)运算符的范围仅限官方指定的符号
    可以看一下官网介绍:
    https://kotlinlang.org/docs/reference/operator-overloading.html
    比较常见的:
    (1)== 与 equals
// 这两个写法一样
"Hello" == "World"
"Hello".equals("World")

(2)"+" 与 plus
(4)in 与 contains
(5)[] 与 get

val map = mapOf(
  "Hello" to 2,
  "World" to 3)

val value = map["Hello"]
// 等同于
val value = map.get("Hello")

(6)[] 与 set

val map = mutableMapOf(
  "Hello" to 2,
  "World" to 3)

map["World"] = 4
// 等同于
map.set("World",4)

(7)> 与 compareTo

2 > 3
// 等同于
2.compareTo(3) > 0

(8)() 与 invoke

val func = fun(){
  println("Hello")
}

func()
// 等同于
func.invoke()
  1. 中缀表达式
2 to 3
infix fun <A,B> A.to(that: B): Pair<A, B> = Pair(this, that)

四. Lambda 表达式

  1. 一个普通函数
fun func(){
  println("Hello")
}
  1. 匿名函数,去掉函数名 func
fun(){
  println("Hello")
}
  1. 匿名函数的传递,此时的 func 是变量名
val func = fun(){
  println("Hello")
}
  1. 匿名函数的类型
val func: () -> Unit = fun(){
  println("Hello")
}
  1. Lambda 表达式的定义
    Java 中 Lambda 表达式是一个 AMS 格式的语法糖,kotlin 中 Lambda 是一个匿名函数的语法糖。
// Java
Runnable lambda = () -> {
  System.out.println("Hello")
};

// Kotlin
val lambda = {
  println("Hello")
}
  1. Lambda 表达式的类型,返回值的类型就是函数体最后一行返回类型,返回值就是最后一行
    (1)没有参数的
val lambda: () -> Unit = {
  println("Hello")
}

(2)有参数的

// java
interface Function1 {
  void invoke(int p);
}
Function1 f1 = (p) -> {
  System.out.println(p);
}

// Kotlin
val f1: (Int) -> Unit = {
  p: Int -> println(p)
}
//或
val f1: Function1<Int,Unit> = {
  p -> println(p)
}
//或
val f1= {
  p: Int -> println(p)
}

(3)参数省略形式

val f1: Function1<Int,Unit> = {
  println(it)
}

五. 案例

为 String 实现四则运算

operator fun String.minus(right: Any?) 
  = this.replaceFirst(right.toString(), "")

operator fun String.times(right: Int): String {
  return (1..right).joinToString(""){this}
}

operator fun String.div(right: Any?): Int {
  val right = right.toString()
  return this.windowed(right.length,1) {
    it == right
  }.count{ it }
}

fun main() {
  val value = "HelloWorld World"

  println(value - "World")

  println(value * 2)

  println(value / "l")


}
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。