一、学习从主函数开始（main）

Hello World！

• Kotlin代码

package study.base

/**
 * Created by zhangxuehui on 2017/6/19.
 */

fun main(args: Array<String>) {
    println("Hello World!")
}

• Java代码

package study.base;

/**
 * Created by zhangxuehui on 2017/6/19.
 */
public class simple01 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

对比：

1. Kotlin不用创建类，可以直接运行main方法；
2. 不需要返回类型，以及静态方法；
3. println();打印语句更加简洁；
4. 参数的定义方式不同：格式：[变量名]：[类型]
5. 包的定义与java相同：package study.base;
6. 可以省略";"

二.变量和常量

**常量定义 **

val <标识符> : <类型> = <初始化值>

• 常量（一次赋值局部变量）val

// val 一次赋值局部变量
    // 方式一
    val a = 1;
    println(a)
    // 方式二
    val d:Double
    var i = 1.1
    d = i
    println(a)
    //  一次赋值之后，再次赋值会报错，如下
    //  val  c = 2.1
    //  d = c//报错

变量定义

var <标识符> : <类型> = <初始化值>

• 变量 var

    var a:Int = 1;//方式一，指定类型
    var b = 2.1;//方式二，自动推导类型
    var c = 3.2
    b = c

空安全类型

• ?表示，类型可以为null

val a: Long? = null;

三. 函数fun

• 有返回值

fun sum( x:Int, y:Int):Int{
   return x*y
}

• 无返回值

fun sum( x:Int, y:Int):Unit{//:Unit可以省略，相当于java 的void
   println(x*y)
}

备注
1.形参必须指定类型。
2.Unit为返回一个无意义的值，相当于java 的空返回，可以省略不写。
3.Unit，可以使用return形式结束语句。

四、基本类型（main）

1.数字类型：Number

• Number类型

类型	位宽	实例
Double	64	var d:Double = 1.0
Float	32	var f:Float = 1.0F
Long	64	var l:Long = 10L
Int	32	var i:Int = 1
Short	16	var s:Short = 1
Byte	8	var b:Byte = 1

• 代码

    var d:Double = 1.0 //双精度
    var f:Float = 1.0F //浮点型
    var l:Long = 10L//长类型
    var i:Int = 1//整型
    var s:Short = 1//短类型
    var b:Byte = 1//字符型

• 显式转换

• 代码实现

fun main(args: Array<String>) {
    val a: Long = 2;
    println( a.toDouble())
}

**显示转换的方法 **

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

2.字符类型：Char

Char类型即字符类型，不可以直接用做数值。

字符是由单引号包裹的'1'，特殊的字符通过反斜杠\转义;

下面的字符序列支持转义：

\t,\b,\n,\r,',",\和$。编码任何其他字符，使用 Unicode 转义语法：\uFF00。

我们可以将字符显示的转义为Int数字：

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() //显示转换为数值类型
}

3.布尔类型：Boolean

Boolean类型与java相同，布尔值只有 true 或者 false，可以进行与、或、非等常规操作；

4.数组类型：Array

数组类型用Array表示，有get、set、size等方法；

• 数组的定义

定义固定长度的数组

    //定义一个固定长度的数组，格式： arrayOfNulls<类型>(长度);
    var arr = arrayOfNulls<Int>(10);

定义空数组

    //定义一个空数组，需要指定类型
    var arr: Array<Int> = emptyArray();
    //定义一个空数组，需要不指定类型
    var arr= emptyArray<Int>();

定义带默认值的参数（数组的装箱操作）

    //推断类型
    var arr3= arrayOf(1,2,3);
    //指定类型，不可以通过变量设置
    var arr4 = booleanArrayOf(true,false)

通过闭包初始化数组

    //闭包初始化数组，格式：Array([长度],{[变量]->[表达式]})，
    //例如：{i->i*i}，相当于var i = 0；i++；i = i * i；
    var arr5 = Array(5,{i->i*i})

备注
1.装箱：可以理解为带初始值变量定义；
2.闭包：即lamada表达式

• 数组的使用
  get与set

    //设置数据 格式arr.set([位置],[具体数据])
    arr.set(0, 10);
    //获取数据
    println(arr.get(0))

[]的使用(与java相同)

    //设置数据 
    arr[0] = 10;
    //获取数据
    println(arr[0])

size方法

    //获取数组的尺寸，java是使用length
    println(arr.size)

indices方法

   //获取全部的索引
   println(arr5.indices)//输出0..4

• 数组的遍历

遍历数组的值

  for(a in arr){
        println(a)
    }

遍历数组的索引

  for(a in arr.indices){
        println(a)
    }

• 方法

/**
 * Concatenates this string with the string representation of the given [other] object. If either the receiver
 * or the [other] object are null, they are represented as the string "null".
 */
public operator fun String?.plus(other: Any?): String

/**
 * Returns an array of objects of the given type with the given [size], initialized with null values.
 */
public fun <reified @PureReifiable T> arrayOfNulls(size: Int): Array<T?>

/**
 * Returns an array containing the specified elements.
 */
public inline fun <reified @PureReifiable T> arrayOf(vararg elements: T): Array<T>

/**
 * Returns an array containing the specified [Double] numbers.
 */
public fun doubleArrayOf(vararg elements: Double): DoubleArray

/**
 * Returns an array containing the specified [Float] numbers.
 */
public fun floatArrayOf(vararg elements: Float): FloatArray

/**
 * Returns an array containing the specified [Long] numbers.
 */
public fun longArrayOf(vararg elements: Long): LongArray

/**
 * Returns an array containing the specified [Int] numbers.
 */
public fun intArrayOf(vararg elements: Int): IntArray

/**
 * Returns an array containing the specified characters.
 */
