参考资料：
参考资料
kotlin
1、kotlin编译原理是先编译为class文件，再在java 虚拟机上执行
2、变量
var = 1 变量
val = 2 常量
kotlin存在类型推导机制
var c:Int = 1
kotlin不存在基本类型，将全部使用对象类型
3、函数
fun test(){}
fun add(a:Int,b Int):Int{
return a+b;
}
由于存在类型推导，所以：
fun add(a:Int,b:Int) = a+b
函数的调用
fun main(){
test()
println(add(1,2))
}
4、选择语句
if when:
fun max(int:a,int b):Int{
if(a>b) return a
else return b
}
kotlin的if可以包含返回值， if语句的最后一行会作为返回值返回
fun max(a:Int,b Int):Int{
return if(a>b) a else b;
}
kotlin的if必须有else,否则会报错
fun getScore(name:String) = if(name=="Tom") "不及格"
else if(name == "Jim") "良好"
else if(name == "Fiona") "优秀"
else "名字非法"
Kotlin中的== 是Java中的equal,比较的是 内容
Kotlin中的===是Java中的==,比较的是引用
when的实现也必须要有else，否则会报错
fun getScore(name:String):String = when(name){
"Tom"->"不及格"
"Jim"->"及格"
"Fiona"->"优秀"
else->"名字非法"
}
when支持参数检查
fun checkNumber(num:Number){
when(nun){
is Int->println("Int")
is Double->println("double")
else println("others")
}
}
when 可以不传递参数
fun getScore(name:String) = when{
name == "Tom" ->"不及格"
name == "Jim" ->"及格"
name == "Tony"->"良好"
name == "Fiona"->"优秀"
else ->"名字非法"
}
fun getSore(name:String) = when{
//若name以Tom开头则命中此分支
}
5、循环语句
when和Java差不多 for-in是对Java for-each的加强
val range = 0..10
双闭区间
fun main(){
var range = 0..10
for(i in range){
println(i)
}
}
左闭右开
fun main(){
var range = 0..10
for(i in 0 until 10){
println(i)
}
}
跳步
fun main(){
var range = 0..10
for(i in 0 until 10 step 2){
println(i)
}
}
降序
fun main(){
var range = 0..10
for(i in 10 downTo 1){
println(i)
}
}
6、类和对象的初始化
class Person{
var name = ""
var age = 0
fun printInfo(){
println(name+"'s age is "+name)
}
}
使用person类
fun main(){
Person p1 = Person()
p1.name = "Finoa"
p1.age = 12
p1.printInfo()
}
继承
class Student : Person{
var grade = ""
var name = ""
var age = 0
fun study(score:Int):Int{
println("score is "+score)
return score
}
}
final修饰的类不可以被继承、需要使用open关键字修饰
open class Person{
...
}
构造
主构造
class Student(var name:String,var age:Int) :Person{
}
open class Person(var name:String,var age:Int){
}
继承有参构造的类
class Student(var name:String,var age:Int,var score:String):Person(name,age){
...
}
次构造
无参构造，字符串默认为"",Int默认为0
class Student(name:String,age:Int,score:String,grade:Int):Person(name,age){
constructor(name:String,age:Int,score:String):this(name,age,score,0)
constructor():this("",0,"",0){
}
}
fun main(){
Student s1 = Student("Jimmy",10,"88",1)
Student s2 = Student("Fiona",18,"98")
Student s3 = Student()
}
无主构造
如类不使用主构造，则后续继承类也不需要使用构造即可去掉继承类的（）,次构造可以调用父类构造super进行初始化，但是次构造的参数在其他地方无法引用
class Student:Person{
constructor(name:String,age:Int,number:String):super(name,age){
}
fun study(){
println(name,age)
println(number)报错，若number是主构造的参数则可引用
}
}
7、接口
interface Study{
fun study()
fun readBooks()
fun doHomework()
}
继承接口只需使用,进行拼接，并需要实现接口的所有函数
class Student(name:String,age:Int,grade:string):Person(name,age),study{
override fun study()
}
kotlin支持接口方法的默认实现，则继承类无需必现实现此方法
8、数据类和单例类
数据类只处理和数据相关的，如get、set、hashCode、equals、toString
9、Lambda
集合的创建和遍历
list：
fun main(){
val list = ArrayList<Int>()
list.add(1)
list.add(2)
list.add(3)
val list1 = listOf<Int>(1,2,3,4,5)
list1.add(6)//listOf不可变，只可查
}
map：
fun main(){
可变
val map = HashMap<String,String>()
map.put("1","Jimmy")
map["2"] = Tommy
println(map.get("1"))
println(map["2"])
不可变
val map1 = mapOf<String,String>("3" to "Fiona","4" to "whilt")
可变
val map2 = mutableMapOf<String,String>("5" to "Kevin",6 to "Dabby")
遍历
for((key,value) in map){
println("key is "+key +" value is "+value)
}
}
lambda可以传递代码
参数名1：参数类型，参数名2：参数类型->函数体
fun main(){
val list = listOf<String>("a","aba","aabb","a")
var maxStr = ""
for(str in list){
if(str.length>maxStr.length) maxStr=str
}
println("max is "+maxStr)
}
kotlin把空指针异常检查提前到了编译期，若空指针则会报错
java的做法
public void Student(Study study){
if(study==null){
return;
}
study.doHomework()
study.doExtrawork()
}
kotlin的做法
fun Student(study:Study){
study.doHomework()
study.doExtraWork()
}
fun main(){
Student s1 = Student(null)//kotlin这么写会报错
Student s2 = Student(Study())//ok
}
?的意思是当前参数可为空，如果可为空的话，则此对象调用的方法必须要保证不为空，说白了如果使用？就表示参数对象可为空，因此就不要调参数对象的方法了，毕竟这个对象都可能为空