Kotlin笔记

gmf532196

208人浏览 · 2021-09-07 15:35:49

gmf532196 · 2021-09-07 15:35:49 发布

Kotlin:
应用程序的build.gradle：
　　apply plugin:'com.android.application'
apply plugin:'kotlin-android'
模块build.gradle:
buildscript{
   ext.kotlin_version = '1.1.2'
   repositories{
       jcenter()
   }
   dependencies{
   classpath 'com.android.tools.build:gradle:2.3.1'
       classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
   }

kotlin(java)JVM下运行, kotlin(javascript)脱离JVM运行
kotlinc, kotlinc-jvm交互式

kotlin源文件不需要相匹配的目录和包，源文件可以放在任何文件目录。
如果没有指定包，默认为 default 包。

默认导入：有多个包会默认导入到每个 Kotlin 文件中：
　　kotlin.*
   kotlin.annotation.*
   kotlin.collections.*
   kotlin.comparisons.*
   kotlin.io.*
   kotlin.ranges.*
   kotlin.sequences.*
   kotlin.text.*

在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小
位操作符
对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

   shl(bits) – 左移位 (Java’s <<)
   shr(bits) – 右移位 (Java’s >>)
   ushr(bits) – 无符号右移位 (Java’s >>>)
   and(bits) – 与
   or(bits) – 或
   xor(bits) – 异或
   inv() – 反向

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。
与 Java 不同的是，Kotlin 中数组是不协变的（invariant）。
除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：
[] 运算符代表调用成员函数 get() 和 set()。

字符串: 和 Java 一样，String 是不可变的
Kotlin 支持三个引号 """ 扩起来的字符串，支持多行字符串，
String 可以通过 trimMargin() 方法来删除多余的空白
默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入

函数定义
　使用关键字 fun，参数格式为：参数 : 类型

   fun sum(a: Int, b: Int): Int { // Int 参数，返回值 Int
       return a + b
   }
   表达式作为函数体，返回类型自动推断：

fun sum(a: Int, b: Int) = a + b

public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型
无返回值的函数(类似Java中的void)：

   fun printSum(a: Int, b: Int): Unit {
       print(a + b)
   }

   // 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
   public fun printSum(a: Int, b: Int) {
       print(a + b)
   }

可变长参数函数，用 vararg 关键字进行标识：

lambda(匿名函数)
　　fun main(args: Array<String>) {
       val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
       println(sumLambda(1,2)) // 输出 3
   }

定义常量与变量：
　变量　：var <标识符> : <类型> = <初始化值>
　常量：只能赋值一次的变量(类似Java中final修饰的变量
　　val <标识符> : <类型> = <初始化值>
　
　常量与变量都可以没有初始化值,但是在引用前必须初始化；
　编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

Kotlin 支持单行和多行注释；与 Java 不同, Kotlin 中的块注释允许嵌套。

字符串模板：$ 表示一个变量名或者变量值
　$varName 表示变量值　；　
　　　var a = 1
　　　val s1 = "a is $a"
　${varName.fun()} 表示变量的方法返回值:
　　　a = 2
val s2 = "${s1.replace("is", "was")}, but now is $a"

NULL检查机制: Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理
//类型后面加?表示可为空
   var age: String? = "23"
   //抛出空指针异常
   val ages = age!!.toInt()
   //不做处理返回 null
   val ages1 = age?.toInt()
   //age为空返回-1
   val ages2 = age?.toInt() ?: -1

当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null。
当 str 中的字符串内容不是一个整数时, 返回 null:
fun parseInt(str: String): Int? {
// ...
}

Any是所有类的超类，默认有三个函数 : equals() / hashCode() / toString()
//注：Any 不是 java.lang.Object。

如果一个类要被继承，可以使用 open 关键字进行修饰。
open class Base(p: Int) // 定义基类
class Derived(p: Int) : Base(p)

接囗：Kotlin 接口与 Java 8 类似，使用 interface 关键字定义接口，允许方法有默认实现。
实现接口：一个类或者对象可以实现一个或多个接口。
接口中的属性：只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性：
   interface MyInterface{
       var name:String //name 属性, 抽象的
   }

   class MyImpl:MyInterface{
       override var name: String = "runoob" //重写属性
   }
函数重写：实现多个接口时，可能会遇到同一方法继承多个实现的问题

Kotlin 扩展：可以对一个类的属性和方法进行扩展，且不需要继承或使用 Decorator 模式。
扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响

扩展函数：在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式：
   fun receiverType.functionName(params){
       body
   }
receiverType：表示函数的接收者，也就是函数扩展的对象
functionName：扩展函数的名称
params：扩展函数的参数，可以为NULL

   class User(var name:String)
   /**扩展函数**/
   fun User.Print(){
       print("用户名 $name")
   }
扩展函数是静态解析：并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明
也可以定义一个空类：class Empty
class Runoob {
       var name: String = ……
       var url: String = ……
       var city: String = ……
   }
   我们可以像使用普通函数那样使用构造函数创建类实例：
   val site = Runoob() // Kotlin 中没有 new 关键字
要使用一个属性，只要用名称引用它即可
site.name // 使用 . 号来引用
site.url

Koltin 中的类可以有一个主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后:
class Person constructor(firstName: String) {}
如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。
class Person(firstName: String) {}

类对象的创建：首先会按顺序执行类中init代码块，然后再执行构造方法里代码，并且我可以在init代码块中使用类声明的属性

getter 和 setter 都是可选
如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，因为它是只读的。
var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]
var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1 // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int? // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1 // 类型为 Int 类型,默认实现 getter

枚举类最基本的用法是实现一个类型安全的枚举。
枚举常量用逗号分隔,每个枚举常量都是一个对象。
   enum class Color{
       RED,BLACK,BLUE,GREEN,WHITE
   }
每一个枚举都是枚举类的实例，它们可以被初始化：
   enum class Color(val rgb: Int) {
       RED(0xFF0000),
       GREEN(0x00FF00),
       BLUE(0x0000FF)
   }

Kotlin 中的枚举类具有合成方法，允许遍历定义的枚举常量，并通过其名称获取枚举常数。

   EnumClass.valueOf(value: String): EnumClass // 转换指定 name 为枚举值，若未匹配成功，会抛出IllegalArgumentException
   EnumClass.values(): Array<EnumClass> // 以数组的形式，返回枚举值
   获取枚举相关信息：

val name: String //获取枚举名称
val ordinal: Int //获取枚举值在所有枚举数组中定义的顺序
自 Kotlin 1.1 起，可以使用 enumValues<T>() 和 enumValueOf<T>() 函数以泛型的方式访问枚举类中的常量：

enum class RGB { RED, GREEN, BLUE }

companion object也是替代java中的static变量用的。静态内部类