public fun charArrayOf(vararg elements: Char): CharArray

/**
 * Returns an array containing the specified [Short] numbers.
 */
public fun shortArrayOf(vararg elements: Short): ShortArray

/**
 * Returns an array containing the specified [Byte] numbers.
 */
public fun byteArrayOf(vararg elements: Byte): ByteArray

/**
 * Returns an array containing the specified boolean values.
 */
public fun booleanArrayOf(vararg elements: Boolean): BooleanArray

5.字符串类型：String

字符串是由 String 表示的。字符串是不变的。字符串的元素可以通过索引操作读取: s[i] 。字符串可以用 for 循环迭代：

代码

fun main(args: Array<String>) {
    var str = "abc"
    //可以对字符串的每个字符进行遍历
    for (s in str){
        println(s)
    }
}

定义单行字符串

 //字符串的单行定义
    var str1 = "hello world！"

定义多行字符串

    //字符串的多行定义，方式一，转移字符
    var str2 = "方式一：\nhello world！\nhello world！"
    println(str2)
    //字符串的多行定义，方式二，"""，类似html<P>标签
    var str3 =
            """
    方式二：
          hello world！
          hello world！
"""
    println(str3)

输出结果

字符串模版
字符串中可以包含模版表达式，模版表达式包含以下两种：

1.$:输出变量
2.${语句}：输出运算结果

备注：想要输出$符号，请使用'$'，无法使用转义符号\$

代码：$

    var a:Int = 12;
    //输出参数
    var str:String = "a=$a"
    println(str)

代码：${语句}

    //输出函数或方法
    var b:Int = 12;
    var c:Int = 5;
    var str2:String = "12+5=${a+b}\n12*5=${sum(b,c)}"
    println(str2)

输出结果

五、运算符

Kotlin的运算符与java的基本相同，可以参考：运算符重载

实例

val x = (1 shl 2) and 0x000FF000

详解

• shl(bits) – 有符号左移 (相当于 Java’s <<)

• shr(bits) – 有符号右移 (相当于 Java’s >>)
• ushr(bits) – 无符号右移 (相当于 Java’s >>>)
• and(bits) – 按位与
• or(bits) – 按位或
• xor(bits) – 按位异或
• inv(bits) – 按位翻转

六、控制流

1.if表达式

语法与java相同

• 结构

    if(判断) {
        //代码块
    } else {
        //代码块
    }

• 案例

   var a:Int = 13;

    if(a>12) {
        println(a + 1)
    } else {
        println(a - 1)
    }

2.when表达式

when表达式，相当于java 的 switch表达式；

• 普通模式

    var a: Int = 11;
    //普通模式
    when (a) {
        1 -> println(a);//单行可以省略{}
        2 -> {//多行需要添加{}
            println(a * a)
        }
        else -> {//javs使用default，这里默认else
            a++;
            println(a)
        }
    }

• 多分支合一模式

    //分支合一模式
    when (a) {
        1, 2 -> {//多行需要添加{}
            println(a * a)
        }
        else -> {//javs使用default，这里默认else
            a++;
            println(a)
        }
    }

• 使用in判断范围

    //使用in进行范围判断模式
    when (a) {
        in 0..10 -> {//多行需要添加{}
            println(a * a)
        }
        !in 0..-20 -> println(a)
        else -> {//javs使用default，这里默认else
            a++;
            println(a)
        }
    }

• 使用is判断类型

    //使用is进行类型判断模式，貌似意义不大，没想到使用场景
    when (a) {
        is Int -> {
            println(a * a)
        }
        else -> {//javs使用default，这里默认else
            a++;
            println(a)
        }
    }

• 不设置默认值，直接通过方法判断

    var str: String = "odd";
    when {
        isOdd(str) -> println("fun=="+str);
        else -> println(str)
    }

3.for循环

for循环与java有很大的差异，在Kotlin中只有一种使用in函数的方式，没有fori或foreach

• 代码实现

    var arr = arrayOf(1, 2, 3)
    for (i in 1..arr.size) {
        println(arr[i])
    }

3.while 和 do...while

while语句与java完全相同，不解释；

• while

    //while
    var x= -11;
    while (x<0){
        x++;
    }
    println(x)//输出0

• do...while

    //while 和 do...while
    do{
        x++;
    }while (x<0)
    println(x)//输出1

七、返回与跳转

Kotlin具有三种跳转方式

-- return 返回相应参数，或结束相关语句
-- break 结束最近的闭合循环
-- continue 跳到最近的闭合循环的下一次循环

1.break 和 continue 标签

• 设置标签

 //设置标签，标签可以由任何字符组成，例如
    ada@ var a = 0;
    loop@ var a = 0;
    label@ var a = 0;

• break；
  结束当前循环

    var arr = Array(5, { i -> i * 2 })
    a@for (a in arr) {
        if (a == 6) {
            break@a
        }
    }

• continue
  跳过当前，迭代到下一次循环，

    var arr = Array(5,{i->i*2})
    for(a in arr){
        if(a==6){
            continue
        }
        println(a)
    }

备注：是否添加@标签，貌似没有什么影响；

2.return 标签

返回函数的值，或结束当前函数（其实，就是返回一个无意义的值Unit）
代码

• 返回函数值

fun sum(x: Int, y: Int): Int {
    return x * y
}

• 结束当前函数

fun sum(y: Int): Unit {
    if (y == 0)
        return
    println(10 * y)
}

---

八、总结

Kotlin基础篇学习结束，整体体验下来，发现它有如下优点：

1.不用出现java常见的空异常。
2.代码特别简洁，写代码就像写文章一般。
3.减少代码量，可以更关注代码的逻辑。
4.类型推导，可以不设置类型；
5.很棒的字符串模版。

问题：在android中会有怎样的体验呢？