Kotlin语法-Day6
文章目录
- 1.1 定义类和field关键字
- 1.2 主构造函数
- 1.3 次构造函数
- 1.4 初始化代码块
- 1.5 延迟初始化lateinit
- 1.6 惰性初始化by lazy
- 1.6.1普通方式
- 1.6.2 by lazy方式
- 1.7 类的继承与重载
- 1.8 类型转换
1.1 定义类和field关键字
//TODO Kotlin语言中的定义类和field关键字学习
/*
*
* */
class KtBase50{
//修改set get方法
var name:String = ""
get()=field.capitalize() //
set(value) {
field="$value]888"
}
/*背后的事情
private String name=""
public void setName(String name){
this.name="%s"+"]888"
}
public String getName(){
return StringKT.capitalize(this.name)
}
*/
}
fun main() {
//背后的操作 var s=new KtBase50
var s= KtBase50()
//s.setName("lisi)
s.name="lisi"
//System.out.println(s.getName())
println(s.name)
}
var变量有set、get方法
val变量只有get方法
1.2 主构造函数
//TODO Kotlin语言中的主构造函数
/*
*
* */
// 主构造函数：规范来说，都是增加_xxx的方式，临时的输入类型，不能直接用，需要接收下来 成为变量才能用
class KtBase51 (_name:String,_sex:Char,_age:Int,_info:String){
var name=_name
val sex=_sex
var age=_age
get() = field+1
val info=_info
get() = "【$field】"
fun show(){
println(name)
println(sex)
println(age)
println(info)
}
}
fun main() {
var p = KtBase51("张三", 'M', 20, "正在学习KT")
p.show()
//p.sex="" //Val cannot be reassigned val为只读没有set方法
}
1.3 次构造函数
//TODO Kotlin语言中的次构造函数
/*
*
* */
class KtBase52(name :String){
//2个参数的次构造函数，必须要调用著构造函数，否则不通过。 调用主构造函数，为了更好的初始化设置，主构造函数统一管理
constructor(name:String,sex:Char):this(name){
println("2个参数的此构造函数 name:$name,sex:$sex")
}
//3个参数的次构造函数，必须要调用著构造函数
constructor(name:String,sex:Char,age:Int):this(name){
println("3个参数的此构造函数 name:$name,sex:$sex,age:$age")
}
//4个参数的次构造函数，必须要调用著构造函数
constructor(name:String,sex:Char,age:Int,info:String):this(name){
println("4个参数的此构造函数 name:$name,sex:$sex,age:$age,info:$info")
}
}
fun main() {
KtBase52("测试") //主构造函数
KtBase52("张三",'男') //调用两个参数的次构造函数
KtBase52("张三",'男',20) //调用三个个参数的次构造函数
KtBase52("张三",'男',20,"还在学习kt语言") //调用四个参数的次构造函数
}
1.4 初始化代码块
//TODO Kotlin语言中的初始化代码块
/*
* 1.name,age,sex的主构造函数
* 2.init代码块学习
* 3。临时类型只有在 init代码块才能调用
* */
class KtBase53(name:String,age:Int,sex:Char){ //主构造
//初始化块 init代码块
//相当于java的构造代码块
init {
println("主构造函数被调用了 $name,$age,$sex")
}
constructor(name:String):this(name,20,'男'){
println("次构造函数被调用了")
}
}
fun main() {
KtBase53("韩寒",23,'男') //调用主构造
println()
KtBase53("微凉") //调用次构造
}
1.5 延迟初始化lateinit
//TODO Kotlin语言中的延迟初始化lateinit
/*
*
* */
class KtBase54{
lateinit var responseResultInfo:String //先定义 一会再来初始化，所以没有赋值
fun loadRequest(){
responseResultInfo="服务器加载成功，恭喜你"
}
fun showResponseResult(){
//由于你没有初始化，所以只要用这个变量就会崩溃
//Exception in thread "main" kotlin.UninitializedPropertyAccessException:
// lateinit property responseResultInfo has not been initialized
//if (responseResultInfo==null) println()
println("responseResultInfo: $responseResultInfo")
}
}
fun main() {
var a = KtBase54()
//使用之前，加载一下（用到它才加载，懒汉式）
a.loadRequest()
//使用
a.showResponseResult()
}
1.6 惰性初始化by lazy
1.6.1普通方式
直接加载 （饿汉式）
//TODO Kotlin语言中的by lazy
/*
*
* lateinit 是在使用的时候，手动加载的懒加载方式，然后再使用
* 惰性初始化by lazy 是在使用的时候，自动加载的懒加载方式
* */
class KtBase55 {
//>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy 普通方式(饿汉式)
val databaseData1:String =readSQLServerDatabaseAction()
//>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy
// val databaseData2 by lazy { readSQLServerDatabaseAction() }
private fun readSQLServerDatabaseAction() :String{
println("开始读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("结束读取数据库数据中。。。。")
return "data load success ok"
}
}
fun main() {
//>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy 普通方式
val p=KtBase55()
Thread.sleep(5000)
println("即将开始使用")
println("最终显示：${p.databaseData1}")
//>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy
// val p=KtBase55()
//
// Thread.sleep(5000)
//
// println("即将开始使用")
// println("最终显示：${p.databaseData2}")
}
1.6.2 by lazy方式
使用时才加载 （懒汉式）
//TODO Kotlin语言中的by lazy
/*
*
* lateinit 是在使用的时候，手动加载的懒加载方式，然后再使用
* 惰性初始化by lazy 是在使用的时候，自动加载的懒加载方式
* */
class KtBase55 {
//>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy 普通方式(饿汉式)
// val databaseData1:String =readSQLServerDatabaseAction()
//>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy
val databaseData2 by lazy { readSQLServerDatabaseAction() }
private fun readSQLServerDatabaseAction() :String{
println("开始读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("加载读取数据库数据中。。。。")
println("结束读取数据库数据中。。。。")
return "data load success ok"
}
}
fun main() {
//>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy 普通方式
// val p=KtBase55()
//
// Thread.sleep(5000)
//
// println("即将开始使用")
// println("最终显示：${p.databaseData1}")
//>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy
val p=KtBase55()
Thread.sleep(5000)
println("即将开始使用")
println("最终显示：${p.databaseData2}")
}
1.7 类的继承与重载
//TODO Kotlin语言中的继承与重载
/*
*
* */
//所有的类，默认都是final修饰的，不能被继承 需要open关键字
open class Person(val name:String){
open fun showName()="父类 人的姓名是【${name}】"
//所有的函数，默认都是final修饰的，不能被继承 需要open关键字
open fun myPrintln()= println(showName())
}
class Student(val stuname:String):Person(stuname){
override fun showName()="子类 人的姓名是【${stuname}】"
override fun myPrintln()= println(showName())
}
fun main() {
val person:Person =Student("张三")
person.myPrintln()
}
1.8 类型转换
//TODO Kotlin语言中的类型转换
/*
*
* 1.普通运行子类输出
* 2.is Person Student
* 3.is + as 转换
* */
//所有的类，默认都是final修饰的，不能被继承 需要open关键字
open class Person2(val name:String){
open fun showName()="父类 人的姓名是【${name}】"
//所有的函数，默认都是final修饰的，不能被继承 需要open关键字
open fun myPrintln()= println(showName())
}
class Student2(val stuname:String):Person2(stuname){
fun showName2()="子类 人的姓名是【${stuname}】"
override fun myPrintln()= println(showName2())
}
fun main() {
val person: Person2 =Student2("王五")
person.myPrintln()
println(person is Person2)
println(person is Student2)
//is + as
if (person is Student2){
(person as Student2).myPrintln()
}
if (person is Person2){
println((person as Person2).showName())
}
}
