Kotlin 基本要素

最新推荐文章于 2024-05-22 10:17:53 发布
最新推荐文章于 2024-05-22 10:17:53 发布
阅读量361 收藏
点赞数
分类专栏： Kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwj_hewo/article/details/97259014
版权

1 函数和变量

      函数

//     fun max(a: Int, b: Int) : Int {
//          return if (a > b) a else b
//     }

//     fun max(a : Int, b: Int):Int = if (a>b) a else b

fun max(a : Int, b: Int) = if (a>b) a else b

fun main(){
    println(max(10,22))
}

      变量

          可变变量和不可变量

          声明变量的关键字有两个 ：
          • val （来自 value） 一一不可变引用。使用 val 声明的变量不能在初始化之后再次赋值。它对应的是 Java 的 final 变量。

          • var （来自 variable） 一一可变引用。这种变量的值可以被改变。这种声明对应的是普通（非 final）的 Java 变量。 

fun main(){
    //定义了 val 变量的代码块执行期间， val 变量只能进行唯一一次初始化。
    val isSuccess=false
    val message:String
    message= if (isSuccess) "Success" else "fail"
    println(message)
    // val 引用自身是不可变的，但是它指向的对象可能是可变的。
    val languages = arrayListOf("Java")
    languages.add("Android")
    println(languages)
}

       注意：var 关键字允许变量改变自己的值，但它的类型改变不了。

2 类和属性

       类

         把数据和处理数据的代码封装成一个单一的实体

//这种类（只有数据没有其他代码）通常被叫作值对象
class Dog(val name: String, var isOld: Boolean)

      属性

         Kotlin 中，属性是头等的语言特性，类中声明一个属性和声明一个变量一样：使用 val 和 var 关键字。声明成 val 的属性是只读的，而 var 属性是可变的。

class Cat {
    var name: String=""
    var age: Int = 0
}

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


fun main(){
    val cat=Cat()
    cat.age=15
    cat.name="88"
    println(cat.age)

    val teacher=Teacher("sss",44)
    println(teacher.name)
}

    自定义访问器

class Rectangle (private val height: Int, private val width: Int){
    val isSquare: Boolean
        get() = height == width
}

fun createRandomRectangle() : Boolean{
    val random = Random()
    return Rectangle(random.nextInt(), random.nextInt()).isSquare
}

   枚举类

          简单枚举类

enum class Color {
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

          带属性枚举类

enum class Color(val r: Int, val g: Int, val b: Int) {
    RED(255,0,0), ORANGE(255,165,0),
    YELLOW(255,255,0), GREEN(0,255,0),
    BLUE(0,0,255);
    // 给枚举类定义一个方法
    fun rgb()= (r * 256 +g ) * 256 + b
}

fun main(){
    val color=Color.BLUE.rgb()
    println(color)
}

   注意：如果要在枚举类中定义任何方法，就要使用 分号把枚举常量列表和方法定义分开

        使用"when"处理枚举类

fun main(){
    println(getMnemonic(ColorOthers.YELLOW))
     println(getWarmth(ColorOthers.BLUE))
}

fun getMnemonic(color: ColorOthers) =
        when(color){
            ColorOthers . RED ->"Richard"
            ColorOthers.ORANGE ->"Of"
            ColorOthers.YELLOW ->"York"
            ColorOthers .GREEN ->"Gave"
            ColorOthers.BLUE ->"Battle"
            ColorOthers.INDIGO ->"In"
            ColorOthers.VIOLET ->"Vain"
        }

fun getWarmth(color: ColorOthers) =
    when(color){
        ColorOthers.RED, ColorOthers.ORANGE, ColorOthers.YELLOW -> "warm"
        ColorOthers.GREEN -> "neutral"
        ColorOthers. BLUE, ColorOthers.INDIGO, ColorOthers.VIOLET ->"cold "
    }

    “when”结构中使用任意对象

fun mix(c1: ColorOthers,c2 : ColorOthers)=
    when (setOf(c1,c2)){
        setOf(RED, YELLOW) -> ORANGE
        setOf(YELLOW, BLUE) ->GREEN
        setOf(BLUE, VIOLET) -> INDIGO
        else -> throw Exception ("Dirty color")
    }

fun main(){
    println(mix(YELLOW,RED)) // ORANGE
}

