Mo_mo???
Mo_mo???

Flutter Dart：泛型的协变与逆变

Flutter Dart：泛型的协变与逆变_第1张图片

本文字数：16281 字

预计阅读时间 41 分钟

Flutter Dart也支持泛型和泛型的协变与逆变，并且用起来比Java，Kotlin更方便。那么Dart中的泛型协变和逆变，应该如何理解和使用呢？它与Java，Kotlin中的逆变和协变又有什么区别呢？文章将从浅到深跟大家一起来探讨学习。

一、Dart泛型

Dart中的泛型和其他语言的泛型一样，都是为了减少大量的模板代码，举例说明：

// Dart

//这是一个打印int类型msg的PrintMsg

class PrintMsg {

  int _msg;

  set msg(int msg) { this._msg = msg;}

  void printMsg() { print(_msg);}

}

当打印需求发生变化，需要支持打印更多种类的数据类型，不支持范型的话，代码会大量增加，如下面这样：

// Dart

//非范型写法，现在需要新增支持String，double和自定义类的Msg，

class Msg {

  @override

  String toString() { return "This is Msg";}

}

class PrintMsg {

  int _intMsg;

  String _stringMsg;

  double _doubleMsg;

  Msg _msg;

  set intMsg(int msg) { this._intMsg = msg;}

  set stringMsg(String msg) { this._stringMsg = msg;}

  set doubleMsg(double msg) { this._doubleMsg = msg;}

  set msg(Msg msg) {this._msg = msg;}

  void printIntMsg() { print(_intMsg);}

  void printStringMsg() { print(_stringMsg);}

  void printDoubleMsg() { print(_doubleMsg);}

  void printMsg() { print(_msg);}

}

而有范型的支持后，不管增加多少种数据类型，打印类都可以简化成如下几行：

// Dart

//泛型写法，简化成几行代码，且支持无数种数据类型:

class PrintMsg {

    T _msg;

    set msg(T msg) { this._msg = msg; }

    void printMsg() { print(_msg); }

}

1、泛型类型省略

Dart中可以指定实际的泛型参数类型，也可以省略。实际上，编译器会自动进行类型推断，把泛型参数类型转为dynamic类型。举例说明：

// Dart

List<int> numTest = [1, 2, 3];   //注意int在Dart中是个类，继承自num类。和Java中的基础类型int不一样，java中的int是不能作为泛型的实参的，因为int不是Object的子类。

Mapint> mapTest = {'a': 1, 'b': 2, 'c': 3};

//Dart可简写成如下形式, 但非常不推荐，因为泛型简写会被自动类型推断为dynamic（非泛型简写的类型推断不会变成dynamic）。

List numTest = [1, 2, 3];

Map mapTest = {'a': 1, 'b': 2, 'c': 3}

print(numTest.runtimeType.toString());   // output“List”

print(mapTest.runtimeType.toString());   // output“_InternalLinkedHashMap”

//所以Dart的简写方式，相当于如下形式

List numTest = [1, 2, 3];

Map mapTest = {'a': 1, 'b': 2, 'c': 3};

2、真伪泛型

在Java中，ArrayList是支持泛型的，但是它的数据存储用的却是Object[]，这是因为Java在编译的时候会进行类型擦除，也可以说Java中的泛型是种伪泛型，泛型只存在编译时期，运行时泛型就会被擦除（所以运行时无法获取泛型T的真实类型信息）。

Kotlin最终也会编译生成和Java相同规格的class文件，所以Kotlin中的泛型也会被擦除，也无法使用{a is T;}进行类型判断。

不过Kotlin为泛型的类型判断做了一点改进，支持在inline函数里判断reified修饰的泛型类型。它的原理是，在编译过程中，编译器会将inline内联函数的代码替换到实际调用的地方，并且对reified定义的泛型参数，不进行泛型擦除，而把调用方的形参直接替换成具体的实参类型，这样编译的结果，就支持inline内联函数内部对reified泛型进行类型判断，举例说明:

// Kotlin

inline fun PrintMsg(value:T) {

    LogUtil.d("test", T::class.toString())  // 非inline函数的reified泛型，不能调用T::class

    LogUtil.d("test", value!!::class.toString())  //不管是否inline函数，都会打印参数的真实类型信息

    var b = value is List<*>  // * 不能换成任何具体类型，编译器会报错。注意，PrintMsg方法里的泛型T,不是List中的泛型E, E在Kotlin中运行时都会被擦除成为Object了。

    LogUtil.d("test", b.toString())

    b = "abc" is T  // 非inline函数的reified泛型，则不能调用 is T

    LogUtil.d("test", b.toString())

}

fun main() {

    PrintMsg("test")

    PrintMsg(arrayListOf(1, 2, 3))

    PrintMsg(arrayListOf("a", "b", "c"))

}

// output

//D/test: class java.lang.String   // 在inline函数里，泛型T直接换成了实参类型String

//D/test: class java.lang.String   // 读取的是实参的真实类型信息。

//D/test: false

//D/test: true

//D/test: class java.util.ArrayList   //泛型T换成了实参ArrayList，ArrayList中的元素E已经都换成了Object

//D/test: class java.util.ArrayList   //此处ArrayList中的元素E已经都换成了Object

//D/test: true

//D/test: false

//D/test: class java.util.ArrayList    //泛型T换成了实参ArrayList，此处ArrayList中的元素E已经都换成了Object

//D/test: class java.util.ArrayList   //此处ArrayList中的元素E已经都换成了Object

//D/test: true

//D/test: false

而Dart的泛型是真泛型，在编译期和运行期都可以通过泛型拿到其真实类型，所以Dart中可以直接用泛型进行类型判断，用代码举例说明 ：

// Dart

void PrintMsg(T value) {

  print("test---"+ T.toString());   //使用没有限制，可以获取List中的泛型E的具体类型

  print("test---"+ value.runtimeType.toString());

  var b = value is List;   // 可以直接判断范型结合体的具体类型

  print("test---2 "+ b.toString());

  b = "abc" is T;   //使用没有限制，T就是一种类型

  print("test---3 "+ b.toString());

}

