关闭

JAVA 泛型详解二

标签: 泛型java
270人阅读 评论(0) 收藏 举报
分类:

上一篇给大家初步讲解了泛型变量的各种应用环境,这篇将更深入的讲解一下有关类型绑定,通配符方面的知识。

一、类型绑定

1、引入

我们重新看上篇写的一个泛型:

[java] view plaincopy
  1. class Point<T> {  
  2.     private T x;       // 表示X坐标  
  3.     private T y;       // 表示Y坐标  
  4.   
  5.     public void setX(T x) {  
  6.         this.x = x;  
  7.     }  
  8.   
  9.     public void setY(T y) {  
  10.         this.y = y;  
  11.     }  
  12.   
  13.     public T getX() {  
  14.         return this.x;  
  15.     }  
  16.   
  17.     public T getY() {  
  18.         return this.y;  
  19.     }  
  20. }  
  21.   
  22. //使用  
  23. Point<Integer> p1 = new Point<Integer>();  
  24. p1.setX(new Integer(100));  
  25. System.out.println(p1.getX());  
首先,我们要知道一点,任何的泛型变量(比如这里的T)都是派生自Object,所以我们在填充泛型变量时,只能使用派生自Object的类,比如String,Integer,Double,等而不能使用原始的变量类型,比如int,double,float等。
然后,问题来了,那在泛型类Point<T>内部,利用泛型定义的变量T x能调用哪些函数呢?
[java] view plaincopy
  1. private T x;    
当然只能调用Object所具有的函数,因为编译器根本不知道T具体是什么类型,只有在运行时,用户给什么类型,他才知道是什么类型。编译器唯一能确定的是,无论什么类型,都是派生自Object的,所以T肯定是Object的子类,所以T是可以调用Object的方法的。
那么问题又来了,如果我想写一个找到最小值的泛型类;由于不知道用户会传什么类型,所以要写一个接口,让用户实现这个接口来自已对比他所传递的类型的大小。
接口如下:
[java] view plaincopy
  1. public interface Comparable<T>{  
  2.     public boolean compareTo(T i);  
  3. }  
但如果我们直接利用T的实例来调用compareTo()函数的话,会报错,编译器截图如下:

这是因为,编译器根本无法得知T是继承自Comparable接口的函数。那怎么样才能让编译器知道,T是继承了Comparable接口的类型呢?
这就是类型绑定的作用了。

2、类型绑定:extends

(1)、定义
有时候,你会希望泛型类型只能是某一部分类型,比如操作数据的时候,你会希望是Number或其子类类型。这个想法其实就是给泛型参数添加一个界限。其定义形式为:

[java] view plaincopy
  1. <T extends BoundingType>  
此定义表示T应该是BoundingType的子类型(subtype)。T和BoundingType可以是类,也可以是接口。另外注意的是,此处的”extends“表示的子类型,不等同于继承。
一定要非常注意的是,这里的extends不是类继承里的那个extends!两个根本没有任何关联。在这里extends后的BoundingType可以是类,也可以是接口,意思是说,T是在BoundingType基础上创建的,具有BoundingType的功能。目测是JAVA的开发人员不想再引入一个关键字,所以用已有的extends来代替而已。
(2)、实例:绑定接口
同样,我们还使用上面对比大小的接口来做例子
首先,看加上extends限定后的min函数:
[java] view plaincopy
  1. public interface Comparable<T> {  
  2.     public boolean compareTo(T i);  
  3. }  
  4. //添加上extends Comparable之后,就可以Comparable里的函数了  
  5. public static <T extends Comparable>  T min(T...a){  
  6.     T smallest = a[0];  
  7.     for(T item:a){  
  8.         if (smallest.compareTo(item)){  
  9.             smallest = item;  
  10.         }  
  11.     }  
  12.     return smallest;  
  13. }  
