android之kotlin编程

android之kotlin编程

1.开发环境

android stdio，windows，java，kotlin

2.安装Kotlin插件

在Android Studio的快速开始菜单中，选择Configure>Plugins：（快捷键ctrl+ait+s>Plugins）。下载安装Kotlin（必须） 和 Kotlin Extensions for Android两个插件。

Kotlin插件安装成功后，new中有两个Kotlin相关选项：

1.“KotlinFile/Class”：一般Kotlin类

2.“Kotlin Activity”：Activity类

3.配置Kotlin

1.在工程build.gradle配置文件中（是工程的，不是module）：

在buildscript{}中增加：ext.kotlin_version = '1.0.5-2'//kotlin，可以先用这个版本，有更新软件会提示升级。

在dependencies {}中增加：classpath"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"//kotlin

修改后如下：

buildscript {
    ext.kotlin_version = '1.0.5-2'//kotlin
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.2'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"//kotlin
    }
}

2.在需要使用kotlin的module的build.gradle中配置

在开头增加：apply plugin:'kotlin-android'//kotlin

在dependencies {}中添加：compile"org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"

完成配置。

4.使用kotlin编程

1.Java转成Kotlin

官方建议不要转。

除了语法以外，其他基本相似，java可以使用的库函数资源，kotlin一样可以使用。使用方法一样。

接下来不懂kotlin语法的可以在网上学习一下。

2.简单kotlin写的activity

package com.advance.star.integralsys.kotlin

import android.os.Bundle
import android.support.design.widget.FloatingActionButton
import android.support.design.widget.Snackbar
import android.support.v7.app.AppCompatActivity
import android.support.v7.widget.Toolbar
import com.advance.star.integralsys.R

class KotlinActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_kotlin)
        val toolbar = findViewById(R.id.toolbar) as Toolbar
        setSupportActionBar(toolbar)

        val fab = findViewById(R.id.fab) as FloatingActionButton
        fab.setOnClickListener { view ->
            Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                    .setAction("Action", null).show()
        }
    }

}

3.kotlin的关键字、运算符、常用类型等等简介

