自定义泛型
泛型类
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);
}
}
