Kotlin-面向对象

5.1面向对象的基本概念

5.5.1类

类是由属性和方法组成的，类是面向对象的核心和基础，可以将相似的对象封装在一个类中

5.1.2对象

对象是类的实例化，创建一个对象表示实例化一个类

只有创建对象，才可以使用类的属性和方法

5.1.3面向对象的三大特性

封装，继承和多态

1、封装，是指把类的使用和实现分开，只保留有限的接口给外部使用。

封装只留给开发者一个访问对象的接口，使开发者不能直接访问内部信息

2、继承

3、多态

5.2类与对象

对象：是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。

类：对具有相同特性和行为的对象的抽象

类是对象的模板，对象是类的具体体现。

5.2.1类的定义

class PlayerObject{}

5.2.2成员属性

//定义一个PlayerObject类，并添加普通属性，如姓名、体重、身高，以及组合属性。如健康程度(体重/身高的平方得到的值)
class PlayerObject{
    var name:String="Kotlin"
    set
    var weight=0.0
    set
    var height=0.0
    set
    var BIM:String=""
    get(){
     var b=this.weight/Math.pow(this.height,2.0)
        if(b<=18.5){
            return "偏瘦"
        }else if(b in 18.5..23.9){
            return "过重"
        }else{
            return "肥胖"
        }
    }
}
fun main(args:Array<String>){
    var Player=PlayerObject()
    Player.weight=80.5
    println("${Player.name},${Player.height},${Player.weight},${Player.BIM}")
}

5.2.3成员方法

类的函数==成员方法

5.2.4对象实例化

//以PlayerObject类为例，实例化对象之后调用成员变量和成员方法playBasketBall()
fun main(args:Array<String>){
    var Player=PlayerObject()

    Player.name="Kotlin"
    Player.weight=48.0
    Player.height=1.60

    println("${Player.name},${Player.height},${Player.weight},${Player.BIM}")
    Player.playBasketball()
}

5.2.5构造函数

class PlayerObject constructor(var name:String,var weight:Double,var height:Double){
    var sex:String=""
    set
    val BIM:String
    get(){
        var b=this.weight/Math.pow(this.height,2.0)
        if(b<=18.5){
            return "偏瘦"
        }else if(b in 18.5..23.9){
            return "正常"
        }else{
            return "肥胖"
        }
    }
    fun playBasketball(){
        println("我可以打篮球")
    }
    fun main(args:Array<String>){
        var Player=PlayerObject("Kotlin",48.0,1.60)
        Player.sex="Female"
        println("${Player.name},${Player.sex},${Player.height},${Player.weight},${Player.BIM}")
        Player.playBasketBall()
    }
}

5.2.6继承和多态的实现

1、继承

//定义一个PlayerObject类，并添加普通属性，如姓名、体重、身高，以及组合属性。如健康程度(体重/身高的平方得到的值)
class PlayerObject1{
    var name:String="Kotlin"
    set
    var weight=0.0
    set
    var height=0.0
    set
    var BIM:String=""
    get(){
     var b=this.weight/Math.pow(this.height,2.0)
        if(b<=18.5){
            return "偏瘦"
        }else if(b in 18.5..23.9){
            return "过重"
        }else{
            return "肥胖"
        }
    }
}
fun main(args:Array<String>){
    var Player=PlayerObject1()
    Player.weight=80.5
    println("${Player.name},${Player.height},${Player.weight},${Player.BIM}")
}

2、重载

class Burders(var a:Boolean){
    init{
        if(this.a==true){
            this.show()
        }else{
            this.say()
        }
    }
    fun show(){
        println("show方法")
    }
    fun say(){
        println("say方法")
    }
}
fun main(args:Array<String>){
    var b=Burders(false)
}

5.2.7封装

