Java中的泛型

泛型的分类：

   泛型类、泛型方法、泛型接口

泛型只在编译时 起作用，通过反编译工具反编译.class文件得到的java代码中没有泛型。

泛型类：

public class MyGen<T> {
//T只是一个占位符，占了一个数据类型的位置，这个数据类型什么时候确定，在创建这个类的对象时明确
}

class TestMyGen{
        public static void main(String[] args) {
                 //创建自定义的泛型类的对象  ，明确了T所代表的类型是String
                MyGen<String> my1=new MyGen<String>(); 
                MyGen<Integer> my2=new MyGen<Integer>(); //T所代表的数据类型是Integer
                MyGen<Dog> my3=new MyGen<Dog>();//T所代表的数据类型就是Dog
        }
}
class Dog{
        
}

 

泛型方法：

public class Test2 {
        public static void main(String[] args) {
                MyGen2<String> my1=new MyGen2<String>();
                my1.add("hello");
                my1.show("hello");//Q代表String类型
                my1.show(123);//Q代表Integer类型
                
                my1.fun(123,45,6,7,865); //5个参数
                my1.fun("hello","world");//2个参数
                my1.fun(new Dog());//1个参数， 
                
        }
}
class MyGen2<T>{//泛型类，T在创建类的对象时明确
        
        public <T>void add(T t){  //泛型方法，T在创建类的对象时确
                System.out.println(t);
        }
        
        public <Q> void show(Q q){//Q代表一种数据类型,在调用方法时确定
                
        }
        public <P> void fun(P... p){//可变参数的泛型方法  ，解决参数类型不同，个数不同的方法重载问题
                for (P p2 : p) {
                        System.out.println(p2);
                }
        }
        
}

泛型接口：

 

public class Test3 {
        public static void main(String[] args) {
                MyInt<String> my=new MyInt<String>();//T的类型才明确，String类型
                MyInt2 my2=new MyInt2();
        }
}
interface MyInterface<T>{//泛型接口  (1)T的数据类型可以在实现类时明确，（2）在创建实现类的对象时明确
        
}
class MyInt<T> implements MyInterface<T>{ //实现类也不知道数据，（2）在创建实现类的对象时明确
        
}
class MyInt2 implements MyInterface<String>{//(1)T的数据类型可以在实现类时明确
        
}

 

泛型的高级应用：

 (1)泛型的上限   :确定父类    ，本身和子类可以使用   <? extends 父类类型>  举例
public static void print(ArrayList<? extends Person> al){

        }

 (2)泛型的下限  ：确定子类   ,本身和父类可以使用  <? super 子类的类型>
public static void show(ArrayList<? super Student> al){

 }

 

泛型的应用：

public enum Gender {
	男,女
}

public class Person {
	private String name;
	private int age;
	private Gender sex;
	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;
	}
	public Gender getSex() {
		return sex;
	}
	public void setSex(Gender sex) {
		this.sex = sex;
	}
	public Person(String name, int age, Gender sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "[name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	
	
}

public class Student extends Person {
	private String stuNo;//学号

	public String getStuNo() {
		return stuNo;
	}

	public void setStuNo(String stuNo) {
		this.stuNo = stuNo;
	}

	public Student(String name, int age, Gender sex, String stuNo) {
		super(name, age, sex);
		this.stuNo = stuNo;
	}

	public Student() {
		super();
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString()+"学号="+stuNo;
	}
	
}

public class Teacher extends Person {
	private int teachOfYear;

	public int getTeachOfYear() {
		return teachOfYear;
	}

	public void setTeachOfYear(int teachOfYear) {
		this.teachOfYear = teachOfYear;
	}

	public Teacher(String name, int age, Gender sex, int teachOfYear) {
		super(name, age, sex);
		this.teachOfYear = teachOfYear;
	}

	public Teacher() {
		super();
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString()+"教龄="+teachOfYear;
	}
}

测试类：

import java.util.ArrayList;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		ArrayList<Person> alPer=new ArrayList<Person>();
		//(1)创建Person类型的对象
		Person p1=new Person("marry1", 20, Gender.女);
		Person p2=new Person("marry2", 21, Gender.女);
		Person p3=new Person("marry3", 22, Gender.女);
		//将Person类型的对象存储集合中
		alPer.add(p1);
		alPer.add(p2);
		alPer.add(p3);
		
		
		/***调用遍历的方法*/
		print(alPer);
		
		ArrayList<Student> alStu=new ArrayList<Student>();
		//(2)创建Student类型的对象
		alStu.add(new Student("jack1", 20, Gender.男, "sxt1001"));
		alStu.add(new Student("jack2", 21, Gender.男, "sxt1002"));
		
		/***调用遍历的方法*/
		print(alStu);
		
		ArrayList<Teacher> alTea=new ArrayList<Teacher>();
		//(3)创建Teacher的对象
		alTea.add(new Teacher("Rose1", 80, Gender.女, 60));
		alTea.add(new Teacher("Rose2", 81, Gender.女, 61));
		alTea.add(new Teacher("Rose3", 82, Gender.女, 62));
		alTea.add(new Teacher("Rose4", 83, Gender.女, 63));
		
		/***调用遍历的方法*/
		print(alTea);
		
		System.out.println("\n----------------谁能使用show方法-------------------");
		show(alStu);  //Student
		//show(alTea);报错
		show(alPer);//Person是Stduent的父类
		
		ArrayList<Object> alObj=new ArrayList<Object>();
		alObj.add(new Date());
		show(alObj);//Object是Student的间接父类
		
	}
	/**只要是Person及Person的子类都可以使用这个方法  --泛型的上限，确定了父类Person*/
	public static void print(ArrayList<? extends Person> al){
		for (Person per : al) {
			System.out.println(per);
		}
		System.out.println("\n--------------------------------------");
	}
	
	/**泛型的下限，确定了子类Student， Stduent及Student的父类(直接/间接)*/
	public static void show(ArrayList<? super Student> al){
		for (Object obj : al) {
			System.out.println(obj);
		}
		System.out.println("\n--------------------------------------");
	}
}