作者：feintkotlin（Kotlin学习网）

说明：这篇文章讲述的是Kotlin的基础语法，可能有些比较高级的用法没有包含在里面

变量

var：定义变量

例如：

var name:String

name=“feint”

name="kotlin"

val：定义常量，类似C里面的const，在定义的时候初始化，之后只不能再被改变

例如：

val name=“feint”

varage：可变参数，和java中..语法的效果一样，只能在函数参数列表的最后一个位置上使用

运算符

.. ： 范围运算符

例如：

val oneToNine=1..9 //表示1到9这一数字区间

val isTrue＝2 in onToNine

相关方法：

downTo()、rangeTo()、step()、reversed()

等式：

===：比较两个变量的地址

==：根据类型的equals方法返回相应的结果

数据类型

Number

Boolean

Char：不像在Java中，char不会被默认为是一个数字（无法直接强制转换为Int类型）

String

字符串模版：

var name=“feint”

var info=“my name is $name”

Array

初始化数组：

1. val arr=arrayOf(1,2,3)

2. val arr=Array(21,{k->k+1})//Array(数组大小,初始化数组的lambda表达式)

3. 创建一个二维数组

val level:10;

//创建一个二维数组

val arr= Array(level,{Array(level){0}});

Unit：表示无类型，类似java中的 void

Exception

try{

}catch(e:Exception){

}finally{

}

在Kotlin中异常捕获可以当作表达式使用：

val a=try{

5

}catch(e:Exception){

4

}

类型转换

val str:String ?=any as String

When表达式

可以使用该表达式来替换switch语句

val gStr=when((grade/10) as Int){

9->"Best"

8->"Grate"

7->"Usual"

6->"Not Bad"

else->"Bad”

}

面向对象

构造函数

class Man{

private var name:String;

private var age:Int;

constructor(name: String,age:Int){

this.name=name;

this.age=age;

}

｝

class Man(name: String,age:Int){

private var name:String;

private var age:Int;

init {

this.name=name;

this.age=age;

}

class Man(val name: String,val age:Int){}

类的嵌套

添加了inner关键字，该类只能在其外部类中被调用

inner class Line(val x1:Int,val x2:Int)

使用this@label可以使用外部类中的私有变量

class BasicGraph(val name:String){

private val test:String="Hello";

//

inner class Line(val x1:Int,val x2:Int){

private val test:String="World";

//this@outer_class_name

fun draw():Unit= println("DrawLine ${this@BasicGraph.test} (${x1},${x2})")

}

fun draw():Unit= println("Draw the Graph ${name}");

}

数据类（Data class）

枚举类

enum class Day{

MonDay,TuesDay,WednesDay,ThursDay,Friday,SaturDay,Sunday

}

interface Callable{

fun call():Unit;

}

enum class Animal:Callable{

Dog{

override fun call():Unit= println("I am a dag");

},

Cat{

override fun call():Unit=println("I am a cat");

};

}

定义单例（Singleton）

关键字：object

可以用来存放静态方法和静态变量

object Singleton {

private var count=0;

public val tag="Singleton";

fun doSome():Unit= println("count is ${count++}");

}

//伴生对象，在某个类的内部定义。相当于在类的内部定义一些静态变量

companion object{

}

继承

关键字：open

被该关键字修饰的类能够被继承

关键字：abstract／sealed

修饰抽象类

open abstract class Payment(name:String,bank:String){

abstract fun pay();

}

sealed classes（封装类）：类似于枚举类，不同之处在于封装类中能包含多个不同类型的实例。和普通的类继承的不同之处在于其子类的数量是有限的。

sealed class Animal

class Cat():Animal()

class Dog():Animal()

fun whatAnimal(animal: Animal)=when(animal){

is Cat->"I am a Cat"

is Dog->"I am a Dog"

}

关键字：final

被final修饰的方法不能被子类重写

在Kotlin中方法默认是final的，要想继承，得加上 open 关键字

open fun myPay()="Hello";

可见范围

public：在任何地方可见

private：仅限类内部使用

protected：仅限该类和其子类使用

internal：仅限和该类在同一个包下的类使用

委托

关键字：by

interface Base{

fun say():String;

}

class BaseImp(val name: String):Base{

override fun say(): String ="myname is ${name}"

}

class BaseDele(b:Base):Base by b;

val bd=BaseDele(BaseImp("Green"))

println(bd.say());

函数

命名参数

println("min num is ${min(first = 34,second = 232)}")

扩展函数（Extension function）

为某个添加新的函数

class Hello(val name: String,val country:String){

fun hello():String{

return "hello";

}

}

//Extension function

fun Hello.say(){

println("${hello()}: ${name} -- ${country}")

}

infix function

把类对象默认当作函数的第一个参数使用，此类函数只接收传入一个对象。相当于把函数当作一个二元运算符使用

class Calc(number:Float){

var number:Float

init {

this.number=number;

}

infix fun addPrice(increase:Float){

this.number+=increase;

}

}

val calc=Calc(100f);

cals addPrice 200f;

函数式编程

higher order functions

将一个函数当作另一个函数的参数使用

fun <E> List<E>.min(fn:(E,E)->Boolean):E?{

fun pint(pre:(it:Int)->String){

println(pre(100));

}

pint { return@pint "this number is ${it}" }

将函数作为返回值

fun bar():(String)->String={str:String->str.reversed()}

//{str1,str2->"${str1}:${str2} ->左侧是输入参数，->右侧是函数体

fun concat():(String,String)->String={str1,str2->"${str1}:${str2}"}

println(bar()("hello"));

println(concat()("hello","world"));

将函数声明为变量

fun concat(country:String):(String)->String={str1->"${str1}:${country}"}

var world:(String)->String= concat("China");

println(world("Hello"));

函数引用

在函数名称前添加 ::

println("min is:${minlist.min(::min)}");

fun min(a:Int,b:Int):Boolean{

return a>b;

}

属性

lateinit：延迟初始化

属性扩展

在kotlin中属性扩展，相当于添加了一个getter和一个setter，因此无法对扩展属性进行初始化，也无法获取到幕后字段field

数据类

定义

构造函数中至少要有一个参数，必须要有主构造器（紧接着类名的后面）

data class Student(var name:String,var age:Int);

若要使用无参构造，则需要为每个成员变量赋予一个默认值

data class Student(var name:String="feint",var age:Int=32);

copy

data class默认实现了一个copy方法，类似java中的clone。

val stu=Student("feint",23);

stu.age=14;

val oldStu=stu.copy(age=33);

toString

data class还默认实现了一个toString()方法。输出的样式是这样子的：

User(name=feint, age=20)

语法糖

单行函数：fun plusOne(x:Int)=x＋1

字符串模版：

var name=“feint”

var info=“my name is $name”

等式：

===：比较两个变量的地址

==：根据类型的equals方法返回相应的结果

Nullable语法

使用 ?= 为变量赋予空值

智能类型转换

if(any is String){

//any is smart cast to type of String

}

带标签的while语句

label@while (true){

break@label

}