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
}
}
对象声明