Java泛型应用总结

时间 2019-12-14

标签 java 应用总结栏目 Java 繁體版

原文原文链接

1、泛型的引入缘由java

　　在操做集合的时候，以前方法的定义都是Object类型，向集合中添加对象，都自动向上转型，加入的元素能够是任何类型数组

可是，在取出元素的时候，一般想要使用对象的特有功能，就必须向下转型，此时就可能出现类型转换异常，存在安全隐患。安全

在JDK1.5时候提出一个解决方案：泛型。ide

2、泛型的定义及好处ui

　　泛型：是一种应用在编译时期的安全机制，具体的作法：有点相似于数组的思想，定义操做的时候，指定好要操做的类型信息this

eg：ArrayList<String>：表示该ArrayList只能操做字符串类型的元素，假如要向其中添加Integer类型，就会编译失败。spa

<>尖括号中指定被操纵的对象的类型。设计

　　好处：将运行期间可能出现的异常，转化为编译时期的强制检验，避免了强制类型转换；也提供了设计上的便捷code

3、泛型的擦除和补偿对象

　　泛型擦除：具体指的是编译器在堆源代码进行完类型检查后，在生成字节码文件的时候，会滤过泛型指定的类型信息，因此

生成的字节码文件中不含有具体的类型信息--变为Object或某个范围，使用泛型擦除主要的目的：其实为了兼容性，为了继续使用

Classloader加载类，同时还要知足之前没有泛型类的加载，因此就在检查完类型匹配后，将泛型类型的信息擦除。

　　泛型补偿：当要原本具备泛型的方法在被调用的时候，根据实际类型的Class对象获取类型信息，自动的添加到原来的地方。

 1 import java.util.Iterator;
 2 import java.util.TreeSet;
 3 
 4 /*泛型的简单使用
 5  * */
 6 public class GenericsDemo {
 7 
 8     public static void main(String[] args) {
 9         //TreeSet在添加元素的时候排序，元素必须可以被比较/或传给TreeSet一个比较器
10         TreeSet<Unicorn> t = new TreeSet<Unicorn>();
11         t.add(new Unicorn(2,"huahua"));
12         t.add(new Unicorn(1,"tete"));
13         t.add(new Unicorn(1,"meme"));
14         //遍历集合
15         Iterator<Unicorn> it = t.iterator();
16         while(it.hasNext()){
17             Unicorn u = it.next();
18             System.out.println(u.getAge() + " " + u.getName());
19         }
20     }
21 }
22 
23 class Unicorn implements Comparable<Unicorn>{
24     private int age;
25     private String name;
26     
27     public Unicorn(int age, String name) {
28         this.age = age;
29         this.name = name;
30     }
31 
32     public int getAge() {
33         return age;
34     }
35 
36     public void setAge(int age) {
37         this.age = age;
38     }
39 
40     public String getName() {
41         return name;
42     }
43 
44     public void setName(String name) {
45         this.name = name;
46     }
47 
48     @Override
49     public int compareTo(Unicorn u) {
50         int temp = this.age - u.age;
51         return temp == 0 ? this.name.compareTo(u.name):temp;
52     }
53 }

4、泛型的不一样的使用场景

　　1.泛型类或接口：表示该类或接口之后要操做的引用类型不肯定，因此在定义的时候须要定义为泛型类或接口。

在建立对象的时候，指定具体要操做的类型。类/接口<参数类型>

　　2.泛型方法：表示该方法之后要操做的引用类型不肯定，因此在定义的时候定义为泛型方法，注意：泛型方法的

定义与其所在的类或接口是否为泛型类或接口没有关系。静态方法因为不能访问泛型类的类型参数，因此假如该静态

方法须要使用泛型，则将该方法定义为泛型方法。泛型方法的调用与普通方法没有区别。<参数类型> 返回值

5、泛型的高级应用

　　1.泛型通配符：？表示，一般用于操做任意参数类型的泛型。强调的是通用性。

　　2.泛型的界限：其目的是在必定范围内扩大能够操做的参数类型。分为上界限，和下界限。

　　泛型上界：表现形式：<? extends A> 表示的含义是：能够操做的参数类型能够是，A类型以及A的子类。一般这种

在集合中取出元素的时候经常使用，一般用A类型来接收取出的元素。<=A

　　泛型下界：表现形式：<? super A> 表示的含义是：能够操做的参数类型是：A类型及其父类型。一般这种在接收元素

作比较的时候使用，能够使用本身的比较器，也能够使用父类的比较器。泛型下限的使用很少。>=A

注意：ArrayList<Animal> list = new ArrayList<Cat>(); 这是错误的两边的泛型类型不匹配。

