了解Android studio 初学者零基础推荐（2）

发布于：2025-05-23 ⋅ 阅读:(13) ⋅ 点赞:(0)

在kotlin中编写条件语句

if条件语句

fun main() {
    val trafficLight = "gray"
    if (trafficLight == "red") {
    	println("Stop!")
    } else if (trafficLight == "green") {
        println("go!")
    } else if (trafficLight == "yellow"){
        println("Wait wait...")
    } else {
        println("invalid light color")
    }
}

when语句处理多分支

如果分支数量大于两个，尽可能使用when,提到代码的可读性。

fun main() {
    val trafficLight = "gray"
    when (trafficLight) {
    	"red" -> println("Stop!")
        "green" -> println("go!")
        "yellow" -> println("Wait wait...")
        else -> println("invalid light color")
    }
		
}

fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}


fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}


fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

使用if/else 和when作为表达式

fun main() {
    val trafficLightColor = "Black"

    val message = 
      if (trafficLightColor == "Red") "Stop"
      else if (trafficLightColor == "Yellow") "Slow"
      else if (trafficLightColor == "Green") "Go"
      else "Invalid traffic-light color"

    println(message)
}

fun main() {
    val trafficLightColor = "Amber"

    val message = when(trafficLightColor) {
        "Red" -> "Stop"
        "Yellow", "Amber" -> "Slow"
        "Green" -> "Go"
        else -> "Invalid traffic-light color"
    }
}

总结

Kotlin 中使用可为null性

在kotlin中声明变量时需要立即赋值。

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    val lengthOfName = favoriteActor?.length ?: 0

    println("The number of characters in your favorite actor's name is $lengthOfName.")
}

总结

kotlin使用类和对象

创建类的实例

定义类的方法和属性，和之前学到的定义函数和变量是一样的，不同的是要把函数和变量放在类的内部。

属性中的getter和setter函数

这两个函数主要是根据特殊要求的属性，进行操作，例如某个属性不能为负数，或者读取的某个属性一定为大写等。这种情况下就要定义可变属性。

定义可变属性的语法

如果你没有定义get /set 函数，编译器会自动生成get/set函数：

  • 以 val 关键字开头。
  • val 类型的变量为只读变量，因此不含 set() 函数。

定义构造函数

主要构造函数：一个类只能有一个主要构造函数（在类标头中定义）。主要构造函数可以是默认构造函数，也可以是形参化构造函数。主要构造函数没有主体（表示其中不能不包含任何代码）

定义主要构造函数的完整语法如下：

辅助构造函数：一个类可以有多个辅助构造函数。您可以定义包含形参或不含形参的辅助构造函数。辅助构造函数可以初始化类，具有包含初始化逻辑的主体。如果类有主要构造函数，则每个辅助构造函数都需要初始化该主要构造函数。

定义辅助构造函数的完整代码如下：

class SmartDevice(val name: String, val category: String) {

    var deviceStatus = "online"
	constructor(name: String, category: String, statusCode: Int) : this(name,category) {
        deviceStatus = when (statusCode) {
            0 -> "offline"
            1 -> "online"
            else -> "unkown"
        }
        print("deviceStatus = ${deviceStatus}\n")
    }
    fun turnOn() {
        println("Smart device is turned on.${name}")
    }

    fun turnOff() {
        println("Smart device is turned off.${category}")
    }
}
fun main() {
    val smartTvDevice = SmartDevice(name = "apxu", category = "ok",statusCode = 1)
    smartTvDevice.turnOn()
    smartTvDevice.turnOff()
}

实现类之间的关系

继承

定义可扩展类，需要在class前面添加 open关键字：

继承语法如下所示：

SmartTvDevice的constructor定义没有指定属性是可变还是不可变的，这说明deviceName和deviceCategory形参只是constructor形参，而不是类的属性。

子类中调用父类的方法super.functionname()

父类：

open class SmartDevice(val name: String, val category: String) {

    var deviceStatus = "online"

    open fun turnOn() {
        deviceStatus = "on"
    }

    open fun turnOff() {
        deviceStatus = "off"
    }
}

