目录

泛型在继承方面的体现

 类A是类B的父类，G和G二者不具有子父类关系，二者是并列关系

类A是类B的父类，A是B的父类

通配符的使用

类A是类B的父类，G和G是没有关系的，二者共同父类是:G 

使用通配符后，数据的写入和读取要求

 有限制条件的通配符的使用

自定义泛型的测试

User类 

 DAO类

DAOTest

---

 

泛型在继承方面的体现

 类A是类B的父类，G<A>和G<B>二者不具有子父类关系，二者是并列关系

@Test
	public void test1() {
		Object obj=null;
		String str=null;
		obj=str;//编译通过
		
		Object[] arr1=new Object[10];
		String arr2[]=new String[10];
		arr1=arr2;//编译通过
		
		//此时的list1和list2不具有子父类关系
		List<Object> list1=null;
		List<String> list2=null;
		
		//编译不通过
		list1=list2;
		
		show(list1);
		//编译不通过
		show(list2);
	}
	
	public void show(List<Object> list) {
		
	}

类A是类B的父类，A<G>是B<G>的父类

@Test
	public void test2() {
		AbstractList<String> list1=null;
		List<String> list2=null;
		ArrayList<String>list3=null;
		
		list1=list3;//编译通过
		list2=list3;//编译通过
	}

通配符的使用

通配符？

类A是类B的父类，G<A>和G<B>是没有关系的，二者共同父类是:G<?> 

    @Test
	public void test4() {
		List<Object> list1=null;
		List<String> list2=null;
		
		List<?> list=null;
		
		list=list1;//编译通过
		list=list2;//编译通过
		print(list1);//编译通过
		print(list2);//编译通过
	}
	
	public void print(List<?> list) {
		Iterator<?> it=list.iterator();
		while(it.hasNext()) {
			Object obj=it.next();
			System.out.println(obj);
		}
	}

使用通配符后，数据的写入和读取要求

添加：对于List<?>就不能向其内部添加数据，除了添加null之外

获取：允许读取数据，读取的数据类型为Object

@Test
	public void test5() {
		List<?> list=null;
		List<String> list3=new ArrayList<>();
		list3.add("AAA");
		list3.add("BBB");
		list3.add("CCC");
		
		list=list3;
		//添加：对于List<?>就不能向其内部添加数据。
		//除了添加null之外
		
		list.add("DD"); //编译不通过
		list.add("?");	//编译不通过
		
		list.add(null);	//编译通过
		
		//获取：允许读取数据，读取的数据类型为Object
		Object obj = list.get(0);
		System.out.println(obj);
	}

 有限制条件的通配符的使用

 ? extends A:
       G<? extends A>可以作为G<A>和G<B>的父类，其中，B是A的子类

        G存储的是A和A的子类
 ? super Person:
        G<? super A>可以作为G<A>和G<B>的父类，其中，B是A的父类

        G存储的是A和A的父类

@Test
	public void test6() {
		List<? extends Person> list1=null;
		List<? super Person> list2=null;
		
		List<Student> list3=new ArrayList<>();
		List<Person> list4=new ArrayList<>();;
		List<Object> list5=new ArrayList<>();;
		
		list1=list3; //编译通过
		list1=list4; //编译通过
		list1=list5; //编译不通过
		
		list2=list3; //编译不通过
		list2=list4; //编译通过
		list2=list5; //编译通过
		
		//读取数据
		list1=list3;
		Person p = list1.get(0); //编译通过
		Student st=list1.get(0); //编译不通过
		
		list2=list4;
		Object obj = list2.get(0); //编译通过
		Person obj2=list2.get(0); //编译不通过
		
		//写入数据
		list1.add(new Student()); //编译不通过
		
		list2.add(new Person()); //编译通过
		list2.add(new Student()); //编译通过
	}

自定义泛型的测试

User类 

public class User {

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", age=" + age + ", name=" + name + "]";
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public User() {
		
	}
	private int id;
	public User(int id, int age, String name) {
		super();
		this.id = id;
		this.age = age;
		this.name = name;
	}
	private int age;
	private String name;
}

 DAO类

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 定义泛型类DAO<T>
 * 创建一下方法
 * public void save(String id ,T entity):保存T类型对象到Map变量中
 * public T　get(String id):从map中获取id对应的对象
 * public void update(String id,T entity):替换map中key为id的内容，改为entity对象
 * public List<T> list():返回map中存放的所有T对象
 * public void delete (String id):删除指定id对象
 * 
 * @author CharlieLiang
 * @param <T>
 *
 */
public class DAO<T> {

	private Map<String,T> map;
	
	public DAO() {
		map=new HashMap<>();
	}
	
	//保存T类型对象到Map变量中
	public void save(String id ,T entity) {
		map.put(id, entity);
	}
	
	//从map中获取id对应的对象
	public T get(String id) {
		return map.get(id);
	}
	
	//替换map中key为id的内容，改为entity对象
	public void update(String id,T entity) {
		if(map.containsKey(id)) {
			map.put(id, entity);
		}
	}
	
	//返回map中存放的所有T对象
	public List<T> list(){
		//错误的
//		Collection<T> values = map.values();
//		return (List<T>) values;
		//正确的
		List<T> list=new ArrayList<>();
		Collection<T> values = map.values();
		for(T t:values) {
			list.add(t);
		}
		return list;
	}
	
	//删除指定id对象
	public void delete (String id) {
		map.remove(id);
	}
}

DAOTest

import java.util.List;

import org.junit.jupiter.api.Test;

public class DAOTest {

	@Test
	public void testList() {
		DAO<User> dao = new DAO<>();
		dao.save("1001", new User(1001,34,"周杰伦"));
		dao.save("1002", new User(1002,20,"昆凌"));
		dao.save("1003", new User(1002,20,"蔡依林"));
		
		List<User> list = dao .list();
		list.forEach( i->System.out.println(i));
		
	}
	
	@Test
	public void testUpdate() {
		DAO<User> dao = new DAO<>();
		dao.save("1001", new User(1001,34,"周杰伦"));
		dao.save("1002", new User(1002,20,"昆凌"));
		dao.save("1003", new User(1002,20,"蔡依林"));
		
		dao.update("1003", new User(1003,40,"方文山"));
		
		List<User> list=dao.list();
		list.forEach(i->System.out.println(i));
	}
	
	@Test
	public void testDelete() {
		DAO<User> dao = new DAO<>();
		dao.save("1001", new User(1001,34,"周杰伦"));
		dao.save("1002", new User(1002,20,"昆凌"));
		dao.save("1003", new User(1002,20,"蔡依林"));
		
		dao.delete("1003");
		
		List<User> list=dao.list();
		list.forEach(i->System.out.println(i));
	}
}