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的基本语法就讲完了,参考《第一行代码》第三版,记录下学习的过程。