　　　ArrayList<? extends Animal> list = new ArrayList<Cat>(); 这样才是正确的写法，泛型匹配。

 1 /*定义泛型类，泛型接口，泛型方法
 2  *注意：既然使用泛型，就表示操做的类型不肯定，一般能够调用的
 3  *方法都是公共的方法，从Object里继承获得的方法。
 4  * */
 5 public class Tool<T> {
 6     private T t;
 7     
 8     public T getT() {
 9         return t;
10     }
11 
12     public void setT(T t) {
13         this.t = t;
14     }
15 
16     public void print(T t){
17         System.out.println("print " + t.toString());
18     }
19     public static <Y> void method(Y y){
20         System.out.println("method " + y.toString());
21     }
22 }

 1 /*泛型接口：要么在具体类实现的时候定义参数类型或在建立子类对象的时候明确参数类型
 2  *这是根据何时能够明确操做的类型肯定的。
 3  * */
 4 public interface GenericsInter<T> {
 5     void method(T t);
 6 }
 7 
 8 class A implements GenericsInter<String>{
 9     @Override
10     public void method(String t) {
11         // TODO Auto-generated method stub
12         
13     }
14 }
15 
16 class B<T> implements GenericsInter<T>{
17     @Override
18     public void method(T t) {
19         // TODO Auto-generated method stub
20         
21     }
22 }

 1 import java.util.*;
 2 
 3 /*使用泛型的通配符，泛型上界限*/
 4 public class GenericsBound {
 5     public static void main(String[] args) {
 6         ArrayList<Personn> list1 = new ArrayList<Personn>();
 7         list1.add(new Personn(23, "hehe"));
 8         list1.add(new Personn(34, "nini"));
 9         ArrayList<Student> list2 = new ArrayList<Student>();
10         list2.add(new Student(13,"keke"));
11         list2.add(new Student(19,"oo"));
12         ArrayList<Integer> list3 = new ArrayList<Integer>();
13         list3.add(9);
14         list3.add(4);
15         printCollection(list1);
16         printCollection(list2);
17         printCollection(list3);
18         printCollection1(list1);
19         printCollection1(list2);
20         //printCollection1(list3);---限定了因此不能够传入该参数
21     }
22     
23     //使用的泛型通配符能够操做泛型参数类型是任意的
24     public static void printCollection(Collection<?> c){
25         Iterator<?> it = c.iterator();
26         while(it.hasNext()){
27             System.out.println(it.next().toString());
28         }
29     }
30     //只接收泛型参数类型是Personn及其子类的集合
31     public static void printCollection1(Collection<? extends Personn> c){
32         Iterator<? extends Personn> it = c.iterator();
33         while(it.hasNext()){
34             System.out.println(it.next().toString());
35         }
36     }
37 
38 }
39 
40 class Personn{
41     private int age;
42     private String name;
43     
44     public Personn(int age, String name) {
45         this.age = age;
46         this.name = name;
47     }
48     public int getAge() {
49         return age;
50     }
51     public void setAge(int age) {
52         this.age = age;
53     }
54     public String getName() {
55         return name;
56     }
57     public void setName(String name) {
58         this.name = name;
59     }
60     
61     public String toString(){
62         return "person " + getName() + " " + getAge();
63     }
64     
65 }
66 
67 class Student extends Personn{
68 
69     public Student(int age, String name) {
70         super(age, name);
71     }
72     public String toString(){
73         return "student " + getName() + " " + getAge();
74     }
75 }
76 
77 class Worker extends Personn {
78 
79     public Worker(int age, String name) {
80         super(age, name);
81     }
82     
83     public String toString(){
84         return "worker " + getName() + " " + getAge();
85     }
86 }

1 public static void printCollection3(Collection<? super Student> c){
2         Iterator<? super Student> it = c.iterator();
3         while(it.hasNext()){
4             System.out.println(it.next().toString());
5         }
6}
泛型下界限：此时只能打印参数类型为Student类型及其父类类型的集合

 1 import java.util.Comparator;
 2 import java.util.TreeSet;
 3 /*泛型下界限的使用
 4  *TreeSet(Comparator<? super E>) 对于元素E类型能够使用本身的比较器或者父类的比较器*/
 5 public class Generic_LowBound {
 6     public static void main(String[] args) {
 7         TreeSet<Student> t1 = new TreeSet<Student>(new ComparateByPersonn());
 8         t1.add(new Student(12,"hyhy"));
 9         t1.add(new Student(14,"uiui"));
10         System.out.println(t1);
11         TreeSet<Student> t2 = new TreeSet<Student>(new ComparateByStudent());
12         t2.add(new Student(12,"hyhy"));
13         t2.add(new Student(14,"uiui"));
14         System.out.println(t2);
15     }
16 }
17 
18 class ComparateByPersonn implements Comparator<Personn>{
19     @Override
20     public int compare(Personn o1, Personn o2) {
21         int temp = o1.getName().compareTo(o2.getName());
22         return temp == 0 ? (o1.getAge() -o2.getAge()) :temp;
23     }
24 }
25 
26 class ComparateByStudent implements Comparator<Student>{
27     @Override
28     public int compare(Student o1, Student o2) {
29         int temp = o1.getName().compareTo(o2.getName());
30         return temp == 0 ? (o1.getAge() -o2.getAge()) :temp;
31     }
32 }
33 
34 class ComparateByWorker implements Comparator<Worker>{
35     public int compare(Worker o1, Worker o2) {
36         int temp = o1.getName().compareTo(o2.getName());
37         return temp == 0 ? (o1.getAge() -o2.getAge()) :temp;
38     }
39 }