- 泛型在使用时确定, 但如果提前知道泛型也可以在定义时确定泛型类型, 但这样做体现不了泛型的优势与强大.
- 泛型不存在继承, 即在确定了泛型时, 其操作用相对应的泛型必须一致, 不能存在继承或者多态的关系. 即<> 内的类型必须一致, 不能不同. 但是使用泛型的对象依然是可以存在继承或者多态的关系. 即<> 外的东西存在继承或者多态.
- 泛型只能是引用类型, 不能是基本类型.
1. 泛型的定义 - 定义在类上
作用域在类上, 在任何地方出现都代表是同一类型, 可以参考 ArrayList<T>
定义在类上的泛型是在创建对象时确定的
/*
* 定义具有泛型的类
* 修饰符 class 类名 <范型变量>{
* 范型变量一般用E，K，V，T；
* }
* */
public class MyClass1<E> {
private E e;
public MyClass1() {
}
public MyClass1(E e) {
this.e = e;
}
public E getE() {
return e;
}
public void setE(E e) {
this.e = e;
}
@Override
public String toString() {
return "MyClass1{" +
"e=" + e +
'}';
}
public void print(){
System.out.println(e);
}
}
使用
MyClass1<String> stringMyClass1 = new MyClass1<>();
stringMyClass1.setE("张三");
String str = stringMyClass1.getE();
2. 泛型的定义 - 定义在方法上
定义在方法上的泛型是在真正调用方法的时候才确定, 一般由传入的参数确定, 包含这个方法的类创建对象时, 并不会确定方法上的类型. 定义泛型方法, 是先声明后使用.
/*
泛型方法(方法上含有泛型)
格式:
修饰符 <声明泛型变量> 返回值类型 方法名称(参数列表...) {
//...
}
*/
private <K> K show(K k){
return k;
}
使用
String s = show("333");
Integer integer = show(123);
3. 泛型的定义 - 泛型的上限和下限以及通配符
- 通配符
?
在使用泛型类或者接口时, 在传递的数据中, 泛型类型不明确, 可以使用通配符<?>表示, 但是一旦使用泛型的通配符之后, 里面的只能使用Object类中的共性方法, 集合中元素自身方法无法使用, 具体如下所示.
/*
* 泛型在使用时必须左右一致，不存在继承；
* */
public static void main(String[] args) {
ArrayList<?> list1 ;
ArrayList<String> list2 = new ArrayList<String>();
ArrayList<Integer> list3 = new ArrayList<Integer>();
//下面这行代码会报错,泛型在使用时必须左右一致,不存在继承
ArrayList<Object> list4 = new ArrayList<String>();
//下面两行代码不会报错，使用了通配符，通配符表示任意类型，这是在使用，把？当成任何一种类型，
//？就是任何类型。
list1 = list2;
list1 = list3;
//这行代码会报错 因为两者在定义时使用泛型，一旦确定了类型就不能够改变类型，
//只能是给定的一种泛型类型。
list2 = list3;
}
上面说明了 为什么泛型在使用的时候必须左右一致.
public static void print1(ArrayList<?> list) {
//使用了通配符里面的元素被限定了只能使用Object的方法，
//底层使用的是Object所以不能添加元素,因为不知道里面到底是什么类型的元素
list.add(new Object()); //会报错
list.get(0);
list.remove(0);
list.set(0,new Object()); //会报错
for(Object obj : list) {
System.out.println(obj);
}
}
- 泛型的上限和下限
当使用通配符的时, 我们不想<?>代表所有类型, 我们相对类型有一定的限定, 这时候就需要用到上限和下限了.<? extends 类名>意思是?能代表的类型只能是指定类名的子类, 所以叫做上限.
<? super 类名>意思是?能代表的类型只能是指定类名的父类, 所以叫做下限.
下面用两个例子来说明一下上限和下限
上限: 我们每次startActivity的时候不想都写两行代码去startActivity于是我们新建了一个BaseActivity, 于是变成了这样
public class BaseActivity extends Activity {
public void startActivity(Class clazz){
Intent intent = new Intent(this, clazz);
startActivity(intent);
}
}
public class MyActivity extends BaseActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
startActivity(MainActivity.class);
}
}
但是在使用过程中, 我们发现在之类中调用父类的 startActivity 的时候, 无论传什么进去都可以, 什么String.class, Intent.class, Activity.class 都可以也不会报错, 这样就不爽了, 我们想接收的只是 Activity , 于是我们接着对 BaseActivity 的 startActivity 方法进行改造. 只接收继承自 Activity 的 class. 变成了下面这样.
public class BaseActivity extends Activity {
public void startActivity(Class<? extends Activity> clazz) {
Intent intent = new Intent(this, clazz);
startActivity(intent);
}
}
又或者是只接收有继承了 BaseActivity 的 class.
public class BaseActivity extends Activity {
public void startActivity(Class<? extends BaseActivity> clazz) {
Intent intent = new Intent(this, clazz);
startActivity(intent);
}
}
这样传入的非继承自 Activity 或者 BaseActivity 的那些类就会直接报错. 这就是泛型的上限, 无论你传入参数的中间继承了多少次, 只要最顶层是继承自 BaseActivity 就可以.
下限: 可以简单的理解为, 传入的参数最低要求都是指定的类名或者指定类名的父类. 这个我们一般不常用. 这里就不再举例,
网友评论