三,Kotlin-类型初步

1,类和接口

<1>类的相关概念

类的简介

类是一个抽象的概念
类是具体某些特性的事物的概括
不特定指代任何一个具体的事物
例如:人,车,书 ;数字,字符串,字符也都是类
写法 class<类名>{成员}

对象的简介

对象是一个具体的概念,与类相对
指代某一种类的具体个体

类和对象的关系

一个类通常可以有很多个具体的对象
一个对象的本质只能从属于一个类
对象经常被称为类的对象或类的实例

<2>类的定义

class simpleClass1 {}
//一般的构造器写法儿
class simpleClass2 {
    var string: String

    constructor(string: String) {
        this.string = string
    }
}

//主构造器
class simpleClass3(var string: String) {}

//主构造器和副构造器同时存在
class simpleClass4(var string: String) {
    var arg: Int = 0

    constructor(string: String, arg: Int) : this(string) {
        this.arg = arg
    }
}
//多个副构造器
class simpleClass5 {
    var name: String = ""
    var age: Int = 0
    constructor(name: String) {
        this.name = name
    }
    constructor(age: Int) {
        this.age = age
    }
}

Kotlin中有主构造器和副构造器的概念,主构造器会提取到类名的后面进行声明,这样每次构建该类时这必须通过主构造器,也可以在类中定义其他副构造器,但是所定义的副副构造器必须也有主构造器的声明

<3>类的实例化

    val testClass = simpleClass3("wjf")
    println(testClass.string)
    val testClass2 = simpleClass5(1)
    println("${testClass2.age},${testClass2.name}")

<4>接口

接口的定义和实现

interface simpleInterface1 {
    fun simpleMethod(age: Int): Int
}

class simpleImi : simpleInterface1 {
    override fun simpleMethod(age: Int): Int {
        return 1
    }
}

与Java中不同的是Kotlin中override是一个关键字,当类实现接口时必须带有该关键字

<5>抽象类

抽象类的定义

abstract class simpleABSClass {
    abstract fun absfun()
    open fun canBeOverride() {}
    fun cannotBeOverride() {}
}

open class simpleAbsIme(name: String, age: Int) : simpleABSClass() {
    override fun absfun() {
    }

    final override fun canBeOverride() {
        super.canBeOverride()
        println()
    }
}

class childSimpleAbsIme(name: String, age: Int) : simpleAbsIme(name, age) {
    //父类中的方法加了final 所以该子类不能被复写
//    override fun canBeOverride() {
//        super.canBeOverride()
//        println()
//    }
}

这里有几点需要注意

除了接口和抽象类外定义的类,默认是final类型的不能被继承,如果想继承该类必须在类上加"open"字段
除了接口和抽象类的类必须实现的方法外,默认定义的方法也是final类型的,如果子类想要复写该方法,则必须在该方法前面加"open"字段
如果实现了接口或抽象的方法,不想再被子类复写那么可以在该方法前面加"final"字段

<6>类的属性和类的属性引用

class Person(name: String, age: Int) {
    //类的属性,kotlin中自动生成getter和setter
    var name: String = name
    //    get() {
//        return field
//    }
//    set(value) {
//        field=value
//    }
    var age: Int = age
//    get() {
//        return age
//    }
//    set(value) {
//        field=value
//    }
}
fun main(args: Array<String>) {
    val aPerson = Person("WJF", 25)
    //由于该引用没有具体的实现类所以调用set的时候需要传入具体的receiver
    //类的属性引用
    val testNoClass = Person::name
    testNoClass.set(aPerson, "WWJJFF")
    //有具体实现类的属性引用
    val testHadClass = aPerson::name
    testHadClass.set("WJF")
}

2,扩展方法和扩展属性

一个类中没有的方法可以通过扩展增加该方法
定义形式为:fun receiver.<方法名>(参数列表):<返回值类型>
调用:receiver.<方法名>(参数列表)

   println("WWJJFF".padding(5, '_'))
   println("_".times(10))

fun String.padding(cont: Int, char: Char = ' '): String {

   val padding = (1..cont).joinToString("") { char.toString() }
   return "${padding}${this}${padding}"
}

fun String.times(count: Int): String {
   return (1..count).joinToString("") { this }
}

除了给类增加扩展方法之外,还可以给类增加扩展属性

如果类中没有接收该扩展属性的属性,则只能定义成val形式的只取返回值

class PoorGuy
//类的属性=backing filed +getter +setter
//增加扩展属性money类型为Double
val PoorGuy.money: Double
    get() {
        return 1.0
    }

val guy: PoorGuy = PoorGuy()
val aa = PoorGuy::money//正常的属性引用
val bb = guy::money//具体对象的属性引用

注意:接口中可以定义属性,但是该属性不能有backing filed;因为接口不能存储东西,只能定义行为,接口中可以默认实现,只能是行为,不能持有状态

扩展方法的类型和普通方法的类型一样

3,空类型安全

空类型安全:任意类型都有可空和不可空两种;Kotlin提供了编译级别的预防.

每个方法的返回值或者每个变量在被使用到时如果可为null则编译器会提示使用该值时需要进行null判断;
如果方法的返回则不可为null,则该使用到时可不进行判断;
如果已经确认可为null返回值的已经为null,可使用'!!'直接调用

fun getNameNotNull(): String {
    return "not Null"
}
fun getNameCanNull(): String? {
    return null
}
fun getNameRealOne(): String? {
    return "A Real name"
}
fun main(args: Array<String>) {
    //不用判断,因为肯定不为null
    println(getNameNotNull().length)
    //此时需要判断,可能为null,若不判断编译不过,加?标示不为null时调用.length
    //若为为null则返回null
    println(getNameCanNull()?.length)
    //已经知道了结果肯定不为null,但是此时编译器不认,需要使用!!告诉
    //编译器我已经确定结果肯定不为null
    println(getNameRealOne()!!.length)
    val aName: String = getNameCanNull() ?: return
    //等同于if (aName==null) return
    println(aName.length)
}

任意类型 String Int Any Person等作为变量或者返回值类型时加"?"表示可为空类型,这样在用到该变量或者返回值时需要进行判断

例如:
var abc:String?=null
var p:Any?=null

安全访问和elvis运算符

"?." 安全访问:如果变量为null则直接返回null
"?:" elvis 运算符,如果前面的表达式返回为null 则返回后面的值

    val str:String?="Hellos"
    var len=str?.length?:0

String?和String是什么关系呢?String是String?的子类

平台类型

Kotlin在访问其他语言的对象或者方法时,如果返回String!或者Any!表示,返回的是平台类型,这个时候需要开发者自己判断null or not null

4,智能类型转换

智能类型转换:如果通过已知条件判断出某个类所属类型,可直接使用某类的特性即可,编译器会尽可能的推导类型,远离无用的类型转换

open class Parent {}
class Child : Parent() {
    fun getName(): String {
        return "000";
    }
}
fun main(args: Array<String>) {
    val test: Parent = Child()
    if (test is Child) {
        //不用在使用时再次进行转换
        println(test.getName())
    }
test.getName()
}

智能类型转换是有作用范围的,超过作用范围后其类型还是原来定义的类型

如上例中最后的getName是没有该方法的

安全类型转换:在Java中如果类型转换失败则会抛出类型转换异常,Kotlin中也有这种情况,为了避免它,可使用"as?"如果转换失败则返回null

open class Parent {}
class Child : Parent() {
    fun getName(): String {
        return "000";
    }
}
fun main(args: Array<String>) {
    val test2: Parent = Parent()
    //如果转换失败则返回null,不会抛出异常
    val child: Child? = test2 as? Child
    println(child?.getName())
}