这段代码的意思就是根据传进去的T类型数组a,然后调用其中item的compareTo()函数,跟每一项做对比,最终找到最小值。
从这段代码也可以看出,类型绑定有两个作用:1、对填充的泛型加以限定 2、使用泛型变量T时,可以使用BoundingType内部的函数。
这里有一点非常要注意的是,在这句中smallest.compareTo(item),smallest和item全部都是T类型的,也就是说,compareTo对比的是同一种类型。
然后我们实现一个派生自Comparable接口的类:
[java] view plaincopy
  1. public class StringCompare implements Comparable<StringCompare> {  
  2.     private String mStr;  
  3.   
  4.     public StringCompare(String string){  
  5.         this.mStr = string;  
  6.     }  
  7.   
  8.     @Override  
  9.     public  boolean compareTo(StringCompare str) {  
  10.         if (mStr.length() > str.mStr.length()){  
  11.             return true;  
  12.         }  
  13.         return false;  
  14.     }  
  15. }  
在这段代码,大家可能会疑惑为什么把T也填充为StringCompare类型,记得我们上面说的吗:smallest.compareTo(item),smallest和item是同一类型!!所以compareTo的参数必须是与调用者自身是同一类型,所以要把T填充为StringCompare;
在这段代码中compareTo的实现为,对比当前mstr的长度与传进来实例的mstr长度进行比较,如果超过,则返回true,否则返回false;
最后是使用min函数:
[java] view plaincopy
  1. StringCompare result = min(new  StringCompare("123"),new StringCompare("234"),new StringCompare("59897"));  
  2. Log.d(TAG,"min:"+result.mStr);  
结果如下:

这里有extends接口,我们开篇说过,extends表示绑定,后面的BindingType即可以是接口,也可以是类,下面我们就再举个绑定类的例子。

源码在文章底部给出

(3)、实例:绑定类
我们假设,我们有很多种类的水果,需要写一个函数,打印出填充进去水果的名字:
为此,我们先建一个基类来设置和提取名字:

[java] view plaincopy
  1. class Fruit {  
  2.     private String name;  
  3.   
  4.     public String getName() {  
  5.         return name;  
  6.     }  
  7.     public void setName(String name) {  
  8.         this.name = name;  
  9.     }  
  10. }  
然后写个泛型函数来提取名字:
[java] view plaincopy
  1. public static <T extends Fruit> String getFruitName(T t){  
  2.     return t.getName();  
  3. }  
这里泛型函数的用法就出来了,由于我们已知水果都会继承Fruit基类,所以我们利用<T extends Fruit>就可以限定填充的变量必须派生自Fruit的子类。一来,在T中,我们就可以利用Fruit类中方法和函数;二来,如果用户填充进去的类没有派生自Fruit,那编译器就会报错。
然后,我们新建两个类,派生自Fruit,并填充进去它们自己的名字:
[java] view plaincopy
  1. class Banana extends Fruit{  
  2.     public Banana(){  
  3.         setName("bababa");  
  4.     }  
  5. }  
  6. class Apple extends Fruit{  
  7.     public Apple(){  
  8.         setName("apple");  
  9.     }  
  10. }  
最后调用:
[java] view plaincopy
  1. String name_1 = getFruitName(new Banana());  
  2. String name_2 = getFruitName(new Apple());  
  3. Log.d(TAG,name_1);  
  4. Log.d(TAG,name_2);  
结果如下:

源码在文章底部给出
(4)、绑定多个限定
上面我们讲了,有关绑定限定的用法,其实我们可以同时绑定多个绑定,用&连接,比如:

[java] view plaincopy
  1. public static <T extends Fruit&Serializable> String getFruitName(T t){  
  2.     return t.getName();  
  3. }  
再加深下难度,如果我们有多个泛型,每个泛型都带绑定,那应该是什么样子的呢:
[java] view plaincopy
  1. public static <T extends Comparable & Serializable, U extends Runnable> T foo(T a, U b){  
  2.     …………  
  3. }  
大家应该看得懂,稍微讲一下:这里有两个泛型变量T和U,将T与Comparable & Serializable绑定,将U与Runnable绑定。
好了,这部分就讲完了,下面讲讲有关通配符的用法。

二、通配符

通配符是一个非常令人头疼的一个功能,理解与掌握难度比较大,下面我尽力去讲明白它与泛型变量的区别与用法。

1、引入

