Kotlin基础语法
2021-07-26 本文已影响0人
壹元伍角叁分
kotlin核心点：协成、高阶、闭包
一、Var与Val
var stringData = "嘿嘿嘿"
stringData = "还好还好"
val stringData2 = "哈哈哈"
println(stringData)
println("stringData=$stringData,stringData2=$stringData2")
二、函数
val addInt = addInt(1, 2)
println("addInt=$addInt")
val addInt2 = addInt2(1, 2)
println("addInt2=$addInt2")
val addInt3 = addInt3(1, 2, 3)
println("addInt3=$addInt3")
fun addInt(x: Int, y: Int): Int {
return x + y
}
fun addInt2(x: Int, y: Int) = x + y
fun addInt3(vararg x: Int): Int {
var value = 0
for (i in x) {
value += i
}
return value
}
三、字符串模板
println("我是一长串文字啊................没有换行")
println(
"""没去空格......第一行
第二行
第三行
第四行
"""
)
println(
"""trimIndent去空格......第一行
第二行
第三行
第四行
""".trimIndent()
)
println(
"""trimMargin去空格和竖杠(默认)......第一行
|第二行
|第三行
|第四行
""".trimMargin()
)
println(
"""trimMargin去空格和问号......第一行
?第二行
?第三行
?第四行
""".trimMargin("?")
)
//那如果打印出美元符号呢$
val value = "$123"
println("""打印带美元符号① $value""")
val value2 = "1234"
println("""打印带美元符号② ${'$'}$value2""")
println("""打印带美元符号③ ${'$'}12345""")
四、NULL检查机制
val stringNull: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_null_demo)
//如果为空不执行，
println(stringNull?.length ?: "我为null啊")
//不校验是不是为空，要崩溃的
println(stringNull!!.length)
if (stringNull != null)
println(stringNull.length)
println(test("zs"))
println(test("zs1"))
}
fun test(name: String): Int? {
if ("zs".equals(name)) {
return 100
}
return null
}
五、区间
//正序，含头含尾，打印1-9
for (i in 1..9) {
println("!!!!!! $i")
}
//倒序，含头含尾，打印9-1
for (i in 9 downTo 1) {
println("@@@@@@ $i")
}
//step 设置步长，打印1，3，5，7，9
for (i: Int in 1..10 step 2) {
println("------ $i")
}
//含头不含尾，打印1-9
for (i: Int in 1 until 10) {
println("****** $i")
}
//判断是指是否包含
if (age in 1..10)
println("$age 包含了")
}
Kotlin比较与数组
一、比较两个值
val string1: String = "haha"
val string2: String = "haha"
val string3: String = "hahaha"
val int1: Int? = 1000
val int2: Int? = 1000
val int3: Int? = 10
val int4: Int? = 10
//比较对象的值
//在kotlin中，==等同于java中的equals
println(string1 == string2)//true
println(int1 == int2)//true
//比较对象的地址
println(string1 === string2)//true
println(string2 === string3)//false
println(int1 === int2)//false
println(int3 === int4)//true,这个是为什么？
二、数组
//数组，第一种形式
val arrays = arrayOf(1, 2, 4, 5)
for (array in arrays) {
println("-----$array")//打印出1,2,4,5
}
//数组，第二种形式，不常用。
val arrays2 = Array(10) { value: Int -> (value + 1000) }
for (array in arrays2) {
println("@@@@@$array")//打印出1000-1010
}
Kotlin条件控制
一、条件
大小比较
val a: Int = 100
val b: Int = 200
val maxValue = if (a > b) a else b
println(maxValue)//200
//val maxValue2 =//没有限定类型的话，下面就可以不写返回值，但打印出的值是kotlin.Unit
val maxValue2: Int =//限定了类型，必须要写返回值，否则报错
if (a > b) {
println("最大值是a=$a")//这边可以做一些其他的操作
a//最后一行相当于是返回值
} else {
println("最大值是b=$b")
b
}
println(maxValue2)//200
区间比较
//区间判断
val c: Int = 100
val d: Int = 200
if (c in 1..100 && d in 101..200) {
println("符合条件")//返回
} else {
println("不符合条件")
}
二、when运行
//when，类似java中switch用法
val e: Int = 2
val stringValue = when (e) {
1 -> "一"//一行代码，返回值
2 -> "二"
3 -> "三"
else -> "其他"
}
println(stringValue)//打印"二"
val g: Int = 5
val stringValue2 = when (g) {
in 1..10 -> "1..10"
in 11..20 -> "11..20"
in 21..30 -> "21..30"
else -> "超出"
}
println(stringValue2)//打印"1..10"
val f: Int = 5
val intValue = when (f) {
1 -> {
"一"//可输入多行代码
100 //返回值
}
2 -> {
"二"
200
}
3 -> {
"三"
300
}
else -> {
"其他"
0
}
}
println(intValue)//打印0
when (3) {
1, 3, 5, 7, 9 -> println("奇数")
2, 4, 6, 8, 10 -> println("偶数")
else -> println("其他")
}
Kotlin循环与标签
一、for循环操作
val listOf = listOf<String>("张三", "李四", "王五");
//循环
for (s in listOf) {
println("-------$s")
}
listOf.forEach {
println("!!!!!!$it")//使用默认参数名
}
listOf.forEach { str ->
println("@@@@@@$str")//自定义参数名
}
for (index in listOf.indices) {
println("带有索引的遍历$index=${listOf[index]} ")
}
二、自带标签与系统标签
//自定义标签
abc@ for (i: Int in 1..10) {
cde@ for (j: Int in 1..10) {
println("i=$i,j=$j")
if (i == 5) {
break@abc//如果i==5，break外面的循环
//break@cde//如果i==5，break内部的循环，相当于直接调用break
}
}
}
Kotlin类与对象
一、父类子类与构造函数等
父类person
//class Person其实是public final class Person，不能被继承，要想被继承，前面加open
open class Person(name: String) {//柱构造函数
constructor(name: String, age: Int) : this(name) {//次构造函数1，调用主构造函数
}
constructor(name: String, age: Int, score: Int) : this(name) {//次构造函数2，调用主构造函数
}
}
子类student
class Student(name: String) : Person(name) {//子类必须实现父控件的一个构造函数,这里实现主构造函数
}
class Student2(name: String, age: Int) : Person(name, age) {//子类必须实现父控件的一个构造函数,这里实现次构造函数
}
创建对象，不需要new
Person("张三")
Person("张三", 18)
Student("李四")
Student2("李四", 20)
二、接口和抽象类
interface ICallBack {//接口默认就是open，被继承了才有意义
fun onCallBackMethod()
}
abstract class Person : ICallBack {//abstract有open的特征
abstract fun setName(name: String): String
abstract fun setAge(age: Int): Boolean
}
class Student : Person() {
// override fun setName(name: String): String = "张三"//简单返回
override fun setName(name: String): String {
TODO("Not yet implemented")
}
// override fun setAge(age: Int): Boolean = false//简单返回
override fun setAge(age: Int): Boolean {
TODO("Not yet implemented")
}
override fun onCallBackMethod() {
TODO("Not yet implemented")
}
}
三、data与object
data关键字：标识对象bean
data class Student(var name: String, var age: Int)
var student: Student = Student("张三", 18)
println(student)//Student(name=张三, age=18)
//复制对象参数
val (name1, age1) = student.copy()
println("name1=$name1,age1=$age1")//name1=张三,age1=18
//只需要其中几个参数，需要剔除的用_
val (name2, _) = student.copy()
println("name2=$name2")//name2=张三
object关键字：相当于是个单例
object MyEngine {
fun m() {
println("M run")
}
fun show() {
println("我就只有一个实例")
}
}
四、自己写单列
写法一：
java写法
public class JavaSingleManager {
static class Single {
private static JavaSingleManager javaSingleManager = new JavaSingleManager();
}
static JavaSingleManager getInstance() {
return Single.javaSingleManager;
}
private void show() {
System.out.println("show JavaSingleManager");
}
}
kotlin写法
class KtSingleManager {
object Holder {
val ktSingleManager: KtSingleManager = KtSingleManager()
}
companion object {
fun getInstance(): KtSingleManager = Holder.ktSingleManager
}
fun show() {
println("show KtSingleManager")
}
}
写法二：
java写法
public class LazyJavaSingleManager {
private static LazyJavaSingleManager manager;
public static LazyJavaSingleManager getInstance() {
if (manager == null) {
manager = new LazyJavaSingleManager();
}
return manager;
}
public void show() {
System.out.println("show LazyJavaSingleManager");
}
}
kotlin写法
class LazyKtSingleManager {
companion object {
private var lazyKtSingleManager: LazyKtSingleManager? = null
fun getInstance(): LazyKtSingleManager? {
if (lazyKtSingleManager == null) {
lazyKtSingleManager = LazyKtSingleManager()
}
// return lazyKtSingleManager!!//自己知道不会为null
return lazyKtSingleManager//自己知道不会为null
}
}
fun show() {
println("show LazyKtSingleManager")
}
}