    枚举类ColorOthers

enum class ColorOthers {
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

     不带参数的“when”

import XXX.shapes.ColorOthers.*
fun main(){
    println(mixOptimized(BLUE,VIOLET))
}

fun mixOptimized(c1: ColorOthers,c2 : ColorOthers)=
    when {
        (c1 == RED && c2 == YELLOW) || (c1 == YELLOW && c2 == RED) -> ORANGE
        (c1 == YELLOW && c2 == BLUE) || (c1 == BLUE && c2 == YELLOW) -> GREEN
        (c1 == BLUE && c2 == VIOLET) || (c1 == VIOLET && c2 == BLUE) -> INDIGO
        else -> throw Exception ("Dirty color")
    }

    智能转换 (Kotlin 中，如果你检查过一个变量是某种类型， 后面就不再需要转换它，可以就把它当作你检查过的类型使用)

    智能转换只在变量经过 is 检查且之后不再发生变化的情况下有效。 Kotlin 中，使用 is 检查来判断一个变量是否是某种类型。

fun main(){
   println(eval(Sum(Sum(Num(1) , Num (2)) , Num (4))))
}
fun eval(e: Expr): Int {
   if (e is Num) {
       val n = e as Num
       return n.value
   }
   if (e is Sum) {
       return eval(e.right) + eval(e.left)
   }
   throw IllegalArgumentException("Unknown expression")
}

   接口类  Expr

interface Expr {
    class Num(val value: Int) :Expr
    class Sum(val left: Expr, val right :Expr) :Expr
}

   用if 表达式改写eval 方法

fun eval(e: Expr): Int =
   if (e is Num){
      e.value
   }else if (e is Sum){
      evalIf(e.left)  + evalIf(e.right)
   }else{
      throw IllegalArgumentException("Unknown expression")
   }

用when 表达式改写eval 方法

 fun eval(e: Expr): Int =
   when (e){
     is Num -> e.value
     is Sum -> evalWhen(e.left) + evalWhen(e.right)
     else -> throw IllegalArgumentException("Unknown expression")
   }

代码块作为“if”和“when”的分支

 fun evalMix(e: Expr): Int =
    when (e){
        is Num ->{
            println("num: ${e.value}")
            e.value
        }
        is Sum ->{
           val left= evalMix(e.left)
           val right= evalMix(e.right)
           println("sum: $left + $right")
           left+right
        }
        else ->throw IllegalArgumentException("Unknown expression")
    }


fun main(){
    println(evalMix(Sum(Sum(Num(1) , Num (2)) , Num (4))))
}

---------------------------
System.out: num: 1
System.out: num: 2
System.out: sum: 1 + 2
System.out: num: 4
System.out: sum: 3 + 4
System.out: 7

 3   迭代事物： while循环和for循环

     while 循环

    var sum: Int=0
    var condition: Boolean = true
    while(condition){//当condition为true时执行循环体
      for (i in 1..100){
          sum += i
          if (i == 100)
          condition=false
      }
    }

    do-while 循环

    //循环体第一次会无条件执行，此后，当condition为ture时会执行
    do {
        for (i in 1..100){
            sum += i
            if (i == 100)
            condition=false
        }
    }while (condition)

     迭代数字：区间

   在Kotlin 中没有常规的Java for 循环。在这种循环中，先初始化变量，在循环的每一步更新它的值，并在值满足某个限制条件时退出循环。 为了替代这种最常见的循环用法， Kotlin 使用了区间的概念。区间本质上就是两个值之间的问隔，这两个值通常是数字 ： 一个起始值， 一个 结束值。使用..运算符来表示区间： 

val i=1..10
fun fizzBuzz(number: Int)= when{
    number % 15 == 0 -> "FizzBuzz"
    number % 3 == 0 -> "Fizz"
    number % 5 == 0 -> "Buzz "
    else ->"$number"
}

fun main(){
    for (i in 1..100){
        println(fizzBuzz(i))
    }
    for (i in 100 downTo 1 step 2){
        println(fizzBuzz(i))
    }
}

