简单的自定义泛型类

1.自定义泛型类可以先定义一个正常的实体类，里面有对应的属性和方法，例如：

package com;

import java.util.ArrayList;
import java.util.List;

public class order {
	private String orderName;
	private int orderId;
	
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}
	public int getOrderId() {
		return orderId;
	}
	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}
	@Override
	public String toString() {
		return "order [orderId=" + orderId + ", orderName=" + orderName + "]";
	}	
}

2.然后在属性中加入你想要加入的属性，并在类声明的地方加入有泛型的声明，例如：

package com;

import java.util.ArrayList;
import java.util.List;

//自定义泛型类
public class order<T> {
	private String orderName;
	private int orderId;
	private T t;
	List<T> list = new ArrayList<T>();
	public void add(){
		list.add(t);
	}
	public T getT(){
		return t;
	}
	public void setT(T t){
		this.t = t;
	}
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}
	public int getOrderId() {
		return orderId;
	}
	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}
	@Override
	public String toString() {
		return "order [orderId=" + orderId + ", orderName=" + orderName
				+ ", t=" + t + "]";
	}
	
	
}

3.关于泛型的使用，可以使用下面的方法：

package com;

import java.util.List;

//自定义泛型类的使用
public class testOrder {
	public static void main(String[] args) {
		order<Boolean> Order =  new order<Boolean>();
		Order.setT(true);
		System.out.println(Order.getT()+"===OTHER==="+Order.getOrderName());
		Order.add();
		Order.add();
		Order.add();
		List<Boolean> list = Order.list;
		System.out.println(list);
		System.out.println(Order.toString());
	}
}

4.控制台的输出为：

true===OTHER===null
[true, true, true]
order [orderId=0, orderName=null, t=true]

5.如果比较复杂的，例如多参的

package com;

public class Pair<T> {
	private T first;
	private T last;

	public T getFirst() {
		return first;
	}

	public void setFirst(T first) {
		this.first = first;
	}

	public T getLast() {
		return last;
	}

	public void setLast(T last) {
		this.last = last;
	}

	public Pair(T first, T last) {
		super();
		this.first = first;
		this.last = last;
	}
}

6.一些疑问

7.当然泛型还可以定义多种类型
例如：

package com;

public class Pair<T> {
	private T first;
	private T last;

	public T getFirst() {
		return first;
	}

	public void setFirst(T first) {
		this.first = first;
	}

	public T getLast() {
		return last;
	}

	public void setLast(T last) {
		this.last = last;
	}

	public Pair(T first, T last) {
		super();
		this.first = first;
		this.last = last;
	}
	
	/*静态方法创建泛型*/
	public static <K> Pair<K> create(K fir,K las)
	{
		return new Pair<K>(fir,las);
	}
	
}

8.还可以调用静态方法来进行创建下详见：

		Pair<Integer> p = Pair.create(1,2);
		System.out.println(p.getFirst()+"******"+p.getLast());

9.拓展见：
拓展
10.一个简单的泛型方法

package com;

import java.util.ArrayList;
import java.util.List;

public class fanxing {
	public static void main(String[] args) {
		List<DVD> list =new ArrayList<DVD>();
		DVD dvd = new DVD();
		test(DVD.class);
	}

	private static <T> void test(List<T> lt,T t,Class<T> thisclass) {
		if (thisclass == DVD.class) {
			lt.forEach(x ->{
				DVD dvd = (DVD)x;
			});
			DVD dvd1 = (DVD)t;
			System.out.println("you are right");
		}
	}
}

11.通配符。
类型通配符
我们知道Ingeter是Number的一个子类，同时Generic与Generic实际上是相同的一种基本类型。那么问题来了，在使用Generic作为形参的方法中，能否使用Generic的实例传入呢？在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢？

为了弄清楚这个问题，我们使用Generic这个泛型类继续看下面的例子：

	public static void showKeyValue1(Generic<Number> obj) {
		System.out.println("key value is " + obj.getKey());
	}

	public static void main(String[] args) {
		Generic<Integer> gInteger = new Generic<Integer>(123);
		Generic<Number> gNumber = new Generic<Number>(456);

		showKeyValue1(gInteger);

		// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer>
		// cannot be applied to Generic<java.lang.Number>
		// showKeyValue(gInteger);
	}

通过提示信息我们可以看到Generic不能被看作为`Generic的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic类型的类，这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型。由此类型通配符应运而生。

我们可以将上面的方法改一下：

	public static void showKeyValue1(Generic<?> obj) {
		System.out.println("key value is " + obj.getKey());
	}

也可以这样表示：（限制的是输入的必须是number的子类）

	public static void showKeyValue1(Generic<? extends Number> obj) {
		System.out.println("key value is " + obj.getKey());
	}

类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参 。重要说三遍！此处’？’是类型实参，而不是类型形参 ！ 此处’？’是类型实参，而不是类型形参 ！再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
extends通配符
可以用来限制指定的泛型的范围，只能传入XX类以及XX类的子类，例如：

package com;

public class Pair<T extends Number> {
	private T first;
	private T last;
******************************************
}

	public void add(Pair<? extends Number> p){
		/***********/
	}

只能用P的get方法，不能用P的set方法,set（null）除外
super通配符
可以用来限制指定的泛型的范围，只能传入XX类以及XX类的父类，不能用来定义泛型，例如：

	public void add(Pair<? super Integer> p){
		/***********/
	}

只能用P的set方法，不能用P的get方法，get（object除外）
12.泛型的数组
不能直接用new来创建泛型数组，必须通过强制转换，如：
1.Pair < String>[] ps= null √
2.Pair < String>[] ps = new Pair< String>[2] ×
3.Pair < String>[] ps = (Pair< String>[]) new Pair [2] √
可以通过Array.newInstance(Class,int),创建T[]数组，组要强制转型