// 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> {

T _msg;

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

void printMsg() { print(_msg); }

}

// Dart

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

Map<String, int> 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<dynamic>”

print(mapTest.runtimeType.toString()); // output“_InternalLinkedHashMap<dynamic,dynamic>”

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

List<dynamic> numTest = [1, 2, 3];

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

// Kotlin

inline fun <reified T> 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, 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

void PrintMsg<T>(T value) {

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

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

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

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<String>.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<int> //此处List中的E元素仍然是int对象

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

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

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

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

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

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

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

// Java

public class ArrayList<E> extends AbstractList<E>

implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

transient Object[] elementData;

private int size;

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

public boolean addAll(Collection<? extends 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(Consumer<? super 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<Person> array1 = new ArrayList<Person>();

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

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

ArrayList<Boy> array2 = new ArrayList<Boy>();

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

array2add(new Boy("b2"));

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

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

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

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

array1.addAll(array2);

int count = 0;

Consumer<Person> comsumerPerson = new Consumer<Person>(){

@Override

public void accept(Person person) {

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

// do some action

count++;

}

}

};

// array1的forEach支持Consumer<? super Person>泛型逆变，

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

array1.forEach(comsumerPerson)

ArrayList<Girl> array3 = new ArrayList<Girl>();

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

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

// array3的forEach参数支持Consumer<? super Girl>泛型逆变，

// Person是Girl的超类型，所以Consumer<Person>是Consumer<? super Girl>的子类型，

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

array3.forEach(comsumerPerson)

}

// 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<Person> persons) { //根据多态的概念，persons可以传入List<Person> or 其子类型的对象。

for (var person in persons) {

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

}

}

void main() {

List<Girl> girls = [];

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

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

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

PrintMsg(girls);

List<Boy> boys = [];

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

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

List<Person> persons = [];

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

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

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

}

// 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<Person> persons) { //根据多态的概念，persons可以传入List<Person> or 其子类型的对象。但是，这里的List<Person>实际是不安全的！！！

for (var person in persons) {

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

}

}

void main() {

List<Girl> girls = [];

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

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

}

// Dart

void PrintMsg(List<Person> persons) {

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

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

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

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

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

for (var person in persons) {

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

}

}

main() {

List<Girl> girls = [];

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

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

}

// Kotlin

fun PrintMsg(persons: List<Person>) {

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

//因为在Kotlin中List被定义为只读集合List<out E>，

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

//所以List<Person>中是无法添加一个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<Girl>是List<Person>子类型，

// 可以作为PrintMsg的参数。

PrintMsg(girls)

}

// 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

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类型

}