      迭代数字：map

for main(){
    val binaryReps = TreeMap<Char,String>()
    for (c in 'A'..'F'){
        val binary = Integer.toBinaryString(c.toInt())
        binaryReps[c] = binary
    }
    for ((letter, binary) in binaryReps){
        println("$letter = $binary")
    }
    --------------------------------------------------
    A = 1000001
    B = 1000010
    C = 1000011
    D = 1000100
    E = 1000101
    F = 1000110  

    //迭代集合的同时跟踪当前项的下标
    val list= arrayListOf("10","11","1001")
    for ((index, element) in list.withIndex()){
        println("$index = $element")
    }
}

     使用 in 检查集合和区间的成员    

             使用 in 运算符来检查一个值是否在区间中，或者它的逆运算，!n，来检查这个值是否不在区间中。

fun main(){
    println(isLetter('q'))
    println(isNotDigit('x'))
    //用in 检查作为when分支
    println(recognize('$'))
}

fun isLetter(c: Char)= c in 'a'..'z' || c in 'A'..'Z'
fun isNotDigit(c: Char) = c !in '0'..'9'
fun recognize(c: Char) = when(c) {
    in '0'..'9' -> "It’s a digit!"
    in 'a'..'z',in 'A'..'Z' -> "It’s a letter!"
    else -> "I don’t know..."
}

区间也不仅限于字符。假如有一个支持实例比较操作的任意类（实现了 java. lang.Comparable 接口），就能创建这种类型的对象的区间。如果是这样的区间， 并不能列举出这个区间中的所有对象。

 println("Kotlin" in "Java".."Scala") // true
 println("Kotlin" in setOf("Java","Scala")) // false

 4   Kotlin中的异常

     Kotlin的异常处理

fun main(){
    val number = 10
    val percentage =
        if (number in 0..100)
            number
        else
            //Kotlin 中 throw 结构是一个表达式，能作为另一个表达式 的一部分使用 
            throw IllegalArgumentException("A percentage value must be between 0 and 100: $number ")
}

     try、catch 和 finally

            Kotlin 并不区分受检异常和未受检异常。不用指定函数抛出的异常， 而且可以处理也可以不处理异常。

fun readNumber(reader: BufferedReader): Int?{
    return try {
        val line=reader.readLine()
        Integer.parseInt(line)
    } catch (e: NumberFormatException){
        null
    } finally {
        reader.close()
    }
}
fun main(){
    val reader= BufferedReader(StringReader("258"))
}

