1、泛型
一般情况下我们需要给任何一个变量指定一个具体的类型,而泛型允许我们不指定具体类型,这也使得我们的代码会拥有更好的扩展性。
比如List是一个存放数据的列表,但是其并未限定存放数据的类型,而是使用泛型来实现的,所以我们才可以使用List<String>,List<Int>之类的语法来构建具体类型的列表。
泛型的定义一般有2种使用方式:
- 1、定义泛型类
- 2、定义泛型方法
1.1、定义泛型类
如果我们要定义一个泛型类,就可以这么写:
class TestClass<T> {
fun test(t: T): T {
return t
}
}
此时TestClass
类就是一个泛型类了,我们可以在TestClass
类中使用T
类型的参数和返回值了。
在调用TestClass
类和test
方法时就需要将泛型指定成具体的类型。
val testClass = TestClass<String>()
val result = testClass.test("hello world")
1.2、定义泛型方法
如果我们不想定义泛型类,只想定义泛型方法,其实也很简单。
class TestClass {
fun <T> method(t: T): T {
return t
}
}
此时method方法就是泛型方法了,使用该方法依然需要指定具体的类型
val testClass = TestClass()
val result = testClass.method<String>("hello world")
由于Kotlin拥有非常强大的类型推导机制,我们传入"hello world"
字符串类型的参数,那么泛型的类型就是字符串类型的,因此这里可以省略泛型的指定:
val testClass = TestClass()
val result = testClass.method("hello world")
1.3、泛型的限制
Kotlin允许我们对泛型的类型进行限制,如果我们只想接收数字的类型的,那么我们可以指定泛型的上界对泛型进行约束。
fun <B : Number> method(b: B): B {
return b
}
此时再调用method方法时指定的泛型类型必须是数字类型,否则会报错。
从上面报错可以看出我们指定的泛型类型必须是
Number
类型的,另外,默认情况下,所有泛型都可以指定成可空类型的,这是因为不手动指定上界的时候,默认上界为Any?
,如果想让泛型的类型不可为空,则手动指定泛型的上界为Any
即可。
2、类委托和委托属性
委托是一种设计模式,它的基本原理是:**操作对象自己不会处理某段逻辑,而是把工作委托给另外一个辅助对象去处理。在Java中,对于委托并没有语言层级的实现。
Kotlin中也是支持委托模式的,并且将委托分为了类委托和委托属性。
2.1、类委托
类委托的核心思想是:将一个类的具体实现委托给另一个类实现。Set是一个接口,如果想使用它必须使用它的实现类,比如HashSet。而借助委托模式,我们可以轻松实现一个自己的实现类,比如创建一个MySet类实现Set接口,代码如下:
class MySet<T>(val helepSet: HashSet<T>) : Set<T> {
override val size: Int = helepSet.size
override fun contains(element: T): Boolean = helepSet.contains(element)
override fun containsAll(elements: Collection<T>): Boolean =helepSet.containsAll(elements)
override fun isEmpty(): Boolean=helepSet.isEmpty()
override fun iterator(): Iterator<T> =helepSet.iterator()
}
可以看到MySet构造函数中接收了一个helepSet
参数,这就相当于一个辅助对象,然后在Set接口中的所有方法实现中,我们并没有具体的实现,而是调用了辅助对象相应的方法,这就是委托模式。
既然所有的实现都是调用辅助对象相应的方法,那么还不如直接使用辅助对象得了。但是如果我们只想让大部分实现调用辅助对象的方法,少部分方法由自己实现,甚至加入一些自己独有的方法,这就是委托模式的意义所在。但是如果实现的接口中有特别多的方法,那岂不是要写死,好在Kotlin中有比较好的解决方案,Kotlin中提供了关键字by,只需要在实现的接口后加上by并后接辅助对象,就可以不用写一大堆模板式的代码。
class MySet<T>(val helepSet: HashSet<T>) : Set<T> by helepSet{
}
这段代码实现效果和上述代码完全一致,如果我们想对某个方法进行重写,只需要重写相应的方法即可,而且我们还可以定义自己独有的方法
class MySet<T>(val helepSet: HashSet<T>) : Set<T> by helepSet{
override fun isEmpty(): Boolean =false
fun test(){
Log.e("log","test")
}
}
我们这里重写了isEmpty
方法,并自定义了test()
方法,其他方法和HashSet
接口中的方法保持一致。
2.2、委托属性
委托属性的核心思想:将一个属性的具体实现委托给另一个类去完成。
我们看下委托属性的语法结构:
class MyClass {
var p by Delegate()
}
可以看到使用by
关键字连接了左边的属性p
和右边的Delegate
的实例,这就代表了将属性p委托给Delegate类去完成。当调用属性p的时候会自动调用Delegate类的getValue(),当给属性p赋值时就调用Delegate类的setValue()方法。
因此我们还要对Delegate进行具体的实现才行:
class Delegate {
var properValue: Any? = null
operator fun getValue(myClass: MyClass, property: KProperty<*>): Any? {
return properValue
}
operator fun setValue(myClass: MyClass, property: KProperty<*>, any: Any) {
properValue = any
}
}
这是一种标准的模板代码,在Delegate 中必须实现getValue()
和setValue()
这两个方法,并且都要使用operator
关键字进行声明。
-
getValue()
getValue()
接收两个参数:
- 第一个参数用于声明该Delegate类的委托功能可以在什么类中使用,这里写成MyClass表示仅可以在MyClass中使用;
- 第二个参数
KProperty<*>
是Kotlin中一个属性操作类,可用于获取各种属性相关的值,在当前场景下用不着,但是必须在方法的参数上进行声明。 - 另外
<*>
这种泛型写法表示不关心泛型的具体类型,就类似Java的<?>
。 - 至于返回值类型可以声明成任意类型,可以根据具体的逻辑去实现,上面只是一种实例写法。
-
setValue()
setValue()
接收三个参数,前两个参数的含义和getValue()
中相同,第三个参数表示具体要赋值给委托属性的值,这个参数的类型必须要和getValue()
的返回值类型一致。
其实还有一种情况下,当我们使用val
声明属性p
时,是不需要在Delegate 中实现setValue()
方法的,这点也很好理解,当属性p
声明为val
则不能被重新赋值,所以Delegate中实现setValue()
也就失去了意义。
3、自己实现一个lazy函数
先看下如何使用lazy函数实现懒加载
var uriMathcer by lazy{
}
只有首次调用属性uriMathcer
时才会执行lazy代码块中的代码,并且代码块中最后一行的返回值赋值给uriMathcer
,结合委托属性上面的代码就很好理解了,by lazy
并不是连在一起的关键字,by
是实现委托属性的关键字,而lazy{}
是一个高阶函数,在lazy
函数中会创建并返回一个Delegate
对象,当我们调用属性uriMathcer
时会调用Delegate
对象的getValue()
方法,然后getValue()
又会调用lazy函数传入的Lambda表达式,这样表达式中的代码就能执行了,并且调用属性uriMathcer
后得到的值就是Lambda表达式最后一行代码的返回值。
熟悉了懒加载的原理,我们也可以创建自己的lazy函数,新建一个Later.kt
文件,并编写如下代码:
class Later<T>(val block: () -> T) {}
这里我们定义了一个泛型类,构造函数接收一个函数类型的参数,并返回Later类指定的泛型。
接着在Later类中实现getValue()
方法
class Later<T>(val block: () -> T) {
var value: T? = null
operator fun getValue(any: Any, property: KProperty<*>): T {
if (value == null)
value = block()
return value!!
}
}
getValue()
第一个参数我们指定成了Any
类型,表示委托属性在任何类中使用,然后使用了一个value对值进行缓存,如果value为空就调用构造函数中传入的函数型参数去获取值,否则就直接返回。由于每次调用属性uriMathcer
时都会调用Later类的getValue()方法,所以使用value进行缓存判断,防止多次创建。
由于懒加载是不需要对属性进行赋值的,所以使用val
进行属性声明,并且不需实现setValue()
方法。
到这里委托属性功能已经完成,不过为了模仿lazy
的实现,我们创建一个顶层方法(不定义在任何类中的函数才是顶层函数),代码如下:
fun <T> later(block: () -> T) =Later<T>(block)
我们将这个顶层函数定义为泛型函数,并且接收一个函数类型的参数,这个顶层函数的作用很简单:创建Later类的实例,并将接收的函数类型参数传递给Later类的构造函数。
现在我们创建的later懒加载函数已经完成,下面看下它的使用:
val p by later<UriMatcher> {
val uriMatcher= UriMatcher(UriMatcher.NO_MATCH)
uriMatcher.addURI(authority,"Book",1)
uriMatcher
}
可以看到这里用法和Kotlin内置的lazy
函数是一致的,这里只不过为了学习下委托属性的用法,并没有对同步、空值等方面进行严谨的处理,懒加载当然还是使用Kotlin内置的lazy函数比较稳妥。