Kotlin学习笔记

发表于 | 分类于 | 本页总阅读数 次

基础

1.Hello World

1
2
3
4
5
package io.github.zhengyue

fun main() {
    println("hello kotlin")
}

2.变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 变量的声明和使用
 */
fun main(args: Array<String>) {
    var name = "张三" // 这块空间存放的是字符串类型的数据
    name = "李四"
    println(name)

    // 定义变量时，计算机开出一块存储空间，存放的类型为整形
    var i:Int = 18
    var j:Long = 99999999
    var s:String = "王五"
    
    val number = "hello kotlin" // val定义的变量不能被重新赋值
}

3.函数

1
2
3
4
5
6
7
fun main(args: Array<String>) {
    println(plus(1, 2))
}

fun plus(a:Int, b:Int):Int {
    return a + b
}

4.字符串模板

1
2
3
4
5
6
7
8
9
10
11
12
package io.github.zhengyue

fun diaryGenerater(placeName:String):String {
    var temp = "今天天气晴朗，万里无云，我们去${placeName}游玩，" +
            "首先映入眼帘的是${placeName}${placeName.length}个鎏金大字。"
    return temp
}

fun main(args: Array<String>) {
    val diary = diaryGenerater("中山公园")
    println(diary)
}

5.字符串比较

1
2
3
4
5
6
7
8
9
10
11
12
package io.github.zhengyue

fun main(args: Array<String>) {
    var a:String = "abc"
    var b:String = "Abc"

    println(a==b) // Kotlin中的字符串==处理相当于Java的equals
    println(a.equals(b))

    println(a.equals(b, true)) // 第二个参数是否忽略大小写，true忽略大小写
    println(a.equals(b, false))
}

6.空值处理

​ 当函数传递的参数为空时Kotlin在语法分析阶段直接提示报错，避免空指针传入

​ 如果一定要传入空值加上问号代表参数可以为空

1
2
3
4
5
6
7
8
9
10
11
/**
 * 空值处理，加上问号代表参数可以为空
 */
fun heat(str: String?):String {
    return "热" + str
}

fun main(args: Array<String>) {
    val heat = heat(null)
    println(heat)
}

7.When表达式

​ 满足条件执行相应方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package io.github.zhengyue

fun gradeJujge(score:Int) {
    when(score) {
        10 -> println("考了满分，棒棒哒")
        9 -> println("干得不错")
        8 -> println("还可以")
        7 -> println("还需努力")
        6 -> println("刚好及格")
        else -> println("需要需要加油哦")
    }
}

fun main(args: Array<String>) {
    gradeJujge(3)
}

8.Loop和Range

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package io.github.zhengyue

fun main(args: Array<String>) {
    var nums = 1 .. 100  // [1,100]
    var nums2 = 1 until 100 //[1,100)
    for (num in nums2) {
        print("${num}，")
    }

    var nums3 = 1..20
    for (i in nums3 step 2) { // 步长为2
        println(i)
    }

    var nums4 = nums3.reversed() // 反转

    println(nums4.count()) // 长度
}

9.List和Map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package io.github.zhengyue.basics

fun main(args: Array<String>) {
    var lists = listOf("买鸡蛋", "买大米",
        "买冰淇淋")
    for ((index, value) in lists.withIndex()) {
        println("$index $value")
    }

    var mp = HashMap<String, String>()
    mp["优秀"] = "A"
    mp["良好"] = "B"
    mp["及格"] = "C"
    mp["不及格"] = "D"
    println(mp["优秀"])
}

10.函数表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package io.github.zhengyue.basics

/**
 * 函数表达式
 */
fun add(x:Int, y:Int):Int = x + y

fun main(args: Array<String>) {
    var result = add(1, 2)
    println(result)

    var funI = {x:Int, y:Int -> x+y}
    var result2 = funI(2, 3)
    println(result2)

    var funJ:(Int, Int) -> Int = {x, y -> x + y}
    val result3 = funJ(3, 4)
    println(result3)
}

11.默认参数和具名参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package io.github.zhengyue.basics

/**
 * 具名参数，默认参数
 */
val  Pi = 3.14159f
fun getRectangleArea(lenthgh:Float, width:Float):Float = lenthgh * width

fun getCircularPerimeter(PI:Float = Pi, r:Float):Float =  2 * PI * r

fun getCircularPerimeter2(PI:Float = Pi, d:Float):Float =  PI * d

fun getCylinderVolume(PI:Float = Pi, r:Float, h:Float):Float =  PI * r * r * h

fun getBallSurfaceArea(PI:Float = Pi, r:Float):Float =  4 * PI * r * r

fun main(args: Array<String>) {
    val area = getCircularPerimeter(r = 2.0f)
    println(area)
}

