目录
1.Kotlin语言的Any超类学习
//在KT中，所有的类，都隐式继承了 ：Any() ,你不写，默认就有
// Any类在KT设计中：只提供标准，你看不到实现，实现在各个平台处理就好
class Obj1 : Any()
class Obj2 : Any()
class Obj3 : Any()
// TODO 85.Kotlin语言的Any超类学习
// Any == java Object
fun main(){
println(Obj1().toString())
}
2.Kotlin语言的对象声明学习
object KtBase86{
init {
println("KtBase86 init...")
}
fun show() = println("我是show函数...")
}
// TODO 86.Kotlin语言的对象声明学习
fun main(){
//object KtBase86 既是单例的实例，也是类名
//小结：既然是单例的实例，又是类名，只有一个创建，这就是典型的单例
println(KtBase86) //背后代码：println(KtBase86.INSTANCE)
//背后代码：KtBase86.INSTANCE.show()
println(KtBase86.show())
}3.Kotlin语言的对象表达式学习
interface RunnableKT {
fun run()
}
open class KtBase87 {
open fun add(info: String) = println("KtBase87 add:$info")
open fun del(info: String) = println("KtBase87 del:$info")
}
// TODO 87.Kotlin语言的对象表达式学习
fun main() {
//匿名对象 表达式方式
val p : KtBase87 = object : KtBase87(){
override fun add(info: String) {
//super.add(info)
println("我是匿名对象 add:$info")
}
override fun del(info: String) {
//super.del(info)
println("我是匿名对象 del:$info")
}
}
p.add("张三")
p.del("李四")
//具名实现方式
val p2 = KtBase87Impl()
p2.add("赵六")
p2.del("赵七")
//对java的接口 用 KT[对象表达式] 方式一
val p3 = object : Runnable{
override fun run() {
println("Runnable run...")
}
}
p3.run()
//对java的接口 用 java 最简洁的方式 方式二
val p4 = Runnable {
println("Runnable run2...")
}
p4.run()
//对KT的接口 用 KT[对象表达式] 方式一
object : RunnableKT {
override fun run() {
println("RunnableKT 方式一 run ...")
}
}.run()
}
//小结：Java接口，有两种方式 1（object ： 对象表达式）2 简洁版
// KT接口 只有一种方式 1（object : 对象表达式）
//具名实现 具体名字 == KtBase87Impl
class KtBase87Impl : KtBase87() {
override fun add(info: String) {
//super.add(info)
println("我是具名对象 add:$info")
}
override fun del(info: String) {
//super.del(info)
println("我是具名对象 del:$info")
}
}4.Kotlin语言的伴生对象学习
class KtBase88 {
//伴生对象
companion object {
val info = "BxbInfo"
fun showInfo() = println("显示info:$info")
val name = "Bxb"
}
}
// TODO 88.Kotlin语言的伴生对象学习
//伴生对象的由来：在KT中是没有java这种static静态，半生很大程度和java这种static静态差不多
// 无论KtBase88() 构建对象多少次，我们的伴生对象，只有一次加载
// 无论KtBase88.showInfo() 调用多少次，我们的伴生对象，只有一次加载
// 伴生对象只会初始化一次
fun main() {
println(KtBase88.info)
println(KtBase88.name)
KtBase88.showInfo()
}5.Kotlin语言的嵌套类学习
// TODO 内部类
// 内部类的特点：内部的类 能访问 外部的类
// 外部的类 能访问 内部的类
class Body(_bodyInfo: String){ //身体类
val bodyInfo = _bodyInfo
fun show(){
Heart().run()
}
// 默认情况下：内部的类 不能访问 外部的类，要增加inner成为内部类才可以访问外部类
inner class Heart{ //心脏类
fun run() = println("心脏访问身体信息:$bodyInfo")
}
inner class Kidney{ //肾脏
fun work() = println("肾脏访问身体信息:$bodyInfo")
}
inner class Hand{ //手
inner class LeftHand{
fun run() = println("左手访问身体信息:$bodyInfo")
}
inner class RightHand{
fun run() = println("右手访问身体信息:$bodyInfo")
}
}
}
//TODO 嵌套类
// 默认情况下：都是嵌套关系
// 嵌套类特点：外部的类 能访问 内部的嵌套类
// 内部的类 不能访问 外部类的成员
class Outer{
val info : String = "OK"
fun show(){
Nested().output()
}
class Nested{
fun output() = println(" 嵌套类")
}
}
// TODO 89.Kotlin语言的嵌套类学习
fun main() {
//内部类：
Body("isOK").Heart().run()
Body("isOK").show()
Body("isOK").Kidney().work()
Body("isOK").Hand().LeftHand().run()
Body("isOK").Hand().RightHand().run()
//嵌套类
Outer.Nested().output()
Outer().show()
}6.Kotlin语言的数据类学习
//普通类
class ResponseResultBean1(var msg:String,var code:Int,var data:String):Any()
//set get 构造函数
//数据类 ---- 一般用于Javabean的形式下，用数据类
data class ResponseResultBean2(var msg:String,var code:Int,var data:String):Any()
// set get构造函数 解构操作 copy toString hashCode equals 数据类 生成更丰富
// TODO 90.Kotlin语言的数据类学习
// 1.普通类与数据类的 toString 背后原理
// 2.前面学习过的 == 与 ===
// 3.普通类的 == 背后原理
// 4.数据类的 == 背后原理
fun main() {
// val(v1,v2,v3) = list 这个是list集合之前的 解构操作
println(ResponseResultBean1("loginSuccess",200,"登录成功的数据..."))
//普通类：Any() toString Windows实现打印了 com.bxb.s5.ResponseResultBean1@266474c2
println(ResponseResultBean2("loginSuccess",200,"登录成功的数据..."))
//数据类：Any() 默认重写了父类的 toString 打印子类的toString详情 ResponseResultBean2(msg=loginSuccess, code=200, data=登录成功的数据...)
println()
//前面我们学习 == 值的比较 相当于java的equals === 引用对象比较
println(
ResponseResultBean2("loginSuccess",200,"登录成功的数据...") ==
ResponseResultBean2("loginSuccess",200,"登录成功的数据...")
)
//Any父类的 equals被数据类 重写了 equals 会调用子类的 equals函数（对值的比较）
println(
ResponseResultBean1("loginSuccess",200,"登录成功的数据...") ==
ResponseResultBean1("loginSuccess",200,"登录成功的数据...")
)
//Any父类 的equals 实现 (ResponseResultBean1对象引用 比较 ResponseResultBean1对象引用)
}7.Kotlin语言的copy函数学习
data class KtBase91(var name : String,var age : Int) //主构造
{
var coreInfo : String = "123"
init {
println("主构造被调用了")
}
//次构造
constructor(name : String) : this(name,99){
println("次构造被调用")
coreInfo = "增加非常核心的内容信息"
}
override fun toString(): String {
return "toString name:$name,age:$age,coreInfo:$coreInfo"
}
}
/*
* 生成的toString为什么只有两个参数？
* 答：默认生成的toString 或者 hashcode equals 等等 只管主构造，不管次构造
* */
// TODO 91.Kotlin语言的copy函数学习
fun main() {
val p1 = KtBase91("张三三") //调用次构造初始化对象
println(p1)
val newP2 = p1.copy("李四四",66)
println(newP2)
//copy toString hashcode equals 等等 只管主构造，不管次构造
//注意事项：使用copy 的时候，由于内部代码只处理主构造，所以必须考虑次构造的内容
}8.Kotlin语言的解构声明学习
//普通类
class Student1(var name : String,var age : Int,var sex:Char)
{ //注意事项：component0 顺序必须是 component1 component2 component3 和成员一一对应，顺序下来的
operator fun component1() = name
operator fun component2() = age
operator fun component3() = sex
}
// 数据类
data class Student2Data(var name:String,var age : Int,var sex:Char )
// TODO 92.Kotlin语言的解构声明学习
fun main() {
val(name,age,sex) = Student1("张三",66,'男')
println("普通类解构后：name：$name,age:$age,sex:$sex")
val(name1,age1,sex1) = Student2Data("张三",66,'男')
println("数据类解构后：name：$name1,age:$age1,sex:$sex1")
val(_,age2,_) = Student2Data("张三",66,'男')
println("数据类解构后：age:$age2")
}9.Kotlin语言的运算符重载学习
class AddClass(number: Int,number2: Int)
//写一个数据类，就是为了，toString打印方便而已哦
data class AddClass2(var number1:Int,var number2: Int){
operator fun plus(p1:AddClass2) : Int{
return (number1 + p1.number1) + (number2 + p1.number2)
}
//查看整个 KT可以用的 运算符重载方式
//operator fun AddClass2.
}
// TODO 93.Kotlin语言的运算符重载学习
fun main() {
//C++语言 +运算符重载就行了 -运算符重载就行了
//KT语言 plus代表+运算符重载
println(AddClass2(1,1)+AddClass2(2,2))
}10.Kotlin语言的枚举类学习
//KT想表达 ：枚举其实也是一个class
enum class Week{
星期一,
星期二,
星期三,
星期四,
星期五,
星期六,
星期日
}
// TODO 94.Kotlin语言的枚举类学习
fun main() {
println(Week.星期一)
println(Week.星期日)
//枚举的值等价于枚举本身
println(Week.星期六 is Week)
}
