Kotlin 知识点总结-基础篇
文章目录
一、数据类型
1.1、基本数据类型定义
val anInt: Int = 8
val aLong: Long = 12368172397127391
val aFloat: Float = 2.0F
val aDouble: Double = 3.0
val aShort: Short = 127
val maxByte: Byte = Byte.MAX_VALUE
//延迟初始化lateinit，可不用赋值
lateinit var s:String
1.2、模板操作符
val arg1: Int = 0
val arg2: Int = 1
val charArray:CharArray= charArrayOf('a','b')
println("" + arg1 + " + " + arg2 + " = " + (arg1 + arg2))
println("$arg1 + $arg2 = ${arg1 + arg2}")
//运行结果
//0 + 1 = 1
//0 + 1 = 1
val rawString: String = """
${charArray[0]}
\t
\n
\\\\\\$$$ salary
"""
println(rawString)
//运行结果(下面是模板操作符的打印，这里没添加//注释)
Hello "Trump"
$salary
a
\t
\n
\\\\\\$$$ salary
1.3、类和对象初始化
//1,只有一个构造函数时可以省略constructor关键字
open class MyClass (name:String, sex:String): Any() {
//2.第一个构造函数默认调用init方法，其余的不调用
init {
println(this.javaClass.name+"构造方法调用name:$name sex:$sex")
}
}
class MyClass1(name:String,sex:String):MyClass(name,sex)
fun main() {
val myClass=MyClass1("zhanglei","男")
println(myClass is MyClass1)
}
//返回结果
//com.hongshi.test.MyClass1构造方法调用name:zhanglei sex:男
//true
1.4、空类型和智能类型转换
空类型(任意类型都有可空和不可空两种)
val notNull:String = null//错误,不能为空
val nullable:String?= null//正确，可以为空
notNull.length//正确，不为空的值客户直接使用
nullable.length//错误，可能为空，不能直接获取长度
nullable!!.length//正确，强制认定nullable不可空
nullable?.length//正确，若nullable为空，返回空
//kotlin中null不属于基本数据类型，在数据类型后面加"?"允许返回null
fun getName():String?{
return null
}
fun main() {
val name= getName()
//type1
if (name!=null){
println(name.length)
}
println(name?.length)//判空写法
//type2：
if (name==null){
return
}
println(name.length)
val name= getName() ?: return//判空三目表达式
}
类型转换
//as 类型强转(Child)parent)
//as? 安全的类型强转,转换失败返回null
val child: Child? = parent as? Child
智能类型转换(编译器推导，远离无用的类型转换)
open class Parent()
open class Child():Parent(){
fun getString(){
}
}
fun main(args: Array<String>) {
val parent: Parent = Parent()
if (parent is Child){
//只能类型转换
parent.getString()
}
}
as 新增导包可以取别名
import com.hongshi.test2.Test2 as Test2
二、数组
2.1、定义方式
val arrayOfInt: IntArray = intArrayOf(1,3,5,7)
val arrayOfChar: CharArray = charArrayOf('H', 'e','l','l','o','W','o','r','l','d')
val arrayOfString: Array<String> = arrayOf("我", "是", "码农")
fun main(args: Array<String>) {
println(arrayOfChar)
println(arrayOfChar.joinToString(""))
println(arrayOfChar.joinToString())
println(arrayOfInt.slice(1..3))
//此外，数组大小
println(arrayOfInt.size)
//数组改变指定值
arrayOfInt[1]=111
//数组遍历
for(item in arrayOfInt){
println(item)
}
}
//运行结果
//HelloWorld
//HelloWorld
//H, e, l, l, o, W, o, r, l, d
//[3, 5, 7]
定制化数据与普通数据赋值对比
val helloWorldArray: Array<Char> = arrayOf('H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd')
val helloWorldCharArray: CharArray = charArrayOf('H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd')
其中基本数据类型的数组一共8个(去除包装类定制的数组)
2.2、数组处理方法
2.2.1、slice用法
val str:String="HelloWorld"
fun main() {
println(str.slice(0..1))//[0,1]
println(str.slice(0 until 1))//[0,1)
}
//返回结果
//He
//H
2.2.2、String接收字符串数组初始化
val helloWorldCharArray: CharArray = charArrayOf('H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd')
fun main() {
println(String(helloWorldCharArray))
}
//返回结果
//HelloWorld
2.2.3、遍历
val arrayOfInt: IntArray = intArrayOf(1,3,5,7)
//type1:for-each循环
for (item in arrayOfInt){
println(item)
}
//type2:array的扩展方法forEach循环
arrayOfInt.forEach {
println(it)
}
forEach里面的其实是个lambda表达式，点击跳转到lambda表达式高级写法
三、程序结构
3.1、常量与变量(val,var)
运行时常量
val str编译器常量(等价于java的final)
const val str
3.2、函数
3.2.1、基础写法
//返回值默认Unit，相当于java的void
fun main(args: Array<String>) {
//基本数据类型转换
val arg1 = args[0].toInt()
val arg2 = args[1].toInt()
println("$arg1 + $arg2 = ${sum(arg1, arg2)}")
}
//返回值:Int
fun sum(arg1: Int, arg2: Int): Int{
return arg1 + arg2 //返回结果：1 + 2 = 3
}
main函数的入参可以这里输入，也可以通过命令行输入
kotlin com.TestKt.kt 1 2
3.2.2、简化与匿名函数
//sum函数简写为
fun sum(a:Int,b:Int)=a+b
//匿名函数，类似c中函数指针
var sum=fun(a:Int,b:Int)=a+b
//返回Unit对象可以直接等号后写执行语句
var print=fun(a:Int,b:Int)=printf("asdf")
3.2.3、lambda表达式
lambda是匿名函数
写法{[参数列表]->[函数体，最后一行是返回值]}
3.2.3.1、普通写法
//普通写法
var sum={a:Int,b:Int->a+b}
//没有入参的写法
var printHello={
println("printHello")
}
//有返回值的写法(如下图所示)
var sum={
println("printHello")
1+2
}
//返回结果
//printHello
//3
lambda表达式带入参、返回值的完整写法
val sum = { arg1: Int, arg2: Int ->
println("$arg1 + $arg2 = ${arg1 + arg2}")
arg1 + arg2
}
fun main(args: Array<String>) { // (Array<String>) -> Unit
println(sum(1, 3))
//这里()调用等价于调用invoke方法，invoke方法：kotlin中运算符重载为方法
println(sum.invoke(1, 3))
}
3.2.3.2、简化
lambda表达式只要一个参数可以默认为it
val arrayOfInt: IntArray = intArrayOf(1,3,5,7)
arrayOfInt.forEach {
println(it)
}
//forEach传入参数如果只有一个，可以不写，用it代替
//也可以加上括号，本质上是lambda表达式的函数体
arrayOfInt.forEach ({ println(it) })
- step 1:forEach完整写法
arrayOfInt.forEach ({ element-> println(element) })
- step 2:加上括号
目前JVM上支持的语言光脚本就有一百多种，Kotlin、Groovy、Scala等如果它的参数最后一个是lambda表达式，这个大括号可以移到小括号外面
Scala：想解决Java表达能力不足的问题
Groovy：想解决Java语法过于冗长的问题
Clojure：想解决Java没有函数式编程的问题
Kotlin：想解决Java
arrayOfInt.forEach (){ println(it) }
- step 3:删除括号
idea提示小括号没用，可以删除
arrayOfInt.forEach { println(it) }
- step 4:最终写法：reference
idea提示"Convert lambda to reference"
println函数名作为参数传给forEach,同时println接收Any?任意参数
prinln源码：
@kotlin.internal.InlineOnly
public actual inline fun println(message: Any?) {
System.out.println(message)
}
forEach源码:
forEach接收参数T，而Any相当于java的Object,为任何参数的父类或者间接父类。println通过reference使用了forEach的参数T。
入参、返回值与形参一致的函数可以用函数引用的方式作为实参传入。最终写法如下
arrayOfInt.forEach(::println)
3.2.3.3、forEach退出循环
forEach接收lambda表达式，如果直接return会造成整个main方法的return
fun main() {
val arrayOfInt: IntArray = intArrayOf(1,3,5,7)
arrayOfInt.forEach {
if (it==5){ return }
println(it)
}
println("end")
}
//返回结果(lambda表达式return造成不能执行到println("end"),lambda函数不会)
//1
//3
解决方法，加上标签ForEach@，return@ForEach
注意：ForEach名称可以随便取
fun main() {
val arrayOfInt: IntArray = intArrayOf(1,3,5,7)
arrayOfInt.forEach asdf@{
if (it==5){ return@asdf }
println(it)
}
println("end")
}
3.2.4、函数类型
fun main() {
//无参，返回Unit：()->Unit
var printUsage=fun()= println("asdf")
println(printUsage)
//返回结果：Function0<kotlin.Unit>
//无参，返回一个整型：()->Int
var sum0=fun()=1
println(sum0)
//返回结果：Function0<java.lang.Integer>
//传入整型，返回一个整型：(Int)->Int
var sum1=fun(a:Int)=a
println(sum1)
//返回结果：Function1<java.lang.Integer, java.lang.Integer>
//传入两个整型，返回一个整型：(Int,Int)->Int
var sum2=fun(a:Int,b:Int)=a
println(sum2)
//返回结果：Function2<java.lang.Integer, java.lang.Integer, java.lang.Integer>
//传入字符串，Lambda表达式，返回Boolean：(String,(String)->String)->Boolean
var sum3=fun(a:String,b:(String)->String)=true
println(sum3)
//返回结果：Function2<java.lang.String, kotlin.jvm.functions.Function1<? super java.lang.String, ? extends java.lang.String>, java.lang.Boolean>
//===========总结：invoke有几个参数就叫Function几
//具名函数sum类型(Int,Int)->Int
fun sum(arg1: Int, arg2: Int): Int{
return arg1 + arg2 //返回结果：1 + 2 = 3
}
//对函数的引用reference
println(::sum)
//返回结果：function sum (Kotlin reflection is not available)，反射无法用，使用is关键字判断
println(::sum is (Int,Int)->Int)
//返回结果：true
}
3.3、类成员
3.3.1、函数与方法的区别
In languages such as C++, functions are bits of code that will perform a particular action - but are not associated with an object. functions that are to do with an object are called methods. in java all functions are methods as they are all to do with objects.
方法位于对象上。
函数独立于对象。
对于Java，只有方法。
对于C，只有函数。
对于C++来说，这取决于你是否在一个类中
总结就是一句话：类里边的是方法，类外边的是函数