Kotin语法

数据类型：

1. Boolean
2. Number:包括整形和浮点型
   分类 类型 位数
   浮点型：Double 64
   Float 32
   整型： Long 64
   Int 32
   Short 16
   字节 Byte 8
3. Char类型（Character）
4. 字符串：
   比较：
   a == b 表示比较内容，即类似Java的equals
   a === b 表示对象是否相同
   字符串模板：
   “hello,$name” ==> “hello 小明”

示例代码： val anotherBoolean: Boolean = false val maxInt:Int = Int.MAX_VALUE val aLong:Long = 232 val anotherInt:Int = 0xFF val aInt = 0b00000011 val aFloat:Float = 123F val aDouble:Double = 3.0 val another:Double = 3. val ashort:Short = 123 val abyte:Byte = 127 val aChar:Char = '\u000f' val cChar:Char = '\n' val anInt:Int = 5 val asLong:Long = anInt.toLong() val string:String = "hello world" val formChar:String = String(charArrayOf('d','e','e')) val TAG:String = "MainActivity" override fun onCreate(savedInstanceState: Bundle?) { 
    super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) show("hello world") Log.d(TAG,"\r\n"+cChar + "我的第一个Kotlin项目"+cChar) var arg1:Int = 1 var arg2:Int = 2 Log.d(TAG,"" + arg1 + " + " + arg2 + " = " + (arg1 + arg2)) Log.d(TAG,"$arg1 + $arg2 = ${arg1 + arg2}")//$字符串模板 val rawString:String = """//原始字符串 2 hello """ Log.d(TAG,rawString) Log.d(TAG,"长度：" + rawString.length) 

类和对象

