1.为什么有泛型?
在jdk 1.5之前,任何类型都可以添加到集合中,这是类型不安全的,因为向下转型不安全.如下:
class Point {
private Object x ;
private Object y ;
public Object getX() {
return x;
}
public void setX(Object x) {
this.x = x;
}
public Object getY() {
return y;
}
public void setY(Object y) {
this.y = y;
}
}
// 设置数据
Point p = new Point() ;
p.setX(10); // ⾃动装箱并且向上转型为Object
p.setY(20);
// 取出数据
int x = (Integer) p.getX() ; // 强制向下转型为Integer并且⾃动拆箱
int y = (Integer) p.getY() ;
System.out.println("x = " +x+",y = "+y);
如果设置方设置错了类型,而接收方不知道,就会出现ClassCastException错误,将两个没有关系的对象进行强转了.这时候语法并没有做出任何限制,但是程序出错了,所以说向下转型不安全,会带来隐患.例如:
// 设置数据
Point p = new Point() ;
p.setX(10.2);
p.setY("北纬20度");
// 取出数据
String x = (String) p.getX() ;
String y = (String) p.getY() ;
System.out.println("x = " +x+",y = "+y);
2.泛型的使用
在jdk 1.5中引入泛型,只有指定类型才可以添加到集合中,而且读取对象不用进行向下转型,隐患被消除了.具体语法是:在类声明时通过一个占位符来表示类型,值类实例化时指定需要的类型.
class MyClass<T> {
T value1;
}
MyClass<String> myClass1 = new MyClass<String>();
MyClass<Integer> myClass2 = new MyClass<Integer>();
泛型只能使用类,所有的基本数据类型必须进行装箱.
Java为每个基本数据类型都提供了对应的包装器类型,可以实现自动装箱和自动拆箱.
1)什么是自动装箱?
原来:
Integer i = new Integer(10);
自动装箱:
Integer i = 10;
以上过程会自动根据数值创建Integer对象,自动将基本数据类型转换为包装器类型,这就是自动装箱.
2)什么是自动拆箱?
Integer i = 10; //装箱
int n = i; //拆箱
如上,自动将包装器类型转换成基本数据类型,就是自动拆箱.
3)基本数据类型对应的包装器类型:
int(4字节) Integer
byte(1字节) Byte
short(2字节) Short
long(8字节) Long
float(4字节) Float
double(8字节) Double
char(2字节) Character
boolean(未定) Boolean
4)装箱和拆箱是如何实现的?
装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
private static class IntegerCache {
static final int high;
static final Integer cache[];
static {
final int low = -128;
// high value may be configured by property
int h = 127;
if (integerCacheHighPropValue != null) {
// Use Long.decode here to avoid invoking methods that
// require Integer's autoboxing cache to be initialized
int i = Long.decode(integerCacheHighPropValue).intValue();
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - -low);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。Double、Float的valueOf方法的实现是类似的.
对象实例化时不指定泛型,默认为:Object.(类型擦除)
2.1泛型还可以用来单独定义方法
class MyClass{
public <T> void testMethod(T t) {
System.out.println(t);
}
}
中的T 被称为类型参数,⽽⽅法中的 T 被称为参数化类型,它不是运⾏时真正的参数。
泛型类和泛型方法可以共存,其中泛型方法始终以自己定义的类型参数为准,为了避免混淆两者的类型参数最好不要同名.
使用泛型会导致参数不能统一的问题,如下:
class Message<T> {
private T message ;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
}
public class TestDemo {
public static void main(String[] args) {
Message<Integer> message = new Message() ;
message.setMessage(99);
fun(message); // 出现错误,只能接收String
}
public static void fun(Message<String> temp){
System.out.println(temp.getMessage());
}
}
为了解决参数不统一的问题引入了通配符.
3.通配符
使用通配符可以接收所有参数,又能让用户不可以随意修改类型.
public class TestDemo {
public static void main(String[] args) {
Message<Integer> message = new Message() ;
message.setMessage(55);
fun(message);
}
// 此时使⽤通配符"?"描述的是它可以接收任意类型,但是由于不确定类型,所以⽆法修改
public static void fun(Message<?> temp){
//temp.setMessage(100); ⽆法修改!
System.out.println(temp.getMessage());
}
}
3.1两个子通配符
?extends 泛型上限
?super 泛型下限
public class TestDemo {
public static void main(String[] args) {
Message<Integer> message = new Message() ;
message.setMessage(55);
fun(message);
}
// 此时使⽤通配符"?"描述的是它可以接收任意类型,但是由于不确定类型,所以⽆法修改
public static void fun(Message<? extends Number> temp){
//temp.setMessage(100); 仍然⽆法修改!
System.out.println(temp.getMessage());
}
}
public class TestDemo {
public static void main(String[] args) {
Message<String> message = new Message() ;
message.setMessage("Hello World");
fun(message);
}
public static void fun(Message<? super String> temp){
// 此时可以修改!!
temp.setMessage("bit!");
System.out.println(temp.getMessage());
}
}
上限可以⽤在声明,不能修改;⽽下限只能⽤在⽅法参数,可以修改内容!
4.泛型接口
这个接口实现子类时,可以继续使用泛型,也可以使用具体类型.
interface IMessage<T> { // 在接⼝上定义了泛型
public void print(T t) ;
}
class MessageImpl<T> implements IMessage<T> {
@Override
public void print(T t) {
System.out.println(t);
}
}
public class TestDemo {
public static void main(String[] args) {
IMessage<String> msg = new MessageImpl() ;
msg.print("Hello World");
}
}
interface IMessage<T> { // 在接⼝上定义了泛型
public void print(T t) ;
}
class MessageImpl implements IMessage<String> {
@Override
public void print(String t) {
System.out.println(t);
}
}
public class TestDemo {
public static void main(String[] args) {
IMessage<String> msg = new MessageImpl() ;
msg.print("Hello World");
}
}
5.泛型擦除
泛型是编译时期的概念,到运行时期泛型类和普通类没有区别.
class MyClass<T>{
private T message;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
public void testMethod1(T t) {
System.out.println(t);
}
}
public class Test {
public static void main(String[] args) {
MyClass<String> myClass1 = new MyClass<>();
MyClass<Integer> myClass2 = new MyClass<>();
System.out.println(myClass1.getClass() ==
myClass2.getClass());
}
}
以上代码打印结果为true,因为在运行时期,myClass1和myCllass2的类都是Myclass.
在泛型类被类型擦除时,如果之前泛型类的类型参数部分没有指定上线。类型被翻译成Object类型,如果指定了上限类型,类型被翻译成指定上限类型.