泛型基础
泛型
介绍
（1）泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题
（2）在类声明或实例化时只要指定好需要的具体的类型即可
（3）Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。
同时代码更简洁，健壮
（4）泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回
值的类型，或者是参数类型。
案例
import java.util.List;
public class Generic03 {
public static void main(String[] args) {
//注意，特别强调： E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
Person<String> person = new Person<String>("周小末");
person.show(); //String
/*
你可以这样理解，上面的 Person 类
class Person {
String s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E是什么类型
public Person(String s) {//E 也可以是参数类型
this.s = s;
}
public String f() {//返回类型使用 E
return s;
}
}
*/
Person<Integer> person2 = new Person<Integer>(100);
person2.show();//Integer
/*
class Person {
Integer s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E
是什么类型
public Person(Integer s) {//E 也可以是参数类型
this.s = s;
}
public Integer f() {//返回类型使用 E
return s;
}
}
*/
}
}
//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E> {
E s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
public Person(E s) {//E 也可以是参数类型
this.s = s;
}
public E f() {//返回类型使用 E
return s;
}
public void show() {
System.out.println(s.getClass());//显示 s 的运行类型
}
}泛型的好处
（1）编译时，检查添加元素的类型，提高了安全性
（2）减少了类型转换的次数，提高了效率，说明
1）不适用泛型：
Dog - 加入 -> Object - 取出 -> Dog //放入到ArrayList会先转成Object，在取出时，还需要转成Dog
2）使用泛型
Dog -> Dog -> Dog //放入时和取出时，不需要类型转换，提高效率
（3）不再提示编译警告
泛型的语法
声明
interface 接口{} 和 class 类<K,V>{}
//比如：List，ArrayList
说明：
（1）其中，T，K，V不代表值，而是表示类型
（2）任意字母都可以，常用T表示，是Type的缩写
实例化
要在类名后面指定类型参数的值（类型）如：
（1）List strList = new ArrayList();
（2）Iterator iterator = customers.iterator();
注意事项和使用细节
（1）interface List{}, public class HashSet{}...等等
说明：T,E只能是引用类型
（2）在给泛型指定具体类型后，可以传入该类型或者其子类类型
（3）泛型的适用类型
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<>();
如果我们这样写 List list3 = new ArrayList();默认给它的泛型是[ E就是Object]
即：
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings({"all"})
public class GenericDetail {
public static void main(String[] args) {
//1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
List<Integer> list = new ArrayList<Integer>(); //OK
//List<int> list2 = new ArrayList<int>();//错误
//2. 说明
//因为 E 指定了 A 类型, 构造器传入了 new A()
//在给泛型指定具体类型后，可以传入该类型或者其子类类型
Pig<A> aPig = new Pig<A>(new A());
aPig.f();
Pig<A> aPig2 = new Pig<A>(new B());
aPig2.f();
//3. 泛型的使用形式
ArrayList<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
//在实际开发中，我们往往简写
//编译器会进行类型推断, 老师推荐使用下面写法
ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();
//4. 如果是这样写 泛型默认是 Object
ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
/*
public boolean add(Object e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
*/
Tiger tiger = new Tiger();
/*
class Tiger {//类
Object e;
public Tiger() {}
public Tiger(Object e) {
this.e = e;
}
}
*/
}
}
class Tiger<E> {//类
E e;
public Tiger() {}
public Tiger(E e) {
this.e = e;
}
}
class A {}
class B extends A {}
class Pig<E> {//
E e;
public Pig(E e) {
this.e = e;
}
public void f() {
System.out.println(e.getClass()); //运行类型
}
}
- 点赞
- 收藏
- 关注作者
评论（0）