作者：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
类型 | 数据 | 长度 |
Long | 8 | 字节 |
Int | 4 | 字节 |
Short | 2 | 字节 |
Byte | 1 | 字节 |
Double | 8 | 字节 |
Float | 4 | 字节 |
Boolean
Char：不像在Java中，char不会被默认为是一个数字（无法直接强制转换为Int类型）
String
字符串模版：
var name=“feint”
var info=“my name is $name”
Array
初始化数组：
val arr=arrayOf(1,2,3)
val arr=Array(21,{k->k+1})//Array(数组大小,初始化数组的lambda表达式)
创建一个二维数组
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
}
