Kotlin学习记录

举报
芝士味的椒盐 发表于 2022/04/30 20:56:59 2022/04/30
【摘要】 ​常见的数据类型Byte 存储值范围整数-128-127Short 存储值范围整数-32768-32767Int 存储值范围整数-2147483648-2147483647Long 存储值范围整数-9223372036854775807-9223372036854775807Foat 存储值范围小数，小数点可以精...

​

常见的数据类型

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可以强制转换


​

【版权声明】本文为华为云社区用户原创内容，未经允许不得转载，如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java 数据结构
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入