Kotlin入门之泛型,型变,星投影

作者: wxyass 分类: Android,Kotlin 发布时间: 2018-03-19 20:58

java泛型(前置内容)

泛型

任意的类型。是一种把明确数据类型的工作放在了创建对象或者调用方法时候进行的特殊的类型。

泛型的格式:

<数据类型>

为什么会有泛型?

就是为了解决黄线和类型转换问题。

怎么解决呢?

就是模仿数组解决的,在定义集合的时候,告诉集合,你只能存储什么类型的元素。怎么告诉呢,通过泛型。

泛型的好处:

  • 解决黄色警告线问题。
  • 把运行期间的类型转换异常提前到了编译期间。
  • 优化程序设计。

泛型在哪些地方用啊?

别问我,问API。如果类或者接口后面有<>,那么这就是泛型的体现。它就是要你在使用的时候明确类型的。

泛型一般就在集合中用。

public class ArrayListDemo {
    public static void main(String[] args) {
        // 用ArrayList存储字符串并遍历
        ArrayList<String> array = new ArrayList<String>();

        array.add("hello");
        array.add("world");
        array.add("java");
        // array.add(10);// 等价于array.add(new Integer(10));

        Iterator<String> it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
            // System.out.println(it.next());
        }

        // 数组在定义的时候,就明确告诉你了,我们的元素是某种固定的类型。不能是其他类型。
        // String[] strArray = new String[3];
        // strArray[0] = "hello";
        // strArray[1] = "world";
        // strArray[2] = 0;

    }
}

泛型类

/*
 * 泛型类:把泛型定义在类上。
 */
public class Tool2<QQ> {

    public void show(QQ qq) {
        System.out.println(qq);
    }

}




public class Tool2Test {
    public static void main(String[] args) {
        // Tool2 t = new Tool2();
        // t.show("hello");
        // t.show(10);

        Tool2<String> t = new Tool2<String>();
        t.show("hello");

        Tool2<Integer> t2 = new Tool2<Integer>();
        t2.show(10);
    }
}

泛型方法

/*
 * 你为了保证方法传递不同的参数,你就在类上明确了类型。
 * 这样的话,你有没有发现一个问题呢?
 * 它要是能够在调用方法的时候,才去明确类型该有多好呢?
 * 
 * 泛型方法:把泛型加在方法上。
 */
public class Tool {
    public <BYD> void show(BYD byd) {
        System.out.println(byd);
    }
}   



public class ToolTest {
    public static void main(String[] args) {
        Tool t = new Tool();
        t.show("hello");
        t.show(10);
    }
}   

泛型接口

1 泛型的基本语法-1

什么是泛型

泛型的类型或者说类型的抽象
鸭子类型在静态语言中的一种近似实现

基本语法

fun main(args: Array<String>) {

    val a = 2
    val b = 3
    val c = maxOf(a,b)
    println(c)

    val complex3 = Complex1(3.0, 4.0)
    val complex4 = Complex1(3.0, 5.0)
    println(complex3)
    println(complex4)

    val complex = Complex(3.0, 4.0)
    val complex2 = Complex(3, 5)
    println(complex)
    println(complex2)
}

data class Complex1(val a: Double, val b: Double):Comparable<Complex1>{

    override fun compareTo(other: Complex1): Int {
        return (value() - other.value()).toInt()
    }

    fun value():Double{
        return a*a + b*b
    }

    override fun toString(): String {
        return "($a + $b i)"
    }
}

data class Complex<T: Number>(val a: T, val b: T){

    override fun toString(): String {
        return "($a + $b i)"
    }
}

// 泛型
fun <T: Comparable<T>> maxOf(a: T, b: T): T{
    return if( a < b) b else a
}

2 泛型的基本语法-2

3 泛型的实现机制

4 型变-1

5 型变-2

6 星投影

7 小案例:泛型实现一个MVP框架

如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!

发表评论

邮箱地址不会被公开。 必填项已用*标注