      try作为表达式

fun readNumber(reader: BufferedReader){
  //Kotiin 中的 try 关键字就像 if 和 when 一样，引入了一个表达式，可以把它的值赋给一个变量
   val number = try {
       Integer.parseInt(reader.readLine())
   }catch (e: NumberFormatException){
       //catch代码块之后函数不会继续执行
       return
   }
   println(number)
}
fun main(){
   val reader = BufferedReader(StringReader("not a number"))
   readNumber(reader)
}
fun readNumber(reader: BufferedReader){
  //Kotiin 中的 try 关键字就像 if 和 when 一样，引入了一个表达式，可以把它的值赋给一个变量
   val number = try {
       Integer.parseInt(reader.readLine())
   }catch (e: NumberFormatException){
       null
   }
   println(number)
}
fun main(){
   val reader = BufferedReader(StringReader("not a number"))
   readNumber(reader) // null
}

重要内容概况

• fun 关键字用来声明函数。 val 关键字和 var 关键字分别用来声明只读变量 和可变变量。

• 在变量名称前加上$前缀或者用 $｛｝包围一个表达式，来把值注入到字符串中。

• if 是带返回值的表达式。

• 在检查过变量具有某种类型之后不必显式地转换它的类型，编译器自动帮你完成。

• 简洁的语法 1. . 5 会创建一个区间。区间和数列允许 Kotlin 在 for 循环中使 用统一的语法和同一套抽象机制，并且还可以使用 in 运算符    和！in 运算符来检查值是否属于某个区间。

• Kotlin 中的异常处理和 Java 非常相似，除了 Kotlin 不要求你声明函数可以抛出的异常。

 

参考内容：Kotlin 实战

下一篇：函数的定义与调用：https://blog.csdn.net/lwj_hewo/article/details/97916709

 

 

 

lwj_bj
关注
专栏目录
Kotlin入门(8)空值的判断与处理
aqi00的博客
07-20 2万+
上一篇文章介绍了如何对循环语句进行操作，末尾还演示了发现空串时直接继续下一循环，只是在初始化字符串数组时使用了“val poem2Array:Array = ***”，该表达式不免令人疑惑，为何这里要在String后面加个问号？由此，本文就Kotlin如何判断和处理空值，再做进一步的深入探讨。以往的开发工作之中，少不了要跟各种异常作斗争，常见的异常种类包括空指针异常NullPointerExcep
3.1 Kotlin条件判断语句 if when
不一样的烟火
06-09 2208
什么叫二元判断？就是一个表达式的判断结果只有两种是和否，有一句俗话叫做“如果爱，请深爱；如果不爱，请离开”。这就是一个典型的二元判断，我们用kotlin抽象表示出来：
Kotlin-3逻辑判断
Clear亮的博客
01-15 397
Kotlin学习 —— 3.逻辑判断 一、If else 与java不同点： 1.替代java三元表达式 fun test() { var param1: Int = 10 var result = if (param1 > 5) "大于5" else "小于5" LogUtil.e(result) } 2.可赋值给变量 fun test(){ val max = if (param1 > param2) { param1 * 2 } e
Kotlin从入门到放弃 第二节 Kotlin中的判断语句
weixin_42561996的博客
09-01 1052
首先学习一下if， Kotlin中的if和java中的if几乎没有什么区别。这段代码不需要过多的说明，只要是有一点编程基础都可以看懂。现在看起来和java中的if是一样的，但是前面说的“几乎没有”什么区别，所以还是有区别的。接下来看下不一样的地方。在Kotlin中if语句是可以有返回值的，这个返回值就是if语句每个条件中的最后一行代码。因此我们可以简化一下代码。到这里我们的代码看起来精简很多了，但实际上我们还可以做的更好。
Kotlin 对象判断方法总结
最新发布
m0_50774720的博客
05-22 334
作用：检查字符串是否为空或仅包含空白字符，包括 null 值。作用：用于检查字符串是否为 null 或者其长度是否为零。作用：检查集合或字符串是否包含至少一个元素或字符。作用：检查字符串是否非空且不包含仅空白字符。作用：检查字符串是否为空或仅包含空白字符。作用：检查集合或字符串是否为空。
Kotlin 协程
mlxfora的博客
03-02 427
协程是可以由程序自行控制挂起 恢复的程序 协程可以用来实现多任务的协作执行 协程可以用来解决异步任务控制流的灵活转移 可以让异步代码同步化 可以降低异步程序的设计复杂度 异步逻辑 同步写法 协程的分类 按调用栈 有栈协程：每个协程会分配单独的调用栈 类似线程的调用栈 无栈协程 挂起点状态通过闭包或者对象保存 按调用关系 对称协程：调度权可以转移给任意协程 协程之间对等关系 非对称协程 调度权只能...
kotlin t class.java_Kotlin与Java互操作笔记
weixin_33417488的博客
02-13 567
Kotlin官方一直以100% interoperable with Java™作为第一要素，他不是像Scala一样把类库都自己实现一遍，而是通过扩展函数、函数编程等特性对现有的Java进行增强，同时保持对Java的100%兼容。正是这个特性，我们可以在一个项目中同时使用Java和Kotlin，一个大型的项目，如果换一种语言来实现的话，这个代价是非常大的。但是对于一个Java项目，你可以某一部分使...
Kotlin实战总结
qq_22194581的博客
02-02 459
第二章 Kotlin基础 2.1 基本要素函数与变量 2.1.1 Hello, World! 使用fun声明方法 参数类型放在参数名称后面 数组用Array类进行表示 println 替代 System.out.println 可以省略每行代码结尾的分号 函数不需要一定放在一个类里面 fun main(args: Array&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;
Kotlin入门实例大全(完结)
Shawn的博客
10-23 6336
Kotlin Cases(更新中) Shawn IDE: IntelliJ IDEA 2018.2.3 Kotlin: 1.2.71 JDK: 1.8.0_161 强烈推荐Kotlin官方文档 代码见github 注: 本文中实例部分参考于 runoobJava实例 Kotlin入门实例Kotlin Cases(更新中)1 字符串1.1 字符串比较 StringCompare1.2 查...
Kotlin入门指南：Android开发中文版
在类和对象部分，书中详细阐述了类继承、接口实现、数据类等概念，帮助开发者理解和掌握面向对象编程的核心要素。同时，Anko库的引入让开发者可以更便捷地编写Android代码，特别是其提供的扩展函数功能，能有效提高...
Kotlin 类型检测与类型转换
热门推荐
Lud的博客
07-04 1万+
类型检测 is 运算符 is运算符可以检查对象A是否是特定的类型，还可以检查一个对象是否属于某种数据类型（Int、String等）。 is运算符相当于java中的 instanceof Kotlin中我们可以在运行时通过 is 或者 !is 来检查对象是否符合所需的类型 println("abc" is String) println("abc" !is String) ...
Kotlin中的空判断
abs625的博客
11-26 9599
Kotlin中的空判断前言字符串空判断空字符串：""纯空格字符串：" "null字符串：null值为null字符串："null"集合空判断集合值为null集合size为0尾巴 前言 Kotlin中一切皆对象，这里我们理解成对象的空判断。由于Kotlin是空安全的，普通可空对象可以通过 ?. 来避免产生空指针异常。 ... val p: Person? = null println("age is : ${p?.age}") ... 就算p对象为null，运行的时候也不会产生空指针异常而导致应用退出，打印如
java-Kotlin：如果条件为true,则将变量转换为不可为空
weixin_44109689的博客
12-21 877
我的意思是跟随. 考虑以下代码： // Can be a Long or null val data1= param1.toLongOrNull() val data2= param2.toLongOrNull() val dataN= paramN.toLongOrNull() // Proceed with the action if ALL of the data are...
Kotlin语言基础（三）——语言特性
一切皆是定数的博客
09-14 1394
kotlin部分语言特性
kotlin正则的使用
luoyanda的博客
10-23 4195
1.正则一些常用的转义符。 .:任意单个字符 ?:0或一个前置元素 +:1或n个前置元素 *:任意个前置元素 ^:后置元素起始 $:后置元素结束 [ab]:a或b [a-h]:a到h任意一个都可以,-表示区间，没有就只有明确写出的字符才符合 \s:空格符 \w：大小写字母和数字，[a-zA-Z0-9] \d:数字，大小写（哈哈哈哈哈哈哈哈） {n,m}:前置元素最少出现n次，最多出现m次 2.常用的方法 1：matches：只有全部的待匹配字符符合模型才匹配，返回true，比较严格。 2：containsM
Kotlin中的空判断处理
Android菜鸟的专栏
10-14 4494
Kotlin中的一个伟大创前举就是空指针的处理，在代码的编译阶段就能检测可能出现的空指针问题，示例代码如下： data class Person(var name: String? = null) fun sayHello(name: String) { println("Hello $name") } fun main() { val person = Person("Even") if (person.name != null) { sayHello(pers
Kotlin 语法的简单介绍
qq_35742975的博客
07-14 332
1.  var相当于Java中的 public        常见的类型有 Java 中为 public boolean aBoolean=true; Kotlin 中为 var boolean: Boolean = true     Java 中为 public int aInt =0;                          K
Kotlin第二弹：Kotlin基本数据类型
m0_58941767的博客
09-05 2401
基本数据类型包括Byte、Short、Int、Long、Float、Double本节就到这里了，希望大家可以好好掌握这一节的Kotlin知识，消化完之后就准备开始下一节的学习吧。
Kotlin - 布尔类型和逻辑运算
Moriafly的博客
07-01 2852
布尔类型 Boolean 是一种只有两个可能值的数据类型： true 和 false 。 它也被称为逻辑类型。 val t = true // t is true val f = false // f is false println(t) // true println(f) // false 注意，不能将整数值赋给布尔变量。在 Kotlin 中，0 不等于 false 。 逻辑运算符 布尔类型的变量通常用于构建带有逻辑运算符的逻辑表达式。 Kotlin 有四个逻辑运算符 NOT、 AND、 OR
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值