认识泛型

12.1.什么是泛型？
泛型—广泛的数据类型。
将某一个类/接口/方法/变量的数据类型象使用参数一样传递给类/接口/方法/变量。
数据类型的参数化，任意化
12.2.为什么需要泛型？
第一天 类中的x,y变量需要int

package wangxing20200811_1_1;
public class Lian1 {
     public int x;
     public int y;
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
}

package wangxing20200811_1_1;
public class Test {
	public static void main(String[] args) {
		Lian1 s1=new Lian1();
		s1.setX(66);
		s1.setY(100);
		System.out.println(s1.getX()+" "+s1.getY());     
	}
}

运行结果

第二天 类中的x,y变量需要double ,我们创建一个新类修改了一下x,y变量数据类型

package wangxing20200811_1_1;
public class Lian2 {
	private double x;
	private double y;
	public double getX() {
		return x;
	}
	public void setX(double x) {
		this.x = x;
	}
	public double getY() {
		return y;
	}
	public void setY(double y) {
		this.y = y;
	}
}

package wangxing20200811_1_1;
public class Test {
	public static void main(String[] args) {
		Lian1 s1=new Lian1();
		s1.setX(66);
		s1.setY(100);
		System.out.println(s1.getX()+" "+s1.getY());  
		Lian2 s2=new Lian2();
		s2.setX(66.66);
		s2.setY(77.77);
		System.out.println(s2.getX()+"  "+s2.getY());
	}
}

运行结果

第三天 类中的x,y变量需要String ,我们创建一个新类修改了一下x,y变量数据类型
第四天 类中的x,y变量需要char ,我们创建一个新类修改了一下x,y变量数据类型
…
当我们需要很多个业务逻辑相似，但是数据类型不同的java类时，我们又不想创建出多个业务逻辑相似，但是数据类型不同的java类。
我们就会想能不能用一个类把业务逻辑相似，但是数据类型不同的多个java类，统一一下
要解决这个统一问题我们就会首先处理数据类型的统一，要处理数据类型的统一，我们就会想到java.lang.Object类。
例如

package wangxing20200811_2_1;
public class Lian1 {
	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;
	}
}

package wangxing20200811_2_1;
public class Lian2 {
	public static void main(String[] args) {
		Lian1 a=new Lian1();
		a.setX(180);
		a.setY(28);
		//类型转换
		int sum=(Integer)(a.getX())+(Integer)(a.getY());
	    System.out.println(sum);
	}
}

运行结果

虽然我们可以使用Object来统一数据类型，但是在使用的时候需要进行强制类型转换，如果转换不当会出现类型转换异常 java.lang.ClassCastException。
这是我们需要处理的是在具体操作使用的过程中能不能不进行强制类型转换，避免类型转换异常 java.lang.ClassCastException发生。
这时我们就会想我们能不能把数据类型，象参数一样传递给我们需要使用的java类，这要我们既可以统一类型，可以避免强制类型转换。
这式泛型就被研究出来，解决上面的问题。
12.3.如何创建一个泛型类/泛型接口？

package wangxing20200911_3_1;
public class Lian1<A> {
    private A x;
    private A y;
	public A getX() {
		return x;
	}
	public void setX(A x) {
		this.x = x;
	}
	public A getY() {
		return y;
	}
	public void setY(A y) {
		this.y = y;
	}
}

在创建类的时候为类名后面添加一个“<>”,给”<>”中添加单个的大写字母，用来接收具体的某个数据类型。
”<>”中的单个的大写字母可以出现多个，中间使用”,”分割。
类中需要数据类型的部分可以使用单个的大写字母来代替，这是我们我们创建类的时候就可以传递具体的数据类型给单个的大写字母，类中需要数据类型的部分全部都会变成我们传递具体的数据类型。
12.4.泛型类/泛型接口如何使用？
1.使用泛型类创建对象的时候需要传递具体的数据类型。
例如:FanXingLei fanx1=new FanXingLei();
FanXingLei fanx2=new FanXingLei();
2.基本数据类型在被作为泛型的数据类型时，是不被允许的，可以适应基本类型对应的封装类型代替
例如:FanXingLei fanx3=new FanXingLei(); //错误的
FanXingLei fanx4=new FanXingLei();
3.当我们创建泛型对象的时候，没有传递指定的数据类型默认是Object类型。并伴随有警告信息出现。
例如:FanXingLei fanx5=new FanXingLei();
fanx5.setX(Object);
例如

package wangxing20200911_3_1;
public class Lian1<A> {
    private A x;
    private A y;
	public A getX() {
		return x;
	}
	public void setX(A x) {
		this.x = x;
	}
	public A getY() {
		return y;
	}
	public void setY(A y) {
		this.y = y;
	}
}

package wangxing20200911_3_1;
public class Lian2 {
	public static void main(String[] args) {
	Lian1<Integer>fanx1=new Lian1<Integer>();
	fanx1.setX(400);
	fanx1.setY(200);
	//fanx1.setX("四百");
    System.out.println(fanx1.getX()+" "+fanx1.getY());
    int sum=fanx1.getX()+fanx1.getY();
    System.out.println(sum);
    Lian1<String>fanx2=new Lian1<String>();
    fanx2.setX("云想衣裳");
    fanx2.setY("花想容");
    String du=fanx2.getX()+fanx2.getY();
    System.out.println(du);
    //基本数据类型在被作为泛型的数据类型时，是不被允许的，可以适应基本类型对应的封装类型代替
    //Lian1<double>fanx3=new Lian1<double>();
    Lian1<Double>fanx4=new Lian1<Double>();
    //当我们创建泛型对象的时候，没有传递指定的数据类型默认是Object类型。并伴随有警告信息出现。
	Lian1 fanx5=new Lian1();
	}
}

运行结果

之前学习过的类，他们其实是泛型类
java.util Class ArrayList
ArrayList(Collection<? extends E> c)
java.util Class HashMap<K,V>
java.util Class Hashtable<K,V>
之前学习过的接口，他其实是泛型接口
java.util Interface Map<K,V>
public interface List
public interface Collection

package wangxing20200911_4_1;
//定义一个学生信息类
public class Lian1 {
	private int id;
	private String name;
	private int  age;
	private String address;
	public Lian1() {};
	public Lian1(int id,String name,int age,String address) {
		this.id=id;
		this.name=name;
		this.age=age;
		this.address=address;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}

package wangxing20200911_4_1;
import java.util.ArrayList;
public class Lian2 {
	public static void main(String[] args) {
		Lian1 stu1=new Lian1(111,"张一",18,"西安");
		Lian1 stu2=new Lian1(111,"张二",19,"四川");
		Lian1 stu3=new Lian1(111,"张三",22,"北京");
		ArrayList a=new ArrayList();
		a.add(stu1);
		a.add(stu2);
		a.add(stu3);
		//遍历此集合
		for(Object o:a ) {
		//强制类型转换
	     Lian1 stu=(Lian1)o;
	     System.out.println(stu.getId()+","+stu.getName()+","+stu.getAge()+","+stu.getAddress());
		}
		System.out.println("--------------------------------");
		ArrayList<Lian1> a2=new ArrayList<Lian1>();
	    a2.add(stu1);
		a2.add(stu2);
		a2.add(stu3);
		//遍历此集合
		for(Lian1 bianli:a2) {
			System.out.println(bianli.getId()+","+bianli.getName()+","+bianli.getAge()+","+bianli.getAddress());
		}
	}
}