Kotlin学习——流程控制,when,循环,range工具 & kt里的equals & if实现类似三元表达式的效果

在这里插入图片描述

Kotlin 是一门现代但已成熟的编程语言,旨在让开发人员更幸福快乐。 它简洁、安全、可与 Java 及其他语言互操作,并提供了多种方式在多个平台间复用代码,以实现高效编程。

https://play.kotlinlang.org/byExample/01_introduction/02_Functions

其他关于kt的博客文章如下:

  • Kotlin学习——hello kotlin & 函数function & 变量 & 类 + 泛型 + 继承
  • Kotlin学习——流程控制,when,循环,range工具 & kt里的equals & if实现类似三元表达式的效果

目录

  • 引出
    • Data Classes 数据类
    • Enum classes 枚举类
    • Sealed classes 密封类
    • Object Keyword 对象
      • 对象表达式 object Expression
      • 对象声明 object Declaration
      • 伴随对象 Companion Objects
  • 总结

引出


1.kt中的数据类,提供很多默认的常用方法;
2.kt里可以使用枚举类;
3.密封类,只能在该类中进行实例化;
4.对象表达式,对象声明,伴随对象;

Data Classes 数据类

数据类使创建用于存储值的类变得容易。这样的类会自动提供用于复制、获取字符串表示和在集合中使用实例的方法。

  • 使用数据标识符,data 修饰类
  • toString是自动生成的
  • 拷贝的时候,可以更改某些特性的值
  • 生成的componentN函数,可以按照声明的顺序获取属性的值

Kotlin学习——流程控制,when,循环,range工具 & kt里的equals & if实现类似三元表达式的效果_第1张图片

package com.tianju.classKt

/**
 * 使用数据标识符,data 修饰类
 */
data class User(val name: String, val id: Int) {

    // 重写equals方法
    override fun equals(other: Any?): Boolean {
        return other is User && other.id == this.id
    }
}

fun main() {
    val user = User("peter",1)
    // 自动生成toString方法
    println(user)

    val shir = User("xueLi",1)
    val per = User("peter",1)

    println(shir.hashCode())
    println(per.hashCode())
    // id相同 两个实体类就相同
    println(shir == per)

    println(user.copy())
    // 拷贝出一个新的对象,引用不是同一个
    println(user.copy() === user)

    // copy的时候可以改某些属性值
    println(user.copy("shir"))
    println(user.copy(id=123))

    // 自动生成component1方法,按照顺序获取
    println("user name is ${user.component1()}")
    println("user id is ${user.component2()}")

}

Enum classes 枚举类

枚举类用于对表示有限组不同值(如方向、状态、模式等)的类型进行建模。

  • 通过类名访问枚举常量
  • 使用when语句时,编译器可以推断when表达式是否是穷举的,这样就不需要else情况了
package com.tianju.classKt

/**
 * 定义一个枚举类
 */
enum class State {
    RUNNING,WALKING,SWING
}

fun main() {
    val state = State.RUNNING
    val msg = when(state){
        State.SWING -> "he is swing"
        State.WALKING -> "he is walking"
        State.RUNNING -> "he is running"
    }

    println(msg)
}

具有属性和方法的枚举类

package com.tianju.classKt

/**
 * 具有属性和方法的枚举类
 */
enum class Color(val rgb:Int) {
    RED(0xFF0000),
    GREEN(0X00FF00),
    BLUE(0X0000FF),
    YELLOW(0XFFFF00);

    fun containsRed(): Boolean {
        // RED和YELLOW的RGB值共享第一位(FF)
        return (this.rgb and 0XFF000 !=0)
    }
}

fun main() {
    val red = Color.RED
    // 默认的toString返回常量的名称,这里是“RED”
    println(red)
    println(red.containsRed())

    // 一路点 过去,类似于python
    println(Color.BLUE.containsRed())
    println(Color.YELLOW.containsRed())
}

Sealed classes 密封类

密封类可以限制继承的使用。一旦声明了一个密封的类,就只能在声明密封类的同一个包中对其进行子类化。它不能在声明密封类的包之外进行子类化。

  • 使用关键字sealed 定义一个密封类
  • 不需要else的情况,因为密封类的所有可能的子类都被覆盖了
package com.tianju.classKt

/**
 * 使用关键字sealed 定义一个密封类
 */
sealed class Mammal(val name:String)

// 猫猫
class Cat(val catName:String):Mammal(catName)
// 人类
class Human(val humanName:String,val job:String):Mammal(humanName)

fun greetMammal(m: Mammal): String {
    // 不需要else的情况,因为密封类的所有可能的子类都被覆盖了
    when(m){
        is Human -> return "hello ${m.humanName} work is ${m.job}"
        is Cat -> return "hello ${m.catName} work is eating"
    }
}

fun main() {
    println(greetMammal(Cat(catName = "Arya")))
}

Object Keyword 对象

定义一个类,然后创建该类的多个实例

package com.tianju.classKt

import java.util.Random

class LuckNum {
    fun getNum(){
        var num = Random()
        println(num.nextInt())
    }
}

fun main() {
    // 创建实例
    val a1 = LuckNum()
    val a2 = LuckNum()

    a1.getNum()
    a2.getNum()
}

对象表达式 object Expression

关于单例:

  • Singleton模式:它确保即使有两个线程试图创建该类的一个实例,也只能创建它。
  • 在Kotlin中实现这一点,您只需要声明一个对象:没有类,没有构造函数,只有一个惰性实例。为什么懒惰?因为它将在访问对象时创建一次。否则,它甚至不会被创建。
package com.tianju.classKt

/**
 * 对象表达式
 */
fun nowPrice(normalDay: Int, discountDay: Int): Unit {

    val dayRate = object {
        val normal:Int = 30*normalDay
        val discount:Int = 100*discountDay
    }

    val total = dayRate.normal + dayRate.discount

    println("total price is $total")
}

fun main() {
    nowPrice(10,1)
}

对象声明 object Declaration

对象声明,不是表达式,不能在变量赋值中使用。可以使用它来直接访问其成员:

package com.tianju.classKt

/**
 * 创建一个对象声明
 */
object DoAuth{
    // 创建一个方法
    fun takeParams(name:String,psd:String){
        println("the name is $name, the password is $psd")
    }
}

fun main() {
    DoAuth.takeParams("PET","123")
}

伴随对象 Companion Objects

类中的对象声明定义了另一种有用的情况:伴随对象。从语法上讲,它类似于Java中的静态方法:使用对象的类名作为限定符来调用对象成员。

package com.tianju.classKt

/**
 * 伴随对象,类似于java中的静态方法
 */
class BigBen {
    // 定义一个伴随对象,名字可以省略
    companion object {
        fun getBongs(nTimes: Int){
            for (i in 1..nTimes){
                println("Hello $i")
            }
        }
    }
}


fun main() {
    // 通过 点. 的方式进行调用
    BigBen.getBongs(10)
}

总结

1.kt中的数据类,提供很多默认的常用方法;
2.kt里可以使用枚举类;
3.密封类,只能在该类中进行实例化;
4.对象表达式,对象声明,伴随对象;

你可能感兴趣的:(SpringBoot,kotlin,学习,微信)