重新来看我们上篇用的Point泛型定义:
[java] view plaincopy
  1. class Point<T> {  
  2.     private T x;        
  3.     private T y;        
  4.       
  5.     public Point(){  
  6.           
  7.     }  
  8.     public Point(T x,T y){  
  9.         this.x = x;  
  10.         this.y = y;  
  11.     }  
  12.   
  13.     public void setX(T x) {  
  14.         this.x = x;  
  15.     }  
  16.   
  17.     public void setY(T y) {  
  18.         this.y = y;  
  19.     }  
  20.   
  21.     public T getX() {  
  22.         return this.x;  
  23.     }  
  24.   
  25.     public T getY() {  
  26.         return this.y;  
  27.     }  
  28. }  
这段代码很简单,引入了一个泛型变量T,然后是有两个构造函数,最后分别是利用set和get方法来设置和获取x,y的值。这段代码没什么难度,不再细讲。
我们看看下面这段使用的代码:
[java] view plaincopy
  1. Point<Integer> integerPoint = new Point<Integer>(3,3);  
  2. …………  
  3. Point<Float> floatPoint = new Point<Float>(4.3f,4.3f);  
  4. …………  
  5. Point<Double> doublePoint = new Point<Double>(4.3d,4.90d);  
  6. …………  
  7. Point<Long> longPoint = new Point<Long>(12l,23l);  
  8. …………  
在这段代码中,我们使用Point<T>生成了四个实例:integerPoint,floatPoint,doublePoint和longPoint;
在这里,我们生成四个实例,就得想四个名字。如果我们想生成十个不同类型的实例呢?那不得想十个名字。
光想名字就是个事,(其实我并不觉得想名字是个什么大事…… T _ T ,没办法,想不出更好的例子了…… )
那有没有一种办法,生成一个变量,可以将不同类型的实例赋值给他呢?

2、无边界通配符:?

(1)、概述
先不讲无边界通配符是什么,同样拿上面的例子来看,如果我们这样实现:
[java] view plaincopy
  1. Point<?> point;  
  2.   
  3. point = new Point<Integer>(3,3);  
  4. point = new Point<Float>(4.3f,4.3f);  
  5. point = new Point<Double>(4.3d,4.90d);  
  6. point = new Point<Long>(12l,23l);  
在这里,我们首先,利用下面的代码生成一个point实例,注意到,在填充泛型时,用的是?
[java] view plaincopy
  1. Point<?> point;  
然后,各种类型的Point实例,都可以赋值给point了:
[java] view plaincopy
  1. point = new Point<Integer>(3,3);  
  2. point = new Point<Float>(4.3f,4.3f);  
  3. point = new Point<Double>(4.3d,4.90d);  
  4. point = new Point<Long>(12l,23l);  
这里的?就是无边界通配符。通配符的意义就是它是一个未知的符号,可以是代表任意的类。
所以这里可能大家就明白了,这里不光能将泛型变量T填充为数值类型,其实任意Point实例都是可以传给point的:比如这里的Point<String>(),Point<Object>()都是可以的

(2)、?与T的区别
大家可能会有疑问,那无边界通配符?与泛型变量T有什么区别呢?
答案是:他们俩没有任何联系!!!!!
泛型变量T不能在代码用于创建变量,只能在类,接口,函数中声明以后,才能使用。
比如:

[java] view plaincopy
  1. public class Box<T> {  
  2.    public T get(){  
  3.        …………  
  4.    };  
  5.    public void put(T element){  
  6.        …………  
  7.    };  
  8. }  
而无边界通配符?则只能用于填充泛型变量T,表示通配任何类型!!!!再重复一遍:?只能用于填充泛型变量T。它是用来填充T的!!!!只是填充方式的一种!!!
比如:
[java] view plaincopy
  1. //无边界通配符填充  
  2. Box<?> box;  
  3. //其它类型填充  
  4. Box<String> stringBox;  
(3)、通配符只能用于填充泛型变量T,不能用于定义变量
大家一定要记得,通配符的使用位置只有:
[java] view plaincopy
  1. Box<?> box;  
  2. box = new Box<String>();  
