Java自定义泛型类注意点

目录

自定义泛型类

 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型

由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不需要指明类型

 由于子类在继承带泛型的父类时，没有指明了泛型类型。则实例化子类对象时，要指明类型

 泛型不同的引用不能相互赋值

 静态方法中不能使用类的泛型

 异常类不能声明为泛型类

 不能使用new E[], 但是可以E[] arr =(E []) new Object[capacity]

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系.

换句话说，泛型方法所属的类是不是泛型类都没有关系

泛型方法可以是静态的，即copyFromArrayToList可以是静态的

---

自定义泛型类

public class Order<T> {

	String orderName;
	int orderId;
	
	//类的内部结构使用类的泛型
	T orderT;
	
	public Order() {
		
	}
	
	public Order(String orderName,int orderId, T orderT) {
		this.orderName=orderName;
		this.orderId=orderId;
		this.orderT=orderT;
	}
	
	public T getOrderT() {
		return this.orderT;
	}
	
	public void setOrderT(T orderT) {
		this.orderT=orderT;
	}

	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId + ", orderT=" + orderT + "]";
	}
	
	
}

 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型

@Test
	public void test1() {
		//如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
		//要求：如果程序定义了类是带泛型的，建议在实例化时，要指明类的泛型。
		
		Order order=new Order();
		order.setOrderT(123);
		order.setOrderT("ABC");
		
		
		//建议：实例化时指明类的泛型
		Order<String> order1=new Order<>("orderAA",1001,"");
		order1.setOrderT("AA:hello");
	}

由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不需要指明类型

/**
 * SubOrder不是泛型类
 * @author CharlieLiang
 *
 */
public class SubOrder extends Order<Integer>{

}


//在另一个类中的代码
@Test
	public void test2() {
		SubOrder sub1=new SubOrder();
		
		//由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不需要指明类型
		sub1.setOrderT(1122);
		
	}

 由于子类在继承带泛型的父类时，没有指明了泛型类型。则实例化子类对象时，要指明类型

/**
 * SubOrder2<T>仍然是泛型类
 * @author CharlieLiang
 *
 * @param <T>
 */
public class SubOrder2<T> extends Order<T>{

}


//另一个类中的方法
@Test
	public void test3() {
		//由于子类在继承带泛型的父类时，没有指明了泛型类型。则实例化子类对象时，要指明类型
		SubOrder2<String> sub2=new SubOrder2();
		sub2.setOrderT("order2...");
	}

 泛型不同的引用不能相互赋值

@Test
	public void test4() {
		ArrayList<String> list1=new ArrayList<>();
		ArrayList<Integer> list2=new ArrayList<>();
		
		//泛型不同的引用不能相互赋值
//		list1=list2;
	}

 静态方法中不能使用类的泛型

/**
 * 自定义泛型类
 * @author CharlieLiang
 *
 * @param <T>
 */
public class Order<T> {

	String orderName;
	int orderId;
	
	//类的内部结构使用类的泛型
	T orderT;
	
	public Order() {
		
	}
	
	public Order(String orderName,int orderId, T orderT) {
		this.orderName=orderName;
		this.orderId=orderId;
		this.orderT=orderT;
	}
	
	public T getOrderT() {
		return this.orderT;
	}
	
	public void setOrderT(T orderT) {
		this.orderT=orderT;
	}

	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId + ", orderT=" + orderT + "]";
	}
	
	
	//静态方法中不能使用类的泛型
//	public static void show(T orderT) {
//		System.out.println("ABC");
//	}
	
}

改进：可以把静态方法改为泛型方法

public static <T> void show(T orderT) {
		System.out.println("ABC");
	}

 

 异常类不能声明为泛型类

/**
 * 异常类不能声明为泛型类
 * @author CharlieLiang
 *
 * @param <T>
 */
public class MyException<T> extends Exception{

}

 不能使用new E[], 但是可以E[] arr =(E []) new Object[capacity]

        //编译不通过
		T[] arr=new T[10];
		
		//编译通过
		T[] arr2 =(T[]) new Object[10];

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系.

换句话说，泛型方法所属的类是不是泛型类都没有关系

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

/**
 * 自定义泛型类
 * @author CharlieLiang
 *
 * @param <T>
 */
public class Order<T> {

	String orderName;
	int orderId;
	
	//类的内部结构使用类的泛型
	T orderT;
	
	public Order() {
		//编译不通过
//		T[] arr=new T[10];
		
		//编译通过
		T[] arr2 =(T[]) new Object[10];
	}
	
	public Order(String orderName,int orderId, T orderT) {
		this.orderName=orderName;
		this.orderId=orderId;
		this.orderT=orderT;
	}
	
	/**
	 * 如下的3个方法都不是泛型方法
	 * @return
	 */
	public T getOrderT() {
		return this.orderT;
	}
	
	public void setOrderT(T orderT) {
		this.orderT=orderT;
	}

	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId + ", orderT=" + orderT + "]";
	}
	
	
	//静态方法中不能使用类的泛型
//	public static void show(T orderT) {
//		System.out.println("ABC");
//	}
	
	
	//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
	//换句话说，泛型方法所属的类是不是泛型类都没有关系
	public <E> List<E> copyFromArrayToList(E[] arr){
		ArrayList<E> list=new ArrayList<>();
		for(E e:arr) {
			list.add(e);
		}
		return list;
	}
}

//测试泛型方法
	@Test
	public void test5() {
		Order<String> order=new Order<>();
		Integer arr[]=new Integer[] {1,2,3,4};
		
		//泛型方法在调用时，指明泛型参数的类型
		List<Integer> list=order.copyFromArrayToList(arr);
		System.out.println(list);
	}

运行结果：

[1, 2, 3, 4]

泛型方法可以是静态的，即copyFromArrayToList可以是静态的

原因：泛型参数是在调用方法时，确定的。并非在实例化类时，确定的。

//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
	//换句话说，泛型方法所属的类是不是泛型类都没有关系
	//泛型方法，可以声明为静态的。
	//原因：泛型参数是在调用方法时，确定的。并非在实例化类时，确定的。
	public static <E> List<E> copyFromArrayToList(E[] arr){
		ArrayList<E> list=new ArrayList<>();
		for(E e:arr) {
			list.add(e);
		}
		return list;
	}