kotlin是一种运行在java虚拟机上的静态编程语言，2011年，JetBrains推出了kotlin项目，2016年2月15日正式发布了第一个官方稳定版本V1.0，2017年在google I/O大会上，google正式宣布kotlin成为Android官方开发语言。

在我们的AndroidStudio开发工具中，要想使用Kotlin这个优秀的开发语言，我们需要安装插件，直接在安装插件界面搜索Kotlin然后安装。之后再gradle文件增加如下配置

applyplugin:'kotlin-android'applyplugin:'kotlin-android-extensions'dependencies{compile"org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"}

项目gradle文件

buildscript{ext.kotlin_version='1.1.1'repositories{jcenter()}dependencies{classpath'com.android.tools.build:gradle:2.3.1'classpath"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"//NOTE:Donotplaceyourapplicationdependencieshere;theybelong//intheindividualmodulebuild.gradlefiles}}

完成上面的配置后，我们就可以愉快的玩耍了。

首先我们还和以前一样，创建一个Android项目，自动创建一个Activity之后我们再创建一个java类

publicclassMainActivityextendsAppCompatActivity{@OverrideprotectedvoidonCreate(BundlesavedInstanceState){super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Toolbartoolbar=(Toolbar)findViewById(R.id.toolbar);setSupportActionBar(toolbar);FloatingActionButtonfab=(FloatingActionButton)findViewById(R.id.fab);fab.setOnClickListener(newView.OnClickListener(){@OverridepublicvoidonClick(Viewview){Snackbar.make(view,"Replacewithyourownaction",Snackbar.LENGTH_LONG).setAction("Action",null).show();}});}@OverridepublicbooleanonCreateOptionsMenu(Menumenu){//Inflatethemenu;thisaddsitemstotheactionbarifitispresent.getMenuInflater().inflate(R.menu.menu_main,menu);returntrue;}@OverridepublicbooleanonOptionsItemSelected(MenuItemitem){//Handleactionbaritemclickshere.Theactionbarwill//automaticallyhandleclicksontheHome/Upbutton,solong//asyouspecifyaparentactivityinAndroidManifest.xml.intid=item.getItemId();//noinspectionSimplifiableIfStatementif(id==R.id.action_settings){returntrue;}returnsuper.onOptionsItemSelected(item);}}publicclassTest{privatestaticStringstr=null;publicstaticvoidmain(String[]args){str="Code4Android";System.out.println(str);}}

那上面的代码如果用kotlin实现是什么样子呢。尽管现在我们还不能写出Kotlin代码，但是在安装插件后AS中提供了自动转换Kotlin代码的功能

转换后的Kotlin代码

classMainActivity:AppCompatActivity(){overridefunonCreate(savedInstanceState:Bundle?){super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)valtoolbar=findViewById(R.id.toolbar)asToolbarsetSupportActionBar(toolbar)valfab=findViewById(R.id.fab)asFloatingActionButtonfab.setOnClickListener{view->Snackbar.make(view,"Replacewithyourownaction",Snackbar.LENGTH_LONG).setAction("Action",null).show()}}overridefunonCreateOptionsMenu(menu:Menu):Boolean{//Inflatethemenu;thisaddsitemstotheactionbarifitispresent.menuInflater.inflate(R.menu.menu_main,menu)returntrue}overridefunonOptionsItemSelected(item:MenuItem):Boolean{valid=item.itemIdif(id==R.id.action_settings){returntrue}returnsuper.onOptionsItemSelected(item)}}objectTest{privatevarstr:String?=null@JvmStaticfunmain(args:Array){str="Code4Android"println(str)}}

注意：AS提供的java代码自动转换功能，我们不要轻易使用，更不要转化我们成熟的项目，如果需要就需要我们自己去重构实现。否则会有意向不到的事情等着你，毕竟转换不是那么智能。上面的代码只是让你先简单熟悉下Kotlin代码时什么样子的，接下来我们先去学习一下Kotlin的基本语法。相信很容易上手。

我们由一个简单的”Hello World!”输出程序开始。与新建java文件类似，如下图，我们选择Kotlin File/Class.创建一个Kotlin文件。

packagecom.learnrecord/***CreatedbyCode4Androidon2017/4/21.*/varstr:String=""funmain(args:Array){str="HelloWorld!"println(str)}

上述代码就是简单的输出一个字符串“Hello World”，package 后面跟的是包名，我们看出了和java文件的区别，在包名后面没有以分号“；”结尾。在Kotlin语法中，语句结尾都不在有分号“；”。

在Kotlin中变量声明有两种类型，val修饰变量是只读变量即只能赋值一次，再次赋值时就会编译错误，如果我们需要多次修改值就需要使用var。在上面的 var str: String = “”中，str是变量名，：String,表明该变量是String类型变量，后面就是赋值语句。我们也可以这样写var str= “”省略了生命变量类型，它可以根据赋的值而自动推断出类型。如果我们使用下面赋值语句str=null，发现null是不能赋值的，这就是Kotlin的特性，如果我们想赋值null,可以修改为 var str:String?=””。 fun就是函数生命，而这个main函数就和我们java中的main方法一样，是程序执行的入口。println就是一个打印输出。

在Kotlin中有如下几种Number类型，他们都是继承自Number抽象类。

Float（32位）,Double（64）,Int（32）,Byte（8）,Short（16），Long(64,类型用大写L，如12L)，Any（任意类型），数组类型Array 根据传入的泛型数据自动匹配类型，Kotlin还提供了指定类型的Array,如ByteArray，CharArray，ShortArray，IntArray，LongArray，FloatArray，DoubleArray，BooleanArray。在数组类型中都提供了get(index),set(index,value)及iterator（）方法供我们使用。

valiArray:IntArray=intArrayOf(1,2,3)valsArray:Array=Array(3,{i->i.toString()})valanyArray:Array=arrayOf(1,"2",3.0,4.1f)//可将类型进行混排放入同一个数组中vallArray:LongArray=longArrayOf(1L,2L,3L)函数

我们先来实现一个简单的数值求和的函数，通用实现方法如下

funsum(a:Int,b:Int):Int{returna+b}

传入两个Int型数值，sum是函数名，括号后面的：Int表示该函数返回Int的值，函数体中对两个数字相加并返回。在Kotlin中表达式也可以作为函数体，编译器可以推断出返回类型，可以简化为

funsum(a:Int,b:Int)=a+b

为了更好理解表达式可以作为函数体，我们可以创建一个函数获取两个数的最大值，如下：

funmax1(a:Int,b:Int)=if(a>b)aelseb

需要注意的是若if后有多个表达式,如下

funmax1(a:Int,b:Int)=if(a>b){println(a)a}else{println(b)//如果我们将println(b)放到b的下面,运行会返回kotlin.Unit为无类型，//返回值总是最后一个表达式的返回值或值b}println(max1(1,3))

括号中的表达式顺序决定了返回的值及其类型。

如果我们的方法体仅仅是打印字符串，并不返回值则

funprintInt(a:Int):Unit{println(a)}

Unit就类似我们java中的void，即没有返回值，此时我们可以省略

funprintInt(a:Int){println(a)}

对于函数体，方法或者类等和java一样也有一些修饰符，如下

直接上代码如下

//操作符shl下面对Int和Longvara:Int=4varshl:Int=ashl(1)//Java中的左移运算符>varushr:Int=aushr(3)//无符号右移，高位补0>>>varand:Int=2and(4)//按位与操作&varor:Int=2or(4)//按位或操作|varxor:Int=2xor(6)//按位异或操作^print("/nshl:"+shl+"/nshr:"+shr+"/nushr:"+ushr)print("/nand："+and+"/nor:"+or+"/nxor:"+xor)

输出信息为

shl:8shr:2ushr:0and：0or:6xor:4

在上面的部分操作符可达到逻辑操作符， 当我们使用Boolean时，or() 相当于 ||，and() 相当于 &&， xor() 当操作符两边相反时为true，否则为false ，not()时取反。

遍历数组

funforLoop(array:Array){//第一种方式直接输出字符（类似javaforeach）for(strinarray){println(str)}//Array提供了forEach函数array.forEach{println(it)}//array.indices是数组索引for(iinarray.indices){println(array[i])}//(类似javafor(inti=0;iwhile(i

使用when判断类型

funwhenFun(obj:Any){when(obj){25->println("25")"Kotlin"->println("Kotlin")!isString->println("NotString")isLong->println("NumberisLong")else->println("Nothing")}}

is 和java中instanceof是一个作用判断是否为某个类型。!is即判断不是某个类型。

//@定义label，一般用在内层循环中跳到外层循环:iin0..2等价于java中for（inti=0;ifor(iin0..2){for(jin0..3){println("i:"+i+"j:"+j)if(j==2)//continue@loop//跳到外层循环，继续往下执行break@loop//跳到外层循环label处，跳出改层循环}}

倒序输出是downTo

//倒序输出543210for(iin5downTo0){println(i)}//设置输出数据步长for(iin1..5step3)print(i)//输出14//step和downTo混合使用for(iin5downTo1step3)print(i)//输出52类与枚举

/***constructor:构造函数*constructor无修饰符(如：private)时，constructor可以省略：*当是无参构造函数时，整个构造函数部分也可以省略，省略的构造函数默认是public的*由于primaryconstructor不能包含任何代码，因此使用init代码块对其初始化,*同时可以在初始化代码块中使用构造函数的参数*/openclassPeopleprivateconstructor(varid:String,varname:String){//可以类中初始化属性：varcustomName=name.toUpperCase()//初始化属性//次构造函数，使用constructor前缀声明，且必须调用primaryconstructor，使用this关键字constructor(id:String,name:String,age:Int):this(id,name){println("constructor")}init{println("初始化操作，可使用constructor参数")}//需要open修饰，子类才可以openfunstudy(){print("study")}//People前的冒号":"是继承的意思，实现类接口的时候也是冒号classStudent(id:String,name:String):People(id,name){vartest:Number=3privatevarname1:String?get(){returnname1}set(value){name1=value}//override修饰的方法，默认是可以被继承的。若希望不被继承，可以使用final关键词修饰overridefunstudy(){super.study()}}}

数据类用来保存数据，类似于POJO类，使用data关键词进行定义，编译器默认会为数据类生成以下四个方法

publicclassStaffJ{privateStringname;privateStringposition;privateTage;publicStringgetName(){returnname;}publicvoidsetName(Stringname){this.name=name;}publicStringgetPosition(){returnposition;}publicvoidsetPosition(Stringposition){this.position=position;}publicTgetAge(){returnage;}publicvoidsetAge(Tage){this.age=age;}}

Kotlin数据类：

dataclassStaff(varname:String,valposition:String,varage:T)

通过对比我们就看出了优点了，一行代码就实现了,具体使用

varstaff=Staff("code4Android","Android工程师","22")//实例化对象

要获取某个属性如获取名字staff.name,赋值就是staff.name=”code4Android2″，既然说了这样可以赋值，但是动手的小伙伴说为什么我敲的报错啊，如下

staff.position="前端"

编译报错了，在前面我们说过val修饰的属性只能赋值一次，那在这里val修饰的属性我们是不能再次赋值的。

funmain(arg:Array){varstaff=Staff("code4Android","Android工程师","22")//实例化对象staff.name="code4Android2"varstaff1=staff.copy()//使用copy的时候可以指定默认值，可以指定任意个用逗号","隔开varstaff2=staff.copy(name="ccc",position="kotlin")println("name:${staff2.name}position:${staff2.position}age${staff2.age}")//staff.position="Kotiln"//val不能再次赋值varanotherStaff=Staff("code4Android","Android工程师",22)//实例化对象println("stafftoString():${staff.toString()}")println("anotherStafftoString():${anotherStaff.toString()}")println("staffhashCode():${staff.hashCode()}")println("anotherStaffhashCode():${anotherStaff.hashCode()}")println("staffisequalsanotherstaff?${staff.equals(anotherStaff)}")}

上面使用了字符模板，在Kotlin中有两种字符模板形式，/变量、{}

varname:String="Code4Android"println("我的名字叫$name")println("我的名字叫${name}")/***java允许使用匿名内部类;kotlin也有类似的概念，称为对象表达式-objectexpressions*/openclassKeyBord{openfunonKeyEvent(code:Int):Unit=Unit}/**匿名内部类**/varkey=object:KeyBord(){overrideopenfunonKeyEvent(code:Int):Unit=Unit}

枚举

enumclassColor{RED,BLACK,BLUE,GREEN,WHITE}fundisplay(){varcolor:Color=Color.BLACK//转换指定name为枚举值，若未匹配成功，会抛出IllegalArgumentExceptionColor.valueOf("BLACK")Color.values()//已数组的形式，返回枚举值println(color.name)////获取枚举名称println(color.ordinal)//获取枚举值在所有枚举数组中定义的顺序,0开始}

在Kotlin中枚举还支持方法。

/***funreceiverType.functionName(params){*body*}*receiverType:待扩展的类名*.：修饰符为扩展符*functionName：为自定义的扩展函数名,*params：为自定义的扩展函数参数，可为空*扩展函数作用域，受函数的visibilitymodifiers影响*扩展函数并没有对原类做修改，而是为被扩展类的对象添加新的函数。*有一条规则，若扩展函数和类原有函数一致，则使用该函数时，会优先使用类本身的函数。*/classEmployee(varname:String){funprint(){println("Employee")}}//扩展函数funEmployee.println(){print("println:Employeenameis$name")}/***可以扩展一个空对象*/funAny?.toString1():String{if(this==null)return"toString1:null"else{return"toString1"+toString()}}/***扩展属性*由于扩展属性实际上不会向类添加新的成员,*因此无法让一个扩展属性拥有一个后端域变量.所以,对于扩展属性不允许存在初始化器.*扩展属性的行为只能通过明确给定的取值方法与设值方法来定义，也就意味着扩展属性只*能被声明为val而不能被声明为var.如果强制声明为var，即使进行了初始化，*在运行也会报异常错误，提示该属性没有后端域变量。*/valEmployee.lastName:Stringget(){return"get:"+name}

使用

funmain(arg:Array){varemployee=Employee("Code4Android")employee.print()employee.println()println(employee.toString1())println(employee.lastName)}代理

***被代理接口*/interfaceBase{fundisplay()}/***被代理类*/openclassBaseImpl:Base{overridefundisplay()=print("justdisplayme.")}/***代理类，使用:以及关键词by进行声明*许代理属性和其他继承属性共用*classDrived(base:Base):Basebybase,BaseImpl()*/classDrived(base:Base):Basebybase//使用funshow(){varb=BaseImpl()vardrived=Drived(b)drived.display()}***代理类型：*懒加载：Lazy*观察者：Delegates.observable()*非空属性：Delegates.notNull()*/classWater{publicvarweight:IntbyDelegates.notNull()/***代理属性*/publicvalname:Stringbylazy{println("Lazy.......")"Code4Android"}publicvarvalue:StringbyDelegates.observable("initvalue"){d,old,new->println("$d-->$old->$new")}}funmain(arg:Array){show()varwater=Water()println(water.name)println(water.name)water.value="11111"water.value="22222"water.value="33333"println(water.value)println(water.value)//必须先赋值否则IllegalStateException:Propertyweightshouldbeinitializedbeforeget.water.weight=2print(water.weight)}操作符::

valString.lastChar:Charget()=this[this.length-1]classA(valp:Int)//1,反射得到运行时的类引用:valc=Student::class//2,函数引用funisOdd(x:Int)=x%2!=0valnumbers=listOf(1,2,3)println(numbers.filter(::isOdd))//3，属性引用(在此引用main函数主体外声明的变量)println(::x.get())::x.set(2)println(x)//4，::x表达式评估为KProperty类型的属性//它允许我们使用get()读它的值或者使用名字取回它的属性valprop=A::pprintln(prop.get(A(1)))//5，对于扩展属性println(String::lastChar.get("abc"))//6，与java反射调用println(A::p.javaClass),varf:Array=A::p.javaClass.declaredFields伴生对象

伴生对象(companion object )类似于java中的静态关键字static。在Kotlin没有这个关键字，而是伴生对象，具体用法

openclassPeopleconstructor(varid:String,varname:String){//可以类中初始化属性：varcustomName=name.toUpperCase()//初始化属性//使用constructor前缀声明，且必须调用primaryconstructor，使用this关键字constructor(id:String,name:String,age:Int):this(id,name){println("constructor")}init{println("初始化操作，可使用constructor参数")}//,Kotlin的class并不支持static变量,所以需要使用companionobject来声明static变量,//其实这个platformStatic变量也不是真正的static变量,而是一个伴生对象,companionobject{valID=1}}

使用的话直接People.ID。

在Kotlin中使用object修饰类的时候，。该类是单例对象。

/***使用object定义类，该类的实例即为单例，访问单例直接使用类名，*不能通过构造函数进行访问，不允许有构造函数*Place.doSomething()//访问单例对象*/objectSingleton{fundoSomething(){println("doSomething")}}/***实例化的时候，单例是懒加载，当使用的时候才去加载；而对象表达式是在初始化的地方去加载。**当在类内部使用object关键词定义对象时，允许直接通过外部类的类名访问*内部对象进*而访问其相关属性和方法，相当于静态变量*可以使用companion修饰单例，则访问其属性或方法时，允许省略单例名*MyClass.doSomething()//访问内部单例对象方法*/classMyClass{companionobjectSingleton{fundoSomething(){println("doSomething")}}}