即填充泛型变量T的位置,不能出现在后面String的位置!!!!
下面的第三行,第四行,都是错误的。通配符不能用于定义变量。

再次强调,?只能出现在Box<?> box;中,其它位置都是不对的。

3、通配符?的extends绑定

(1)、概述
从上面我们可以知道通配符?可以代表任意类型,但跟泛型一样,如果不加以限定,在后期的使用中编译器可能不会报错。所以我们同样,要对?加以限定。
绑定的形式,同样是通过extends关键字,意义和使用方法都用泛型变量一致。
同样,以我们上面的Point<T>泛型类为例,因为Point在实例意义中,其中的值是数值才有意义,所以将泛型变量T填充为Object类型、String类型等都是不正确的。
所以我们要对Point<?> point加以限定:只有数值类型才能赋值给point;
我们把代码改成下面的方式:


我们给通配符加上限定: Point<? extends Number> point;
此时,最后两行,当将T填充为String和Object时,赋值给point就会报错!
这里虽然是指派生自Number的任意类型,但大家注意到了没: new Point<Number>();也是可以成功赋值的,这说明包括边界自身。
再重复一遍:无边界通配符只是泛型T的填充方式,给他加上限定,只是限定了赋值给它(比如这里的point)的实例类型。
如果想从根本上解决乱填充Point的问题,需要从Point泛型类定义时加上<T extends Number>:

[java] view plaincopy
  1. class Point<T extends Number> {  
  2.     private T x;       // 表示X坐标  
  3.     private T y;       // 表示Y坐标  
  4.   
  5.    …………  
  6. }  
(2)注意:利用<? extends Number>定义的变量,只可取其中的值,不可修改
看下面的代码:

明显在point.setX(Integer(122));时报编译错误。但point.getX()却不报错。
这是为什么呢?
首先,point的类型是由Point<? extends Number>决定的,并不会因为point = new Point<Integer>(3,3);而改变类型。
即便point = new Point<Integer>(3,3);之后,point的类型依然是Point<? extends Number>,即派生自Number类的未知类型!!!这一点很好理解,如果在point = new Point<Integer>(3,3);之后,point就变成了Point<Integer>类型,那后面point = new Point<Long>(12l,23l);操作时,肯定会因为类型不匹配而报编译错误了,正因为,point的类型始终是Point<? extends Number>,因此能继续被各种类型实例赋值。
回到正题,现在说说为什么不能赋值
正因为point的类型为 Point<? extends Number> point,那也就是说,填充Point的泛型变量T的为<? extends Number>,这是一个什么类型?未知类型!!!怎么可能能用一个未知类型来设置内部值!这完全是不合理的。
但取值时,正由于泛型变量T被填充为<? extends Number>,所以编译器能确定的是T肯定是Number的子类,编译器就会用Number来填充T
也就是说,编译器,只要能确定通配符类型,就会允许,如果无法确定通配符的类型,就会报错。

4、通配符?的super绑定

(1)、概述
如果说 <? extends XXX>指填充为派生于XXX的任意子类的话,那么<? super XXX>则表示填充为任意XXX的父类!
我们先写三个类,Employee,Manager,CEO,分别代表工人,管理者,CEO
其中Manager派生于Employee,CEO派生于Manager,代码如下:

[java] view plaincopy
  1. class CEO extends Manager {  
  2. }  
  3.   
  4. class Manager extends Employee {  
  5. }  
  6.   
  7. class Employee {  
  8. }  
然后,如果我这样生成一个变量:
[java] view plaincopy
  1. List<? super Manager> list;  
它表示的意思是将泛型T填充为<? super Manager>,即任意Manager的父类;也就是说任意将List<T>中的泛型变量T填充为Manager父类的List变量,都可以赋值给list;

从上面的代码中可以看出new ArrayList<Employee>(),new ArrayList<Manager>()都是正确的,而new ArrayList<CEO>()却报错,当然是因为CEO类已经不再是Manager的父类了。所以会报编译错误。
这里还要注意一个地方,从代码中可以看出new ArrayList<Manager>()是可以成功赋值给 List<? super Manager> list的,可见,super关键字也是包括边界的。即边界类型(这里是Manager)组装的实例依然可以成功赋值。
(2)、super通配符实例内容:能存不能取
上面我们讲了,extends通配符,能取不能存,那super通配符情况又怎样呢?我们试试看:


