• Java之泛型


    1. 概述
              在引入泛型之前,Java类型分为原始类型、复杂类型,其中复杂类型分为数组和类。引入泛型后,一个复杂类型就可以在细分成更多的类型。
              例如原先的类型List,现在在细分成List<Object>, List<String>等更多的类型。
              注意,现在List<Object>, List<String>是两种不同的类型,他们之间没有继承关系,即使String继承了Object。下面的代码是非法的:

    1 List<String> ls = new ArrayList<String>();
    2 List<Object> lo = ls;

             这样设计的原因在于,根据lo的声明,编译器允许你向lo中添加任意对象(例如Integer),但是此对象是List<String>,破坏了数据类型的完整性。
             在引入范型之前,要在类中的方法支持多个数据类型,就需要对方法进行重载,在引入范型后,可以解决此问题(多态),更进一步可以定义多个参数以及返回值之间的关系。例如:

    1 public void write(Integer i, Integer[] ia);
    2 public void write(Double  d, Double[] da);

    的范型版本为:

    1 public <T> void write(T t, T[] ta);

    在看下面代码:

     1 public class GenericTest {
     2 
     3     public static void main(String[] args) {
     4         List list = new ArrayList();
     5         list.add("qqyumidi");
     6         list.add("corn");
     7         list.add(100);
     8 
     9         for (int i = 0; i < list.size(); i++) {
    10             String name = (String) list.get(i); // 1
    11             System.out.println("name:" + name);
    12         }
    13     }
    14 }

          定义了一个List类型的集合,先向其中加入了两个字符串类型的值,随后加入一个Integer类型的值。这是完全允许的,因为此时list默认的类型为Object类型。在之后的循环中,由于忘记了之前在list中也加入了Integer类型的值或其他编码原因,很容易出现类似于//1中的错误。因为编译阶段正常,而运行时会出现“java.lang.ClassCastException”异常。因此,导致此类错误编码过程中不易发现。

    通过使用泛型,解决上面异常,修改代码如下:

     1 public class GenericTest {
     2 
     3     public static void main(String[] args) {
     4         /*
     5         List list = new ArrayList();
     6         list.add("qqyumidi");
     7         list.add("corn");
     8         list.add(100);
     9         */
    10 
    11         List<String> list = new ArrayList<String>();
    12         list.add("qqyumidi");
    13         list.add("corn");
    14         //list.add(100);   // 1  提示编译错误
    15 
    16         for (int i = 0; i < list.size(); i++) {
    17             String name = list.get(i); // 2
    18             System.out.println("name:" + name);
    19         }
    20     }
    21 }

    总结: 使用泛型可以指代任意对象类型,定义的容器所放的内容是一个统一的类型;   

    java中泛型的引入主要是为了解决两个方面的问题:
    1. 集合类型元素在运行期出现类型装换异常,引入泛型增加编译时类型的检查;(即:消除强制类型转换,提高 Java 程序的类型安全)
    2. 解决开发时重复代码的编写,能够复用算法。(比如:在类中的方法支持多个数据类型,就需要对方法进行重载)

    2. 定义泛型类

    我们直接上代码:

     1 package com.learn.chap06.sec01;
     2 
     3 public class Fdemo<T> {  // 泛型类
     4     private T a;
     5 
     6     public Fdemo(T a) {
     7         super();
     8         this.a = a;
     9     }
    10 
    11     public T getA() {
    12         return a;
    13     }
    14 
    15     public void setA(T a) {
    16         this.a = a;
    17     }
    18     
    19     public void print(){
    20         System.out.println("Obeject类型为:"+a.getClass().getName());
    21     }
    22     
    23     
    24 }
     1 package com.learn.chap06.sec01;
     2 /**
     3  * 定义泛型类    (使用泛型可以指代任意对象类型)
     4  * @author Administrator
     5  *
     6  */
     7 public class Fdemotest {
     8     
     9     public static void main(String[] args) {
    10         Fdemo<Integer> test = new Fdemo<Integer>(12);
    11         test.print();
    12         System.out.println("test="+test.getA());
    13         
    14         Fdemo<String> strFdemo = new Fdemo<String>("我是中国人");
    15         strFdemo.print();
    16         System.out.println("strFdemo="+strFdemo.getA());
    17     }
    18 }

    运行结果:

    Obeject类型为:java.lang.Integer
    test=12
    Obeject类型为:java.lang.String
    strFdemo=我是中国人

    3. 限制泛型:

    我们直接上代码:

    1 package com.learn.chap06.sec02;
    2 
    3 public class Animal {
    4     public void say() {
    5         System.out.println("它是动物");
    6     }
    7 }
     1 package com.learn.chap06.sec02;
     2 
     3 public class Dog extends Animal{
     4 
     5     @Override
     6     public void say() {
     7         // TODO Auto-generated method stub
     8         System.out.println("它是一只狗");
     9     }
    10     
    11     
    12 }
     1 package com.learn.chap06.sec02;
     2 
     3 public class Cat extends Animal{
     4 
     5     @Override
     6     public void say() {
     7         // TODO Auto-generated method stub
     8         System.out.println("它是一只猫");
     9     }
    10     
    11     
    12 }
     1 package com.learn.chap06.sec02;
     2 
     3 public class Demo<T extends Animal>{
     4     private T ob;
     5 
     6     public Demo(T ob) {
     7         super();
     8         this.ob = ob;
     9     }
    10 
    11     public T getOb() {
    12         return ob;
    13     }
    14 
    15     public void setOb(T ob) {
    16         this.ob = ob;
    17     }
    18     
    19     public void print(){
    20         System.out.println("T的类型是:"+ob.getClass().getName());
    21     }
    22 }
     1 package com.learn.chap06.sec02;
     2 /**
     3  * 限制泛型
     4  * @author Administrator
     5  *
     6  */
     7 public class Test {
     8     public static void main(String[] args) {
     9         Demo<Dog> demo = new Demo<Dog>(new Dog());
    10         //demo.say(); 
    11         demo.print();
    12         
    13         //Demo<Integer> demo = new Demo<Integer>(new Dog()); // 由于泛型定义Demo类的类型必须为Animal或其子类Dog和Cat,而Integer不是Animal的子类,所以类型被限制,即:限制泛型,导致编译报错
    14         Demo<Animal> demo2 = new Demo<Animal>(new Cat());
    15         demo2.print();
    16         
    17         Demo<Cat> demo3 = new Demo<Cat>(new Cat());
    18         demo3.print();
    19         
    20     }
    21 }

    运行结果:

    T的类型是:com.learn.chap06.sec02.Dog
    T的类型是:com.learn.chap06.sec02.Cat
    T的类型是:com.learn.chap06.sec02.Cat

    4. 通配符泛型:

    我们直接上代码:

     1 package com.learn.chap06.sec03;
     2 
     3 import com.learn.chap06.sec02.Animal;
     4 import com.learn.chap06.sec02.Cat;
     5 import com.learn.chap06.sec02.Demo;
     6 import com.learn.chap06.sec02.Dog;
     7 
     8 public class Test1 {
     9     /**
    10      * 通配符泛型
    11      * @param demo
    12      */
    13     public static void take(Demo<?> demo){ // <?> 即为:通配符泛型
    14         demo.print();
    15     }
    16     
    17     public static void main(String[] args) {
    18         Demo<Dog> demo1 = new Demo<Dog>(new Dog());
    19         take(demo1);
    20         
    21         Demo<Cat> demo2 = new Demo<Cat>(new Cat());
    22         take(demo2);
    23         
    24         Demo<Animal> demo3 = new Demo<Animal>(new Animal());
    25         take(demo3);
    26     }
    27 }

    运行结果:

    T的类型是:com.learn.chap06.sec02.Dog
    T的类型是:com.learn.chap06.sec02.Cat
    T的类型是:com.learn.chap06.sec02.Animal

    5. 泛型方法:

     1 package com.learn.chap06.sec04;
     2 
     3 public class Test {
     4     
     5     /**
     6      * 泛型方法
     7      * @param t
     8      */
     9     public  static <T> void f(T t) {
    10         System.out.println("T的类型是:"+t.getClass().getName());
    11     }
    12     
    13     public static void main(String[] args) {
    14         f(1);
    15         f("hello");
    16         f(1.0f);
    17         f(new Object());
    18     }
    19 }

    运行结果:

    T的类型是:java.lang.Integer
    T的类型是:java.lang.String
    T的类型是:java.lang.Float
    T的类型是:java.lang.Object

    现在使用泛型没问题了吧!呵呵

  • 相关阅读:
    口袋摸球
    后渗透(四)数据包捕获
    后渗透(二)权限提升
    文件上传11-21
    MySQL之UDF提权
    《白帽子讲Web安全》读书笔记(一)
    XSS盲打获取cookies&&XSS钓鱼&&XSS键盘记录
    nginx目录穿越漏洞复现&&nginx目录遍历漏洞复现
    python教程(一)·简介
    DataPipeline如何实现数据质量管理?
  • 原文地址:https://www.cnblogs.com/eaglezb/p/5983567.html
一二三 - 开发者的网上家园