关键字	作用	案例
package	指定包路径	package com.test.kotlin
import	引入类	import android.os.Bundle.*
class	定义一个类，类名不必与文件名相同	class KotlinClass{}
var	定义变量	var a=1 | var a:int = 1 | var a:int  a=1
val	定义常量	val a=1 | val a:int = 1 | val a:int  a=1
fun	1.定义函数 2.方法体只有一条语句，并且自动推测返回类型 3.如果方法是一个public的，则必须明确写出返回类型 4.返回一个没有意义的值（类似Java中的void） 5.如果是返回Unit类型，则可以省略(对于public方法也是这样)	1.fun sum(a: Int, b:Int): Int {     return a + b } 2.fun sum(a: Int, b: Int) = a + b 3.public fun sum(a: Int, b: Int): Int = a + b 4.fun printSum(a:Int, b: Int): Unit {     print(a + b) }
Double	64	1.2 | 1.5e10
Long	64 | 大写 L  |十六进制：0x |二进制：0b |不支持8进制	1L | 0x01 | 0b0000 0001
Float	32 | 用 f或者 F标记	1.3f
Int	32
Short	16
Byte	8
identityEquals	1.判断实例相同，仅物理空间相同才相同 2.在Java平台数字是物理存储为JVM的原始类型，除非我们需要一个可空的引用（例如int？）或泛型. 后者情况下数字被装箱（指的是赋值的时候把实例复制了一下，不是相同实例）。装箱数字不会保存它的实例	1.val a: Int = 100 print(a identityEquals a) // Prints 'true' val boxedA: Int? = a val anotherBoxedA: Int? = a print(boxedA identityEquals anotherBoxedA) // !!!Prints 'false'!!! 2. val a: Int = 100 print(a == a) // Prints 'true' val boxedA: Int? = a val anotherBoxedA: Int? = a print(boxedA == anotherBoxedA) // Prints 'true'
不可空类型	int，long,float,short,double
可空类型	Integer，Long，Float，Double
=	赋值，在逻辑运算时也有效
==	等于运算，比较的是值，而不是引用
===	完全等于运算，不仅比较值，而且还比较引用，只有两者一致才为真
显式转换	Kotlin不支持隐式扩大转换,转换需要显式处理 toByte(): Byte toShort(): Short toInt(): Int toLong(): Long toFloat(): Float toDouble(): Double toChar(): Char	ar a: Byte = 10 var b: Int = a //编译错误 //可以显示转换的去扩大类型 var b: Int = a.toInt()
运算符	Kotlin支持标准的算数操作符，并在相应的类上定义为成员函数（但编译器会针对运算进行优化，将函数调用优化成直接的算数操作）。  对于按位操作(bitwise operation)，没有特别的符号来表示，而是直接使用命名函数.	val x = (1 shl 2) and 0x000FF000 //已经支持位运算操作 (只能对 Int 或者 Long 使用) shl(bits) – signed shift left (Java's <<) shr(bits) – signed shift right (Java's >>) ushr(bits) – unsigned shift right (Java's >>>) and(bits) – bitwise and 位与 or(bits) – bitwise or 位或 xor(bits) – bitwise xor 位异或 inv() – bitwise inversion 位反转
Characters	Characters 用 Char来表示；用单引号表示一个Character；可以调用显示转换把Character转换为Int。         跟数字类型相同，Char类似与java的基本类型char，Char?类似于Java引用类型Character，从非空类型Char到可空类型Char?的转换需要装箱操作。	var charP: Char = 'a' // fun decimalDigitValue(c: Char): Int {   if (c !in '0'..'9')     throw IllegalArgumentException("Out of range")   return c.toInt() - '0'.toInt() // Explicit conversions to numbers }
Booleans	跟java一样，Boolean类型有两种值：true和 false。支持”||”,”&&”,”!”三种运算。
Array	跟Java的Array类型，它有get、set函数（使用时可以用[]，通过符号重载的约定转换）以及其他的有用的成员函数，也有size属性。        可以使用库函数arrayOf ()来创建一个包含数值的数组；或者arrayOfNulls<T>()可以创建一个指定大小，元素都为空的数组；或者使用函数来创建一个数组	//可以使用下面方式定义一个数组 var a1: Array<String> = arrayOf("data1", "data2") var a2 = arrayOfNulls<String>(10) var a3 = Array(10, {i -> (i + i).toString()})
原始类型的数组	Kotlin有专门的类来表示原始类型的数组，避免了装箱开销: ByteArray, ShortArray, IntArray等等.这些类和Array并没有继承关系,但是它们有同样的方法属性集.它们也都有相应的工厂方法	varintA = intArrayOf(0, 1, 2)
String	字符串用String表示。字符串是不可变的。         字符串的原始字符可以使用操作符访问： str[i].字符串可以使用for{: .keyword }循环遍历	var str: String ="info" for(c in str) {      println(c) }
转义字符串	可能由转义字符、原生字符串、换行和任意文本；转义字符串很像java的String；转义方式采用传统的反斜杠。	val str = "Hello, world!\n"
原生字符串	使用三个引号(""")包括，内部没有转义，可以包含换行和任何其他文本	val text =""" for (c in "test info")     println(c)  """
模板表达式	字符串可以包含模板表达式，即一些小段代码，会求值并把结果合并到字符串中。模板表达式以$符号开始，包含一个简单的名称；或者用花括号扩起来，内部可以是任意表达式	val i = 1 val str = "i =$i" // evaluates to "i = 1" // val s ="abc" val str = "$s.length is ${s.length}"// evaluates to "abc.length is 3"
Java与Kotlin的类型映射(原始数据)
Java中非原始类型的内置类型与Kotlin的映射
集合类型的映射
数组类型的映射
If表达式	在Kotlin中，if{: .keyword }是一个表达式，它会返回一个值；最后一行的表达式作为返回值；可以代替三元运算符 (如 ? 三元表达式)。	// Traditional usage var max = a if (a < b)   max = b // With else var max: Int if (a > b)   max = a else   max = b // As expression val max = if (a > b) a else b //if{: .keyword }的分支可以是代码段,最后一行的表达式作为段的返回值 val max = if (a > b) {     print("Choose a")     a   }   else {     print("Choose b")     b   }
For循环	for{:.keyword } 循环可以对任何提供迭代器(iterator)的集合进行遍历 for{: .keyword }可以循环遍历任何提供了迭代器的集合。         Ø  有一个成员函数或者扩展函数iterator()，它返回一个类型         Ø  有一个成员函数或者扩展函数next()，并且         Ø 有一个成员函数或者扩展函数hasNext()返回 Boolean.	for (item incollection)   print(item)   //循环体可以是一个代码块. for (item: Int inints) {   // ... }   //如果你想要遍历一个数组或者一个list，你可以这么做：   for (i inarray.indices)    print(array[i])
While循环	while{:.keyword } 和 do{: .keyword }..while{: .keyword }的使用方法和其他语言一致.	while (x > 0) {   x-- } do {   val y = retrieveData() } while (y != null) // y is visible here!
When表达式	when{: .keyword } 替代了c语言风格的switch操作符 2. when{: .keyword }将它的参数和所有的分支条件进行比较，直到某个分支满足条件。 when{: .keyword }既可以被当做表达式使用也可以被当做语句使用。          如果它被当做表达式,符合条件的分支的值就是整个表达式的值，如果当做语句使用，则忽略单个分支的值。         就像if{:.keyword }，每一个分支可以是一个代码块,它的值是最后的表达式的值。          else{: .keyword} 分支将被执行如果其他分支都不满足条件。如果 when{: .keyword }作为一个表达式被使用，else{: .keyword }分支是必须的，除非编译器能够检测出所有的可能情况都已经覆盖了。	when (x) {   1 -> print("x == 1")   2 -> print("x == 2")   else -> { // Note the block     print("x is neither 1 nor 2")   } }   //多个分支合并 when (x) {   0, 1 -> print("x == 0 or x ==1")   else -> print("otherwise") }   //在判断分支条件的地方使用任何表达式 when (x) {   parseInt(s) -> print("s encodesx")   else -> print("s does not encodex") }   //可以检查一个值 in{: .keyword }或者 !in{: .keyword }一个范围或者集合 when (x) {   in 1..10 -> print("x is in therange")   in validNumbers -> print("x isvalid")   !in 10..20 -> print("x is outside therange")   else -> print("none of theabove") }   //可以检查一个值is{: .keyword }或者!is{: .keyword }某种特定类型 val hasPrefix = when(x) {   isString -> x.startsWith("prefix")  else -> false }   //可以用来替代链 if{: .keyword }-else{: .keyword } when {   x.isOdd() -> print("x is odd")   x.isEven() -> print("x is even")   else -> print("x is funny") }
跳转	跟其他语言类似，Kotlin 有三种跳出结构方式：         Ø  return{: .keyword }              默认情况下，从最近的一个封闭的方法或者方法表达式跳出.        Ø  break{: .keyword }.             终止最近的封闭循环        Ø  continue{: .keyword }.            直接进入循环体的下次循环
中断和继续标签	在Kotlin中任何表达式都可以用label{:.keyword }（标签）来标记。label的格式是被'@'标识符标记，例如：abc@, fooBar@都是有效的label：         如果有多重循环，带标签的break会跳转出标签所指示的那一个循环。带标签的continue会跳转到标签所指向的那个循环,进入该循环的下一次循环。	//可以在一个方法前面放一个label。 loop@ for (i in1..100) {   // ... } //可以将label与 break{: .keyword }或者continue{: .keyword }一起使用 // break执行后将跳转到标记处 // continue{:.keyword }将进入循环体的下次循环 loop@ for (i in1..100) {   for (j in 1..100) {     if (...)       break@loop   } }
return	在Kotlin里，函数字面量、局部函数和对象表达式等函数都可以被嵌套在一起适当的返回方式允许我们从外部方法返回值。          带标签的return，最重要的一个用途，就是让我们可以从函数字面量中返回	fun foo() {   ints.forEach {     if (it == 0) return     print(it)   } } //这个 return{:.keyword }表达式从最近的封闭的方法中返回，例如‘foo’。