Kotlin 学习手记——构造器，【深夜思考】
val persons = HashMap<String, Person>()
//函数名也可以与类的名字不同
fun Person(name: String): Person {
return persons[name] ?: Person(1, name).also { persons[name] = it }
}
类似 String 有常见的工厂方法调用：
fun main() {
val str = String()//调用的是构造函数
val str1 = String(charArrayOf('1', '2'))//调用的是工厂函数 实际是一个函数指向了 String 的构造函数
}
可以自己给系统 String 类添加工厂方法，一般写成函数名跟类名一样
fun String(ints: IntArray): String {
return ints.contentToString()
}
感觉其实就是一个函数返回类型为对应的类
与 java 不同，kotlin 中啥也不写，默认就是
public的，而 java 中不写默认是default包内可见kotlin 中多一个限制可见性的
internal关键字，去掉了default关键字对于
protected, java 是包内可见，而 kotlin 是类内可见，这点不同，当然子类肯定都是可见的，kotlin 中protected不能用来修饰类和顶级生命
internal这个关键字比较有意思，可以在 kotlin 中用作模块化隔离可见性
比如在一个模块中声明：
//internal 只在模块内可见，模块外的 kotlin 访问不到
internal class CoreApiKotlinA {
//指定 JvmName 使 java 也不能访问该方法
@JvmName("%abcd")
internal fun a(){
println("Hello A")
}
}
而在依赖它的模块中使用它会报错：
//kotlin 中访问其他模块的 internal 的类会报错 不可见
val coreApiKotlinA = CoreApiKotlinA()
coreApiKotlinA.a()
但是通过 java 代码却可以使用，此时可以通过internal 方法上添加@JvmName("xxx")注解指定一个非法的 java 变量可达到 java 不能调用的目的，但实际上 java 是能看到的，只不过不能打出来合法的方法名而已。
//java 是可以访问 internal 的 kotlin 类的，但是可以指定 JvmName 使 java 也不能访问对应方法
CoreApiKotlinA coreApiKotlinA = new CoreApiKotlinA();
coreApiKotlinA.%abcd();
get 可见性必须和属性可见性一致, 不能定义 public 属性的 get 为 private
set 可见性不能大于属性的可见性, 不能定义 private 属性的 set 为 public
lateinit 这玩意好像有坑，kotlin 中的新玩意，大神都嫌弃它，我们可以了解一下，既然是坑我们不用去记住它，免得被坑。。
lazy是比较推荐的延迟初始化方式，实际上它是一个属性代理
接口代理其实就是可以把一些没必要实现的接口方法隐藏起来不去实现，方便一些，而不用每一个接口都要写一下。其中by关键字右边的就是实际代理类对象，它是构造函数中的一个属性，by关键字左边的是代理类对象实现的接口。
例子：
//超级数组 同时支持 list 和 map 接口，通过接口代理的方式不必实现 list 和 map 接口的所有方法
class SuperArray<E>(
private val list: MutableList<E?> = ArrayList(),
private val map: MutableMap<Any, E> = HashMap()
) : MutableList<E?> by list, MutableMap<Any, E> by map {
override fun isEmpty() = list.isEmpty() && map.isEmpty()
override val size: Int
get() = list.size + map.size
override fun clear() {
list.clear()
map.clear()
}
override operator fun set(index: Int, element: E?): E? {
if (list.size <= index) {
repeat(index - list.size + 1) {
list.add(null)
}
}
return list.set(index, element)
}
override fun toString(): String {
return """List: [map]"""
}
}
fun main() {
val superArray = SuperArray<String>()
val superArray2 = SuperArray<String>()
superArray += "Hello"
superArray["Hello"] = "World"
superArray2[superArray] = "World"
superArray[1] = "world"
superArray[4] = "!!!"
println(superArray)
println(superArray2)
}
lazy属性代理 代理了 Person 实例的 firstName 的getter方法，实际是一个函数 传递一个 lambda 表达式
class Person(val name: String){
//lazy 属性代理 代理了 Person 实例的 firstName 的 getter 方法
// 实际是一个函数 传递一个 lambda 表达式
val firstName by lazy {
name.split(" ")[0]
}
val lastName by lazy {
name.split(" ")[1]
}
}
observable 代理属性，监听 set 值变化：
class StateManager {
//observable 代理属性，监听 set 值变化
var state: Int by Delegates.observable(0) {
property, oldValue, newValue ->
println("State changed from newValue")
}
}
自定义代理属性：
class Foo {
val x: Int by X()
var y: Int by X()
}
class X {
operator fun getValue(thisRef: Any?, property: KProperty<*>): Int {
return 2
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, i: Int) {
}
}
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论