Kotlin基础（一）Kotlin快速入门

Kotlin快速入门

一、函数

 /*
 *  1.函数可以定义在文件最外层，不需要把它放在类中
 *  2.可以省略结尾分号
 * */
 fun main(args: Array<String>) {
     println(max2(1,2))
     println(max(3,5))
 }

 fun max(a: Int, b: Int): Int{
     return if (a>b) a else b
 }

 /*
 *  与Java不同，Kotlin中，除了循环（for、do和do/while）
 *  以外大多数控制结构都是表达式，而不是语句（表达式和语句的区别？）。
 *  所以可以有如下写法。既然有了值（可推断返回类型），就可以省略返回类型。注意，只有
 *  表达式体函数的返回类型可以省略，对于有返回值的代码块体函数不可省略（这么设计的好处？）。
 * */
 fun max2(a: Int, b: Int)=if (a>b) a else b

二、变量

 fun main(args: Array<String>) {
     //声明变量的三种方式
     val a="For the Lichking!"
     val b: Int=88
     val c=8.8e8
     val d: String
     d="ssss"

    /*
    * 声明变量的关键字有两个：
    * val（来自value），不可变引用。相当于Java中的final变量。
    * var（来自variable），可变引用（不同于Javascript,类型仍然不可变）。
    * 相当于Java中的普通变量
    * */

     /*
     * 如果编译器能确保只有唯一一条初始化语句被执行，可根据条件使用不同值初始化它。
     * */
     val message: String
     val isTrue: Boolean=true
     if (isTrue) message="true" else message="false"
 }

三、字符串模板

 fun main(args: Array<String>) {
     //只需要在变量名前加"$"就可以在字符串字面量中引用变量
     val name=if (args.isNotEmpty()) args[0] else "Kotlin"
     println("Hello,${name}")

     //还可以这么玩儿
     println("Hello,${if (args.isNotEmpty()) args[0] else "NoJava"}")
 }

四、类

1.java类

 public class Person {
     private final String name;

     public Person(String name){
         this.name=name;
     }

     public String getName() {
         return name;
     }
 }

转换为Kotlin类

 //这种只有数据没有其他代码的类，通常被叫做值对象
 class Person(val name: String)

属性：

 /*
 *  在Java中，字段和其访问器的组合叫做属性。
 *  Kotlin的类中声明一个变量就是声明一个属性。
 * */
 class Man(
         val name:String, //只读属性：生成字段和其getter
         var isMarried:Boolean) //可写属性：生成字段和getter、setter

 class Rectangle(val height: Int,val width: Int){
     val isSquare: Boolean
     //自定义访问器
     /*get() {
         return height==width
     }*/

     get() = height==width
 }

 fun main(args: Array<String>) {
     val tang=Man("Tang Jiujia",false)
     println("My name is ${tang.name}")

     val rectangle=Rectangle(22,33)
     println(rectangle.isSquare)
 }

五、目录和包

 package gemetry.shapes

 import java.util.*

 class Rectangle(val height:Int,val width: Int){
     val isSquare: Boolean
         get() = height==width
 }

 //顶层函数
 fun createRectangle(): Rectangle{
     val random = Random()
     return Rectangle(random.nextInt(),random.nextInt())
 }

 //Kotlin中，可以把多个类放在同一个文件中，文件的名字还可以随意取
 //因此可以不创建shapes文件夹，直接用shapes文件代替文件夹。
 //当然，坚持Java的目录文件结构仍然是个不错的选择
 class RectangleUtil()

 package gemetry.example

 //可以这样导入顶层函数，当然使用"*"时顶层函数也会被导入
 import gemetry.shapes.createRectangle

 fun main(args: Array<String>) {
     println("Height: ${createRectangle().height}"+"\n"+"Width: ${createRectangle().width}")
 }

