变量和函数
变量
- val 不可变变量,无法再次赋值
- var 可变变量
- 强制类型转换：变量 as 类型
//主函数
fun main() {
//自动推导成整型变量
var a = 10
//显式声明变量类型
//kotlin中没有基本数据类型，全部使用对象数据类型，首字母大写
var b: Int
//延迟初始化
lateinit var c :Int
//判断是否初始化
if(!::c.isInitialized){
c=100
}
}
集合
fun main() {
//不可变数组
val list = listOf("Apple","banana","orange","pear")
//可变数组
val mutlist = mutableListOf("Apple","banana","orange","pear")
mutlist.add("watermelon")
//集合,map同理
val set = setOf("Apple", "banana", "orange", "pear")
val mutableSet = mutableSetOf("Apple", "banana", "orange", "pear")
val mapOf = mapOf("apple" to 1, "banana" to 2)
//map
val map = HashMap<String, Int>()
//相当于put
map["Apple"] = 1
map["orange"] = 2
//相当于get
val number = map["Apple"]
}
函数
fun+函数名+(变量:变量类型,......)+:返回类型+{}
fun largerNumber(a: Int, b: Int): Int {
return max(a, b)
}
//当函数只有一行代码时不用写函数体，用等号连接代码
fun largerNumber2(a: Int, b: Int): Int = max(a, b)
//返回值类型可自动推断
fun largerNumber3(a: Int, b: Int) = max(a, b)
//函数参数默认值（类似python）
fun printParams(num : Int = 100,str :String){
println("number is $num,str is $str")
}
//使用时可以使用键值对
fun main() {
printParams(num = 10,str = "zhaolu")
//输出number is 10,str is zhaolu
}
静态方法（类方法）
使用companion object实现近似静态方法
class FuncDemo {
companion object{
fun doAction(){
print("do action")
}
}
}
fun main() {
FuncDemo.doAction()
//输出do action
}
也可以使用顶层方法
创建一个Helper kotlin file，里面写方法，其他类可以直接使用此函数
//Helper
fun doSomething(){
println("do something")
}
//其他类
fun main() {
doSomething()
//输出do something
}
逻辑控制
if
/*
* if语句使用方法同java
* if可以有返回值
* */
fun largerNumber(a: Int, b: Int) = if (a > b) a else b
when
/*
* when相当于switch
* 匹配值 -> 执行语句
* */
fun getScore(name: String) = when (name) {
"Tom" -> 100
"Jack" -> 95
"Lily" -> 80
else -> 0
}
//可判断数据类型，用Int
fun checkNumber(num :Number) {
when (num){
is Int -> print("number is Int")
is Double -> print("number is Double")
else -> print("don't know")
}
}
while
同java
for
类似python
//定义区间,闭区间
val range = 1..5
for (i in range){
print(i);
}
println(" ")
//左闭右开
val range2 = 0 until 5
for (i in range2) {
print(i)
}
println(" ")
//设置步长
for(i in 0 until 10 step 2){
print(i)
}
println(" ")
//降序
for(i in 10 downTo 1){
print(i)
}
面向对象
类与对象
类的定义与继承
//加open关键字才可以继承，默认不可以继承
open class Person{
var name =""
var age = 0
fun eat(){
println(name+"is eating"+",his age is "+age)
}
}
//继承使用:clsaasName(),子类的构造函数必须调用父类的构造函数
class Student : Person(){
var sno = ""
var grade = 0
}
//类名后加主构造函数
//init块中可以写主构造函数逻辑
class Student2(val sno :String,val grade:Int):Person(){
init {
println("Sno is"+sno)
println("Grade is"+grade)
}
}
open class Person2(val name:String ,val age:Int){
fun eat(){
println(name+"is eating"+",his age is "+age)
}
}
//class Student3(val sno :String,val grade:Int):Person2(){} //No value passed for parameter 'age'
//继承有主构造函数的父类
class Student3(val sno :String,val grade:Int,name: String,age: Int):Person2(name,age){
//次构造函数
constructor(name: String,age: Int):this("",0,name,age){}
constructor():this("",0)
}
类实例的创建
fun main() {
//创建对象省略new
var p = Person()
//kotlin中去掉了get，set方法，直接使用 .属性名 赋值
p.name = "Tom"
p.age = 10
p.eat()
val s1 = Student2("01921210001",100)
}
接口
定义
interface Study {
fun readBook()
//接口方法默认实现
fun doHomeWork(){
println("doHomework default implementation")
}
}
使用接口
//继承实现统一使用冒号，用逗号分隔
class StuInterface(name: String, age: Int) : Person2(name, age), Study {
override fun readBook() {
println("read book")
}
}
fun main() {
val s = StuInterface("tom", 20)
s.doHomeWork()
s.readBook()
}
修饰符
- public:默认,所有类可见
- private:同java，只对当前类可见
- protected:只在当前类和子类使用（与java不同）
- internal:只对同一模块的类可见
数据类
//数据类自动生成equals(),hashcode(),tostring()方法
data class CellPhone(val brand:String,val price:Int)
单例类
//单例类，使用object
object Singleton {
fun singletonTest(){
println("singletonTest is called")
}
}
fun main() {
Singleton.singletonTest()
}
密封类
当when传入一个密封类，会自动检查该密封类的子类，强制要求处理每个子类
sealed class Result
class Success(val msg:String):Result()
class Failure(val error:Exception):Result()
Lambda编程
- 形式:{参数1:类型,参数2:类型 -> 函数体}
- 当lambda参数是函数最后一个参数可以拿到外边
- 当lambda参数是唯一参数括号可以不写
- 当参数列表只有一个可以用it代替，不用声明参数名
fun main() {
val list = listOf("Apple","banana","orange","pear")
//原始写法，maxByOrNull根据传入的条件遍历，找到最大值
val lambda = { fruit: String -> fruit.length }
val maxLen = list.maxByOrNull(lambda)
//省略写法
println("max is "+list.maxByOrNull { it.length })
//map把集合中的函数映射成为另一个值
val map = list.map { it.toUpperCase() }
for (s in map) {
println(s)
}
//flilter过滤
val filter = list.filter { it.length <= 5 }
for (s in filter) {
println(s)
}
val any = list.any { it.length <= 5 }
val all = list.all { it.length <= 5 }
println("any is "+any)
println("all is "+all)
Thread{ print("thread is start")}.start()
}
空指针检查
//变量不许为空，如果需要为空，在后面加？
class Study {
fun readBook(){
println("read book")
}
fun doHomework(){
println("do homework")
}
}
fun doStudy(study: Study){
study.doHomework()
study.readBook()
}
//变量不许为空，如果需要为空，在后面加？
fun doStudy2(study: Study?){
study?.doHomework()
study?.readBook()
}
fun main() {
//Null can not be a value of a non-null type Study
// doStudy(null)
doStudy2(null)
}
val c = if(a!=null){
a
}else {
b
}
//可以简化为
val c = a ?: b
//非空断言语句，在变量后加!!，不推荐
let函数
obj调用let函数，立即执行lambda表达式代码，同时将obj传递到表达式中，即obj2
obj.let{obj2->
//执行语句
}
//作为空指针判断辅助工具
fun doStudy3(study: Study?){
study?.let { stu ->
stu.doHomework()
stu.readBook()
}
}
fun doStudy4(study: Study?){
study?.let {
it.readBook()
it.doHomework()
}
}
其他技巧
字符串内嵌表达式
//使用${obj.name}
fun main() {
val brand = "xiaoMi"
val price = 1999
println("$brand's price is $price")
//输出xiaoMi's price is 1999
}
with函数
两个参数，第一个参数为任意类型的对象，第二个参数为lambda表达式，在lambda表达式中提供第一个参数对应的上下文，并使用最后一行代码作为返回值
fun main() {
val list = listOf("apple","banana")
val res = with(StringBuilder()){
for (s in list) {
append(s)
append("\n")
}
//返回值
toString()
}
println(res)
}
run函数
类似with
fun main() {
val list = listOf("apple","banana")
//只有此处有区别
val res = StringBuilder().run {
for (s in list) {
append(s)
append("\n")
}
toString()
}
println(res)
}
apply函数
类似run，区别在于无返回值，返回调用对象本身
fun main() {
val list = listOf("apple","banana")
//res为StringBuilder类型
val res = StringBuilder().run {
for (s in list) {
append(s)
append("\n")
}
}
//需要加toString()
println(res.toString())
}
repeat函数
//将lambda表达式执行n遍
repeat(n){
//lambda表达式
}
