java新特性之泛型

一、java新特性(JDK1.5)

1.可变参数：

public [static][final]返回值 方法名称([参数类型 参数名称][参数类型…参数名称]){}

如：对于任意参数的整数相加

public static int add(int...data)          //可变参数，“...”表示一个数组结构
{
    int result=0;
    for(int i=0;i<data.length;i++)
    {
        result+=data[i];
    }
    return result;
}

注意：如果方法需要传递多种类型参数，可变参数一定放在最后，有且只有一个可变参数。

2.foreach循环(增强型for循环)

for(数据类型 临时变量:数组(集合))
{
    //循环次数为数组长度，而每循环一次都会顺序取出数组中的一个元素值赋给临时变量
}

注意：foreach用于数组和集合类的遍历输出。一般不推荐修改内容，如果要修改内容推荐旧版本for循环。

3.静态导入

如果一个类中只有静态方法，导入时只需要加入static，好比在主类中定义的方法那样，可被主类直接调用。

二.泛型（重要新特性）

1.泛型作用：

解决程序参数转换问题。主要解决向下转型出现的安全隐患

2.泛型概念：

在类定义的时候并不会设置类中的属性或方法中参数的具体类型而是在类使用的时候才定义
泛型的基本语法：
   class My<T>{T vaule};  -->T:类型参数，可以指代任何引用类型

3.泛型解决的问题：

a.用于检测编译器参数类型设置问题:只有出入参数与使用使用时定义类型一致才可以设置。
b.取消向下转型带来的隐患。

4.泛型方法：

public <T>T  test(T t)
{
    return t;
}

<T>类型参数定义在返回类型之前
如果泛型类与泛型方法共存，使用同一个类型参数T，泛型类的T和泛型方法T没有关系。泛型方法始终以自己定义的类型参数为准。

5.通配符(重点)：解决参数统一问题

有一下程序：

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<String> message=new Message<>();
		message.setMessage("holle world");
		fun(message);              //只能接收String类型参数
	}
public static void fun(Message<String> temp)
{
	System.out.println(temp.getMessage());
}
}

如果泛型的类型设置不是String而是Integer就会出错。

解决方案：想要接收所有泛型类型，又不让用户随意修改内容，则引入通配符。
 

(1)?(用于方法参数):指代任意类型。
       fun(MyClass <> myclass):表示可以接受任意类型的MyClass对象。
       使用?通配符，只能取值，而不能修改。因为类型不确定。
(2)?的子类通配符：
         ? extends 类：设置泛型上限(可用于类或者方法参数)
         ? extends Number：只能是Number或者其子类
	 用于方法参数只能取值，不能赋值。
	
         ? super 类：设置泛型下线(只用于方法参数)
         ？super String：表示设置String或其父类(Object)
	 用于方法参数时，可以修改值。

使用通配符解决上述问题：只能取值，不能修改

public class TestDemo {
	public static void main(String[] args) {
		Message<String> message=new Message<>();
		message.setMessage("holle world");
		fun(message);
	}
	
	//此时使用通配符“?”描述的是它可以接收任意类型，但由于不确定类型，所以不能修改内容
public static void fun(Message<?> 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("holle world");
		fun(message);
	}
	//此时使用通配符“?”描述的是它可以接收任意类型，也能修改内容
public static void fun(Message<? super String> temp)
{
	temp.setMessage("holle");   //可以修改内容
	System.out.println(temp.getMessage());
}
}

6.泛型接口：

(1).接口定义上使用<T>,表示泛型接口
    interface IMessgae<T>{        //在接口上定义泛型
        public void print(T t);
    }

子类实现接口：interface IMessage<T>{}

(1)继续保留泛型：class Message<T> implements IMessage<T>{}

interface IMessage<T>{                   //泛型接口
	public void print(T t);
}
class Message<T>implements IMessage<T>    //继续保留泛型
{
	@Override
	public void print(T t) {
		System.out.println(t);
	}
}

(2)声明泛型类型：class Message implements IMessage<String>{}

interface IMessage<T>{                   //泛型接口
	public void print(T t);
}
class Message<T>implements IMessage<String>    //声明泛型类型
{
	@Override
	public void print(String t) {
		System.out.println(t);
	}
}

7.泛型擦除：

(1).泛型信息只存在代码编译阶段，进入JVM之前与泛型相关的信息会被擦除.
(2).泛型信息与普通类在JVM中没有区别。
(3).泛型是JVM语法糖(自动拆装箱)
     语法糖：方便开发者开发，在运行阶段无卵用。
(4)在泛型类被擦除时，之前泛型类中的参数如果没有上线，则被擦成Object，如果有上限，则被替换成上限。

泛型擦除范例：

class MyClass<T>{}
public class TestDemo {
	public static void main(String[] args) {
		MyClass<String> myClass=new MyClass<>();
		MyClass<Integer>myClass2=new MyClass<>();
		System.out.println(myClass.getClass()==myClass2.getClass());    //结果为true
	}
}