先看存的部分:

[java] view plaincopy
  1. List<? super Manager> list;  
  2. list = new ArrayList<Employee>();  
  3. //存  
  4. list.add(new Employee()); //编译错误  
  5. list.add(new Manager());  
  6. list.add(new CEO());  
首先,需要声明的是,与Point<? extends Number> point中point的类型是由Point<? extends Number>确定的,相同的是list的类型是也是由List<? super Manager> ;list的item的类型始终是<? super Manager>,即Manager类的任意父类,即可能是Employee或者Object.
大家可能疑惑的地方在于,为什么下面这两个是正确的!而list.add(new Employee()); 却是错误的!
[java] view plaincopy
  1. list.add(new Manager());  
  2. list.add(new CEO());  
因为list里item的类型是<? super Manager>,即Manager的任意父类,我们假如是Employee,那下面这段代码大家能理解了吧:
[java] view plaincopy
  1. List<Employee> list = new ArrayList<Employee>();  
  2. list.add(new Manager());  
  3. list.add(new CEO());  
在这里,正因为Manager和CEO都是Employee的子类,在传进去list.add()后,会被强制转换为Employee!
现在回过头来看这个:
[java] view plaincopy
  1. List<? super Manager> list;  
  2. list = new ArrayList<Employee>();  
  3. //存  
  4. list.add(new Employee()); //编译错误  
  5. list.add(new Manager());  
  6. list.add(new CEO());  
编译器无法确定<? super Manager>的具体类型,但唯一可以确定的是Manager()、CEO()肯定是<? super Manager>的子类,所以肯定是可以add进去的。但Employee不一定是<? super Manager>的子类,所以不能确定,不能确定的,肯定是不允许的,所以会报编译错误。
最后再来看看取:

在这段代码中,Object object = list.get(0);是不报错的,而Employee employee = list.get(0);是报错的;
我们知道list中item的类型为<? super Manager>,那编译器能肯定的是<? super Manager>肯定是Manger的父类;但不能确定,它是Object还是Employee类型。但无论是填充为Object还是Employee,它必然是Object的子类!
所以Object object = list.get(0);是不报错的。因为 list.get(0);肯定是Object的子类;
而编译器无法判断list.get(0)是不是Employee类型的,所以Employee employee = list.get(0);是报错的。
这里虽然看起来是能取的,但取出来一个Object类型,是毫无意义的。所以我们认为super通配符:能存不能取;

5、通配符?总结

总结 ? extends 和 the ? super 通配符的特征,我们可以得出以下结论:
◆ 如果你想从一个数据类型里获取数据,使用 ? extends 通配符(能取不能存)
◆ 如果你想把对象写入一个数据结构里,使用 ? super 通配符(能存不能取)
◆ 如果你既想存,又想取,那就别用通配符。

6、常见问题注意

(1)、Point与Point<T>构造泛型实例的区别
同样以Point泛型类为例:
[java] view plaincopy
  1. class Point<T> {  
  2.     private T x;       // 表示X坐标  
  3.     private T y;       // 表示Y坐标  
  4.   
  5.     public Point(){  
  6.   
  7.     }  
  8.     public Point(T x,T y){  
  9.         this.x = x;  
  10.         this.y = y;  
  11.     }  
  12.   
  13.     public void setX(T x) {  
  14.         this.x = x;  
  15.     }  
  16.   
  17.     public void setY(T y) {  
  18.         this.y = y;  
  19.     }  
  20.   
  21.     public T getX() {  
  22.         return this.x;  
  23.     }  
  24.   
  25.     public T getY() {  
  26.         return this.y;  
  27.     }  
  28. }  
我们来看看下面这种构造Point泛型实例有什么区别:
[java] view plaincopy
  1. //使用Point<?>  
  2. Point<?> point1 = new Point(new Integer(23),new Integer(23));  
  3. Point<?> point2 = new Point(new String(""),new String(""));  
  4. //直接使用Point  
  5. Point point3 = new Point(new Integer(23),new Integer(23));  
  6. Point point4 = new Point(new String(""),new String(""));  