讯享网 class 妹子 : 人 { 
    override var 性格: String override var 长相: String override var 声音: String constructor(性格: String, 长相: String, 声音: String) : super(性格, 长相, 声音) { 
    this.性格 = 性格 this.长相 = 长相 this.声音 = 声音 // Log.d("妹子", "她性格：$性格，长相：$长相, 声音：$声音") } } class 帅哥 constructor (var 性格:String,var 长相:String,var 声音:String){ 
    init { 
    Log.d("帅哥","他性格：$性格，长相：$长相, 声音：$声音") } } open class 人(open var 性格:String,open var 长相:String,open var 声音:String){ 
    init { 
    Log.d("妹子", "new 了一个 ${this.javaClass.simpleName}：$性格，长相：$长相, 声音：$声音") } } 

1. val 我喜欢的妹子:人 = 妹子(“温柔”,“甜美”,“动人”)
2. val 我膜拜的帅哥: 帅哥 = 帅哥(“彪悍”,“帅气”,“浑厚”)
3. 空类型安全
4. ？可以为空
5. !! 不可能为空

代码示例： val name = getName() ?: return; val value:String? = "hello world" Log.d(TAG,"name = " + getName()?.length) Log.d(TAG, value!!.length.toString()) 4.类型转换和智能类型转换 val mParent:Parent = Child() if (mParent is Child){ 
    Log.d(TAG,parent.packageName) } 

安全类型转换：

讯享网val sub: SubClass? = parent as? SubClass 

如果转换失败返回null,不抛异常

5.数组Array

val TAG:String = "Arrayexample"; val arrayOfInt:IntArray = intArrayOf(1,3,5,7) val arrayOfChar:CharArray = charArrayOf('f','d','e','a','b') val arrayOfString:Array<String> = arrayOf("我是码农") val arrayOf书记:Array<市委书记> = arrayOf(市委书记("张"),市委书记("李")) fun main(args: Array<String>) { 
    Log.d(TAG, "" +arrayOfInt.size + "") for (i in arrayOfChar){ 
    Log.d(TAG, "" +i + "") } Log.d(TAG, arrayOfChar.joinToString("")) arrayOfInt.slice(1..2)//切片，取范围内的值 

运行时常量： val x = getX() 编译器编译的时候并不能确切的知道它的值

编译期常量：const val x = 2;

讯享网var = variable var x = "Hello Wolrd"//定义变量 x = "Hi Macal"//再次复制 

类型推导：

val string = "hello world" /推导出String类型 val value = 5 //Int常量 val x = getString() + 5 //String类型 val FINAL_HELLO_WORLD:String = "hello world" val FINAL_HELLO_CHANL = "HELLOCHINAL"//类型推导  

7函数
注意事项：
功能单一
函数名要做到顾名思义
参数不能太多

讯享网fun show(): Unit { 
   //Unit相当于void，可以省略不写 val arg1 = 1 val arg2 = 2 Log.d("Hello","$arg1 + $arg2 = ${sum(arg1,arg2)}") int2Long(3) } fun sum(arg1: Int, arg2: Int): Int { 
    return arg1 + arg2; } fun sum1(arg1: Int,arg2: Int) = arg1 + arg2 //等价于sun val int2Long = fun(x:Int):Long{ 
   //匿名函数：函数也可以没有名字 return x.toLong() } 

写法：{[参数列表] -> [函数体，最后一行是返回值]}

var sum = { 
   arg1:Int,arg2:Int -> println("$arg1 + $arg2 = ${arg1 + arg2}") arg1 + arg2 } val printlnHello={ 
    println("hello") } 

应用：

讯享网

讯享网sum(2,3) 等价于 sum.invoke(2,3) 

数组遍历：

args:数组

args.forEach({ 
   println(it)}) 终极版： args.forEach(::println) 终止循环(添加标签@，终止的是迭代，而不是这个函数)： args.forEach ForEach@{ 
    if(it == "q" return@ForEach println(it) } 

Lambda表达是的简化：

。函数参数调用是最后一个Lambda可以移出去

。函数参数只有一个Lambda，调用是小括号可以省略

。Lambda只有一个参数可默认为it

。入参，返回值与形参一致的函数可以用函数应用的方式作为实参实参传入

9.类成员和和变量

讯享网class X class A{ 
    var b = 0//可以加访问修饰符，默认public lateinit var c:String //延时初始化 lateinit var d:X val e:X by lazy{ 
   //val只能通过lazy初始化  X() } get(){ 
    return field } set(value){ 
    field = value } } 

10.运算符(待学)
11.表达式（中缀表达式，分支表达式，when表达式 ）
中缀表达式：只有一个参数，并且用infix修饰的函数

class Book { 
    infix fun on(place:String){ 
    } fun main(){ 
    Book() on "My Desk" } } 

讯享网 分支表达式： if语句 

private const val DEBUG = 1 private const val USER = 0; val mode = if(args[0] == "1"){ 
   //if语句有返回值，就是最后一句 DEBUG }else{ 
    USER } 

when表达式：（kotlin没有switch）

讯享网val x = 5 when(x){ 
    is Int -> Log.i(TAG,"hello $x") in 1..100 -> Log.i(TAG,"$x is in 1-100") !in 1..100 -> Log.i(TAG,"$x is not in 1-100") args[0].toInt() -> Log.i(TAG,"x == arg[0]") } val mode = when { 
   //when也有返回结果，类似加强版的switch，支持任意类型 args.isNotEmpty && args[0] == "1" -> 1 else ->0 } 

fun xunhuan(args: Array<String>){ 
    for (arg in args){ 
    System.out.print(arg) } for (index,values) in args.widthIndex(){ 
    System.out.print("$index -> $values") } for (indexedValue in args.widthIndex()){ 
    System.out.print("${indexedValue.index} -> ${indexedValue.value}") } val list = MyIntList() list.add(1) list.add(2) list.add(3) for (i in list){ 
    System.out.print(i) } } class MyIterator(val interator: Iterator<Int>){ 
   //自定义迭代器 operator fun next():Int{ 
    return interator.next() } operator fun hasNext():Boolean{ 
    return interator.hasNext(); } } class MyIntList{ 
    private val list = ArrayList<Int>(); fun add(int: Int){ 
    list.add(int) } fun remove(int: Int){ 
    list.remove(int) } operator fun iterator():MyIterator{ 
    return MyIterator(list.iterator()) } } 

while循环：

讯享网var x = 5 while (x > 0){ 
    System.out.println(x) x-- } do { 
    System.out.println(x) }while (x > 0) continue和break和Java类似（跳过和跳出循环） 多层循环嵌套的终止结合标签使用 Outer@for(...){ 
    Inner@while(i<0){ 
    if(..)break@Outer } } 

fun sum(arg1:Int,arg2:Int):Int = arg1 + arg2 fun test(){ 
    sum(arg2 = 2,arg1 = 1) } 

变长参数：

讯享网val array = intArrayOf(1,2,3,4) hello(*array,string = "hello")//*只支持数组，其他类型不支持 fun hello(vararg ints:Int,string: String){ 
    ints.forEach(::println) System.out.println(string) }