常见的数据类型
Byte 存储值范围整数-128-127 Short 存储值范围整数-32768-32767 Int 存储值范围整数-2147483648-2147483647 Long 存储值范围整数-9223372036854775807-9223372036854775807 Foat 存储值范围小数，小数点可以精确到6位 Double 存储值范围小数，小数点可以精确到15-16位 String 存储值范围字符串，用”'双引号引起来的字符串都可以存
Var的智能数据推断
//不指定数据类型，可以自行推断i的类型为Int类型 var i = 18 //指定数据类型，存放的数据必须为Long类型 var j:Long = 999999
常量与变量
var 声明变量 val 声明常量-----》只读数据类型
函数编写规则
fun 函数名(参数名:参数类型):返回值类型{ 函数体 }
Lambda函数式编程
fun main(args:Array<String>){ //Lambda函数式编程 val plus = { x:Int, y:Int -> x+y} val less = { x:Int, y:Int -> x-y} val multiply = { x:Int, y:Int -> x*y} val except = { x:Int, y:Int -> x/y} println(plus(1,1)) println(less(1,1)) println(multiply(2,2)) println(except(2,2)) }
字符串模版
fun main(args: Array<String>) { println(diaryTemplate("nice")) } /** * @author shenj * @title: diaryTemplate * @date 2020/11/20 10:47 */ fun diaryTemplate(info: String): String { //即使用${}获取对应参数名的值 var a = "今天心情真${info},别人的心情也${info}" return a }
知识补充【1】
//equals忽略字母大小写比较，通过设置ignoreCase为true实现，默认为false var str1 = "abc" var str2 = "aBC" println(str1.equals(str2,true)) //在输入的参数后面加上?表示参数可以为null，为null时对应参数的输出为null /** * @author shenj * @title: diaryTemplate * @date 2020/11/20 10:47 */ fun diaryTemplate(info: String?): String { var a = "今天心情真${info},别人的心情也${info}" return a }
When函数（相当于switch，但是比switch强大）
fun performanceEvaluation(grades:Int):String{ when(grades){ 10 -> return "满分哦" 9 -> return "优秀哦" 8 -> return "不错哦" 7 -> return "良好哦" 6 -> return "及格哦" else -> return "长路漫漫还需努力！" } }
for循环和数组
/** * @title: Demo2 * @projectName my_kotlin1 * @author shenj * @date 2020/11/20 11:38 */ fun main(args: Array<String>):Unit { //..表示声明了一个数组包含值1~10，也可以使用listOf()生成数组 var list1 = 1 .. 10 for(value in list1){ println(value) } //until表示声明一个数组1~9（不包含10）[1,10) var list2 = 1 until 10 for(value in list2){ println(value) } //for可以通过step设置步长 var list3 = 1 until 10 for(value in list3 step 2){ println(value) } var lists = 1 until 10 //数组的reversed()反转数组并返回一个新数组，数组还有一个list.count统计个数的方法 var list4 = lists.reversed() for(value in list4){ println(value) } }
- 在当长度确定时，数据不确定时可以使用
val strings = arrayOfNulls(size)创建数组
Map集合
//创建不可变集合，返回值是Map var map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78) println(map)//按添加顺序排列 println("mapOf的返回对象的实际类型：${map.javaClass}") //创建可变集合 var mutableMap = mutableMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78) println(mutableMap)//按添加顺序排列 println("mutableMapOf的返回对象的实际类型：${mutableMap.javaClass}") //创建HashMap集合 var hashMap = hashMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78) println(hashMap)//不保证排列顺序 println("hashMapOf的返回对象的实际类型：${hashMap.javaClass}") //创建LinkedHashMap var linkedHashMap = linkedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78) println(linkedHashMap)//按添加顺序排列 println("linkedMapOf的返回对象的实际类型：${linkedHashMap.javaClass}") //创建TreeMap集合 var treeMap = sortedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78) println(treeMap)//按key由小到大排列 println("sortedMapOf的返回对象的实际类型：${treeMap.javaClass}") fun main(args: Array<String>):Unit { //使用treemap var map = TreeMap<String,String>() map["k1"] = "v1" map["k2"] = "v2" println(map["k1"]) }
函数表达式
//函数体只有一个返回值的时候 val plus = { x:Int, y:Int -> x+y} fun plus(n:Int, m:Int):Int = n + m
知识补充【2】
\\\\Kotlin中的数据类型的转换通过数据"."的方式转换 var s:String = "99" var b:Int b=s.toInt() \\\\使用!!表示输入的值必须不为null才能计算，?表示可为null var a = readLine() var b = readLine() var c = a!!.toInt() var d = b!!.toInt() println("a + b = ${c+d}")
try捕获异常
try { var c = a!!.toInt() var d = b!!.toInt() println("a + b = ${c+d}") }catch (e:Exception){ println("数据异常输入") }
递归
//由于计算的数字返回的结果比较大这里使用java中的BigInteger数据类型 fun main(args: Array<String>):Unit { println(fact(BigInteger("70"))) } /** * @author shenj * @title: fact * @date 2020/11/20 14:55 */ fun fact(num:BigInteger):BigInteger{ if(num == BigInteger.ONE){ return BigInteger.ONE }else{ return num* fact(num- BigInteger.ONE) } }
尾递归（防止堆栈溢出）、（Kotlin特性非java特性）
//使用tailrec关键字修饰递归方法可以优化递归，并在参数列表中加入每次递归的结果 fun main(args: Array<String>):Unit { println(fact(BigInteger("100000"),BigInteger("0"))) } /** * @author shenj * @title: fact * @date 2020/11/20 14:55 */ tailrec fun fact(num:BigInteger,result:BigInteger):BigInteger{ if(num == BigInteger.ZERO){ return BigInteger.ONE }else{ return fact(num-BigInteger.ONE,result+num) } }
面向对象
继承
//使用open关键字使子类可以继承父类 open class FatherClass(name:String, age:Int) { var name:String = name var age:Int = age open var temper = "暴躁的" //使用open关键字使子类可以重写父类的方法 open fun character(){ println("父类的实现类对象："+name+"今年年龄:"+age+"性格:"+temper) } } //子类继承父类 class SonClass(name: String, age: Int) : FatherClass(name, age) { override var temper = "安静的" override fun character(){ println("子类的实现类对象："+name+"今年年龄:"+age+"性格:"+temper) } } fun main(args: Array<String>) :Unit{ var fartherOp = FatherClass("Matrix",56) fartherOp.character() var sonOp = SonClass("Marry",18) sonOp.character() }
抽象类和多态
//抽象类 bstract class Human(name: String) { abstract fun eat() abstract fun hair() } //抽象实现类 class Man(name:String):Human(name) { private var name=name override fun eat() { println("${name}大口吃！") } override fun hair() { println("${name}寸头！") } override fun toString(): String { return "Man(name='$name')" } } //抽象实现类 class Girl(name: String) : Human(name) { private var name = name override fun eat() { println("${name}小口吃！") } override fun hair() { println("${name}长发！") } override fun toString(): String { return "Girl(name='$name')" } } //子类实现抽象类的时候重写方法时，抽象类无需加open
抽象类和接口
//抽象类 abstract class Human(name: String) { abstract fun eat() abstract fun hair() } //接口 interface Iskill { fun makeUp() } //实现类 class Man(name:String):Human(name) { private var name=name override fun eat() { println("${name}大口吃！") } override fun hair() { println("${name}寸头！") } override fun toString(): String { return "Man(name='$name')" } } //实现抽象类，和接口 class Girl(name: String) : Human(name), Iskill { private var name = name override fun eat() { println("${name}小口吃！") } override fun hair() { println("${name}长发！") } override fun makeUp() { println("涂抹skr神仙水！") } override fun toString(): String { return "Girl(name='$name')" } } var person1 = Man("Liming") var person2 = Girl("Alin") var personList = listOf(person1,person2) personList.forEach { s-> println(s.eat()) } personList.forEach { s-> println(s.hair()) } for (value in personList){ println(value.toString()) } person2.makeUp() } //Kotlin中的接口是可以给函数实现函数体的 //Kotlin中的多继承也是通过接口来实现的，因为能给接口中的函数实现函数体，间接地相当于实现了多个父类的继承。 //如果两个父类接口中有相同的函数，那么我们可以通过super<父接口1>的方式来继承指定父类的函数体 //super<TestB>.commonFun()
知识补充【3】
//可以使用is关键字来判断一个对象是否属于一个类，比如：Man is Human 返回为Boolean值 //foreach(闭包)中的可以不用s->println(s)；默认的值为it,使用println(it)
代理和委托（by）、单例（object）
//使用object关键字代替class即选择单例模式，全局同一个对象 object BigHeadSon:IHouseWork { override fun doTheWashingUp() { println("BigHeadSon,1/1") } } //使用by关键字表示IHouseWork的方法指向BigHeadSon.doTheWashingUp()委托BigHeadSon对象 class LittleHeadDad:IHouseWork by BigHeadSon{ override fun doTheWashingUp() { BigHeadSon.doTheWashingUp() } } fun main(args: Array<String>):Unit { var farther = LittleHeadDad() var son = BigHeadSon println(farther.doTheWashingUp()) }
枚举，注重数据
enum class Week { 礼拜一,礼拜二,礼拜三,礼拜四,礼拜五,礼拜六,礼拜日 } fun main(args: Array<String>):Unit { //打印指定枚举元素 println(Week.礼拜一) //.ordinal获取枚举元素在枚举中的位置，起始位置为0 println(Week.礼拜一.ordinal) }
密封类(印章类),注重类型
//印章类，规定允许存在的类型 sealed class Son { class Horse():Son(),IAnimalBehavior{ override fun eat() :String = "草" } class DonKey():Son(), IAnimalBehavior{ override fun eat(): String = "野草" } } fun main(args: Array<String>):Unit { var donkey = Son.DonKey() var horse = Son.Horse() println(donkey.eat()) println(horse.eat()) }
知识补充【4】
1、数据类型如果需要使用一个类的实现类的话也就是强制转换，可以使用如下方法： val dataBuf = msg as ByteBuf as可以强制转换
