Kotlin基础语法第一篇

Kotlin基础语法第一天

1.变量

//kotlin 定义变量用var 定义常量用val,这里没有加数据类型是因为kotlin有类型推导机制
var a = 10
val b = 20
//完整的定义如下
var a:Int = 10
val b:Int = 20

2.函数

//函数的定义 fun关键字必写，后面跟上方法名称最后是驼峰命名法，然后是小括号参数列表，后面跟返回值如果没有就不写
fun methodName(param1:Int,param2:Int):Int{
    return param1+param2
}
//变形，当函数体中只有一行代码的时候，kotlin允许我们不用写大括号，返回类型直接跟方法体
fun methodName(param1:Int,param2:Int):Int=param1+param2
//变形，因为kotlin的类型推导机制返回类型也可以省略
fun methodName(param1:Int,param2:Int)=param1+param2

3.流程控制语句

//if语句和java的没有什么区别，唯一的是if可以当作返回值返回
fun largeNumber3(num1: Int, num2: Int): Int {
    return if (num1 > num2) {
        num1
    } else {
        num2
    }
}
//简化2
fun largeNUmber05(num1: Int, num2: Int) = if (num1 > num2) {
    num1
} else {
    num2
}
//简化3
fun largeNumber06(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

//Int、Long、Float、Double都是Number的子类
fun checkNumber(number: Number) {
    when (number) {
        is Int -> print("Int")
        is Double -> print("Double")
        else -> print("is not Number")
    }
}
//不在when中写参数
fun getScore01(name: String) = when {
    name == "Tom" -> 77
    name == "Jer" -> 88
    else -> 0
}

4.循环语句

// ..这个是闭环相当于数学中的[0,10]
for (i in 0..10){
    print(i)
}
println()
// 这是一个半开区间 相当于数学中的[0,10)
for (i in 0 until 10){
    print(i)
}
println()
//步长 每次加2
for (i in 0..10 step 2){
    print(i)
}
println()
//下降区间[10,1]
for (i in 10 downTo 1){
    print(i)
}

5.对象

//Kotlin中没有new关键字，创建对象直接对象名跟上括号即可
fun main() {
    val person = Person()
    person.name = "Tom"
    person.age = 10
    person.eat()
}

open class Person{
    var name=""
    var age=0
    fun eat(){
        print("吃饭"+name+"----"+age)
    }
}

//继承
//我们定义一个Student类继承Person，但是发现报错，是因为kotlin中默认是不能继承的，需要再父类中加入open关键字
class Student:Person(){
    var sno =""
    var grade=0
}

//次构造函数，次构造函数必须直接或者间接调用主构造函数
class Tom(var name:String,var age:Int,var sno:String,var grade: Int){
    constructor(like:String,grade: Int):this("",0,like,grade)
    constructor():this("",0)
}

6.接口

/*
* 接口 基本和java一致 kt的接口和继承统一用 : 中间用逗号隔开 当然java在jdk1.8之后有了接口可以有具体的方法，kt也是支持的
* */
interface Test08 {
    fun eat()
    fun sleep()
    fun skip(){
        print("跳跃")
    }
}
//这里实现接口就不用写小括号了，因为接口没有主构造方法
class Dog: Test08 {
    override fun eat() {
        TODO("Not yet implemented")
    }

    override fun sleep() {
        TODO("Not yet implemented")
    }
}

7.修饰符

// public  所有类都可以访问,kotlin默认都是public
// private 只有自己可以访问
// protected 子类可以访问
// internal  比如自己开发了一个模块，但是有一些函数是在模块内部调用的，不想暴露给别人的话

8.数据类

//数据类同java中新建一个类定义变量重写 get set toString equals hashCode 的作用是一样的 这些kt都帮你默认实现了,特别适合做json格式化类
data class Cellphone(var brand:String,var price:String)

9.单例

//java中的单例 在kt中实现就是这么简单
object SingleTon{
    fun  test(){
        print("SingleTon is call")
    }
}

10.集合

//这个集合只可读取，不可以操作 不可以修改 增加 删除
val listOf = listOf("a", "b", "c")
//可变 可以修改 增加 删除
val mutableListOf = mutableListOf<String>("d", "e", "f");
mutableListOf.add("g")
for (item in mutableListOf){
    println(item)
}

//hashMap
val hashMap = HashMap<String, Int>()
hashMap["a"] = 1
hashMap["b"] = 2

val mapOf = mapOf<String, Int>("c" to 1, "d" to 2)
//遍历map
for ((key,value) in mapOf){
    print(key+"---"+value)
}

11.函数式API

//求出最长单词的索引
val list = listOf<String>("apple","banner","orange","supermarket")
var maxLength=""
for (fruit in list){
    if (fruit.length>maxLength.length){
        maxLength = fruit
    }
}
print(maxLength)

//集合的函数式API
val maxLengths = list.maxBy { it.length }
print(maxLengths)
//上述为lambda表达式在起作用 {参数名1:参数类型,参数名2:参数类型 -> 函数体}
//演变01
var lambda = {fruit:String -> fruit.length}
val maxBy = list.maxBy(lambda)
//演变02 当lambda为函数的最后一个参数时候，可以将lambda放到（）外面
var maxBy02 = list.maxBy(){fruit:String -> fruit.length}
//演变03 当lambda是函数的唯一参数的时候函数可以将括号省略
var maxBy03 = list.maxBy{fruit:String -> fruit.length}
//演变04 由于kt的类型推导机制可以将类型去掉
var maxBy04 = list.maxBy{fruit -> fruit.length}
//演变05 当lambda只有一个参数时候，参数可以不写直接用it关键字替代
var maxBy05 = list.maxBy{it.length}


//常用api之map 将集合中的每个元素映射成另外一个值，映射规则在lambda中指定，最终生成新的集合
val map = list.map { it.toUpperCase() }
for (item in map){
    println(item)
}
//常用api之filter 过滤器
val map1 = list.filter { it.length <= 6 }
.map { it.toUpperCase() }
for (item in map1){
    println(item)
}
//常用api之 any all；any函数用于判断集合中是否至少存在一个元素满足指定条件；all函数用于判断集合中是否所有元素都满足指定条件

//调用java的函数式API
Thread(object :Runnable{
    override fun run() {
        TODO("Not yet implemented")
    }

}).start()

//简化01 只有一个待实现方法可以不写
Thread(Runnable {

}).start()
//简化02 根据Test13简化步骤而来
Thread{

}.start()

12.空指针检查

//kotlin有非常轻的非空判断，其实这么些已经预防了空指针。
fun doStudy(person:Person){
    person.eat()
}
//这是会报错的
fun main(){
    doStudy(null)
}

//如果我们person需要为空的话可以在类型后面跟上?,但是这里因为person可能为空，在调用方法的时候会报错，我们需要在每个方法上加入?
fun doStudy(person:Person?){
    person?.eat()
}
//工具let,解决对象多个方法多次加入?,let函数中的it就是Person对象
fun doStudy(person:Person?){
    person?.let{
        it.eat()
    }
}

今天的kotlin的基本语法就讲完了，参考《第一行代码》第三版，记录下学习的过程。