package generic;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
泛型的使用
1. jdk5.0新增的特性
2.在集合中使用泛型:
总结:
集合接口或集合类在jdk5.日时都修改为带泛型的结构。
在实例化集合类时,可以指明具体的泛型类型
指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器)使用到类的泛型的位置,都指定为实例化时的泛型
比如: add(E e) ---> 实例化以后: add(Integer e)
注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换。
如果实例化时,没有指明泛型的类型。默认类型为java.lang.object类型。
3.自定义泛型结构:泛型类、泛型接口、泛型方法
*/
public class GenericTest {
public static void main(String[] args) {
GenericTest genericTest=new GenericTest();
genericTest.test1();
genericTest.test2();
genericTest.test3();
}
//在集合中使用泛型之前
public void test1() {
ArrayList<Object> list=new ArrayList<Object>();
list.add(123);
list.add(123);
list.add(123);
//list.add("aaa");
for(Object score:list) {
int stuScore=(Integer)score;
System.out.println(stuScore);
}
}
//在集合中使用泛型
public void test2() {
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(123);
list.add(123);
list.add(123);
//list.add("aaa");
Iterator<Integer> iterator=list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
public void test3() {
Map<String, Integer> map=new HashMap<String, Integer>();
map.put("aaa", 123);
map.put("bbb", 123);
map.put("ccc", 123);
Set<Entry<String, Integer>> entry=map.entrySet();
Iterator<Entry<String, Integer>> iterator=entry.iterator();
while (iterator.hasNext()) {
Map.Entry<String,Integer> entry2 = (Map.Entry<String,Integer>) iterator.next();
String key= entry2.getKey();
Integer value=entry2.getValue();
System.out.println(key+" "+value);
}
}
}
自定义泛型结构:
package generic;
import java.util.List;
public class GenericTest1 {
public static void main(String[] args) {
GenericTest1 g1=new GenericTest1();
g1.test1();
g1.test2();
g1.test3();
}
public void test1() {
//静态方法不能使用类的泛型
//异常类不能是类的泛型
//泛型方法可以是静态类
//如果定义了泛型类,实例化没有指明类的泛型,则认为此泛型类型为bject类型
/*
Order order = new Order();
order. setOrderT(123);
order . setOrderT("ABC" );
*/
//建议实例化指明类的泛型
Order<String> order = new Order<String>();
order.setOrderT("ABC" );
}
public void test2() {
//由于子类在继承带泛型的父类时,指明了泛型类型。则实例化子类对象时,不再需要指明泛型。
SubOrder subOrder=new SubOrder();
subOrder.setOrderT(112);
}
//测试泛型方法
public void test3() {
Order<String> order=new Order<String>();
Integer[] arr=new Integer[] {1,2,3,4};
//泛型方法在调用时,指明泛型参数的类型
List<Integer> list=order.copyFromArrayToList(arr);
System.out.println(list);
}
}
package generic;
import java.util.ArrayList;
import java.util.List;
public class Order<T> {
String orderName;
int orderId;
T orderT;
public Order() {
// TODO Auto-generated constructor stub
}
public Order(String orderName,int orderId,T orderT) {
// TODO Auto-generated constructor stub
this.orderName=orderName;
this.orderId=orderId;
this.orderT=orderT;
}
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Override
public String toString() {
// TODO Auto-generated method stub
//return super.toString();
return orderName+" "+orderId+" "+orderT;
}
public <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list=new ArrayList<E>();
for (int i = 0; i < arr.length; i++) {
E e = arr[i];
list.add(e);
}
return list;
}
}
```java
package generic;
public class SubOrder extends Order<Integer>{
}
泛型在继承方面的体现:
package generic;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest2 {
/*
* 1.泛型在继承方面的体现
* 虽然类A是类B的父类,但是G<A> 和G<B>二者不具备子父类关系,二者是并列关系。
* 补充:类A是类B的父类,A<G>是B<G>的父类
*/
//通配符 ?
public static void main(String[] args) {
GenericTest2 genericTest2=new GenericTest2();
genericTest2.test1();
}
public void test1(){
List<String> list=new ArrayList<String>();
list.add("aa");
//不能添加null之外的数据,允许读取数据
List<?> list1=null;
list1=list;
//list=list1;
//list1.add()
Iterator<?> iterator=list1.iterator();
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
System.out.println(object);
}
}
@SuppressWarnings({ "unused", "null" })
public void test2() {
//有限制条件的通配符
List<? extends Person> list1=null;
List<? super Person> list2=null;
List<Student> list3=null;
List<Person> list4=null;
List<Object> list5=null;
list1=list3;
list1=list4;
//list1=list5;
//list2=list3;
list2=list4;
list2=list5;
Person person=list1.get(0);
//list1.add(new Person());
list2.add(new Person());
list2.add(new Student());
}
}
package generic;
public class Person {
}
package generic;
public class Student extends Person{
}