六、表示和处理选择：枚举和when

 package gemetry.enums

 enum class Color(val r: Int,val g: Int,val b:Int){
     RED(255,0,0),ORANGE(255,165,0),YELLOW(255,255,0),
     GREEN(0,255,0),BLUE(0,0,255); //这里分号不能省略，如果要在枚举类
     //中定义任何方法，必须用分号把常量列表和方法分开。

     //同Java一样，可以在枚举类中声明属性和方法
     fun rgb()=(r*256+g)*256+b
 }

 fun getMc(color: Color)=
         when (color){
             Color.BLUE -> "blue"
             //不写"break"
             //可以多个情况一起
             Color.GREEN,Color.RED -> "green or red"
             //必须把所有的可能的情况都列出来,不然就用"else"
             Color.YELLOW,Color.ORANGE ->"others"
         }

 fun mix(c1: Color,c2: Color)=
         //与Java中的switch只能使用常量（枚举常量、字符串、数字字面量）
         //不同，when允许使用任何对象,任何表达式
         when (setOf<Color>(c1,c2)){
             setOf(Color.RED,Color.YELLOW) -> "orange"
             setOf(Color.YELLOW,Color.BLUE) ->"GREEN"
             setOf(Color.BLUE,Color.RED) -> "unknow"
             else -> "???"
         }

 fun mix2(c1: Color,c2: Color)=
         //不带参数的when
         when{
             (c2==Color.RED && c2==Color.YELLOW) ||
                     (c1==Color.YELLOW && c2==Color.RED) -> "orange"
             else -> "others"
         }

 fun main(args: Array<String>) {
     println(getMc(Color.ORANGE))
     println(mix(Color.YELLOW,Color.BLUE))
     println(mix2(Color.RED,Color.GREEN))
 }

七、智能转换和“代码块最后表达式就是结果”

 package gemetry

 interface Expr
 class Num(val value: Int) : Expr //实现了Expr
 class Sum(val left: Expr,val right: Expr) : Expr
 /*
 fun eval(e: Expr) : Int=
         if (e is Num) e.value
         else if (e is Sum) eval(e.right)+ eval(e.left)
         else throw IllegalArgumentException("Unknown expression")*/

 fun eval(e: Expr): Int=
         //when表达式不仅限于检查值是否相等，也可用于检测when实参类型。
         when(e){
             is Num -> e.value //"is" 判断后自动转换为该类型
         // （被判断的属性必须是一个val属性，而且不能有自定义访问器）
             is Sum -> eval(e.right) + eval(e.left)
             else -> throw IllegalArgumentException("Unknown expression")
         }

 fun evalWithLogging(e: Expr) : Int=
         when(e){
             is Num -> {
                 println("num: ${e.value}")
                 e.value //代码快的最后一个表达式就是结果
                 /*
                 * 规则-----“代码块中最后的表达式就是结果”，在所有使用代码块并期望得到一个
                 * 结果的地方成立。但是，这个规则对常规函数不成立。一个函数要么具有不是代码
                 * 块的表达式函数体，要么具有包含显示return语句的代码块函数体。
                 * */
             }

             is Sum -> {
                 val left= evalWithLogging(e.left)
                 val right= evalWithLogging(e.right)
                 println("sum: $left+$right")
                 left+right
             }
             else -> {
                 throw IllegalArgumentException("Unknown Expression")
             }
         }

 fun main(args: Array<String>) {
     println(eval(Sum(Sum(Num(),Num()),Num())))
     println(evalWithLogging(Sum(Sum(Num(),Num()),Num())))
 }

八、迭代

1.when 同Java中一样

2.for: 仅以for-each循环的形式存在 for <item> in <elements>

3.while:同Java

4.区间：为了代替Java中的普通for循环。区间本质就是值之间的间隔，这两个值通常是数字：一个起始值，一个结束值。使用..运算符表示。

能迭其所有值的区间，叫做数列。

 val i: Int=0
     for (i in 1..10){
         println(i)
     }

 val i: Int=0
     //反向迭代，步长为2
     for (i in 20 downTo 1 step 2) println(i)

5.迭代map

 fun main(args: Array<String>) {
     val binaryReps=TreeMap<Char,String>()

     for (c in 'A'..'F') { //区间迭代字符
         val binary=Integer.toBinaryString(c.toInt())
         binaryReps[c]=binary //根据键来更新map的简明语法
     }

     for ((l,b) in binaryReps) println("$l=$b") //迭代map
 }

6.使用in来检查值是否在区间中

 fun isLetter(c: Char)= c in 'a'..'z' || c in 'A'..'Z'
 fun isNotDigit(c: Char)=c !in '0'..'9' //不在区间中

println("Kotlin" in "Java".."Scala")//字符串是按字母顺序表比较
    // （因为String就是这样实现Comparable接口的）

九、异常

1.Kotlin并不区分受检异常和非受检异常，因此函数可以不抛出特定异常，异常可以被处理或者不处理。

2.“try”可以作为一个表达式。