void main() {

  PrintMsg("abc");

  PrintMsg(List<int>.from({1,2,3}));

 PrintMsg(List.from({"a","b","c"}));

}

// output

//I/flutter (21231): test---String

//I/flutter (21231): test---String

//I/flutter (21231): test--- false

//I/flutter (21231): test--- true

//I/flutter (21231): test---List   //此处List中的E元素仍然是int对象

//I/flutter (21231): test---List   //此处List中的E元素仍然是int对象

//I/flutter (21231): test--- false

//I/flutter (21231): test--- false

//I/flutter (21231): test---List  //此处List中的E元素仍然是String对象

//I/flutter (21231): test---List  //此处List中的E元素仍然是String对象

//I/flutter (21231): test--- true

//I/flutter (21231): test--- false

通过示例代码和output log，我们可以看出，泛型是编译期的一个概念，在运行期，Java/Kotlin 把泛型都转换成了Object，而Dart保留了具体的实参类型，都不再是一个不确定的形参类型。

二、泛型关系：协变，逆变和不变

协变，逆变和不变是一种描述泛型类型关系变化的概念。在了解Dart中的协变，逆变和不变之前，我们先来搞清楚什么是类型关系。

1、类和类型，子类和子类型

类和类型的关系容易混淆。Dart中的类可分为两大类: 泛型类和非泛型类。

非泛型类是开发中接触最多的类。非泛型类去定义一个变量时，这个非泛型类就是这个变量的类型。例如:

  •  定义一个非泛型类 Class Person，那么就会有个Person类型。

  •  定义一个非泛型类 Class Boy extend Person类，会有个Boy类型

泛型类比非泛型类复杂，一个泛型类可以对应无限种类型。在定义泛型类的时候会定义泛型形参，要拿到一个真实的泛型类型，就需要在使用泛型类的地方，给泛型类传入具体的类型实参替换定义中的类型形参。

我们经常使用的集合基本都会使用泛型，所以以集合举例说明，List是一个类，它不是一个类型，它可以衍生成无限种类型。例如，List， List，List>都是不同的类型。

所以，每个非泛型类会对应一个类型。而每个泛型类，会对应无限种类型。

知道了类和类型的关系，我们再来看子类和子类型的关系。

子类就是派生类，它继承父类。例如: class Boy extends Person，则Boy就是Person的子类，Person 是 Boy类的父类。

子类型没有继承关系，它的定义是: 需要A类型值的任何地方，都可以使用B类型的值来替换，则B类型就是A类型的子类型，或A类型是B类型的超类型。‍

举例说明：

  • Boy是Person的子类和子类型。

  • List类可以衍生出很多类型，这些类型之间都不是子类关系，但可能是子类型关系。如 List不是List的子类，但是List是List的子类型(Dart默认支持协变，后面会讲)。

  • List是Iterable的子类，但因为List不是一种类型，所以List和Iterable不是子类型关系。

所以属于子类关系的类型，也会成为子类型关系。例如：Boy是Person的子类，它能代替Person出现的任何地方，所以它们之间存在子类型关系。而double不能替代int出现的地方，所以它们不存在子类型关系。但子类型关系，不一定是子类关系。

介绍完泛型和子类型关系概念，下面开始具体介绍类型关系变换：协变，逆变和不变。我们下面以Java为示例进行概念说明，在Java代码中使用 和 来表达协变与逆变（在Kotlin中用 和 表示 ）。

2、类型关系的定义与意义

协变，逆变和不变是用来描述类型转换后的类型关系，其定义如下:

