泛型1

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

 

泛型

       泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制。
       泛型的特点：
              1、提高了程序的安全性。
              2、将运行期遇到的问题题ClassCastException转移到了编译期。
              3、省去了类型强转的麻烦。
              4、泛型类的出现优化了程序设计。
       泛型格式：通过<>来定义要操作的引用数据类型。
       通常在集合框架中很常见，只要见到<>就要定义泛型，其实<>就是用来接收类型的。

      当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

      如：

1. class GenericDemo   
2. {  
3.     public static void main(String[] args)   
4.     {  
5.   
6.         ArrayList<String> al = new ArrayList<String>();//定义String类型的泛型  
7.   
8.         al.add("abc01");  
9.         al.add("abc0991");  
10.         al.add("abc014");  
11.   
12.         //al.add(4);//al.add(new Integer(4));  
13.           
14.   
15.         Iterator<String> it = al.iterator();  
16.         while(it.hasNext())  
17.         {  
18.             String s = it.next();  
19.   
20.             System.out.println(s+":"+s.length());  
21.         }  
22.     }  
23. } 

      什么时候定义泛型类？

             当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

      泛型定义在类上：

             泛型类定义的泛型，在整个类中有效。如果被方法使用，
              那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
              class Demo<T>{    //T代表某一具体类型
                    public void show(T t){
                           System.out.println("show:"+t);
                    }
                    public void print(T t){
                           System.out.println("show:"+t);
                    }

             }

       泛型定义在方法上：
              为了让不同方法可以操作不同类型，而且类型还不确定。
       那么可以将泛型定义在方法上
              public  void show(T t){
                    System.out.println("show:"+t);
              }
       静态方法上的泛型
       静态方法不可以访问类上定义的泛型。
       如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
       public  static <T> void method(T t){
              System.out.println("method:"+t);
       }
       泛型定义在接口上：
       泛型定义在接口上，如果没有指定具体类型，那么就由调用者指定类型
       interface Inter<T>{
              void show(T t);
       }
       class InterImpl<T> implements Inter<T>{               //T类型不明确，可以由调用者指定具体类型
              public void show(T t){
                    System.out.println("show :"+t);
              }

      }

 

通配符
       <?>通配符,类型不明确，也可以理解为占位符。
       泛型的限定：
              <？ extends E>: 可以接收E类型或者E的子类型,上限。

             <？ super E>:可以接收E类型或者E的父类型,下限

      如：

1. import java.util.*;  
2. class  GenericTest  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         /* 
7.         ArrayList al = new  ArrayList(); 
8.         al.add(new Person("heihei")); 
9.  
10.         ArrayList al1 = new ArrayList(); 
11.  
12.         al1.add("haha1"); 
13.         al1.add("haha2"); 
14.  
15.         al.addAll(al1); 
16.  
17.         System.out.println(al);int.next().getName(); 
18.         */  
19.   
20.   
21.         /**/  
22.           
23.         ArrayList<Person> al = new    ArrayList<Person>();//定义泛型  
24.         al.add(new Person("ahah"));  
25.   
26.         ArrayList<Student> al1 = new ArrayList<Student>();  
27.   
28.         al1.add(new Student("haha"));  
29.   
30.         al.addAll(al1);  
31.           
32.   
33.         Iterator<Person> it = al.iterator();  
34.   
35.         while(it.hasNext())  
36.         {  
37.             System.out.println(it.next().getName());  
38.         }  
39.   
40.   
41.   
42.   
43.     }  
44. }  
45. class Person  
46. {  
47.     private String name;  
48.     Person(String name)  
49.     {  
50.         this.name = name;  
51.     }  
52.     public String getName()  
53.     {  
54.         return name;  
55.     }  
56.     public String toString()  
57.     {  
58.         return "person :"+name;  
59.     }  
60. }  
61.   
62. class Student extends Person  
63. {  
64.     Student(String name)  
65.     {  
66.         super(name);  
67.     }  
68.   
69. } 

 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------