对象-接口-抽象
其它Kotlin文章
Android学习Kotlin之一、常量-条件-函数-高阶函数
Android学习Kotlin之二、Null安全 -字符串操作- 类型转换
Android学习Kotlin之三、标准库函数-集合List-Set-Map
Android学习Kotlin之四、定义类-初始化-继承
Android学习Kotlin之五、对象-接口-抽象类
Android学习Kotlin之六、泛型-扩展函数
本编文章会讲到的知识点
- 对象
- 对象声明
- 对象表达式
- 伴生对象
- 类的使用
- 嵌套类
- 数据类
- copy
- 解构声明
- 使用数据类的条件
- 枚举类
- 接口
- 抽象类
对象
使用object关键字，你可以定义一个只能产生一个实例的类-单例
使用object关键字有三种方式：
- 对象声明
- 对象表达式
- 半生对象
对象声明
通过object定义类，相当于java中的单例模式，有利于组织代码、管理状态
object Tools{
init {
println("init初始化")//因为是单例模式，多次调用只会执行一次
}
fun getDate():String{
return return SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(Date())
}
}
println(Tools.getDate())//和java中调用static方法一样
println(Tools.getDate())//再次调用 不会执行init初始化代码块
对象表达式
有时候你不一定非要定义一个新的命名类不可，也许你需要某个现有类的一种变体实例，但只需用- -次就行了，事实上，对于这种用完就丢的类实例，连命名都可以省了。这个对象表达式是XX的子类，这个匿名类依然遵循object关键字的-一个规则，即一旦实例化，该匿名类只能有唯- - -个实例存在。
/**
* 对象表达式 定义一个可继承的类
*/
open class Stu {
open fun getName() = "神雕侠侣"
}
/**
* 通过对象表达式生成一个类
*/
val s = object : Stu() {
override fun getName() = "杨过和小龙女"
fun getAge():Int{
return 18
}
}
//和使用对象声明一样使用s类直接调用其函数
println("我的名字：${s.getName()}")//我的名字：杨过和小龙女
println("我的年龄：${s.getAge()}")//我的年龄：18
伴生对象
如果你想将某个对象的初始化和一一个类实例捆绑在一起，可以考虑使用伴生对象，使用companion修饰符， 你可以在一个类定义里声明一个伴生对象，一个类里只能有一个伴生对象；无论初始化多少次类，伴生对象只会初次的时候执行一次。
class Associated{
//无论初始化多少次类，伴生对象只会初次的时候执行一次。
companion object{
init {
println("我是伴生对象初始化了")
}
}
// 类的init代码块，每初始化一次类时都会执行
init {
println("我是Associated对象初始化了")
}
}
// 伴生对象
Associated()// 初始化第一次
println("--------------------------")
Associated()// 初始化第二次
类的使用
嵌套类
如果一个类只对另一个类有用，那么将其嵌入到该类中并使这两个类保持在一起是合乎逻辑的，可以使用嵌套类。
class Nesting{
class InerNesting{
fun getName(name:String){
println("我是嵌套类 ${name}")
}
}
fun getName(name:String){
InerNesting().getName(name)
}
}
// 使用
Nesting().getName("外部类调")
Nesting.InerNesting().getName("内部类调")
数据类
是专门设计用来存储数据的类，数据类提供了toString的个性化实现，==符号默认情况下，比较对象就是比较它们的引用值，数据类提供了equals和hashCode的个性化实现
data class classStudent(var name:String,var age:Int)
// data类 默认toString方法
println(classStudent("小明",19))//classStudent(name=小明, age=19)
println(classStudent("小明",19)===classStudent("小明",19))
copy
除了重写Any类的部分函数，提供更好用的默认实现外，数据类还提供了一个函数，它可以用来方便地复制一个对象。假设你想创建一个Student实例，除了name属性，它拥有和另一个现有Student实例完全一样的属性值，如果Student是个数据类，那么复制现有Student实例就很简单了，只要调用copy函数,给想修改的属性传入值参就可以了。
/**
* copy类
*/
data class classCopy(var name:String,var age:Int){
constructor(name:String):this(name,18){
}
}
// copy类 使用
val copy1 = classCopy("小明")
val copy2 = copy1.copy("baby")
println(copy1)
println(copy2)
解构声明
解构声明的后台实现就是声明component1、component2等若干个组件函数，让每个函数负责管理你想返回的一个属性数据，如果你定义一个数据类，它会自动为所有定义在主构造函数的属性添加对应的组件函数。
/**
* 解构声明
*/
data class decosClass(var name:String,var age:Int){
}
// 解构声明
var (n,a) =classCopy("小明",18)
println("name:${n} age:${a}")
使用数据类的条件
正是因为上述这些特性，你才倾向于用数据类来表示存储数据的简单对象，对于那些经常需要比较、复制或打印自身内容的类，数据类尤其适合它们。然而，一个类要成为数据类,也要符合一定条件。总结下来,主要有三个方面:
- 数据类必须有至少带一个参数的主构造函数
- 数据类主构造函数的参数必须是val或var
- 数据类不能使用abstract、open、sealed和inner修饰符
枚举类
枚举类,用来定义常量集合的一种特殊类。
enum class MyEnum{
NORTH,
SOUTH,
WEST
}
//枚举类
val type = MyEnum.NORTH
when(type){
MyEnum.NORTH-> println(666)
MyEnum.SOUTH-> println(888)
MyEnum.WEST -> println(999)
}
接口
Kotlin规定所有的接口属性和函数实现都要使用override关键字，接口中定义的函数并不需要open关键字修饰，他们默认就是open的。
//定义接口
interface OnItemClick{
val name:String
fun itemClick(index:Int)
}
//实现接口
class MAdapter(override val name: String) : OnItemClick{
override fun itemClick(index: Int) {
TODO("Not yet implemented")
}
}
- 内部匿名接口使用
如果内部接口在最后一个参数，可以在方法后面实现。使用invoke()方法回调数据。
setName("111") { s, s1 ->
Log.e("TAG", "kotlin 接口返回+$s $s1")
}
private fun setName(n: String, f: (t: String, l: String) -> Unit) {
f.invoke(n, "冷雨")
}
抽象类
要定义一个抽象类，你需要在定义之前加上abstract关键字，除了具体的函数实现，抽象类也可以包含抽象函数只有定义，没有函数实现。
//定义抽象类
abstract class BaseClass{
open fun initView(){}
abstract fun initData()
}
//继承抽象类
class MyClass : BaseClass() {
//重新initView函数
override fun initView(){
}
//继承initData函数
override fun initData() {
TODO("Not yet implemented")
}
}