子类：

class SmartTvDevice(deviceName: String, deviceCategory: String) :
    SmartDevice(name = deviceName, category = deviceCategory) {

    var speakerVolume = 2
        set(value) {
            if (value in 0..100) {
                field = value
            }
        }

     var channelNumber = 1
        set(value) {
            if (value in 0..200) {
                field = value
            }
        }

    fun increaseSpeakerVolume() {
        speakerVolume++
        println("Speaker volume increased to $speakerVolume.")
    }

    fun nextChannel() {
        channelNumber++
        println("Channel number increased to $channelNumber.")
    }

    override fun turnOn() {
        super.turnOn()
        println(
            "$name is turned on. Speaker volume is set to $speakerVolume and channel number is " +
                "set to $channelNumber."
        )
    }

    override fun turnOff() {
        super.turnOff()
        println("$name turned off")
    }
}

可见性修饰符

public,private,protected,internal

Kotlin 提供了以下四种可见性修饰符：

  • public：默认的可见性修饰符。可让系统在任何位置访问声明。对于您想在类外部使用的属性和方法，请标记为 public。
  • private：可让系统在相同类或源文件中访问声明。

某些属性和方法可能仅在类的内部使用，而且您不一定想让其他类使用。您可以使用 private 可见性修饰符标记这些属性和方法，以确保其他类不会意外访问它们。

  • protected：可让系统在子类中访问声明。对于您想在定义它们的类及其子类中使用的属性和方法，请使用 protected 可见性修饰符进行标记。
  • internal：可让系统在相同模块中访问声明。internal 修饰符与 private 类似，但您可以从类的外部访问内部属性和方法，只要是在相同模块中进行访问即可。
为属性指定可见性修饰符

open class SmartDevice(val name: String, val category: String) {

    ...

    private var deviceStatus = "online"

    ...
}

您也可以将可见性修饰符设置为 setter 函数，并将修饰符放在 set 关键字之前。语法如下图所示：

为方法指定可见性修饰符

为构造函数指定可见性修饰符

1.修饰符在类名之后，constuctor关键字之前

2.及时构造函数没有参数，也要保留constuctor关键字和（）

open class SmartDevice protected constructor (val name: String, val category: String) {

    ...

}

为类指定可见性修饰符

internal open class SmartDevice(val name: String, val category: String) {

    ...

}

理想情况下，您应努力严控属性和方法的可见性，因此请尽可能通过 private 修饰符来声明属性和方法。如果您无法确保它们私有，请使用 protected 修饰符；如果您无法确保它们受到保护，请使用 internal 修饰符；如果您无法确保它们仅在内部使用，请使用 public 修饰符。

指定适当的可见性修饰符

定义属性委托

有很多属性的内容有相同的约束，例如：音量，频道的等都是0~100之间，如果每个属性都写一个setter，就会有很多相同的代码，为了简化代码，我们可以使用委托。

定义委托语法如下：

若要实现您可以委托实现的目标类，您必须熟悉接口。

创建接口语法如下所示：

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

class RangeRegulator(
    initialValue: Int,
    private val minValue: Int,
    private val maxValue: Int
) : ReadWriteProperty<Any?, Int> {

    var fieldData = initialValue

    override fun getValue(thisRef: Any?, property: KProperty<*>): Int {
        return fieldData
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
        if (value in minValue..maxValue) {
            fieldData = value
        }
    }
}

class SmartTvDevice(deviceName: String, deviceCategory: String) :
    SmartDevice(name = deviceName, category = deviceCategory) {

    override val deviceType = "Smart TV"

    private var speakerVolume by RangeRegulator(initialValue = 2, minValue = 0, maxValue = 100)

    private var channelNumber by RangeRegulator(initialValue = 1, minValue = 0, maxValue = 200)

    ...

}

kotlin使用函数类型和lambda表达式

fun关键字来声明函数，使用fun关键字声明函数可供调用，函数也属于数据类型，可以将函数存储在变量中，将函数传递到函数，或从函数返回函数等。这一切都可以通过lambda表达式来实现。

只需函数引用运算符::,语法如下：

