Kotlin快速上手
一、Kotlin基础
1.数据类型声明
在Kotlin中要定义一个变量需要使用var关键字
//定义了一个可以修改的Int类型变量
var number = 39
如果要定义一个常量可以使用val关键字,等价于Java的final关键字.
val name = "miku"
//给val定义的常量再次赋值就会提示错误
name = "ミク"
在Kotlin中要声明一个数据类型必须要使用var或者val来定义.
2.数据类型
Kotlin的数据类型分为基本数据类型和引用数据类型.
基本数据类型:Boolean、Number、Char
引用类型:可空类型、Object、数组类型
Kotlin中的Number类型泛指所有跟数字有关的类型,int、float、double、long
//java.lang.Integr Int--->int
var intNumber:Number = 39
//java.lang.Float Float--->float
var floatNumber:Number = 39.0f
//java.lang.Double Double--->double
var doubleNumber:Number = 39.000000000000000
//java.lang.Long Long--->long
var longNumber:Number = 39L
2.1.Kotlin预定义的基本数据类型
var intType:Int = 39 //int
var shortType:Short = 39 //short
var byteType:Byte = 0 //byte
var boolType:Boolean = true //boolean
var stringType:String = "miku" //String
var floatType:Float = 39f //float
var doubleType:Double = 39.0000000000 //double
var longType:Long = 39L //long
var numberType:Number = 39 //Integr、Float、Double、Long
var charType:Char = '0' //char
字符串拼接,通过${}直接引用变量,不再需要引号 + 引号的方式
val name = "komine"
val text = "私の名前は${name}と申します。"
print(text)
2.2.元组
元组是一个固定长度,且不能被修改的数据结构
//二阶元组
var person1 = Pair("komin",16)
//三阶元组
var person2 = Triple("komine",18,"女")
person2.first //第一个元素的值
person2.second //第二个元素的值
person2.third //第三个元素的值
Kotlin的元组其实就是一个泛型对象的封装.通过反编译生成的.class文件可以看出,二阶元组其实是对应Pair类,
三阶元组其实是对应Triple类. first、second、third分别对应getFirst()、getSecond()、getThrid()方法.
如果用Java来实现的话差不多就是下面这个样子,可以看到,元组不过是Kotlin在源码阶段提供的一种更方便的语法而已.
public class MyPair<First,Second> {
private final First mFirstValue;
private final Second mSecond;
public MyPair(First first, Second second){
this.mFirstValue = first;
this.mSecond = second;
}
public First getFirst() {
return mFirstValue;
}
public Second getSecond() {
return mSecond;
}
}
2.3.可空类型
Kotlin定义了一种可以为空的数据类型,只有声明为可空类型的变量才能将null赋值于它.默认声明的类型全部都是非空类型.
var str:String? = null //在类型的后面添加?表示该类型可空
print(str?.length) //通过?.方式来访问可空类型的成员方法或变量,如果str是null则后面的调用会返回null,不会报错
//如果你明确知道,str在某个时候肯定不为空,可以通过!!操作该变量,但如果str为空则会抛出空指针异常
print(str!!.length)
2.4.数组
在Kotlin中定义一个数组非常简单.调用arrayOf()即可创建一个数组.
var names = arrayOf("miku","rin","luka")
var numbers = arrayOf(16,14,17)
//跟Java一样,也可以通过[下标]的方式访问数组的元素
print(names[0])
//创建一个指定长度的数组,值为null
var fixedArray = arrayOfNulls<Int>(39)
//创建一个空数组
var emptyArray = emptyArray<Int>()
2.5.集合
Kotlin的集合分为可变集合和不可变集合.可变集合都是由Mutable开头的.
可变集合
//MutableList集合,该集合可以包含相同元素
var mutableList = mutableListOf("miku","rin","luka")
//键值对,包含Key和Value的集合
var mutableMap = mutableMapOf<String,String>()
var linkedHashMap = linkedMapOf<String,String>() //等价mutableMap
//MutableSet集合,该集合不会出现相同的元素,如果集合已经包含某个值,添加的时候会忽略添加操作
var mutableSet = mutableSetOf<Object>()
var linkedSet = linkedSetOf<String>() //等价mutableSet
不可变集合
//List集合,无法进行添加操作
var list = listOf("miku","rin","luka")
//Map集合,无法进行添加操作
var map = mapOf(Pair("miku",16))
var linkedMap =
//Set集合,无法进行添加操作
var set = setOf<Int>(0,1,2,3,4,5,6,7,8,9)
2.5.1扩展方法
toList() 返回一个不可变List集合
toMap() 返回一个不可变的Map集合
toSet() 返回一个不可变的Set集合
2.5.2集合操作
类似.Net中的Linq查询
any 判断集合中是否有满足条件的元素
var mutableList = mutableListOf("miku","rin","luka")
val result:Boolean = mutableList.any(){
it == "miku" //有一个元素的值为miku
}
all 判断集合中的所有元素是都否满足条件
var mutableList = mutableListOf("miku","rin","luka")
val result:Boolean = mutableList.all(){
it.isNotEmpty() //元素的长度大于0
}
none 判断集合中的所有元素是否都不满足条件,满足则返回true
var mutableList = mutableListOf("miku","rin","luka")
val result:Boolean = mutableList.none(){
it.isNotEmpty() //元素的长度等于0 false
}
count 返回满足条件的元素个数,类似sql中的select count(*) from table where xx = xx
var mutableList = mutableListOf("miku","rin","luka")
val result: Int = mutableList.count {
it == "miku" //返回集合中元素值为miku的元素个数
}
reduce 从第一个元素到最后一个元素的累加
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result: Int = numbers.reduce() {
sum: Int, i -> sum + i //sum:声明一个用于接收累加结果的变量 i->:循环每一个元素,sum + i:累加每个元素到sum
}
reduceRight 从最后一个元素到第一个元素的累加
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result: Int = numbers.reduceRight() {
sum: Int, i -> sum + i
}
fold 跟reduce类似,不过可以设置初始化,从初始值开始累加
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result: Int = numbers.fold(10){
sum, i -> sum + i
}
foldRight...
sumOf 返回集合中所有元素的总和,该集合的元素必须是Number类型
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.sumOf{
it
}
dropWhile 去除满足条件的元素,直到不满足为止,返回剩余元素的集合
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.dropWhile {
it < 5
}
filter 过滤不满足条件的元素,返回满足元素的新集合
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.filter {
it < 5
}
filterNot 过滤满足条件的元素,返回不满足元素的新集合
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.filterNot {
it < 5
}
take 返回从第一个元素开始的N个元素
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.take(5) //{1,2,3,4,5}
takeLast 返回从最后一个元素开始的N个元素
...
takeWhile 返回从第一个元素开始符合给定条件的元素
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.takeWhile {
it > 0
}
drop 返回去掉N个元素之后的列表
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.drop(1)
dropLastWhile 返回从最后一个元素开始,去掉满足条件的元素
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.dropLastWhile {
it > 5
}
slice 保留指定下标对应的元素
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.slice(listOf(1,2,3))
map 将集合中的元素通过某种方法转换后,返回一个新集合
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
val result = numbers.map {
val diff = 10
it * diff
}
后续更新...
2.6.类型转换
Kotlin通过as关键字将一个类型转换为另一个类型.
var numberType:Number = 39
var intType:Int = numberType as Int
Kotlin可以通过 is 关键字自动完成装箱的操作.
open class GameConsole{
}
class PS4 : GameConsole() {
}
class NintendoSwitch : GameConsole() {
public val version = "10.0"
}
fun main(args: Array<String>) {
val gameConsoles = arrayOf(PS4(),NintendoSwitch())
val gameConsole = gameConsoles[1]
//会自动完成装箱操作,在当前调用范围内将gameConsole识别NitendoSwitch,可以直接访问对象的成员,不需要手动转换
if(gameConsole is NintendoSwitch){
print(gameConsole.version)
}
}
3.运算符
Kotlin特有的运算符有===、!==
3.1.恒等和非恒等
判断两个对象之间的地址是否相等
var obj1 = Object()
var obj2 = Object()
if(obj1 === obj2){
println("恒等")
}
if(obj1 !== obj2){
println("非恒等")
}
3.2.位运算
只有Int和Long类型可以使用.
val i:Int = 10
val j:Int = 20
val result = i shl j //有符号左移
result = i shr j //有符号右移
result = i ushr //无符号右移
result = i and j //按位与
result = i or j //按位或
result = i xor //按位异或
result = i inv j //按位取反
3.3.区间运算符
表示某个值是否在某个范围或者集合之中.
//i >=0 && i <= 100
if(i in 0..100){
print(i)
}
数组或者集合是否包含某个值
val names = arrayOf("miku","rin","luka")
if("miku" in names){
print("包含")
}
4.条件语句
when是Kotlin提供类似Java中Switch的条件语句.它能做到Switch能做到的所有事,并且还提供了更方便的语法.
fun test(i:Int){
when(i){
// case 1
1 ->{
}
//case 2
2 -> {
}
//i >= 3 && i <= 9
in 3..9 ->{
}
//default
else ->{
}
}
}
when如果不提供参数也可以当作if elseif使用
5.循环语句
跟Java的使用差别不大,一般配合区间运算符in来更简便的使用
val names = arrayOf("miku","rin","luka")
for (name in names){
println(name)
}
//遍历数组或集合带索引
for ((index,name) in names.withIndex()){
}
val i = 0
for (i in 0..99){ //i = 0;i <= 99;i++
println(i)
}
var i = 10
while (i > 0){
println(i)
i--
}
do {
i--
println(i)
}while (i > 0)
//foreach
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
numbers.forEach{ it ->
println(it)
}
//foreach 带索引
val numbers = mutableListOf(1,2,3,4,5,6,7,8,9)
numbers.forEachIndexed{index, i ->
println("index[${index}] = $i")
}
6.函数
Kotlin中定义函数使用fun关键字.如果方法不需要返回值可以不写,或者写Unit
fun sum(number1:Int,number2:Int):Int{
return number1 + number2
}
6.1默认参数
Kotlin中添加了默认参数的支持,当一个方法指定了参数的默认值,则调用的时候可以不提供该参数的值.
要使用默认参数,在参数的后面添加=进行赋值操作.
fun sum(number1:Int,number2:Int = 0):Int{
return number1 + number2
}
6.2可变参数
和Java一样,Kotlin也提供可变参数的支持,使用vararg关键字声明可变参数
fun sum(vararg number:Int){
//number在使用的时候其实是一个数组类型的变量,可以调用数组的一些方法
}
6.3Lambda表达式
Lambda表达式可以看作是一个匿名的函数.
var execute:(Int,Int) -> Int = {x,y ->
x * y
}
println(execute(10,10))
如果函数只有一个参数时可以省略不写,这个时候用it来表示
var execute:(String) -> String = {
it
}
println(execute("komine"))
6.4高阶函数
Kotlin支持将函数作为参数或者返回值,包含这样操作的函数称为高阶函数.将函数作为参数时使用双冒号::来传递.
fun main(args: Array<String>) {
call(::method)
}
fun call(m:(number:Int) -> Int){
println(m(39))
}
fun method(number:Int):Int{
return number * number
}
也可以使用Lambda表达式来表示一个匿名参数.
call{number: Int -> return@call number * number }
Kotlin本身也提供了一些高阶函数供我们使用,比如apply函数,在Android中初始化变量可以这样写.
var paint = Paint().apply {
this.isAntiAlias = true
this.color = Color.BLACK
this.style = Paint.Style.STROKE
this.strokeWidth = 10f
}
6.5内联函数
Kotlin支持内联函数,跟C++的内联函数作用一致,因为函数的执行有压栈和出栈的步骤,会带来一定的开销.
在将函数声明为内联函数的时候,在编译的时候,编译器会在所有调用函数的地方,将函数调用直接替换成函数体的内容.
一般来说,内联函数中的嵌套逻辑不能太复杂,C++的内联函数是否替换是由编译器决定的,Kotlin会按照inline关键直接替换.
通过反编译生成的class文件可以看到,内联函数就是直接将有函数调用的地方,直接替换成函数体的内容.
fun main(args: Array<String>) {
test()
}
inline fun test(){
for (i in 0..99){
println(i)
}
for (i in 0..99){
println(i)
}
for (i in 0..99){
println(i)
}
for (i in 0..99){
println(i)
}
for (i in 0..99){
println(i)
}
for (i in 0..99){
println(i)
}
}
反编译结果
如果函数的参数中有函数参数类型或者Lambda表达式,也可以使用noinline关键字指定不参数内联的函数.
crossinline关键字待补充...
二、Kotlin进阶
1.协程
协程是跑在线程上的产物,它拥有自己的栈内存和局部变量,被称为轻量级Thread.它的内部实现是由编译器来完成的.
在使用协程之前,需要添加依赖
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1'
简单用法
GlobalScope.launch(context = Dispatchers.Default, start = CoroutineStart.DEFAULT) {
//延时1.5秒
delay(1500L)
println("当前线程:" + Thread.currentThread().name)
println("World")
}
println("Hello,")
println("当前线程:" + Thread.currentThread().name)
Thread.sleep(3000L)
context:协程的上下文,这里设置的是CoroutineDispatch协程运行的线程调度器,它有四种线程模式:
Dispatchers.Default //默认
Dispatchers.IO //工作在其他线程
Dispatchers.Main //主线程
Dispatchers.Unconfined //不指定就是在当前线程,kotlinx.coroutines.DefaultExecutor
也可以自己创建一个协程上下文,这个上下文也可以理解为协程所运行在的线程.
val context = newSingleThreadContext("single")
start:启动模式,默认是CoroutineStart.DEFAULT,就是创建之后就会启动
CoroutineStart.DEFAULT
CoroutineStart.ATOMIC
CoroutineStart.UNDISPATCHED
CoroutineStart.LAZY 懒加载模式,它会返回一个Job对象,你可以手动开启它.
val job = GlobalScope.launch(context = Dispatchers.Default, start = CoroutineStart.LAZY) {
//延时1秒
delay(1500L)
println("当前线程:" + Thread.currentThread().name)
println("World")
}
println("Hello,")
println("当前线程:" + Thread.currentThread().name)
job.start()
Thread.sleep(3000L)
GlobalScope.async 带返回值
suspend fun main(args: Array<String>) {
val result = GlobalScope.async {
delay(1000L)
return@async "async"
}
println(result.await())
Thread.sleep(3000)
}
async会阻塞当前协程,会等待当前协程执行完毕,调用await()的函数需要使用suspend关键字修饰.
协程的挂起,suspend表示当前协程被挂起.
fun main(args: Array<String>) {
GlobalScope.launch {
//get方法是被suspend修饰的,表示调用时会将当前协程挂起
val str = get()
//会等待get()执行完毕才会继续执行
printStr(str)
}
//防止进程结束
Thread.sleep(3000L)
}
suspend fun get():String{
println("get()正在执行..")
delay(1000)
return "data"
}
suspend fun printStr(str:String){
println(str)
}
协程之间也可以嵌套,调用await会阻塞外部协程,代码还是会按顺序运行
fun main(args: Array<String>) {
GlobalScope.launch {
val str = GlobalScope.async {
return@async get()
}.await()
GlobalScope.launch{
printStr(str)
}
}
//防止进程结束
Thread.sleep(3000L)
}
suspend fun get():String{
println("get()正在执行..")
delay(1000)
return "data"
}
suspend fun printStr(str:String){
println(str)
}
待补充...
2.面向对象
2.1类的声明
和很多语言一样,Kotlin使用class关键字来声明一个类.
class Person{
}
2.1.1内部类
class Person{
//内部类的声明使用inner关键字修饰
inner class Info{
}
}
要实例内部类需要先实例化主类
val person = Person("miku")
val info = person.Info()
2.1.2数据类
通过data class 修饰的类称为数据类,数据类必须提供一个有参的构造函数.数据类一般不定义方法.
data class MyData(val height:Float,val weight:Float,val money:Float){
}
2.1.3枚举类
跟Java的枚举类使用基本相同.
enum class DirectionEnum{
East{
override fun move() {
//name:当前枚举常量的名称
//ordinal:当前枚举常量的值
println("name$name")
println("value:$ordinal")
}
},
South{
override fun move() {
}
},
West{
override fun move() {
}
},
North{
override fun move() {
}
};
abstract fun move();
}
2.1.4密封类
emm...不知道怎么用,后面补充
2.1.5抽象类
使用abstract关键字声明一个抽象类
open abstract class Person(name:String, age:Int){
}
2.2构造函数
Kotlin的构造函数可以直接写在类名的后面,称为主构造函数,这样定义的构造函数是没有方法体的,要执行初始化操作
可以使用init代码块.
open class Person(name:String, age:Int){
init {
println("主构造函数执行...")
println("name:${name},age = $age")
}
}
2.2.1 副构造函数
通过constructor定义的构造函数称为副构造函数,需要间接调用主构造函数进行初始化
fun main(args: Array<String>) {
val person = Person("miku")
}
open class Person(name:String, age:Int){
init {
println("主构造函数执行...")
println("name:${name},age = $age")
}
//副构造函数需要间接调用主构造函数通过this关键字
constructor(name:String) : this(name,16) {
println("副构造函数执行...")
}
}
2.2.2 构造函数私有化
如果不想类外部访问到类的构造函数,可以使用 private constructor来修饰主构造函数
class ListDialog<T>private constructor(context: Context) :Dialog(context) {
}
2.3继承
如果想让一个类可以被其他类继承,需要在类的声明之前加上open关键字,使用:冒号来继承
open class Person{
open fun sodayo(){}
}
class Student : Person() {
}
如果子类想重写父类定义的方法,该方法必须是open关键字修饰的方法,抽象方法的修饰符默认是open.
2.4静态成员
Kotlin没有提供static关键字,如果想实现Java那样的静态成员调用可以使用companion object代码块来定义静态成员.
在Kotlin中称为伴生对象,用伴生对象的成员来代替静态成员.
class PS4{
companion object{
val FIRMWARE_VERSION:Float = 10.0f
fun boot(){
println("boot...")
}
}
}
跟Java一样,然后通过类名调用静态成员
PS4.boot()
PS4.FIRMWARE_VERSION
2.5接口
使用interface来声明一个接口.与Java的用法并无二致
interface Callback{
fun onSuccess()
fun onFailed()
}
3.泛型
基本使用和Java一致
class Data<T>(private val data:T){
fun get():T{
return data
}
}
val data1 = Data("String")
println(data1.get())
val data2 = Data(16)
println(data2.get())
3.1out和in关键字
Kotlin中使用out和in来代替? extends 和? super使用,具体用法跟Java是类似的.
fun main(){
val ps4List = mutableListOf<PS4>()
setGameConsoles(ps4List)
val gameConsoles = getGameConsoles()
for (gameConsole in gameConsoles){
val ps4 = gameConsole as PS4
ps4.play()
}
}
// out ----> ? extends GamesConsole
fun setGameConsoles(gamConsoles:MutableList<out GameConsole>){
}
//in -----> ? super PS4
fun getGameConsoles():MutableList<in PS4>{
val gameConsoles = mutableListOf<GameConsole>()
gameConsoles.add(PS4())
gameConsoles.add(PS4())
return gameConsoles
}
open class GameConsole{
open fun play(){
}
}
class PS4 : GameConsole(){
override fun play() {
println("ps4 play...")
}
}
class NintendoSwitch : GameConsole(){
override fun play() {
println("ns play...")
}
}
4.委托
其实就是代理设计模式.
4.1委托的使用场景
Java中的代理模式实现
//支付接口
public interface IPay {
void pay();
}
//支付宝支付
public class AliPay implements IPay{
private float mMoney;
public AliPay(float money){
mMoney = money;
}
@Override
public void pay() {
Log.d("Alipay","支付宝支付" + mMoney + "元...");
}
}
//微信支付
public class WeChatPay implements IPay{
private float mMoney;
public WeChatPay(float money){
mMoney = money;
}
@Override
public void pay() {
Log.d("WeChatPay","微信支付" + mMoney + "元...");
}
}
//代理对象
public class ProxyPay implements IPay{
private IPay mPay;
public ProxyPay(IPay pay){
mPay = pay;
}
@Override
public void pay() {
mPay.pay();
}
}
Kotlin的代理模式实现
interface IPay{
fun pay()
}
class Alipay(private val money:Float) :IPay{
override fun pay() {
println("支付宝支付$money...")
}
}
class WeChatPay(private val money: Float) :IPay{
override fun pay() {
println("微信支付$money...")
}
}
class PayDelegate(private val play:IPay) :IPay by play{
//什么都不需要做,系统帮我们完成一系列操作
}
可以看出,Kotlin的委托其实就是简化了代理模式的实现过程.
4.2属性委托
将属性的赋值操作交给其他类来代理.可以通过其他类来统一控制属性的取值,合法性等等操作.
基本使用
//声明一个接口,不一定要接口也可以是一个类
interface IPropertyDelegate
class PS4 :IPropertyDelegate{
var version:String by DataDelegate()
}
class NintendoSwitch :IPropertyDelegate{
var version:String by DataDelegate()
}
class DataDelegate {
private var version:String = ""
operator fun setValue(thisRef: IPropertyDelegate, property: KProperty<*>, value: String) {
this.version = value
}
operator fun getValue(thisRef: IPropertyDelegate, property: KProperty<*>): String {
return this.version
}
}
当给PS4或者NintendoSwitch对象的version赋值的时候,就会去到DataDelegate对象的setValue()方法,达到统一赋值的操作,相同的操作不需要在每个类都写一次
val ps4 = PS4()
ps4.version = "7.55"
println(ps4.version)
val ns = NintendoSwitch()
ns.version = "13.0"
println(ns.version)
5.其他
5.1扩展函数
给某个类添加一个扩展函数,其效果跟成员函数调用一致.一般定义到一个统一的文件中,不需要先定义一个类型,直接写就好
//给String扩展了一个first方法
fun String.first():Char{
return this[0]
}
println("komine".first())
5.1扩展属性
给某个类添加一个扩展属性
val Int.dp:Int
get(){
//简单模拟一下,开发中不是这么计算的
return this * 1.5f.toInt()
}
比如给Int类型添加了一个dp的扩展属性,可以将int值转换为对应的dp
val width = 39.dp
待更新...
