Koitlin_Day04

知识点1:Kotlin运算符及其重载

 * 算术运算符      +  -  *  /  %
 * 自增自减          ++   --
 * 关系运算符     ==   !=  >   <   >=   <=
 * 逻辑运算符   &&  || & |
 * 赋值运算符  +=  -=  *=  /=  %=
 * 其他运算符  xx?xx:xx     instanceof
 * 1.Kotlin每个运算符都对应一个方法,如果说想要把对象之间相加重写对应的方法即可
 * 2.kotlin运算符对应的方法可以在官网查询fun main(args: Array<String>) {    var a = 10
    var b = 16
    var c = a + b
    println(c)//26
    a++
    println(a)//11
    var girl1 = Girl("a",12)    var girl2 = Girl("b",13)    var girl = girl1 + girl2
    println(girl)//Girl(name='ab', age=25)
    var boy1 = Boy("korben",28)    var boy2 = Boy("korben",30)    var s = boy1 +10
    //注意:重写Boy类运算符方法时,参数值的类型以及返回值的类型要根据相加的数值类型
    //比如:boy1+10,重写后的运算符方法的参数值和返回值类型就需要是Int类型
    //如果boy1+boy2 那么重写的运算符方法的参数值和返回值类型就需要时Boy类型
    println(s)//38}class  Girl(var name:String,var age:Int){    operator fun plus(girl: Girl): Girl {        this.age += girl.age        this.name +=girl.name        return this
    }    override fun toString(): String {        return "Girl(name='$name', age=$age)"
    }
}class  Boy(var name:String,var age:Int){    operator fun plus(s:Int): Int {        this.age += s        return this.age
    }    override fun toString(): String {        return "Girl(name='$name', age=$age)"
    }
}

知识点2:运算符重载

/*--------------------需求:写一个类的两个对象相加的和----------------------*/fun main(args: Array<String>) {    var c1 = Cat("黑猫",4)    var c2 = Cat("灰猫",4)    var c = c1 + c2
    println(c)//8}class Cat(var category:String,var leg:Int){    //注意plus()的参数值只能是一个
    operator fun plus(c:Cat):Int{        return this.leg+leg
    }
}

知识点3:运算符重载练习

/*--------------------需求:求一个老师从助教-讲师-副教授-教授的等级和薪资变化 ++----------------------*/fun main(args: Array<String>) {    var t1 = Teacher()//助教
    println(t1)//Teacher(等级=1, 薪资=6000)
    var t2 = t1++//讲师
    println(t2)//Teacher(等级=2, 薪资=7000)
    var t3 = t2++//副教授
    println(t3)//Teacher(等级=3, 薪资=8000)
    var t4 = t3++//教授
    println(t4)//Teacher(等级=4, 薪资=9000)}class Teacher{    var level = 1
    var salary = 6000
   operator fun inc():Teacher{        this.level++
        salary += 1000
        return this
    }    override fun toString(): String {        return "Teacher(等级=$level, 薪资=$salary)"
    }
}

知识点4:类成员的set/get方法

fun main(args: Array<String>) {    var p1 = PersonS()
    println(p1.name)//咚咚锵
    p1.age=19
    println(p1.age)//19
    var p = Person("koben",28)
    println(p)//Person(name='koben' age='12')}//1.kotlin的类成员变量已经默认实现了get/set方法//2.类成员变量可以访问和修改class PersonS{    var name = "咚咚锵"
    var age = 18}class Person(var name: String,age:Int){    var age = 12
    get() {        return field//作用:在get/set里面访问字段
        //如果此处使用return this.age会产生递归 一直调用get()方法
    }    /*get() = this.age*///        get//Person(name='koben')
    override fun toString(): String {        return "Person(name='$name' age='$age')"
    }
}

