泛型
一、泛型类
定义Person类
package cn.itcast.p2.bean;
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public int compareTo(Person p){
// Person p = (Person)obj;
int temp = this.age - p.age;
return temp==0?this.name.compareTo(p.name):temp;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
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;
}
@Override
public String toString() {
return "Person:"+getName()+":"+getAge();
}
}
定义Student类
package cn.itcast.p2.bean;
public class Student extends Person {
public Student() {
super();
}
public Student(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Student:"+getName()+":"+getAge();
}
}
定义Student类
package cn.itcast.p2.bean;
public class Student extends Person {
public Student() {
super();
}
public Student(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Student:"+getName()+":"+getAge();
}
}
定义一个工具类，将工具类中所有的参数类型全部定义为Object 类型，这样所有类型的数据就都能传递进来。这就是泛型类。
public class Tool {
private Object object;
public Object getObject() {
return object;
}
public void setObject(Object object) {
this.object = object;
}
}
操作泛型类
package cn.itcast.p4.generic.define.demo;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;
public class Genericdefinedemo3 {
/**
* @param args
*/
public static void main(String[] args) {
Tool tool=new Tool();
tool.setObject(new Student());
// tool.setObject(new Worker());
Student student=(Student)tool.getObject();
}
}
传入Student 对象以后编译通过，运行无问题。
当传入Worker对象以后编译通过，但是运行出现问题。
这是因为迭代的类型是Student类型。
把 Student student =(Student)tool.getObejct(); 换成Object student=(Obejct)tool.getObject（）以后运行就没有问题了。
在jdk 1.5以后使用泛型来接收类中要操作的引用数据类型。
泛型类什么时候用？ 当类中操作的引用数据类型不确定数据类型的时候，就用泛型l来表示。
定义一个泛型类
public class Tool<QQ>{
private QQ q;
public QQ getObject() {
return q;
}
public void setObject(QQ object) {
this.q = object;
}
/**
* 将泛型定义在方法上。
* @param str
public <W> void show(W str){
System.out.println("show : "+str.toString());
}
public void print(QQ str){
System.out.println("print : "+str);
}
/**
* 当方法静态时，不能访问类上定义的泛型。如果静态方法使用泛型，
* 只能将泛型定义在方法上。
* @param obj
*/
public static <Y> void method(Y obj){
System.out.println("method:"+obj);
}
}
传递一个Student 对象 编译通过。
传递一个Worker（） 对象时，编译就不能通过了。
这是因为定义了泛型。 工具类对象的类型是Student 。Worker和Student 类型不匹配。编译报错。
再一次验证了泛型将运行时的异常放到了编译时。提高了程序的安全性。
二、泛型方法
重新写一个工具类，定义一些泛型‘类’
public class Tool<QQ>{
private QQ q;
public QQ getObject() {
return q;
}
public void setObject(QQ object) {
this.q = object;
}
/**
* 将泛型定义在方法上。可以传递任意类型对象
* @param str
*/
public <W> void show(W str){
System.out.println("show : "+str.toString());
}
public void print(QQ str){
System.out.println("print : "+str);
}
/**
* 当方法静态时，不能访问类上定义的泛型。如果静态方法使用泛型，
* 只能将泛型定义在方法上。
* @param obj
*/
/**
* 当方法静态时，不能访问类上定义的泛型，因为静态不需要对象可以用类名直接访问。
* @param obj
*/
// public static void method2(QQ obj){
// System.out.println("method:"+obj);
// }
**
* 当泛型声明在方法上时，必须放在修饰符的后面，返回值的前面。
*
* @param obj
*/
public static <Y> void method(Y obj){
System.out.println("method:"+obj);
}
}
使用泛型类
package cn.itcast.p4.generic.define.demo;
public class GenericDefineDemo4 {
/**
* @param args
*/
public static void main(String[] args) {
Tool<String> tool = new Tool<String>();
tool.show(new integer(4));
tool.show("abc");
tool.print("hahah");
// tool.print(new Integer(8));
Tool.method("haha");
Tool.method(new Integer(9));
}
}
结果输出
三、泛型接口
package cn.itcast.p4.generic.define.demo;
public class GenericDefineDemo5 {
/**
* @param args
*/
public static void main(String[] args) {
InterImpl in = new InterImpl();
in.show("abc");
InterImpl2<Integer> in2 = new InterImpl2<Integer>();
in2.show(5);
}
}
//泛型接口，将泛型定义在接口上。
interface Inter<T>{
public void show(T t);
}
/**
*
* 第二种实现 传入Q 任意类型的参数
* @author AdMinistrator
*
* @param <Q>
*/
class InterImpl2<Q> implements Inter<Q>{
public void show(Q q){
System.out.println("show :"+q);
}
}
/**
* 第一种实现，传入字符串
* @author Administrator
*
*/
class InterImpl implements Inter<String>{
public void show(String str){
System.out.println("show :"+str);
}
}
相关阅读
我们在编写程序时，经常遇到两个模块的功能非常相似，只是一个是处理int型数据，另一个是处理String类型数据，或者其它自定义类型数据，但