亲宝软件园·资讯

展开

Java泛型通配符的使用详解

乘乘凉 人气:0

泛型在继承方面的体现

类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));
    }
}

加载全部内容

相关教程
猜你喜欢
用户评论