android开发---Kotlin语言基础语法

目录

数据打印

变量

函数

程序逻辑控制

  if

 when

循环

---

数据打印

IDE采用的androidStudio 可自行官网下载

https://developer.android.google.cn/studio/archive?hl=zh-cn

1. 新建项目

2. 添加一个main方法，main()函数的左边出现了一个运行标志的小箭头。现在我们只要点击一下这个小箭

头，并且选择第一个Run选项，就可以运行这段Kotlin代码了

快速上手：没有安装编译器可以选择线上开发 https://try.kotlinlang.org

fun main () { println("hello world") }

变量

在Kotlin中定义变量的方式和Java区别很大，在Java中如果想要定义一个变 量，需要在变量前面声明这个变量的类型，比如说int a表示a是一个整型变量，String b表示b是一个字符串变量。而Kotlin中定义一个变量，只允许在变量前声明两种关键字：val和var。

val（value的简写）用来声明一个不可变的变量，这种变量在初始赋值之后就再也不能重新赋值，对应Java中的final变量。

var（variable的简写）用来声明一个可变的变量，这种变量在初始赋值之后仍然可以再被重新赋值，对应Java中的非final变量。

java	Kotlin	数据类型
int	Int	整型
long	Long	长整型
short	Short	短整型
float	Float	单精度浮点型
double	Double	双精度浮点型
boolean	Boolean	布尔型
char	Char	字符型
byte	Byte	字节型

Kotlin会自动判断数据类型 当然可以采用手动指定的形式 如下所示

fun main() { val a : Int = 10 println("a =" + a) }

函数

fun main() {
 val a = methodName(10,1)
 println("a=$a")
}

fun methodName(param1: Int, param2: Int): Int {
 return param1+param2
}

fun main() { ... }

• fun: 这是定义函数的关键字。无论你要定义什么函数，都需要用 fun 来声明。
• main: 这是函数的名字。在 Kotlin 中，main 函数是程序的入口点。当你运行一个 Kotlin 程序时，它首先会执行 main 函数中的代码。
• () { ... }: 函数名后面的括号里可以包含参数，但这里 main 函数没有任何参数。大括号 { ... } 包含了函数的主体部分，即实际执行的代码。
• val a = methodName(10, 1): 调用 methodName 函数，并将返回的结果赋值给变量 a。这里传递了两个参数：10 和 1。
• println("a=$a"): 打印变量 a 的值到控制台

fun methodName(param1: Int, param2: Int): Int { ... }

• 函数的参数列表。这个函数接收两个参数：

  • param1: Int: 参数 param1 的类型是 Int，即整数类型。
  • param2: Int: 参数 param2 的类型也是 Int。

• : Int: 函数的返回类型。这里的 Int 表示这个函数会返回一个整数值。

输出结果：

程序逻辑控制

  if

与java不同的是 Kotlin的if是有返回值的

fun main() {
    val a : Int = 10
    val c : Int = 1
    val b = methodName(a, c)
    println(b)

}


fun methodName(num1: Int , num2: Int) : Int{
    val value = if (num1 > num2) {
        num1
    }else {
        num2
    }
    return value
}

 when

如果你熟悉 Java，你可能会发现 Java 中的 switch 语句有一些局限性。传统的 switch 语句在以下几个方面不够理想：

1. 类型限制：在 Java 中，switch 语句只能用于整型（int 和 short 等）、字符型（char）以及从 Java 7 开始支持的字符串（String）。对于其他数据类型，switch 不适用。

2. 缺乏默认处理：switch 语句中的每个 case 需要显式地添加 break 语句，否则会导致“穿透”现象，执行完当前 case 后会继续执行下一个 case，这容易导致意外的错误和难以追踪的 bug。

在 Kotlin 中，这些问题得到了解决，when 语句提供了更强大的功能和更简洁的语法。具体来说：