如果A，B表示类型，f(*)表示类型转换，< 表示子类型关系(比如，A

  • f(*)是

    协变

    （covariant）的，当A

  • f(*)是

    逆变

    （contravariant）的，当A

  • f(*)是

    不变

    （invariant）的，当A

上面的定义看起来比较抽象，下面以Java中的ArrayList集合举例说明：

  • ArrayList这种形式的泛型是

    支持协变的

    ，它可以被赋值为ArrayList、ArrayList，但是不能被赋值为ArrayList

    • ArrayList这种形式的泛型是

      支持逆变的

      ，它可以被赋值为ArrayList、ArrayList，但是不能被赋值为ArrayList

      • ArrayList这种形式的泛型是

        不变的

        ，就是说ArrayList list，不能被赋值为ArrayList，也不能被赋值为ArrayList，只能被赋值为ArrayList

        为什么要提出上面的协变与逆变概念呢？其意义就是为了让泛型实现多态。

        我们知道，多态能将子类/实现类的对象赋值给父类/父接口，从而实现相同引用类可以指向不同实现体。比如PrintMsg(num i)，参数可以传入int，double，num，这样就能用一个方法实现不同数据类型的相似功能。

        那么泛型不能实现多态吗？因为泛型使用场景会牵扯到两种类型Class1，所有要分情况来说：

        • 对于Class1来说，是支持多态的，比如

          Collection

          collect = new

           ArrayList

          ()；

        • 对于Class2来说，有两个维度去理解：

        （1）Class2本身是支持多态的，比如ArrayList

        Number> list, 这个list可以add任何Number子类的对象，如 list.add(

        （2）Class1结合体是不支持多态的，比如ArrayList list = new ArrayList()，这个是不对的（注意，Java泛型结合体是不变的，默认是不支持协变的）。

        因此，范型结合体不支持多态，而逆变和协变为这种场景提供了支持多态的解决方案。

        3、多态的实现和限制

        首先，在Java中，普通泛型是“不变”的，即不支持多态，以ArrayList举例说明：

        ArrayList list1 = new ArrayList();

        ArrayList list2 = new ArrayList();

        list1 = list2；// 编译错误！

        Integer是Number的子类，如果可以把list2赋值给list1，则二者都指向了new ArrayList()。这时，list1.get取数据没问题，因为里边都是Integer的对象。但是如果list1.add(Double)，从list1的角度来说是正确的，因为Double也是Number类型。但是从list2的角度来说就是错误的，因为Double肯定不是Integer类型，list2取出一个Double类型的数据，这是破坏语言基本规则的，肯定不能通过编译。

        所以普通泛型只能是不变的，即其普通泛型结合体不支持多态。

        那如何解决普通泛型不支持多态的问题呢？

        上面举例中，如果普通泛型支持多态，写入会导致问题。那通过限制不允许写入，就可以解决这个问题，如下：

        ArrayList list1 = new ArrayList();

        ArrayList list2 = new ArrayList();

        list1 = list2；

        Number a = list1.get(0)；

        list1.add(1) // 编译错误！

        上面extends Number>其实就是实现了泛型协变，即：

        Integer  <  Number

        ArrayList  < ArrayList

        因为list1 只能读不能写，所以能保证上面的泛型协变，实现了范型结合体的多态。

        上面的范型协变，是写限制的范型，那可不可以即支持多态还不限制写呢？

        通过限制范型不允许读，就可以解决这个问题，如下：

        ArrayList list1 = = new ArrayList();

        ArrayListlist2=new ArrayList();

        list1 = list2；

        Number a = list1.get(0)；// 编译错误！

        list1.add(1)；

        首先，任何范型只能写入声明的类及其子类的对象才不会出错。上面list1 = list2，list1和list2相当于都指向了ArrayList，list1.add的都是Number及其子类的对象，也肯定是Number父类的子类，所以list.add不会出错。

        但是如果list2.add过Object的对象，list1.get读出来的就不是Number的对象了，这肯定是破坏语言基本规则的，所以此时的多态，就通过限制范型不允许读来避免问题。

        上面super Number>其实就是实现了泛型逆变，即：

        Number <  Object

        ArrayList  >  ArrayList

        因为list1 只能写不能读，所以能保证上面的泛型逆变，也实现了范型结合体的多态。

        4、协变和逆变的应用和实践

        上面了解完泛型结合体的多态实现，接下来我们就要正确运用协变和逆变，这需要对其使用的场景有充分的理解。

        协变很好理解，和我们常用的多态场景是类似的。协变只能读取数据，不能添加数据，所以只能作为生产者，向外提供数据，不能向它写入数据。

        逆变就不太好理解，其难以理解的点就在于，一个超类型，数据更泛化（可能泛化到Object），那不是做不了什么吗？如果把逆变的场景换到参数的函数功能复用，而非参数的数据使用，就能更好理解了。

        协变和逆变在集合中都有广泛的运用，所有我们继续以Java的ArrayList为例，举例说明：

        // Java

        public class ArrayList extends AbstractList

                implements List, RandomAccess, Cloneable, java.io.Serializable {

            transient Object[] elementData;

            private int size;

            // 省略代码......

            public boolean addAll(Collectionextends E> c) { // c参数支持协变

                Object[] a = c.toArray();  // 对c进行读操作

                int numNew = a.length;

                ensureCapacityInternal(size + numNew); 

                System.arraycopy(a, 0, elementData, size, numNew); // 写入到elementData数组中

                size += numNew;

                return numNew != 0;

            }

            public void forEach(Consumersuper E> action) {// action参数支持逆变

                Objects.requireNonNull(action);

                final int expectedModCount = modCount;

                @SuppressWarnings("unchecked")

                final E[] elementData = (E[]) this.elementData;

                final int size = this.size;

                for (int i=0; modCount == expectedModCount && i < size; i++) {

                    action.accept(elementData[i]);  // 对action写操作

                }

                if (modCount != expectedModCount) {

                    throw new ConcurrentModificationException();

                }

            }

        }

        class Person {

            String name;

            char sex;

            Person(String n, char s) {

                name = n;

                sex = s;

            }

        }

        class Boy extends Person {

            Boy(String n) {

                super(n, "male");

            }

        }

        class Girl extends Person {

            Girl(String n) {

                super(n, "female");

            }

        }

        public void main() {

            ArrayList array1 = new ArrayList();

            array1.add(new Person("p1b", "male"));

          array1.add(new Person("p1g", "female"));

            ArrayList array2 = new ArrayList();

            array2.add(new Boy("b1"));

            array2add(new Boy("b2"));

          // Boy是Person的子类型，所以Collection也是Collection<？extends Person>的子类型,

           // 而ArrayList继承自Collection，所以ArrayList是Collection的子类型，也同样是Collection<？extends Person>的子类型，

           // 然后，array1的addAll参数支持Collection<？extends Person>泛型协变，

           // 所以，array1的addAll参数可以传入array2.

            array1.addAll(array2);  

            int count = 0;

         Consumer comsumerPerson = new Consumer(){

                  @Override

                  public void accept(Person person) {

                       if(person.name.contain("g")) {

                             // do some action

                             count++;

                       }

                  }

             };

            // array1的forEach支持Consumer泛型逆变，

           //  Consumer参数属于本来类型，默认支持。

            array1.forEach(comsumerPerson)

            ArrayList array3 = new ArrayList();

            array3.add(new Girl("g1"));

            array3.add(new Girl("g2"));

          //  array3的forEach参数支持Consumer泛型逆变，

          // Person是Girl的超类型，所以Consumer是Consumer的子类型，

          // 所以，comsumerPerson可以作为forEach的参数。

            array3.forEach(comsumerPerson) 

        }

        通过上面的例子，我们可以看出来：

        • addAll函数中的参数c是作为生产者，从自身读取元素提供给ArrayList。通过协变参数Collection 中读取的元素肯定是ArrayList中元素E的子类型，子类型放进数组中肯定是支持的。

        • forEach函数中的参数action则是作为消费者，从ArrayList拿取元素提供给给自己使用。在array3.forEach(comsumerPerson) 中，Consumer是Consumer的子类型，可以作为参数传入，comsumerPerson拿到array3的Girl元素，在accept函数中统计Person名字含“g”的人员数。这样comsumerPerson的函数功能就得到了很好的复用。

        把只能从中读取的对象称为生产者（Producer），只能写入的对象称为消费者（Consumer），即只能从Producer中get对象，只能put对象给Consumer，这就是著名的PECS原则（Producer-Extends, Consumer-Super），也是协变和逆变的最佳实践原则。

        在狐友的代码中也通过使用协变和逆变，使得通用类可以适配大量的数据类型。以单例的事件总线LivedataBus为例说明：

        Flutter Dart：泛型的协变与逆变_第2张图片

        事件总线bus通过BusMutableLiveData声明支持协变，这样就可以在总线bus中添加所有BusEvent子类型事件。比如BusMutableLiveData （TeamUpPublishEvent 继承BusEvent），BusMutableLiveData。

        事件总线bus通过Event的类型名称作为key进行事件发布和订阅的匹配桥梁，让发布的事件可以通知到所有订阅者。

        Flutter Dart：泛型的协变与逆变_第3张图片

        Flutter Dart：泛型的协变与逆变_第4张图片

        BusMutableLiveData的observe方法，通过Observer声明参数支持逆变，让在onChange处理相似数据类型的Observer，可以有机会被多次复用。

        而BusMutableLiveData作为可感知生命周期，可观察数据变化的类型，用它来包装总线事件BusEvent，可以方便业务订阅各种事件通知， 如订阅组局发布事件 TeamUpPublishEvent，组局搜索事TeamUpSearchResultEvent ：

        Flutter Dart：泛型的协变与逆变_第5张图片

        a2a831043d6b371648c78c75d75e120e.jpeg

        这里，TeamUpPublishEvent的事件订阅者，会在onChanged收到事件时，先判断发布成功才会刷新UI。TeamUpSearchResultEvent的事件订阅者，则会在onChanged收到事件时上报搜索的结果。

        所以，通过运用协变和逆变，事件总线LivedataBus只用了简单少量的代码，就支持了无数种事件类型的发布和订阅处理。

        三、Dart协变

        实际上在Dart1.x的版本种是既支持协变又支持逆变，但是在Dart2.x版本开始仅支持协变。所以后面我们就不再讨论Dart的逆变。

        在Dart中所有泛型类都默认支持协变（类似Java的<？extend T>，Kotlin的），不需要像Java或Kotlin一样，需要用额外的关键字声明。

        从上一节的分析可知，协变实际上就是泛型结合体保留了泛型参数的子类型化关系。比如说int是num的子类型，所以List就是List的子类型，这就是结合体的子类型关系保留了泛型参数的子类型关系，用例子说明：

        // Dart

        class Person {

          final String name;

          final String sex;

          Person(this.name, this.sex);

        }

        class Boy extends Person {

          Boy(this.name) : super(this.name, "male");

        }

        class Girl extends Person {

          Girl(this.name) : super(this.name, "female");

        }

        void PrintMsg(List persons) { //根据多态的概念，persons可以传入List or 其子类型的对象。

          for (var person in persons) {

             print('${persons.name}---${persons.sex}');

          }

        }

        void main() {

        List girls = [];

        girls.add(Girl("g1"));

          // Girl是Person的子类型，List支持协变，则List是List子类型。

          // 而PrintMsg函数接收一个List类型，根据协变的原则，可以使用子类型代替超类型，可以使用List类型替代。

          PrintMsg(girls);

          List boys = [];

          boys.add(Boy("b1"));

          PrintMsg(boys);// 同上，List也是List的子类型

          List persons = [];

          persons.add(Person("p1","female"));

          persons.add(Person("p2","male"));

          PrintMsg(persons);// List自身，也是可以的。

        }

        从上面例子可以看出，在Dart中泛型声明默认是支持协变的，不需要像Java那样在代码中额外声明。

        我们在Flutter项目中，也有大量的泛型协变的应用，以实际代码举例：

        Flutter Dart：泛型的协变与逆变_第6张图片

        在buildBody方法中，接受一个List参数进行Page构建。

        再看调用的位置，实际上传参是一个通过buildButton返回的ElevatedButton(继承自Widget)构建出来的一个List，如下所示：

        Flutter Dart：泛型的协变与逆变_第7张图片

        因为List默认支持协变，所以buildBody方法可以接受一个List类型的实参。buildBody方法正是通过协变，支持了更多种类的页面数据，从而构建起item不同，布局类似的page页面。

        四、Dart协变安全

        Java，Kotlin中协变和逆变都是安全的，但是Dart的泛型型变是存在安全问题的，因为Dart中的协变是支持读写的，而Java，Kotlin中协变是不支持写的。

        以List集合为例，它在Java和Kotlin中都是不变的。

        Java通过声明List变量支持协变，并限制其数据T只能读不能写，从而保证了泛型协变安全。

        Kotlin和Java一样，也通过声明List来支持协变并限制其数据只读。但Kotlin对集合做了进一步优化，通过把集合分为可读写集合MutableList和只读集合List来保证安全问题。其中MutableList是可读可写，但不支持协变和逆变，而List只读，且支持协变。

        Dart中，List默认支持协变，又是可读可写的，这样就会存在安全问题，我们举例说明:

        // Dart

        class Person {

          final String name;

          final String sex;

          Person(this.name, this.sex);

        }

        class Boy extends Person {

          Boy(this.name) : super(this.name, "male");

        }

        class Girl extends Person {

          Girl(this.name) : super(this.name, "female");

        }

        void PrintMsg(List persons) { //根据多态的概念，persons可以传入List or 其子类型的对象。但是，这里的List实际是不安全的！！！

          for (var person in persons) {

            print('${persons.name}---${persons.sex}');

          }

        }

        void main() {

        List girls = [];

        girls.add(Girl("g1"));

        PrintMsg(girls);  // Girl是Person的子类型，List支持协变，则List是List子类型。

        }

        上面代码编译和运行都没有问题，但是PrintMsg中的List参数实际是不安全的！！！我们在上面的PrintMsg中对参数进行写操作，如下：

        // Dart

        void PrintMsg(List persons) { 

           //根据多态的概念，persons可以传入List or 其子类型的对象。但是，这里的List类型，因为可写，实际上是不安全的！！！

          // 在Dart1.x版本中运行也是可以通过的，原因不做探究。但是后续main通过girls读出一个Boy来也会出错！

          // 在Dart2.x版本中运行是会报错的:type 'Boy' is not a subtype of type 'Girl'

          // 在Dart中，List都是可读写的，协变的。看似在List中添加Boy，实际上是在List中添加Boy。如果后续从List中读出一个Boy来，这是不允许的。

          persons.add(Boy("b999")); // 编译通过，但运行报错！！！

          for (var person in persons) {

            print('${persons.name}---${persons.sex}');

          }

        }

        main() {

        List girls = [];

        girls.add(Girl("g1"));

        PrintMsg(girls);  // Girl是Person的子类型，List支持协变，则List是List子类型。

        }

        而在Kotlin中的不会存在上面那种问题。Kotlin中集合分为可读写集合MutableList和只读集合List， 举例说明：

        // Kotlin

        fun PrintMsg(persons: List) { 

            // Kotlin中List支持协变，且只读。这样的泛型类型是具有安全性的。

            //因为在Kotlin中List被定义为只读集合List，

            //没有add, remove等写操作方法，

            //所以List中是无法添加一个Boy的。

            persons.add(Boy("b1")) // 此处编译不通过。

            for (person in persons) {

                println(person.name + "---" + person.sex)

            }

        }

        fun main() {

            val girls = listOf(Girl("g1"))

           // Girl是Person的子类型，List支持协变，则List是List子类型，

           // 可以作为PrintMsg的参数。

            PrintMsg(girls)

        }

        在Dart中使用协变List很方便，但是发生协变的情况下，需要注意写操作的控制。

        五、Dart协变关键字convariant

        上面说到，在Dart中泛型声明默认是支持协变的，不需要额外声明。但是，在Dart中有个协变关键字convariant，它又有什么作用呢？举例说明 :

        // Dart

        class Person {

          final String name;

          final String sex;

          Person(this.name, this.sex);

        }

        class Boy extends Person {

          Boy(this.name) : super(this.name, "male");

        }

        class Girl extends Person {

          Girl(this.name) : super(this.name, "female");

        }

        class House { //宿舍

          void checkin(Person person) {

            print('checkin ${persons.name}---${persons.sex}');

          }

        }

        class BoyHouse extends House { //男宿舍

          @override

          void checkin(Person person) { // 因为是重写的checkin方法，参数需要和父类保持一致

            super.checkin(person);

          }

        }

        class GirlHouse extends House { //女宿舍

           @override

           void checkin(Person person) { // 因为是重写的checkin方法，参数需要和父类保持一致

             super.checkin(person);

           }

        }

        void main() {

          var bh = BoyHouse();

          bh.checkin(Boy("b1"));

          bh.checkin(Girl("g1")); //把女孩安排到男宿舍！！！编译运行都不会有问题！

          var gh = GirlHouse();

          gh.checkin(Girl("g2"));

          gh.checkin(Boy("b2"));//把男孩安排到女宿舍！！！编译运行都不会有问题！

        }

        上面的例子中，我们发现可以把女孩安排到男宿舍住，男孩安排到女宿舍住。男女宿舍的划分相当于形同虚设。

        为了解决这个问题，Dart可以通过 covariant 协变关键字，让重写方法中的参数更具体，举例说明：

        // Dart

        class BoyHouse extends House { //男宿舍

          @override

          void checkin(covariant Boy person) { // 重写的checkin方法，但通过covariant协变关键字，限制参数为更具体的Person的子类Boy

             super.checkin(person);

          }

        }

        class GirlHouse extends House { //女宿舍

           @override

           void checkin(covariant Girl person) { // 重写的checkin方法，但通过covariant协变关键字，限制参数为更具体的Person的子类Girl

              super.checkin(person);

           }

        }

        void main() {

          var bh = BoyHouse();

          bh.checkin(Boy("b1"));

          bh.checkin(Girl("g1")); //编译不通过！BoyHouse的checkin限制了参数只能是Boy类型

          var gh = GirlHouse();

          gh.checkin(Girl("g2"));

          gh.checkin(Boy("b2"));//编译不通过！GirlHouse的checkin限制了参数只能是Girl类型

        }

        在我们的摸鱼项目中，也有大量的convariant运用场景，以_KKPageViewState子类代码为例说明：

        Flutter Dart：泛型的协变与逆变_第8张图片

        Flutter Dart：泛型的协变与逆变_第9张图片

        父类State中didUpdateWidget方法只能知道要通知StatefullWidget的更新，通过convariant关键字，可以在子类_KKPageViewState的didUpdateWidget方法中，限制其参数必须是KKPageView (KKPageView 是 StatefullWidget的子类，支持参数协变)。

        六、总结

        通过上面的学习，我们对Dart中的协变有了更深入的理解，开发过程中也能更好更安全地运用Dart中的协变。我们最后总结下文章的核心内容：

        1. 泛型是为了功能复用，减少模板代码而提出来的一种设计思想。

        2.子类关系是一种继承关系，子类型关系则是一种多态关系。子类关系一般是子类型关系，但子类型关系不一定是子类关系。

        3.泛型的逆变，协变和不变，描述的是类型转换关系，是为了泛型结合体支持多态而提出来的。PECS是其最佳的实践原则。

        4.Dart的新版本不支持逆变，支持协变，且默认支持协变。但是Dart的协变支持写操作，有安全隐患，使用时需要额外注意。

        你可能感兴趣的:(flutter,android,kotlin,开发语言,java)

        • Android 屏幕亮度调节 oh嘉嘉加加加
          屏幕亮度调节模式：Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC：值为1，自动调节亮度。Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL：值为0，手动模式。设置屏幕亮度调节模式为手动模式ContentResolvercontentResolver=getActivity().getContentResolv
        • SpringBoot3与SpringBoot2的区别 bjzhang75 springboot
          文章目录1、JDK环境2、SpringFramework版本3、主要变化和新特性3.1配置变化3.2GraalVM3.3安全性改进3.4性能优化3.4.1启动时间3.4.2内存使用3.5改进的依赖管理3.6全新启动器3.7Kotlin支持SpringBoot3与SpringBoot2的区别1、JDK环境SpringBoot3最低要求JDK17SpringBoot2最低要求JDK82、SpringF
        • java多态介绍及与C++多态性的比较 xiaoweids 编程语言javajavaservletjvm
          一、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。1.如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。2.如果a是接口A的一个引用，那么,a必须指向实现了接
        • android10 系统定制：增加应用使用数据埋点，应用使用时长统计 ljl_jiaLiang android系统定制
          需求意在统计应用的使用时长和开始结束时间，最终生成一个文件可以直观看出什么时候进入了哪个应用、什么时候退出，如图：每行记录了应用的进入或退出，以逗号分割。分别记录了事件开始时间，应用包名，进入或退出（1或2），应用名称。根据上面的数据记录可以看出：2024-08-1209:52:54进入了设置，09:52:57退出设置回到了桌面，09:53:11进入了包名为com.example.intellig
        • js数组方法map和filter 人间废料记 javascriptjavascript前端
          目录.map()方法概念语法注意使用场景.filter()方法概念语法注意使用场景.map()和.filter()的区别和联系.map()方法概念.map()函数是JavaScript数组结构中很实用的一个方法之一。可以将map()方法视为经过一个循环并在回调函数中编写语句（格式化、数据处理）以构造一个新数组。用来创建新数组、修改其内容并保持原始数组不变的通用方法。当出现需要修改现有数组的内容并将
        • javascript - 模拟 for-in 循环 廖马儿
          获取："key,value"在for循环中。varlist={'aaa':'111','bbb':'222','ccc':'333'};我知道可以用forin语句获取键值对的值如下for(varkeyinlist){key;//输出aaabbbccclist[key]//输出为111222333}
        • IDEA测试类启动报 “java: 常量字符串过长” 解决办法 无休居士 Java工程常见异常javaintellij-ideaide
          目录标题问题描述问题分析解决办法其他办法问题描述问题分析字符串长度过长，导致idea默认使用的javac编译器编译不了。查询资料发现，原因是javac在编译期间，常量字符串最大长度为65534。解决办法Javac编译器改为Eclipse编译器。File->Settings->Build,Execution,Deployment->Compiler->JavaCompiler其他办法如果不是新建pr
        • java基础-线程间通信方式 问道飞鱼 Java开发技术java开发语言
          文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
        • Java 后端程序员必须要懂的几种框架分享 Java烟雨 javamvc开发语言
          MVC框架MVC模式是软件工程中的一种软件架构模式，可以把软件系统分为三个基本部分：模型（Model），编写程序应有的功能（实现算法等等）、进行数据管理和数据库设计，。视图（View），界面设计人员进行图形界面设计。控制器（Controller），负责转发请求，对请求进行处理。比较知名的MVC框架有SpringMVC，是一种基于请求驱动类型的轻量级Web框架，目的是帮助我们后端程序员简化开发。我个
        • Java 中自定义线程池 胡英俊俊俊 #JUCjava开发语言
          Java中自定义线程池的方式在Java开发中，线程池是非常常用的工具，它能够帮助我们更好地管理多线程任务，提升并发性能并避免过度创建线程导致的系统资源消耗。在Java中，线程池主要由ThreadPoolExecutor提供，该类支持自定义线程池的核心参数，如线程数、任务队列以及拒绝策略等。在这篇文章中，我们将讨论如何通过ThreadPoolExecutor来实现自定义线程池，以及常用的配置和使用方
        • 浅拷贝与深拷贝 ・T・T・ 面试前端javascriptlodash
          浅拷贝浅拷贝创建了一个新的对象或数组，但仅复制了顶层的属性或元素。对于嵌套的对象或数组，复制的仍然是引用。Object.assignObject.assign是JavaScript中用于复制对象属性的一个方法。它可以用来实现浅拷贝consttarget={};constsource={a:1,b:{c:2}};//浅拷贝source到targetObject.assign(target,sourc
        • java unix网络编程_《UNIX网络编程 卷2：进程间通信(第2版)》PDF 下载 weixin_39688019 javaunix网络编程
          图书目录：第一部分简介第1章简介1.1概述1.2进程、线程与信息共享1.3IPC对象的持续性1.4名字空间1.5fork、exec和exit对IPC对象的影响1.6出错处理：包裹函数1.7Unix标准1.8书中IPC例子索引表1.9小结习题第2章PosixIPC2.1概述2.2IPC名字2.3创建与打开IPC通道2.4IPC权限2.5小结习题第3章SystemVIPC3.1概述3.2key_t键和
        • Java Spring Boot 全面教程 极客代码 玩转Javajavaspringboot开发语言后端
          一、SpringBoot简介与环境搭建1.1SpringBoot简介SpringBoot是一种基于Java的开源框架，由PivotalSoftware开发，旨在简化新Spring应用程序的初始化、配置和部署过程。它遵循约定优于配置的原则，通过内嵌的Tomcat、Jetty或Undertow等容器，使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。SpringBoot包含了
        • Linux+Docker：3分钟实现MinIO在线部署与Java集成 码龄23年 linuxdockerjava
          Linux下使用Docker安装MinIO1.拉取MinIO镜像dockerpullminio/minio2.创建挂载目录mkdir-p/opt/minio/datamkdir-p/optl/minio/config3.检查端口占用sudolsof-i:9000...4.启动MinIO容器dockerrun--nameminio\#容器名称-p9010:9000\#映射主机端口9010到容器端口9
        • SpringBoot项目 俺叫啥好嘞 spring系列springspringboot
          SpringBoot项目大概分为四层：（1）DAO层：包括XxxMapper.java(数据库访问接口类)，XxxMapper.xml(数据库链接实现)；（这个命名，有人喜欢用Dao命名，有人喜欢用Mapper，看个人习惯了吧）（2）Bean层：也叫model层，模型层，entity层，实体层，就是数据库表的映射实体类，存放POJO对象；（3）Service层：也叫服务层，业务层，包括XxxSer
        • TypeScript 快速入门 echozzi 1024程序员节
          一、TypeScript是什么TypeScript是一种由微软开发的自由和开源的编程语言。于2012年推出。TypeScript是JavaScript的一个超集。为JavaScript添加了类型系统。TypeScript与JavaScript的区别TypeScriptJavaScriptJavaScript的超集用于解决大型项目的代码复杂性一种脚本语言，用于创建动态网页可以在编译期间发现并纠正错误
        • Java-后端程序员个人知识总结 金肴羽 java开发语言
          文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
        • WebRTC之LiveKit的基础入门使用（入门必看） tabzzz 前端webrtcweb3typescript
          LiveKit本文主要是讲解在Next13+中如何使用LiveKit来实现简单的音视频通话，想了解更多的还是要去官方文档去掌握更复杂、高级的使用方法。什么是LiveKitLiveKit是一个开源的实时通信平台，基于WebRTC，主要用于构建高质量的音视频通话、实时数据传输和互动应用。LiveKit除了方便以外的大优势就是它提供了丰富的API和SDK，支持多种平台，包括Web、iOS、Android
        • Android应用架构 — 从MVC到MVVM，基于android的app开发 m0_66264134 程序员架构移动开发android
          角色划分Model:用来保存程序的数据状态，比如数据存储，网络请求等。View:GUI组件构成，向用户展示Model中的数据。Controller:连接用户和系统，响应交互，传递数据。解决的问题MVC最重要的目的并不是规定各个模块应该如何交互和联系，而是将原有的混乱的应用程序划分出合理的层级，把以往一团混乱的代码，按照展示层和领域层分成两个部分。这种分离使得位于领域层中的领域对象可以不需要对展示层
        • 一文说透 Android 应用架构 MVC、MVP、MVVM 和 组件化，Android基础入门教程 Java后时代 2024年程序员学习android架构mvc
          然后，就是我们的View层的代码，同样，我对代码做了删减：@Route(path=BaseConstants.EYEPETIZER_MENU)publicclassHomeActivityextendsCommonActivityimplementsHomeContract.IView{//实例化PresenterprivateHomeContract.IPresenterpresenter;{p
        • JAVA之接口 java萌新小白
          接口接口的概述电脑上面的主板有很多接口，比如内存条的接口，有了这个接口，可以插入多个内存条，主板和内存条可能不是同一家生产厂商，但是两种物体却能结合到一起，正是因为这个接口的存在。只要厂家遵循这个接口，主板和内存条就可以随意更换，提高了可插拔性，接口其实也是体现着一种规范。在java语言里面使用interface来声明一个接口，接口其实是一个特殊的抽象类，在接口里面的方法全部都是抽象的。关于接口，
        • Android保存Activity状态 wishes丶啊
          在Activity#onSaveInstanceState()可以对数据进行保存，然后在Activity#onCreate()中获取代码:classMainActivityextendsActivity{@OverrideprotectedvoidonCreate(BundlesavedInstanceState){if(savedInstanceState!=null){Stringname=s
        • Spring6学习笔记4：事务 ·云扬· SSMJava#Spring学习笔记spring
          1JdbcTemplate1.1简介Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作准备工作①搭建子模块搭建子模块：spring-jdbc-tx②加入依赖org.springframeworkspring-jdbc6.0.2mysqlmysql-connector-java8.0.30com.alibabadruid1.2.15③创建jdbc.propertie
        • Java程序的分层设计 天天进步2015 架构设计java开发语言
          Java程序的分层设计通常遵循分层架构（LayeredArchitecture）的原则，将应用程序分为多个相互独立但有依赖关系的层。这样设计有助于降低耦合度，提高可维护性和可扩展性。典型的Java分层设计包括以下几层：1.表示层（PresentationLayer/ViewLayer）功能：用户界面层，负责与用户交互。将用户输入的信息传递给业务层，同时将业务层返回的结果展示给用户。一般使用JSP、
        • java中的ide、sdk是什么,javaee\javase\javame区别 极客Thomas idejavaeclipse
          ide：integrateddevelopmentenvironment集成开发环境简单的来说就是提供编译代码等一系列功能的开发环境比如：eclipsesdk：servicedevelopmentpack服务开发包简单来说就是一些封装的功能代码，做成了一个包，给我们可以直接调用比如jdk1.8jdkjavase（JavaPlatform，StandardEdition）标准版本，在电脑上运行jav
        • java 基础 i0208 java开发语言
          基础数据类型，方法，类，异常处理：Java零基础入门学习（小白也能看懂！）_java零基础自学-CSDN博客List在Java中，List接口是集合框架中非常重要的一个接口，它提供了存储和操作有序集合的方法。List是一个接口，因此不能直接实例化，但可以通过其实现类（如ArrayList,LinkedList,Vector等）来使用。List接口的主要实现类ArrayList:动态数组实现，适用于
        • PTA:7-32 最小公倍数（递归） 萠哥啥都行 java开发语言
          本题目要求读入2个整数a和b，然后输出它们的最小公倍数。输入格式:输入在一行中给出2个正整数，以空格分隔。输出格式:输出最小公倍数。输入样例:在这里给出一组输入。例如：614输出样例:在这里给出相应的输出。例如：42importjava.util.Scanner;publicclassMain{publicstaticintgcd(inta,intb){//辗转相除求最大公约数if(b==0){r
        • 前端开发深入了解webpack 史努比的大头 前端
          什么是webpackWebpack是一个现代JavaScript应用程序的模块打包工具。它主要用于将各种资源（如JavaScript、CSS、图片等）打包成一个或多个文件，以优化Web应用的加载性能。Webpack的核心功能包括：模块化：支持将代码拆分为模块，便于管理和重用。打包：将多个模块和资源打包成一个或多个文件，减少HTTP请求。加载器（Loaders）：处理不同类型的文件（如转换ES6到E
        • Reactive 编程-Vert.x Flying_Fish_Xuan python开发语言
          Reactive编程与Vert.x：高效异步Java微服务框架一、什么是Reactive编程？Reactive编程是一种异步编程范式，专注于数据流和事件的传播处理。与传统的阻塞式编程不同，Reactive编程能够更好地处理高并发和异步操作，特别适合实时系统、流处理以及需要快速响应的场景。Reactive编程的核心原则包括：响应性（Responsive）：系统能够快速响应用户请求，并保持低延迟。弹性
        • Cocos2d、Cocos2dx、Cocos Creator、Cocos Studio的区别 Thomas游戏圈
          一、Cocos2d和Cocos2dx的区别【开发语言】：Cocos2d是Object-C写的，Cocos2dx是C++写的，支持使用C++、Lua或Java进行开发。【运行平台】：Cocos2d只能在IOS下运行，Cocos2dx是跨平台的，适配iOS、Android、HTML5、Windows和Mac系统，功能侧重于原生移动平台。点击链接加入群聊【Unity/Cocos交流群】【国籍】：Coco
        • 插入表主键冲突做更新 a-john
          有以下场景： 用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 问题： 如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 解决： mysql中提供了一个sql语
        • Android xml资源文件中@、@android:type、@*、？、@+含义和区别 Cb123456 @+@?@*
          一.@代表引用资源 1.引用自定义资源。格式：@[package:]type/name android：text="@string/hello"   2.引用系统资源。格式：@android:type/name     android:textColor="@android:color/opaque_red"
        • 数据结构的基本介绍 天子之骄 数据结构散列表树、图线性结构价格标签
          数据结构的基本介绍 数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。   经典的数据结构大致如下：   一：线性数据结构 (1)：列表 a
        • 通过二维码开放平台的API快速生成二维码 一炮送你回车库 api
           现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。        html代码如下:(二维码将生成在这div下) ? 1  &nbs
        • ImageIO读取一张图片改变大小 3213213333332132 javaIOimageBufferedImage
          package com.demo; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * @Description 读取一张图片改变大小 * @author FuJianyon
        • myeclipse集成svn（一针见血） 7454103 eclipseSVNMyEclipse
                                           &n
        • 装箱与拆箱----autoboxing和unboxing darkranger J2SE
          4.2　自动装箱和拆箱 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 4.2.1　autoboxing和unboxing 在Java中，所有要处理的东西几乎都是对象(Object)
        • ajax传统的方式制作ajax aijuans Ajax
          //这是前台的代码 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
        • 只用jre的eclipse是怎么编译java源文件的？ avords javaeclipsejdktomcat
          eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ &nb
        • 前端模块化 bee1314 模块化
          背景： 前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。   JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
        • 处理百万级以上的数据处理 bijian1013 oraclesql数据库大数据查询
          一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。         2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
        • mac 卸载 java 1.7 或更高版本 征客丶 javaOS
          卸载 java 1.7 或更高 sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 成功执行此命令后，还可以执行 java 与 javac 命令 sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 成功执行此命令后，还可以执行 java
        • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析 bit1129 Stream
          第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 第二部，Spark Streaming读取Kafka中的数据，进行实时分析   本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
        • Erlang vs TNSDL bookjovi erlang
                TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
        • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个 ljy325 企业应用
          　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 相关新闻： （1）IT行业成五大疾病重灾区：过劳死平均37.9岁
        • 读《研磨设计模式》-代码笔记-原型模式 bylijinnan java设计模式
          声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * Effective Java 建议使用copy constructor or copy factory来代替clone()方法： * 1.public Product copy(Product p){} * 2.publi
        • 配置管理---svn工具之权限配置 chenyu19891124 SVN
          今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 pepos    component    webapps 在conf里面的auth里赋予的权限配置为 [groups]
        • 浅谈程序员的数学修养 comsci 设计模式编程算法面试招聘
                                           浅谈程序员的数学修养
        • 批量执行 bulk collect与forall用法 daizj oraclesqlbulk collectforall
          BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。     有关FORALL语句的用法请参考：批量SQL之 F
        • Linux下使用rsync最快速删除海量文件的方法 dongwei_6688 OS
          1、先安装rsync：yum install rsync 2、建立一个空的文件夹：mkdir /tmp/test 3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。
        • Yii CModel中rules验证规格 dcj3sjt126com rulesyiivalidate
          Yii cValidator主要用法分析：  yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError  
        • 基于vagrant的redis主从实验 dcj3sjt126com vagrant
          平台: Mac 工具: Vagrant 系统: Centos6.5 实验目的: Redis主从   实现思路 制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box   制作sentos6.5+redis的box   mkdir vagrant_redis cd vagrant_
        • Memcached(二)、Centos安装Memcached服务器 frank1234 centosmemcached
          一、安装gcc rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]： 建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码...... rpm -ivh kernel-head
        • Remove Duplicates from Sorted List hcx2013 remove
          Given a sorted linked list, delete all duplicates such that each element appear only once. For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
        • Spring4新特性——JSR310日期时间API的支持 jinnianshilongnian spring4
          Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
        • 浅谈enum与单例设计模式 247687009 java单例
          在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构 造器，导出静态成员变量，以便调用者访问。 第一种 package singleton; public class Singleton { //导出全局成员 public final static Singleton INSTANCE = new S
        • 使用switch条件语句需要注意的几点 openwrt cbreakswitch
          1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 int main() { int n = 1; switch(n) { case 1: printf("--1--\n"); default: printf("defa
        • 配置Spring Mybatis JUnit测试环境的应用上下文 schnell18 springmybatisJUnit
          Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 单元测试的app context不支持从外部properties文件注入属性 @Value注解不能解析带通配符的路径字符串 解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 第二个问题的具体实例是：    
        • Java 定时任务总结一 tuoni javaspringtimerquartztimertask
           Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
        • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法 yangshangchuan rank相似度计算文本相似度词袋模型余弦相似度
          本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。   最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下：     1、注册多个账号（一般10个以上）。     2、从多个账号中选择一个账号，发表1-2篇博文