目录
1.Kotlin语言的初始化块学习
//username: String ,userage:Int , usersex :Char 临时类型 必须要二次转换才能用
class KtBase75(username: String ,userage: Int , usersex : Char) //主构造
{
//这个不是java的static{}
//这个相当于java的{} 构造代码块
//初始化块 init代码块
init {
println("主构造函数被调用了 $username,$userage,$usersex")
//如果第一个参数是false，就会调用第二个参数的lambda
//判断name是不是空值，isNotBlank ""
require(username.isNotBlank()){ "你的username空空如也，抛出异常" }
require(userage > 0){
"你的userage年龄不符合，异常抛出"
}
require( usersex == '男' || usersex == '女'){
println("你的性别很奇怪了，异常抛出")
}
}
constructor(username: String) : this(username,87,'男'){
println("次构造函数被调用了")
}
}
// TODO 76 Kotlin语言的初始化块学习
// 1.name,age,sex的主构造函数
// 2.init代码块学习 require
// 3.临时类型只有在 init 代码块才能调用
fun main() {
KtBase75("张三",22, '男') //调用主构造
println()
KtBase75("李四") //调用次构造
//KtBase75("") //调用次构造
//KtBase75("张三",-1,'男') //调用主构造
}2.Kotlin语言的构造初始化顺序学习
//第一步 ：生成val sex :Char
class KtBase76(_name : String ,val sex :Char) //主构造
{
//第二步：生成val name //由于它写在init代码块前面，所以先生成这个。其实它是和init代码块同时进行的
val name = _name
init {
val nameValue = _name //第三步：生成nameValue
println("init代码块打印：nameValue:$nameValue")
}
//次构造函数 必须调用主构造函数
constructor(name:String,sex:Char,age :Int) : this(name,sex){
//第五步：生成次构造函数的细节
println("次构造 三个参数的，name:$name,sex:$sex,age:$age")
}
//第四步
val bxb = "AAA"
}
// TODO 76 Kotlin语言的构造初始化顺序学习
//1.main调用次构造 name sex age
//2.主构造的val 变量
//3.nameValue = _name
//4.init{nameValue 打印}
fun main() {
KtBase76("bxb",'男',22)
}3.Kotlin语言的延迟初始化lateinit学习
class KtBase77
{
lateinit var responseResultInfo:String //等会再来初始化，先定义再说，没有赋值
//模拟服务器加载
fun loadRequest(){ //延迟初始化，属于懒加载，用到你再给你加载
responseResultInfo = "恭喜你，服务器加载成功"
}
fun showResponseResult(){
//由于你没有给他初始化，所以只能用到它，就崩溃
// if(responseResultInfo == null) println()
// println("responseResultInfo : $responseResultInfo")
if (::responseResultInfo.isInitialized){
println("responseResultInfo : $responseResultInfo")
}else{
println("你没有初始化加载")
}
}
}
// TODO 77 Kotlin语言的延迟初始化lateinit学习
//1.lateinit responseResultInfo 定义
//2.request 懒加载
//3.showResponseResult
//4.main 先请求 再显示
fun main() {
val p = KtBase77()
//使用它之前，加载一下（用到它才加载，就属于，懒加载）
p.loadRequest()
//使用它
p.showResponseResult()
}
4.Kotlin语言的惰性初始化by lazy学习
class KtBase78
{
//>>>>>>>>>>>下面是 不使用惰性初始化 by lazy 普通方式（饿汉式 没有任何懒加载的特点）
//val databaseData1 = readSQLServerDatabaseAction()
//>>>>>>>>>>>使用惰性初始化by lazy 普通方式
val databaseData2 by lazy { readSQLServerDatabaseAction() }
private fun readSQLServerDatabaseAction():String{
println("开始读取数据库中....")
println("开始读取数据库中....")
println("开始读取数据库中....")
println("开始读取数据库中....")
println("开始读取数据库中....")
println("开始读取数据库中....")
println("开始读取数据库中....")
println("开始读取数据库中....")
println("结束读取数据库中....")
return "database data load success ok"
}
}
// TODO 78 Kotlin语言的惰性初始化by lazy学习
fun main() {
//>>>>>>>>>下面是 不使用惰性初始化by lazy 普通方式（饿汉式 没有任何懒加载的特点）
// val p = KtBase78()
// Thread.sleep(5000)
// println("即将开始使用")
// println("最终显示：${p.databaseData1}")
val p = KtBase78()
Thread.sleep(5000)
println("即将开始使用")
println("最终显示：${p.databaseData2}")
}5.Kotlin语言的初始化陷阱学习
class KtBase79{
var number = 9
init {
number = number.times(8)
}
}
// TODO 79 Kotlin语言的初始化陷阱学习
fun main() {
println(KtBase79().number)
}?6.Kotlin语言的初始化陷阱二学习
class KtBase80{
val info : String
init {
info = "Bxb"
getInfoMethod()
}
fun getInfoMethod() {
println("info:${info[0]}")
}
}
// TODO 81 Kotlin语言的初始化陷阱二学习
fun main() {
KtBase80()
}7.Kotlin语言的初始化陷阱三学习
class KtBase81(_info:String){
private val info = _info
val content : String = getInfoMethod()
private fun getInfoMethod() = info
}
// TODO 81 Kotlin语言的初始化陷阱三学习
fun main() {
println("内容的长度是：${KtBase81("Bxb").content.length}")
}
8.Kotlin语言的继承与重载的open关键字学习
//KT所有的类，默认是final修饰的，不能被继承，和java相反
//open ： 移除final修饰
open class Person(private val name : String){
private fun showName() = "父类的姓名是：【${name}】"
//KT所有的函数，默认是final修饰的，不能被继承，和java相反
open fun myPrintln() = println(showName())
}
class Student(private val subName : String) : Person(subName){
private fun showName() = "子类的姓名是：【${subName}】"
override fun myPrintln() = println(showName())
}
// TODO 82.Kotlin语言的继承与重载的open关键字学习
fun main(){
val person : Person = Student("张三")
person.myPrintln()
}9.Kotlin语言的类型转换学习
import java.io.File
//KT所有的类，默认是final修饰的，不能被继承，和java相反
//open ： 移除final修饰
open class Person2(private val name : String){
fun showName() = "父类的姓名是：【${name}】"
//KT所有的函数，默认是final修饰的，不能被继承，和java相反
open fun myPrintln() = println(showName())
}
class Student2(private val subName : String) : Person2(subName){
fun showName2() = "子类的姓名是：【${subName}】"
override fun myPrintln() = println(showName2())
}
// TODO 83.Kotlin语言的类型转换学习
fun main(){
val p : Person2 = Student2("张三三")
p.myPrintln()
println(p is Person2)
println(p is Student2)
println(p is File)
//is + as 一般是配合一起使用
if (p is Student2){
(p as Student2).myPrintln()
}
if (p is Person2){
println((p as Person2).showName())
}
}10.Kotlin语言的智能类型转换学习
//KT所有的类，默认是final修饰的，不能被继承，和java相反
//open ： 移除final修饰
open class Person3(val name : String){
private fun showName() = "父类显示：【${name}】"
open fun myPrintln() = println(showName())
fun methodPerson() = println("我是父类的方法...") //父类独有的函数
}
class Student3(val nameSub : String) : Person3(nameSub){
override fun myPrintln() = println("子类的显示：【${nameSub}】")
fun methodStudent() = println("我是子类的方法...")
}
// TODO 84.Kotlin语言的智能类型转换学习
fun main(){
val p : Person3 = Student3("张三三")
println(p.myPrintln())
(p as Student3).methodStudent()
println(p.myPrintln())
p.methodStudent()
p.methodStudent()
//智能类型转换：根据上面as转成的类型，自动明白，你现在的类型就是上面的类型
}