1. 类型灵活性：Kotlin 的 when 语句支持多种数据类型，包括整型、字符型、字符串、甚至是自定义对象和范围。你可以用它处理更复杂的条件判断，而不必受限于 switch 语句的类型限制。

2. 自动处理：Kotlin 的 when 语句自动处理了类型匹配，并且不需要像 switch 那样手动添加 break。每个 when 分支都是独立的，不会自动“穿透”到下一个分支，从而避免了 switch 中常见的错误。

3. 类型匹配：when 语句支持更复杂的匹配模式，如范围匹配、类型检查等，使得代码更加简洁易读。你还可以在 when 语句中使用任意表达式作为条件，而不仅仅是常量。

Java：

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3; // Example input

        // Traditional switch statement
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day");
                break;
        }
    }
}

 Kotlin：

fun main() {
    val day = 3 // Example input

    // Kotlin when statement
    when (day) {
        1 -> println("Monday")
        2 -> println("Tuesday")
        3 -> println("Wednesday")
        4 -> println("Thursday")
        5 -> println("Friday")
        6 -> println("Saturday")
        7 -> println("Sunday")
        else -> println("Invalid day")
    }
}

循环

在 Java 中，我们主要使用两种循环语句：while 循环和 for 循环。Kotlin 也提供了这两种循环，但在 for 循环方面，Kotlin 对 Java 的 for 循环进行了很大的改进和优化。首先，我们来简要介绍一下 Kotlin 的 while 循环，因为它的用法与 Java 中的 while 循环几乎没有区别，所以我们这里不再详细讲解。如果你对 while 循环不太熟悉，通常在 C、C++ 或其他主流编程语言中，它们的用法是类似的。

接下来，我们重点介绍 Kotlin 中的 for 循环。在 Kotlin 中，for 循环与 Java 中的 for-i 循环有所不同。Kotlin 省略了 Java 中常用的 for-i 循环，而 for-each 循环则被改进为更为强大的 for-in 循环。我们只需学习 for-in 循环的用法即可。

在深入了解 for-in 循环之前，我们需要先了解一个 Kotlin 中的概念——区间。区间是 Kotlin 中一个非常实用的特性，它在 Java 中是没有的。我们可以使用如下 Kotlin 代码来定义一个区间：

val range = 0..10

这段代码定义了一个从 0 到 10 的区间，其中两个端点都是闭合的，也就是说 0 和 10 都包含在这个区间内。用数学符号表示就是 [0,10][0, 10][0,10]。这种语法虽然看起来有些特别，但在 Kotlin 中这是完全合法且非常常用的。

区间在 for-in 循环中发挥着重要作用，我们可以利用区间来简化循环逻辑，避免使用传统的计数器变量。接下来我们将详细介绍如何在 for-in 循环中使用这些区间，以及它们如何简化循环操作。

fun main() {
 for (i in 0..10) {
 println(i)
 }
}

Kotlin 中可以使用 until 关键字来创建一个左闭右开的区间

val range = 0 until 10

上述代码表示创建了一个 0 到 10 的左闭右开区间，它的数学表达方式是 [0, 10) 。修改 main() 函

数中的代码，使用 until 替代 .. 关键字，你就会发现最后一行 10 不会再打印出来了。

默认情况下， for-in 循环每次执行循环时会在区间范围内递增 1 ，相当于 Java for-i 循环中

i++ 的效果，而如果你想跳过其中的一些元素，可以使用 step 关键字：

fun main() {
    for (i in 0 until 10 step 2) {
        println(i)
    }
}

上述代码表示在遍历 [0, 10) 这个区间的时候，每次执行循环都会在区间范围内递增 2 ，相当于

for-i 循环中 i = i + 2 的效果。

.. 和 until 关键字都要求区间的左端必须小于等于区间的右端，也就

是这两种关键字创建的都是一个升序的区间。如果你想创建一个降序的区间，可以使用 downTo

关键字，用法如下：

fun main() {
 for (i in 10 downTo 1) {
 println(i)
 }
}