12.字符串和数字的相互转换

1
2
3
4
5
6
7
8
9
10
11
12
package io.github.zhengyue.basics

fun main(args: Array<String>) {
    var a = "123"
    var b = 123

    a = b.toString()
    b= a.toInt()

    println(a is String)
    println(b is Int)
}

13.输入

1
2
3
4
5
6
7
8
9
10
fun main(args: Array<String>) {
    println("请输入第一个数字：")
    var numStr1 = readLine()
    println("请输入第二个数字：")
    var numStr2 = readLine()

    var num1:Int = numStr1!!.toInt() // !!确保输入的字符串不为空
    var num2:Int = numStr2!!.toInt()
    println("${num1} + ${num2} = ${num1 + num2}")
}

14.异常处理

1
2
3
4
5
6
7
8
9
10
11
package io.github.zhengyue.basics

import java.lang.Exception

fun main(args: Array<String>) {
    try {
        var a = 2 / 0
    } catch (e:Exception) {
        e.printStackTrace()
    }
}

面向对象

1.静态属性和动态行为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Girl(var chactor:String, var voice:String) {
    fun smile() {
        println("hahahaha")
    }

    fun cry() {
        println("55555")
    }
}

fun main(args: Array<String>) {
    var girl = Girl("漂亮", "甜美")
    println("这个女孩声音${girl.voice}")
    girl.cry()
    girl.smile()
}

2.封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 封装
 */
class Dog {
    private var name = "小黑"
    fun setName(name: String) {
        this.name = name
    }

    fun getName():String {
        return this.name
    }
}

fun main(args: Array<String>) {
    var dog = Dog()
    println(dog.getName())

    dog.setName("小黄")
    println(dog.getName())
}

3.继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 有open关键字的类，才能被继承
open class Father {
    var chactor:String = "性格内向"

    // 方法同样有open关键字才能重写
    open fun  action() {
        println("公共场合喜欢大声喧哗")
    }
}


class Son : Father() {
    override fun action() {
        println("儿子很乖，不大声喧哗")
    }
}

4.抽象类和多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 抽象类，抽象方法必须在子类实现
abstract class Human(var name:String) {
   abstract fun eat()
}

class Man(name: String): Human(name) {
    override fun eat() {
        println("${name}哇哇哇大口吃")
    }
}

class Woman(name: String):Human(name) {
    override fun eat() {
        println("${name}呜呜呜小口的吃")
    }
}

fun main(args: Array<String>) {
    var person = Man("小明")
    person.eat()

    var person2 = Woman("小红")
    person2.eat()
}

5.接口

1
2
3
4
5
6
7
8
9
10
11
12
13
interface IMan {
    fun eat()
}

/**
 *  接口后面不用跟小括号实现，抽象类需要
 */
class Man:IMan {
    override fun eat() {
        println("大口吃饭")
    }

}

6.委托和代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class BigHeadSon: IWashBowl {
    override fun washing() {
        println("我是大头儿子，我在洗碗，一次赚一块钱")
    }
}

// 通过by关键字委托给其他类
class SmallHeadFather: IWashBowl by BigHeadSon() {
    override fun washing() {
        println("我是小头爸爸，")
        BigHeadSon().washing()
        println("我是看着儿子把碗洗好了")
    }
}	

fun main(args: Array<String>) {
    var father = SmallHeadFather()
    father.washing()
    // 我是小头爸爸，我赚了十块钱
	// 我是大头儿子，我在洗碗，一次赚一块钱
	// 我是看着儿子把碗洗好了
}

7.单例模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface IWashBowl {
    fun washing()
}

// object关键字代表该类为单例模式的类
object BigHeadSon: IWashBowl {
    override fun washing() {
        println("我是大头儿子，我在洗碗，一次赚一块钱")
    }
}

// 单例模式下委托类后面不再添加小括号，即类无需再创建
class SmallHeadFather: IWashBowl by BigHeadSon {
    override fun washing() {
        println("我是小头爸爸，我赚了十块钱")
        BigHeadSon.washing()
        println("我是看着儿子把碗洗好了")
    }
}

8.枚举

1
2
3
4
5
6
7
enum class 枚举 {
    星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日
}

fun main(args: Array<String>) {
    println(枚举.星期一.ordinal)
}

9.印章类

1
2
3
4
5
6
7
8
9
10
11
sealed class Son {
    fun sayHello() = println("大家好")

    class 驴(): Son()
    class 骡子(): Son()
}

fun main(args: Array<String>) {
    var s: Son = Son.驴()
    s.sayHello()
}
如果你觉得有帮助，慷慨如你，可以扫描下面的二维码赞赏一下