JAVA--泛型

目录

概述

泛型类

泛型方法

泛型接口

泛型限定

---

 

概述

       JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。

好处：

1. 将运行时期出现问题ClassCastException(类型转换错误)，转移到了编译时期，方便让程序员解决问题，让运行时期问题减少，提高安全性。
2. 避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型：

通常是在集合框架中很常见，只要见到<>就要定义泛型。

其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

泛型类

什么时候定义泛型类：

       当类中要操作的引用数据类型不确定的时候。早期定义Object来完成扩展，现在定义泛型来完成扩展。

import java.util.*;
/*
泛型类的使用
*/
class GenericDemo2{
	public static void main(String[] args){
		// 泛型前做法
		Util<Worker> u=new Util<Worker>();
		u.setObject(new Worker());
		Worker w=u.getObject();
		/*
		// 泛型前做法
		Tool t=new Tool();
		t.setObject(new Worker());
		Worker w=(Worker)t.getObject();*/
	}
}


// 泛型后做法
// 泛型类
class Util<QQ>{	// QQ相当于占位符，可随意定义，具体类型看定义初始化时写的类型
	private QQ q;
	public void setObject(QQ q){
		this.q=q;
	}
	public QQ getObject(){
		return q;
	}
}

// 泛型前做法
class Tool{
	private Object obj;
	public void setObject(Object obj){
		this.obj=obj;
	}
	public Object getObject(){
		return obj;
	}
}

// 工作者类
class Worker{}
// 学生类 
class Student{}

泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么当泛型类的对象明确要操作的具体类型后，该泛型类所有要操作的类型就已经固定了。

那么，为了让不同方法可以操作不同类型，而且类型还不确定，就可以将泛型定义在方法上。

注意：

1. 泛型一般写在方法返回值类型前。

     2. 静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

import java.util.*;
/*
泛型方法的使用
*/
class GenericDemo3{
	public static void main(String[] args){
		System.out.println("--------Demo--------");
		Demo<Integer> d=new Demo<Integer>();
		d.show(new Integer(4));
		// d.print("haha");
		
		System.out.println("--------Demo2--------");
		Demo2 d2=new Demo2();
		d2.show(new Integer(4));
		d2.show(new Boolean(true));
		d2.print("haha");
		d2.print("heihei");
		
		System.out.println("--------Demo3--------");
		Demo3<String> d3=new Demo3<String>();
		d3.show("lala");
		d3.print(5);
		d3.method(new Boolean(true));
		Demo3.method(new Boolean(false));
		Demo3.method("lala");
	}
}

class Demo<T>{
	public void show(T t){
		System.out.println("show:"+t);
	}
	
	public void print(T t){
		System.out.println("print:"+t);
	}
}

class Demo2{
	public <T> void show(T t){
		System.out.println("show:"+t);
	}
	
	public <Q> void print(Q q){
		System.out.println("print:"+q);
	}
}

class Demo3<T>{
	public void show(T t){
		System.out.println("show:"+t);
	}
	
	public <Q> void print(Q q){
		System.out.println("print:"+q);
	}
	
	/*public static void method(T t){	// 这种不可以，因为T是非静态类型变量
		System.out.println("method:"+t);
	}*/
	
	public static <W> void method(W w){
		System.out.println("method:"+w);
	}
}

泛型接口

import java.util.*;
/*
泛型接口
*/
class GenericInter{
	public static void main(String[] args){
		
		InterImpl<Integer> i=new InterImpl<Integer>();
		i.show(5);
		
		InterImpl<String> i2=new InterImpl<String>();
		i2.show("haha");
		
		/*InterImpl i=new InterImpl();
		i.show("haha");*/
	}
}

class InterImpl<T> implements Inter<T>{
	public void show(T t){
		System.out.println("show:"+t);
	}
}

/*
class InterImpl implements Inter<String>{
	public void show(String s){
		System.out.println("show:"+s);
	}
}*/

interface Inter<T>{
	void show(T t);
}

泛型限定

? : 通配符。也可以理解为占位符

泛型的限定：

? extends E:可以接收E类型或者E的子类型。上限。

? super E:可以接收E类型或者E的父类型。下限。