上面的四行代码中,point1,point2生成的是Point<?>的实例,填充的是无边界通配符。而point3和point4则非常奇怪,没有了泛型的<>标识,直接使用Point生成的实例,那它填充的是什么呢?
这四行代码在编译和运行时,都没有报错,而且输出结果也一样!
那么问题就来了:
[java] view plaincopy
  1. Point<?> point1 = new Point(new Integer(23),new Integer(23));  
  2. Point<?> point2 = new Point(new String(""),new String(""));  
在上面的代码中,使用了无界通配符,所以能够将各种Point实例赋值给Point<?> point1
而省略了泛型标识的构造方法,依然能将各种Point实例赋值给它:
[java] view plaincopy
  1. Point point3 = new Point(new Integer(23),new Integer(23));  
  2. Point point4 = new Point(new String(""),new String(""));  
这说明:构造泛型实例时,如果省略了填充类型,则默认填充为无边界通配符!
所以下面这两个是对等的:
[java] view plaincopy
  1. Point point3 = new Point(new Integer(23),new Integer(23));  
  2. Point<?> point3 = new Point(new Integer(23),new Integer(23));  
最后重复一遍:构造泛型实例时,如果省略了填充类型,则默认填充为无边界通配符!
0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

java泛型详解

学习java或者软件开发的出去编程有时候项目经理经常会问到有关泛型的理解; 泛型:是指在定义类或者接口的时候可以为类和接口指定类型形参,该类型形参在定义变量和创建对象的确定 1、定义泛型类,程序实例代...
  • hgd613
  • hgd613
  • 2013-10-12 20:24
  • 13060

java 泛型详解-绝对是对泛型方法讲解最详细的,没有之一

对Java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1...
  • qq_24084925
  • qq_24084925
  • 2017-03-30 18:17
  • 491

JAVA泛型详解

http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html 普通泛型 Java代码  cl...
  • mtawaken
  • mtawaken
  • 2013-08-07 10:33
  • 15764

java泛型详解

1、什么是java泛型? 泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口...
  • chs0113
  • chs0113
  • 2016-04-29 01:02
  • 29685

Java基础知识总结(七)——泛型

心得: 我觉得Java泛型的意义在于在我们使用父类引用操作子类时(擦除),让编译器和JVM来代替我们进行必要的类型检查和转换(checkcast指令,桥方法,signature这些都是编译器和JVM...
  • Zerohuan
  • Zerohuan
  • 2015-12-31 00:15
  • 978

详解Java泛型type体系整理

一直对jdk的ref使用比较模糊,早上花了点时间简单的整理了下,也帮助自己理解一下泛型的一些处理。 java中class,method,field的继承体系 java中...
  • wakeupwakeup
  • wakeupwakeup
  • 2016-06-22 11:17
  • 748

夯实JAVA基本之一——泛型详解(2):高级进阶

前言:被温水煮惯了,梦想的东西总是不敢于尝试,失败了又怎样,最多从头来过。上一篇给大家初步讲解了泛型变量的各种应用环境,这篇将更深入的讲解一下有关类型绑定,通配符方面的知识。一、类型绑定1、引入我们重...
  • harvic880925
  • harvic880925
  • 2015-11-17 10:24
  • 8991

java 泛型详解-绝对是对泛型方法讲解最详细的

对Java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1...
  • myself8202
  • myself8202
  • 2017-07-10 12:09
  • 1279

java 泛型详解-绝对是对泛型方法讲解最详细的,没有之一

对java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概...
  • s10461
  • s10461
  • 2016-12-30 11:44
  • 48508

Java泛型类详细解读

什么是泛型? 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一...
  • liuwen55
  • liuwen55
  • 2017-05-08 17:07
  • 403
    个人资料
    • 访问:281334次
    • 积分:2854
    • 等级:
    • 排名:第14381名
    • 原创:54篇
    • 转载:87篇
    • 译文:0篇
    • 评论:32条
    最新评论