Kotlin学习记录

常见的数据类型

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){//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) {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):Unit {//..表示声明了一个数组包含值1~10，也可以使用listOf()生成数组var list1 = 1 .. 10for(value in list1){println(value)}//until表示声明一个数组1~9（不包含10）[1,10)var list2 = 1 until  10for(value in list2){println(value)}//for可以通过step设置步长var list3 = 1 until  10for(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集合

//创建不可变集合，返回值是Mapvar 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}")//创建LinkedHashMapvar 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):Unit {//使用treemapvar map = TreeMap()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才能计算，?表示可为nullvar 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):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):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 = namevar age:Int = ageopen 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) :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=nameoverride 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 = nameoverride 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=nameoverride 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 = nameoverride 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.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):Unit {var farther = LittleHeadDad()var son = BigHeadSonprintln(farther.doTheWashingUp())
}

枚举，注重数据

enum class Week {礼拜一,礼拜二,礼拜三,礼拜四,礼拜五,礼拜六,礼拜日
}fun main(args: Array):Unit {//打印指定枚举元素println(Week.礼拜一)//.ordinal获取枚举元素在枚举中的位置，起始位置为0println(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):Unit {var donkey = Son.DonKey()var horse = Son.Horse()println(donkey.eat())println(horse.eat())
}

知识补充【4】

	1、数据类型如果需要使用一个类的实现类的话也就是强制转换，可以使用如下方法：val dataBuf = msg as ByteBufas可以强制转换

• 🙋‍♂️2020/11/21总结(全):

  完成，Kotlin因为是基于java开发的，可以更好的提高开发java的效率，弥补了java中一些短板，学的比较快但是都是能够清楚明白的，也回归了java的知识点，Kotlin的特性比较友好，学起来一点都不觉得吃力，最主要还是java为基础.
  重点：数据类型和java的相同，when补充了java中没有switch的尴尬，使用${}方式取值有JSP的特点,Kotlin的递归优化、委托
  难点：理解Kotlin和Java的差异
  

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！