知识点5:修改成员的可见性

 @ FileName:修改成员的可见性` --->也就是使用private修饰成员变量或者setfun main(args: Array<String>) {    /*var s = School("21","dalian")
    var s1 = School("23","shanghao")
    println(s)
    println(s1)*/
    var l = LOL()
    println(l.name)//XY
    l.age = 26//修改LOL里面的年龄
    println(l.age)//26}class LOL{//对应java只有成员变量和set/get方法
    var name = "XY"/*----------需求:在外面 只能访问name  不能修改name   在里面可以修改-:使用private修饰name的set方法-------*/
    private set
    var age = 23/*---需求:在外面 在外面既不能访问age  也不能修改age  在里面可以:使用private关键字修饰成员变量sex------*/
    private var sex = "gilr"}class Student(){//对应的Java编码:类中有name和age成员变量及其set/get方法(注意;Student后面有没有()都一样的 )
    var name = "齐德龙"
    var age =  "17"}class School(name:String,place:String){//对应的Java编码:类中只有一个有参构造方法}class Fat(var name: String,var leg:Int){//对应的Java编码:类中有成员变量及其set/get方法,以及有参构造方法}

知识点6:自定义访问器

/*--------------------Start Kotlin----------------------*//**
 * @ FileName:   `06.自定义访问器`--->也就是自定义set/get方法内的内容
 * @ Author:   LanSir
 * @ Time:    2018/8/8 17:09
 * @ Description:
 * 每一个字段都可以通过filed表示!
 */fun main(args: Array<String>) {    var worker = Worker()
    println(worker.name)//齐德龙
    println(worker.age)//1
    worker.name="12"
    println(worker.name)//王德发
    worker.age=2
    println(worker.age)//20}//set作用,在外部修改的时候限制内容或者范围class Worker{    var name = "齐德龙"
    set(value) {field = "王德发"}    var age = 1
    set(value) {if (age<100 && age >18)field=value else field = 20}
}

知识点7:主构函数及其参数使用

fun main(args: Array<String>) {    var s = Stu("XY",18)
    println(s.name)//XY
    println(s.age)//18
    s.age = 25
    s.name = "sir"
    println(s.age)//25
    println(s.name)//sir}//Kotlin构造函数 --->主构函数class Stu(name:String,age:Int){    var name = "王德发"
    var age = 16
    /*init {
        this.name = name
        this.age = age
    }*/
    override fun toString(): String {        return "Stu(name='$name', age=$age)"
    }
}

知识点8:var和val在主构函数中的使用

 * 1.如果没使用var\val修饰,参数在其他地方不能使用\
 * 2.使用var修饰的,在其它地方可以使用,也可以修改
 * 3.如果使用val修饰,在其它地方可以使用,但是不能修改
 */fun main(args: Array<String>) {    var p = Pig("yezhu",60.5)
    p.weight
    p.weight = 90.2
    println(p.weight)//90.2}//var/val 相当于我们定义了字段 可以直接使用class Pig(var name:String,var weight:Double)

知识点9:次构函数

fun main(args: Array<String>) {    var dt1 = Doctor("dong")    var dt2 = Doctor("dong",23)
    println(dt1)//Doctor(name='dong')
    println(dt2)//Doctor(name='dong')}class Doctor(var name: String){    //次构函数必须调用主构函数,必须要把参数传递给主构函数
    constructor(name:String,age:Int):this(name)    override fun toString(): String {        return "Doctor(name='$name')"
    }
}

知识点10:次构函数间调用

fun main(args: Array<String>) {

}class DD(var age:Int){    //次构函数必须调用主构函数,必须把参数传给主构函数
    constructor(age: Int,height:Double):this(age)    //次构函数可以调用主构函数,可以调用次构函数(其实是间接调用快乐主构函数)
    constructor(age: Int,height: Double,weight:Double):this(age,height)
}

知识点11:次构函数使用

 * 构造函数加var和val只能在主构函数里面加  次构函数不能加
 * 主构函数参数可以直接加上var和val使用  次构函数只能够自己定义变量进行保存
 */fun main(args: Array<String>) {    var lov = Lov("咚咚锵")
    println(lov.phone)
}class Lov(var name:String){    var age = 18
    var phone = "7Plus"
    constructor(name: String,age:Int,phone:String):this(name){        //次构函数不能加var/val,只能通过这种方式
        this.age = age        this.phone = phone
    }
}

作者：蓝Renly
链接：https://www.jianshu.com/p/9c738b37c326