自定义泛型

泛型类

1、语法
访问修饰符 class 类名<泛型通配符> { }

代码实现

public class Box<T> {//type

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
//    String name;
//
//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        this.name = name;
//    }

//    private Object obj;
//    public Object getObj() {
//        return obj;
//    }
//    public void setObj(Object obj) {
//        this.obj = obj;
//    }
}

测试

public class Test {
    public static void main(String[] args) {
//        Box box = new Box();
        //如果使用固定的类型，那么存取数据只能是固定的类型
//        box.setName("cxk");
//        box.setName(30);


        //如果使用Object类型那么存取数据需要不断转型
//        box.setObj(10);
//        box.setObj("cxk");

        Box<String> box = new Box<String>();
        box.setT("cxk");

        Box<Integer> box1 = new Box<Integer>();
        box1.setT(10);
    }
}

泛型接口

访问修饰符 interface <泛型通配符> { }

代码实现

public interface GenricInterface<T> {
    void show(T t);
}
public class GenricInterfaceImpl implements GenricInterface<Integer>{
    @Override
    public void show(Integer t) {
        System.out.println(t);
    }
}

泛型方法

访问修饰符 <T> void 方法名<T> { 方法体 }

代码演示

public class GenricMehthod {

    public void show1(String str) {
        System.out.println(str);
    }

    public  <T> void show2(T t) {
        System.out.println(t);
    }

    public  static <T> void show3(T t) {
        System.out.println(t);
    }

    public void show4(List<?> list) {
        System.out.println(list);
    }



    public void show5(List<Number> list) {
        System.out.println(list);
    }

    //定义泛型的上边界
    public void show6(List<? extends Number> list) {
        System.out.println(list);
    }
    //定义泛型的下边界
    public void show7(List<? super Number> list) {
        System.out.println(list);
    }
}

测试

public class GenricMethodTest {
    public static void main(String[] args) {
        GenricMehthod gm = new GenricMehthod();
//        gm.show1(10);//报错
//        gm.show2(10);
//        gm.show2("cxk");
//        gm.show2(10.2);
//        List<Integer> list1 = new ArrayList<Integer>();
//        list1.add(1);
//        list1.add(2);
//        List<String> list2 = new ArrayList<String>();
//        list2.add("abc");
//        list2.add("cxk");
//        
//        gm.show4(list2);

        //Integer是Number的子类
//        List<Integer> list = new ArrayList<Integer>();
//        list.add(1);
//        list.add(2);
//        gm.show5(list);//代码报错，  泛型中不存在多态的概念

//        List<Integer> list = new ArrayList<Integer>();
//        list.add(1);
//        list.add(2);
//        gm.show6(list);//代码不报错

//        List<Integer> list = new ArrayList<Integer>();
//        list.add(1);
//        list.add(2);
//        gm.show7(list);//代码报错

        List<Object> list = new ArrayList<Object>();
        list.add(1);
        list.add(2);
        gm.show7(list);//代码不报错

    }
}

泛型上下边界

<? extends T> 上边界 

表示该通配符所代表的类型是T类型的子类。 例如往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。 

<? super T> 下边界 

表示该通配符所代表的类型是T类型的父类。例如当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

Collections类

• 代码实现

public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("cxk");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");

        System.out.println(list);

        //static void reverse(List<?> list)    将集合元素调换顺序
        Collections.reverse(list);
        System.out.println(list);

        //static void shuffle(List<?> list)     将集合的顺序打乱
        Collections.shuffle(list);
        System.out.println(list);

        //static <T> void  fill(List<? super T> list, T obj)   将集合中的所有的元素都替换成指定的元素
//        Collections.fill(list, "张三");
//        System.out.println(list);

        //static int frequency(Collection<?> c, Object o)  获取指定元素在集合中出现的次数
        int count = Collections.frequency(list, "张三");
        System.out.println(count);

        //static <T extends Comparable<? super T>> void sort(List<T> list)  将集合中元素进行排序(自然顺序)
        //在排序的时候，这个集合中的类型必须实现Comparable接口重写compareTo方法，实现可比较
        Collections.sort(list);
        System.out.println(list);

        System.out.println("==============================");
        List<Person> persons = new ArrayList<Person>();
        Person p1 = new Person("cxk",35);
        Person p2 = new Person("lisi",32);
        Person p3 = new Person("awangwu",33);

        persons.add(p2);
        persons.add(p3);
        persons.add(p1);

//        Collections.sort(persons);
//        System.out.println(persons);
        Collections.sort(persons, new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                return o2.getAge() - o1.getAge();
            }
        });
        System.out.println(persons);
    }
}