Kotlin

Learning Kotlin: 泛型

泛型接口/类（泛型类型）

定义泛型累些那个，实在类型名之后、主构造函数之前用尖括号括起的大写西姆类型参数指定：

1
2
3
4
5
6
7
8
9
interface Drink<T> {
	fun drink(t: T)
}

class DrinkApple : Drink<String> {
    override fun drink(t: String){
        println("drink: ${t}")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
abstract class Color<T>(var t: T /*泛型字段*/){
    abstract fun printColor()
}

class Blue(){
    val color = "blue"
}

class BlueColor(t: Blue) : Color<Blue>(t){
    override fun printColor(){
        println("color:${t.color}")
    }
}

泛型字段

泛型方法

类型参数要放在方法名的前面：

1
2
3
4
fun <T> fromJson(json: String, tClass: Class<T>): T? {
	val t: T? = tClass.newInstance()
    return t
}

泛型约束

限定泛型参数的类型

1
2
3
4
//所传递的参数类型 T 必须满足是 User 的子类或 User 类
fun <T: User> fromJson(json: String, tClass: Class<T>): T? {
	
}

泛型中的 out 与 in

泛型

型变

java泛型中的一些概念

  • java 中的通配符类型参数： ? extends E

  • 通配符<? extends E>表示包括E在内的所有子类,称为协变

  • 通配符<? super E>表示包括E在内的所有父类,称为逆变

  • 协变: 表示包括E在内的所有子类,泛型对象只能读取,称为生产者

  • 逆变: 表示包括E在内的所有父类,泛型对象只能写入,称为消费者

资料：

Kotlin 泛型中的 in 和 out

一文读懂 kotlin 的协变与逆变 – 从 Java 说起

Kotlin

Learning Kotlin: 密封类

Sealed classes are used for representing restricted class hierarchies, when a value can have one of the types from a limited set, but cannot have any other type. They are, in a sense, an extension of enum classes: the set of values for an enum type is also restricted, but each enum constant exists only as a single instance, whereas a subclass of a sealed class can have multiple instances which can contain state.

If you are like me, you probably did not understand that on a first read, especially without real-world code samples.

Sealed class rules

  • Sealed classes are abstract and can have abstract members.
  • Sealed classes cannot be instantiated directly.
  • Sealed classes cannot have public constructors (The constructors are private by default).
  • Sealed classes can have subclasses, but they must either be in the same file or nested inside of the sealed class declaration.
  • Sealed classes subclass can have subclasses outside of the sealed class file.

Declaring a sealed class

1
sealed class Fruit()

The important part of the code above is the sealed modifier. As mentioned in the sealed class rules, a sealed class can have subclasses but they must all be in the same file or nested inside of the sealed class declaration. However, subclasses of the sealed class subclasses do not have to be in the same file. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Nested
sealed class Fruit() {
    class Apple() : Fruit()
    class Orange() : Fruit()
}
sealed class Fruit
// Not nested
class Apple() : Fruit()
class Orange() : Fruit()
// Fruits.kt
sealed class Fruit() {
    class Apple() : Fruit()
    class Orange() : Fruit()
    open class UnknownFruit(): Fruit()
}
// SomeOtherFile.kt
class Grape : Fruit() // Not Acceptable
class Tomato : UnknownFruit() // Acceptable

The key benefit of using sealed classes comes into play when you use them in a when expression. If it’s possible to verify that the statement covers all cases, you don’t need to add an *else* clause to the statement. However, this works only if you use *when* as an expression (using the result) and not as a statement.

1
2
3
4
5
6
// Invalid
override fun getItemViewType(position: Int): Int {
    return when (fruits[position]) {
        is Fruit.Apple -> R.layout.item_apple
    }
}

The piece of code above fails because we MUST implement ALL types. The error thrown says: 

1
When expression must be exhaustive, add necessary 'is Orange' branch or else branch instead

This just means that we must include all types of Fruit in the when expression. Or use a catch-all else block. 

1
2
3
4
5
6
override fun getItemViewType(position: Int): Int {
    return when (fruits[position]) {
        is Fruit.Apple -> R.layout.item_apple
        is Fruit.Orange -> R.layout.item_orange
    }
}

Bonus: how can we apply sealed classes in a real-world scenario in Android?

There are many ways that sealed classes can be used, but one of my favorites is in a RecyclerView adapter.

Let’s say we want to display a list of fruits in a RecyclerView, where each fruit has its own ViewHolder.

Apple has anAppleViewHolder and Orange has an OrangeViewHolder. but we also want to make sure that every new Fruit added has its own ViewHolder explicitly specified, or we throw an exception. We can easily do this with sealed classes.

Show me the code: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
sealed class Fruit {
    class Apple : Fruit()
    class Orange : Fruit()
}
class FruitAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
private val fruits = arrayListOf<Fruit>()
override fun getItemCount() = fruits.size
    
    override fun getItemViewType(position: Int): Int {
        return when (fruits[position]) {
            is Fruit.Apple -> R.layout.item_apple
            is Fruit.Orange -> R.layout.item_orange
        }
    }
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        val layoutInflater = LayoutInflater.from(parent.context)
return when (viewType) {
            R.layout.item_apple -> {
                val itemView = layoutInflater.inflate(R.layout.item_apple, parent, false)
                AppleViewHolder(itemView)
            }
            R.layout.item_orange -> {
                val itemView = layoutInflater.inflate(R.layout.item_orange, parent, false)
                OrangeViewHolder(itemView)
            }
            else -> throw UnknownViewTypeException("Unknown view type $viewType")
        }
    }
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        val fruit = fruits[position]
when (fruit) {
            is Fruit.Apple -> (holder as AppleViewHolder).bind(fruit)
            is Fruit.Orange -> (holder as OrangeViewHolder).bind(fruit)
        }
    }
// ... other methods
}

参考：

https://proandroiddev.com/understanding-kotlin-sealed-classes-65c0adad7015