[Java知识库]集合框架（3）——泛型

泛型

将类型参数化

1.定义泛型

在定义类、接口、方法时，定义泛型

//类中定义泛型
public class Work<P> {
    public void work(P p) {

    }
}

可以定义多个泛型

//类中定义泛型
public class Work<P,M> {
    public void work(P p) {
    }
    public M method() {
        return null;
    }
}

2.使用泛型

如果没有指定泛型的类型，默认的类型就是Object

public class Test {
    public static void main(String[] args) {
        //声明了一个Work<Person> 类型的引用
        Work<Person> work1;
        //声明了一个Work<Employee> 类型的引用
        //虽然都是Work类型，但泛型不同，类型就不同了
        Work<Employee> work2;
        //创建了一个Work对象，泛型是Person
        work1 = new Work<Person>();
        //不是多态 Work<Person> 不继承 Work<Employee>
        //错误
        //work1 = new Work<Employee>();
        work2 = new Work<Employee>();
        work1.work(new Person());
        work2.work(new Employee());
    }
}

public class HourWork extends Work<Employee, Double>{
    @Override
    public void work(Employee p) {
        // TODO Auto-generated method stub
        super.work(p);
    }
    @Override
    public Double method() {
        // TODO Auto-generated method stub
        return super.method();
    }
}

//实现类
public class TestImpl implements ITest<String>,Comparator<String>{
    @Override
    public String method(String e) {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public int compare(String o1, String o2) {
        // TODO Auto-generated method stub
        return 0;
    }
}

public class Test {
    //方法中定义的泛型
    public <E> E myMethod(E e) {
        return null;
    }
    public static void main(String[] args) {
        Test t = new Test();
        String str = t.myMethod("a");
        System.out.println(str);
    }
}

数组是有协变功能，但泛型没有

协变：父类类型的数组，引用子类类型的数组对象，发生协变

Person[ ] persons = new Employee[3];

3.泛型的符号

？：表示任意类型

？extends类型：泛型类型的上限

？super类型：泛型类型的下限

public class Test {
    public static void main(String[] args) {
        //数组
        //数组中既可以存Person对象也可以存 Employee对象
        Person[] persons = new Employee[3]; //协变
        persons[0] = new Person();
        persons[1] = new Employee();
        //定义一个引用，既能存储List<Person>的引用 又能存储 List<Employee>引用
        //错误
        //List<Person> list = new ArrayList<Employee>();

        //继承于Person的任意类型
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person());
        List<Employee> employeeList = new ArrayList<Employee>();
        //指定泛型类型的上限
        List<? extends Person> list1 = personList;
        list1 = employeeList;
        //指定泛型的下限
        List<? super Employee> list2 ;
        List<SalaryEmployee> semployeeList = new ArrayList<SalaryEmployee>();

        //错误
        //list2 = semployeList;

        List objList = new ArrayList();
        list2 = personList;
        list2 = objList;

        //Collections：为集合提供服务的工具类

        //错误
        //Collections.addAll(employeeList, new Person(),new Person());

        //正确
        Collections.addAll(personList, new Person(),new Person());

        //错误
        //Collections.copy(new ArrayList<Employee>(), new ArrayList<Person>());
    }

    public void method(List<? extends Person> list) {

    }
}