目录
自定义泛型类
如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为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");
// }
}
异常类不能声明为泛型类
/**
* 异常类不能声明为泛型类
* @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;
}
