// 创建一个集合,保存 ABCD
// <E>中 E 代表要保存的元素类型
// 新建的对象中<>和<E>中类型保存一致
// JDK 1.7出来的,菱形泛型
// 如果=前声明了泛型,那么=后面泛型可以省略不写,表示类型一致,即为<>
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
// 迭代器遍历
Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()) {
// 添加泛型之后可以省去强转类型的麻烦
String next = iterator.next();
System.out.println(next);
}
泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。
/*
* 人类
*/
public class Person {
private String name;// 姓名
private int age;// 年龄
// 构造
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
// get/set
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 重新 toString
@Override
public String toString() {
return "[姓名:" + name + ", 年龄:" + age + "]";
}
}
/*
* 学生类
*/
public class Student extends Person{
// 构造
public Student() {
super();
}
public Student(String name, int age) {
super.setName(name);
super.setAge(age);
}
@Override
public String toString() {
return "[姓名:" + getName() + ", 年龄:" + getAge() + "]";
}
}
/*
* 泛型类(泛型类声明时<>中的字母自定)
* 泛型类的类型在初始化类的对象的时候确定
*/
public class Worker<T>{
// 利用泛型写成员变量
private T t;
// 利用泛型写 get/set 方法
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public void sayHi(T t) {
System.out.println(t);
}
// 这里中的<T> 和上面的<T>是不一样的
// 调用静态方法的时候,可能还没有对象,没有对象就没声明指定泛型,所有不能用
public static<T> void fun(T t) {
System.out.println(t);
}
// 声明不同方向得到方法,在调用泛型方法的时候,指定泛型的类型
// <Z> 声明一个泛型,只有声明过,才能使用
public<Z> void print(Z z) {
System.out.println(z);
}
// 工作
public void work() {
System.out.println("打代码~");
}
}
//创建集合 保存3个学生
ArrayList<Student> students = new ArrayList<>();
students.add(new Student("lbw", 21));
students.add(new Student("white", 20));
students.add(new Student("wwk", 19));
//获取迭代器
ListIterator<Student> listIterator = students.listIterator();
Student student = listIterator = student.listIterator();
Student student = listIterator.next();
System.out.println(student);
//因为Worker类和Student类没有任何关系
//所以这里会出错
//但是如果不写泛型 只有在运行期才会报错
//写上泛型 可以把运行期报错 转化到 编译器就报错
Worker worker = (Worker)listIterator.next();
? extends E(向下限定)
?是子类, E 是父类,?中只能是 E 的子类
? super E(向上限定)
?是父类, E 是子类,?中只能是 E 的父类
/*
* 创建一个保存人的集合
* 创建一个保存学生的集合
*/
ArrayList<Person> personList = new ArrayList<>();
personList.add(new Person("甲", 18));
personList.add(new Person("乙", 20));
ArrayList<Student> studentlist = new ArrayList<>();
studentlist.add(new Student("丙", 22));
studentlist.add(new Student("丁", 19));
// ? extends E(只能填 E 的子类)
// studentlist extends personList
personList.addAll(studentlist);
System.out.println(personList);
int ... num 相当于传入的参数是个数组,可以接收多个参数,只能是方法参数的最后一个
JDK 1.5使用
public static void test(int ... num) {
// 遍历
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}
}