fun main() {
    val trickFunction = ::trick
}

fun trick() {
    println("No treats!")
}

使用 lambda 表达式重新定义函数

lambda表达式提供了简洁的语法定义函数，不用fun关键字。我们可以直接将lambda表达式存储在变量中，不需要对其他函数进行函数引用。

fun main() {
    //val trickFunction = ::trick
    val trickFunction = trick
    trick()
    trickFunction()
}

val trick = {
    println("No treats!")
}


//fun trick() {
//    println("No treats!")
//}

在kotlin中使用函数类型和lambda表达式

如果需要将函数存储在变量中需要使用函数引用运算符（::）。语法如下所示：

fun main() {
    val trickFunction = ::trick
}

fun trick() {
    println("No treats!")
}

使用lambda表达式重新定义函数

lambda表达式提供了简洁的语法来定义函数，无需使用fun关键字。我们可以直接将lambda表达式存储在变量中，无需对其他函数进行函数引用。

在赋值运算符（=）前面，添加var或val关键字，后跟变量名称，以供我们在调用函数时使。赋值运算符（=）后面是lambda表达时，它由一对大括号构成，大括号中的内容是函数正文。语法如下：

fun main() {
    val trickFunction = trick
    trick()
    trickFunction()
}

val trick = {
    println("No treats!")
}

将函数用作数据类型

fun main() {
    val trickFunction = trick
    trick()
    trickFunction()
    treat()
}
val trick = {
    println("No treats!")
}
val treat: () -> Unit = {
    println("Have a treat!")
}

将函数作为返回值

语法：

fun main() {
    val treatFucntion = trickOrTreat(false)
    val trickFucntion = trickOrTreat(true)
    treatFucntion()
    trickFucntion()
}
fun trickOrTreat(isTrick:Boolean) -> Uint {
    if (isTrick) {
        return trick
    } else {
        return treat
    }
}
val trick = {
    println("No treats!")
}
val treat = {
    println("Have a treat!")
}

讲一个函数作为参数传递给另一个函数

fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val cupcake: (Int) -> String = {
        "Have a cupcake!"
    }

    val treatFunction = trickOrTreat(false,coins)
    val trickFunction = trickOrTreat(true,cupcake)
    treatFunction()
    trickFunction()
}
fun trickOrTreat(isTrick: Boolean, extraTreat: (Int) -> String): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        println(extraTreat(5))
        return treat
    }
}
val trick = {
    println("No treat")
}

val treat = {
    println("Have treat")
}

可为null的函数类型

fun trickOrTreat(isTrick: Boolean, extraTreat: ((Int) -> String)?): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        if (extraTreat != null) {
            println(extraTreat(5))
        }
        return treat
    }
}

fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val treatFunction = trickOrTreat(false, coins)
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}

省略lambda参数名

将lambda表达式直接传入函数

fun main() {
    val treatFunction = trickOrTreat(false, { "$it quarters" })
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}

使用尾随lambda语法

当函数类型是函数的最后一个参数时，您可以使用另一个简写选项来编写 lambda。在这种情况下，您可以将 lambda 表达式放在右圆括号后面以调用函数。语法如下图所示：

val treatFunction = trickOrTreat(false) { "$it quarters" }

使用repeat()函数

如果一个函数返回或接受另一个函数作为实参，该函数就称为高阶函数，trickOrTreat() 函数是一个高阶函数示例，因为它接受 ((Int) -> String)? 类型的函数作为参数，并返回 () -> Unit 类型的函数。

Kotlin 提供了几个有用的高阶函数，您可以利用新掌握的 lambda 知识对这些函数加以利用。

repeat() 函数就是这样一种高阶函数。repeat() 函数是使用函数表达 for 循环的简洁方式。在后续单元中，您会经常使用该函数以及其他高阶函数。repeat() 函数具有以下函数签名：

repeat(times: Int, action: (Int) -> Unit)


fun main() {
    val treatFunction = trickOrTreat(false) { "$it quarters" }
    val trickFunction = trickOrTreat(true, null)
    repeat(4) {
        treatFunction()
    }
    trickFunction()
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布