kotlin
kotlin 完全兼容 java，可以和java互相调用，2017年谷歌正式将其作为android开发的第一语言。kotlin编译后产生与java编译后相同的class字节码文件。
基础语法
第一个代码 hello world
fun main(){
print("hello world")
}
可以看出kotlin与java的区别，结尾不需要；
定义变量
kotlin 定义变量 使用val，var。val 可以看做java中的final不可修改。
kotlin与其他高级语言一样，可以类型推导。
val i : Int = 10
var a = 10
val b = 10
a = a * 10
b = b * 10 //此行会报错，val cannot be reassingned ,会建议修改为var
print("a=$a")//打印变量不用再像java一样拼接了，直接使用$后接变量即可
for循环
kotlin中舍弃了for-i的操作，采用for-in
//0..10 数学中表示为[0,10]
for( a in 0..10){
print(a)
}
//打印结果为：012345678910
until ，数学中为[0,10)
for( a in 0 until 10){
print(a)
}
打印结果为：0123456789
downto ，降序 数学中为[10,0]
for(a in 10 downTo 0){
prtin(a)
}
打印结果为：109876543210
step 步长
for(a in 0 until 10 step 2){
print(a)
}
打印结果：02468
for ( i in 10 downTo 0 step 2){
print(i)
}
打印结果为：1086420
方法
kotlin中方法的结构如下
fun 方法名(参数:类型):返回值{
}
//取得a+b的返回值
fun add(a:Int, b:Int):Int{
return a+b
}
val c = add(1,2)
print("c=$c")
打印结果：c=3
条件语句 （if，when）
if语句
基本与java保持一致，例如输入分数，显示等级
fun level(score:Int): String{
if (score >= 90){
return "优秀"
}else if (score >= 70 && score < 90){
return "良好"
}else if (score >= 60 && score < 70){
return "及格"
}else{
return "不及格"
}
}
print(level(80))
打印结果为：良好
然后根据kotlin可以简化一下代码：
fun level2(score:Int): String{
return if (score >= 90){
"优秀"
}else if (score >= 70 && score < 90){
"良好"
}else if (score >= 60 && score < 70){
"及格"
}else{
"不及格"
}
}
kotlin自动推到返回值的属性，在进一步进行简化：
fun level3(score:Int)=
if (score >= 90){
"优秀"
}else if (score >= 70 && score < 90){
"良好"
}else if (score >= 60 && score < 70){
"及格"
}else{
"不及格"
}
when
有些类似java中的switch，继续使用上面分数的例子
when的匹配规则匹配条件->{对应逻辑} 花括号中有且仅有一行的时候可以省略
fun level4(score:Int): String {
return when (score) {
in 90..100 -> "优秀"
in 70 until 90 -> "良好"
in 60 until 70 -> "及格"
else -> "不及格"
}
}
同样省略类型推导，最终可以写成下面这样
fun level5(score:Int) =
when (score) {
in 90..100 -> "优秀"
in 70 until 90 -> "良好"
in 60 until 70 -> "及格"
else -> "不及格"
}
此时when直接返回了一个string字符串，不考虑到复用情况，可以直接使用变量来接收了。
val score = 100
val a = when (score) {
in 90..100 -> "优秀"
in 70 until 90 -> "良好"
in 60 until 70 -> "及格"
else -> "不及格"
}
print(a)
打印结果：优秀
集合
list(listof，mutableListOf)
listof
kotlin中创建一个list，使用listof函数(此集合为不可变):
fun list(){
val list = listOf("a","b","c",2)
//遍历打印list
for ( i in list){
println("i="+i)
}
}
也可以指定list的泛型：
val list :List= listOf(“a”,“b”,“c”,2)
此时，list中仅可以存string类型，2为int类型，就会报错了。
mutableListOf
可变长的list,其余方法与listof没区别。
val list = mutableListOf<String>("a","b","c")
list.add("d")//listof是没有add方法的
set(setof,mutablesetof)
与list基本一致，只是set存储的数据不能是重复的，可以用来去重。
map(mapof, mutablemapof)
mapof
kotlin中map的使用：
fun map (){
val map = mapOf("key1" to "values1","key2" to "values2","key3" to 3)
for ( (key,values) in map){
println(key+"-"+values)
}
}
mutablemapof
使用方式与mapof一致，mutablemap是可变长的map，使用map[“key”]=values添加数据。
fun map (){
val map = mutableMapOf<String,String>("key1" to "values1","key2" to "values2","key3" to "3")
map["key4"]="4"
for ( (key,values) in map){
println(key+"-"+values)
}
}
类
与java中相同，都是使用class关键字表示类
class Animal{
var eat = ""
var sleep = 0
var play = ""
fun action(){
print("爱吃${eat},每天睡${sleep}小时，玩${play}")
}
}
调用：
val animal = Animal()
animal.eat = "肉"
animal.play = "球"
animal.sleep = 12
animal.action()
打印结果：爱吃肉,每天睡12小时，玩球
继承
kotlin默认的类是不能继承的，默认类相当于java中的final。如果想要继承一个类，需要添加open关键字。
open class Animal{
var eat =""
var sleep =0
var play =""
fun action(){
print("爱吃${eat},每天睡${sleep}小时，玩${play}")
}
}
class Dog : Animal() {
var name = “”
}
//也可以将参数写到主构造函数中，主构造没有函数体，如果有需要可以写在init{}中
class Dog(val name :String) : Animal() {
}
val dog = Dog("小a")
上述代码中Animal类在被Dog类继承的时候，有一个(),这表示的是Dog类继承Animal的无参构造函数。如果将Animal内的参数放入主构造函数中，那么完整代码如下：
open class Animal(val eat:String,val sleep:Int,val play:String){
fun action(){
print("爱吃${eat},每天睡${sleep}小时，玩${play}")
}
}
class Dog(val name :String,eat:String,sleep:Int,play:String) : Animal(eat,sleep,play) {
}
val dog = Dog("小a",eat = "骨头",16,"毛线")
次构造函数：constructor
Kotlin中规定，次构造函数必须调用主构造函数。次构造函数有函数体，使用关键字constructor修饰。给上面的Dog类添加次构造函数：
class Dog(val name :String,eat:String,sleep:Int,play:String) : Animal(eat,sleep,play) {
constructor(eat:String,sleep:Int,play:String) : this("",eat,sleep,play)
}
val dog2 = Dog(eat = "肉",10,"飞盘")
dog2.action()
打印结果：爱吃肉,每天睡10小时，玩飞盘
当类中没有主构造函数，只有次构造函数的时候，使用super关键字
class Dog1 : Animal {
constructor(eat:String,sleep:Int,play:String) : super(eat,sleep,play)
}
接口
与java相同，使用interface关键字
//定义接口aaa，类b实现aaa接口
interface aaa{
fun a()
}
class b:aaa{
override fun a() {
TODO("Not yet implemented")
}
}
数据类(data)
直接使用data关键字，可以省略toString,hashcode,equals等方法的重写
data class Cat(val eat:String)
val cat = Cat("fish")
print(cat)
打印结果为：Cat(eat=fish)
单例模式(object)
kotlin中单例模式的实现十分简单，只需要将class 替换为object即可。
object Singleton{
}
上述就是单例模式的写法，我们可以在其中添加函数。
object Singleton{
fun instans(){
print("this is singleton!!!")
}
}
//调用
Singleton.instans()
