【java】【泛型】泛型genetic

一、泛型

泛型的由来

        通过Object转型问题引入，早起Object类型可以接收任意的对象类型，但是在实际使用中，会有类型转换的问题，也就存在安全隐患，所以java提供了泛型来解决这个安全问题。

        子类对象在当做参数传递时有时会被自动提升为object类型，但后面想使用该类的方法（子类特有的方法）时，就需要进行类型强制转换。有时若忘记进行转换时，编译也能通过，但是运行时会出错，存在安全隐患。

1、泛型概述

<>：里面放的是引用数据类型，指定集合里只能放指定引用数据类型，包括子类

        泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

2、泛型好处

    * 提高安全性(将运行期的错误转换到编译期，编译器就会给出可能错误的提示)

    * 省去强转的麻烦

        在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。   

        泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

3、泛型基本使用

    * <>中放的必须是引用数据类型，后面添加的是该类及子类对象

4、泛型使用注意事项

    * 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型) 

    * 泛型最好不定义为Object，因为它是所有类的父类，加与不加没什么意义

import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;

public class Demo1_Generic {
	public static void main(String[] args) {
		//demo1();
		//int[] arr = new byte[5];				//数组要保证前后的数据类型一致
		//ArrayList<Object> list = new ArrayList<Person>();	//集合的泛型要保证前后的数据类型一致
		//ArrayList<Object> list = new ArrayList<>();		//1.7版本的新特性,菱形泛型
		ArrayList<Object> list = new ArrayList<>();		//泛型最好不要定义成Object,没有意义
		list.add("aaa");
		list.add(true);
	}

	public static void demo1() {
		ArrayList<Person> list = new ArrayList<Person>();
		list.add(new Person("张三", 23));
		list.add(new Person("李四", 24));
		
		Iterator<Person> it = list.iterator();
		while(it.hasNext()) {
		    //System.out.println(it.next());
			
		    //System.out.println(it.next().getName() + "..." + it.next().getAge()); //next方法只能调用一次,如果调用多次会将指针向后移动多次,张三，24
		    Person p = it.next();  //调用一次	 		
		    System.out.println(p.getName() + "..." + p.getAge());
		}
	}
}

二、ArrayList存储字符串和自定义对象并遍历泛型版

import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
public class Demo2_Generic {
	public static void main(String[] args) {
		//demo1();
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("张三", 23));
		list.add(new Person("李四", 24));
		list.add(new Person("王五", 25));
		list.add(new Person("赵六", 26));
		
		Iterator<Person> it = list.iterator();
		while(it.hasNext()) {
			Person p = it.next();				//将集合中的每一个元素用Person记录，无需进行类型强制转换
			System.out.println(p.getName() + "..." + p.getAge());
		}
	}
	public static void demo1() {
		ArrayList<String> list = new ArrayList<>();		//创建集合对象
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());    //无需进行类型强制转换
		}
	}
}

三、泛型类（在类上单独使用，不实现借口）

定义类：public class Tool<T>

实例化：Tool<student> t = new Tool<student>()；

四、泛型方法

1、非静态方法

定义方法：public  void show(T t)

调用方法：t.show<student>()

方法泛型需要最好与类的泛型一致：因为实例化对象的时候，泛型也相当于通过参数传递进类里，而类里的方法泛型不一致就会导致出错。解决方法：需要在方法上声明另外的泛型，使用时直接传递该泛型即可

定义方法：public<Q>  void show(Q q)

2、静态方法：随着类的加载而加载

方法泛型和类泛型不能一致，因为类名.静态方法时对象可能还没创建，即类泛型还不知道，就会出现错误，此时方法就必须声明自己的泛型，而不能跟类的泛型一样。

此刻的一样多一层意思：

public  void show(Q q) ：不行，这里的Q是随着类的加载而加载，这里需要换一个泛型即T，不能跟类一致

public<Q>  void show(Q q)：可行，这里的Q是随着静态方法的加载而加载，是在方法上声明我自己的泛型，跟类不一样

五、泛型接口

1、类在实现接口的时候就指定具体泛型

class Demo implements Inter<String> {		//推荐用这种
	@Override
	public void show(String t) {
		System.out.println(t);
	}

2、方法实现接口的时候再自己定义一下泛型

class Demo<T> implements Inter<T> {	//没有必要在实现接口的时候给自己类加泛型
	@Override
	public void show(T t) {
		System.out.println(t);
	}
	
}

六、泛型高级之通配符

* A:泛型通配符<?>

    * 任意类型，如果没有明确，那么就是Object以及任意的Java类了

* B:? extends E

    * 向下限定，E及其子类

* C:? super E

    * 向上限定，E及其父类