//封装一个类，完成两个数的加减乘除，并针对num1,num2和operator三个变量进行不同的权限赋予，然后输出运算结果
class CalculatorNum(protected var num1:Int,private var num2:Int){
    public var operator:Char='+'
    fun getnum1(){
        println("${num1}")
    }
    internal fun getnum2(){
        println("${num2}")

    }
    fun caculatNum(){
        when(this.operator){
            '+'->{
                println("两个数相加:${this.num1+this.num2}")
            }
            '-'->{
                println("两个数相减:${this.num1-this.num2}")
            }
            '*'->{
                println("两个数相乘:${this.num1*this.num2}")
            }
            '/'->{
                println("两个数相除:${this.num1/this.num2}")
            }
        }
    }
}
fun main(args:Array<String>){
    var CaculatorNum=CalculatorNum(100,20)
    CaculatorNum.operator='-'
    CaculatorNum.getnum1();
    CaculatorNum.getnum2();
    CaculatorNum.caculatNum();
}

//创建一个父类Outer，并创建两个子类继承这个父类，查看public,protected,private,internal修饰符
open class Outer{
    private var a=1
    protected var b=2
    internal var c=3
    open public var d=4
}
class subclass:Outer(){
    fun test(){
        println(super.b)
        println(super.c)
        println(super.d)
    }
}
class Unrelated(public val o:Outer){
    fun test(){
        println(o.c)
        println(o.d)
    }
}

5.3 Kotlin对象高级应用

5.3.1this关键字的使用

//当类被实例化后，this同时被实例化为该类的对象，这时候对类使用javaClass方法，将打印该类名
class athis(){
    private var a:String="this is a "
    fun showclass(){
        println(this.javaClass)
    }
    fun seta(a:String):String{
        this.a=a
        return a
    }
    fun geta():String{
        return this.a
    }
}
fun main(args:Array<String>){
    var athis=athis()
    athis.seta("this is a")
    print(athis.geta())
}

5.3.2super关键字的使用

open class superfather(){
    var a=10
    fun message(){
        println("This is class superfather fun")
    }
}
class son:superfather(){
    fun show(){
        super.message()
        println(super<superfather>.a)
        println("This is class son fun")
    }
}
fun main(args:Array<String>){
    val son=son()
    son.show()
}

5.3.3 open关键字的使用

class Person{
    private var Name="Kotlin"
    class Language{
        var list= arrayListOf("中文","英语","日语")
        var str=list.joinToString ()
    }
    inner class Names{
        fun changeName(newName:String){
            Name=newName
            println("您可以看到新的名字是${Name}")

        }
    }
}
fun main(args:Array<String>){
    println(Person.Language().str)
    Person().Names().changeName("Kotlin")
}

5.3.5数据类

//创建一个文章数据类，该数据类存储有id号，文章标题name和文章描述dec三个变量
data class article(var id:Int,var name:String,var dec:String)
fun main(args:Array<String>){
    var article=article(1,"Kotlin","全栈编程语言")
    println(article.toString())//序列化
    var newName=article.copy(id=2,name="Java",dec="面向对象编程语言")
    println(newName.toString())//更改属性
    var(id,name,dec)=article
    println("${id},${name},${dec}")//解构
    println("${article.component1()},${article.component2()},${article.component3()}")//component方法
}

5.3.6枚举类

//创建两个枚举类，分别是rainbow(彩虹的颜色),和corour（颜色的rgb值)
enum class rainbow{
    赤,橙,黄,绿,青,蓝,紫
}
enum class corour(val rgb:Int){
    RED(0xFF000),GREEN(0x00FF00),BLUE(0x0000FF)
}
enum class anonys{
    WATTING{
        override fun signal()=TALKIN
    },
    TALKIN{
        override fun signal()=WATTING
    };
    abstract fun signal():anonys
}
fun main(args:Array<String>){
    println(rainbow.values().joinToString() )
    println(corour.GREEN)
    println(corour.valueOf("BLUE").name)
    println(corour.valueOf("BLUE").ordinal)//序号
    println(corour.values().joinToString { it.name+":"+it.rgb })
    println(corour.valueOf("BLUE").rgb)
    println(anonys.values().joinToString { it.name })

}

5.3.7 对象表达式和对象声明

//创建一个类A，然后在main函数中创建一个与类A相关的对象表达式
open class A(x:Int){
    public open val y:Int=x

}
fun main(args:Array<String>){
    var ab:A=object :A(10){
        override val y=15
    }
}

对象声明