基类:
class Fruit {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
实现类:
class Banana extends Fruit {
public Banana() {
setName("banana");
}
}
class Orange extends Fruit {
public Orange() {
setName("Orange");
}
}
泛型函数 绑定类型
/**
* 泛型函数 绑定类型
*
* @param t
* @param <T>
* @return 我们已知水果都会继承Fruit基类,所以我们利用<T extends Fruit>就可以限定填充的变量必须派生自Fruit的子类。
* 一来,在T中,我们就可以利用Fruit类中方法和函数;
* 二来,如果用户填充进去的类没有派生自Fruit,那编译器就会报错。
*/
public static <T extends Fruit> String getFruitName(T t) {
return t.getName();
}
定义泛型接口
public interface Comparable<T> {
public boolean comparTo(T i);
}
/**
* @param
* @param <T> 接口实现类是什么类型,就返回什么类型,
* 传入类型必须要和定义类型保持一致(泛型的优势)
* 添加上extends Comparable之后,就可以使用Comparable接口里的函数了
* @return
*/
public static <T extends Comparable> T min(T... a) {
T smallest = a[0];
for (T item : a) {
if (smallest.comparTo(item)) {
smallest = item;
}
}
return smallest;
}
定义接口的实现类
public class StringCompare implements Comparable<StringCompare> {
private String mStr;
public StringCompare(String string){
this.mStr = string;
}
@Override
public boolean comparTo(StringCompare str) {
if (mStr.length() > str.mStr.length()){
return true;
}
return false;
}
}
使用:
@Override
protected void onResume() {
super.onResume();
showGenericity();
StringCompare result = min(new StringCompare("123"),new StringCompare("234"),new StringCompare("59897"));
Log.d(TAG,"min:"+result.mStr);
}
private void showGenericity() {
String name1 = getFruitName(new Orange());
String name2 = getFruitName(new Banana());
Log.e("Fruit:", name1.toString() + "\n" + name2.toString());
}