Java泛型方法与泛型类的使用------------（五）

　　泛型的本质就是将数据类型也参数化, 普通方法的输入参数的值是可以变的,但是类型(比如: String)是不能变的,它使得了在面对不同类型的输入参数的时候我们要重载方法才行. 泛型就是将这个数据类型也搞成跟参数的值一样可以变的.

　　泛型分为泛型接口,泛型类和泛型方法. 泛型接口,泛型类大家都比较熟悉了,应该都用过List, ArrayList. List就是泛型接口,ArrayList就是泛型类,我们经常看到List <E>的声明, new ArrayList<E>()的定义, 这里面的E可以是String, 也可以自己定义的类. 我感觉泛型类就JDK提供的就基本够用了,自定义使用的场景非常少了. 反而是泛型方法,对与解析自定义数据结构非常有用, 类似于toString这种场景是百试不爽.

-----------------------------------------------------------泛型方法应用实例--------------------------------------------

泛型方法不一定要在泛型类里面

定义:

1. 函数上的泛型定义
 
          当函数中使用了一个不明确的数据类型，那么在函数上就可以进行泛型的定义。
 
          public <泛型的声明> 返回值类型  函数名( 泛型 变量名  ){
 
          }

 例如:

package Test;
 
import org.junit.Test;
 
public class fanxing {
 
    /**
     * 定义一个泛型方法，泛型方法也可以声明为static
     *@param t1
     */
//    public static <T> void testFanxing(T t1){
    public <T> void testFanxing(T t1){
        System.out.println(t1);
    }
 
    //测试泛型类
    @Test
    public void test1(){
        fanxing fx=new fanxing();
        fx.testFanxing(2);
        fx.testFanxing("字符串");
        fx.testFanxing(new User("1", "QLQ"));
    }
}
 
//用于测试泛型类的类
class User{
    private String id;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    protected User(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
 
}

 结果:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZ8AAAB6CAIAAADvfslGAAAXV0lEQVR4nO2d+XMbx5XH5++Jy5WUK7+Q8Q9bRSi7+8NWtrZ2q7y7icuVsqEwiik5Lru8W0k2Shx513ZCRKJIW6Z1RZcli5fI4SlBkklRokgRpEiCIHiAN0EQIG7w7v1hgJmenu45OANiCL5PvR+AQb+Z9/p1f6d7AEocQmh2Ka00BADFy8zsct+At2/AOzO7DCZ0RaFrYj0coqlboaMCgDwSmFvpH/QF5lbAcOsf9BW6MhZDUbdChwQA+WVweGJ2fgVMaYPDE4UujpWAugFHi/nF1aGRyfnFVTClDY1MFro+VkKqW6HjAYD88nJsenEpBMayl2PThS6RZYC6HXWGX9ybn3k+N90fmB6Ynhyc9HsmfEPe8eFR78jw2NjQiHfUN7WxsVnoMC1jdDywtLwGxrLR8UChS2QZ2urmfvLyQc9wV/dQ53eejseD7Q9ftLoH+Af9LfefN3f1NXU8bWzvbWh70tjee+DBAxbg6W9Y3dje3EynNzKpTCaRzsRSmfVkJpzI+OZjq/HM9OJq//BELFEkdz6vb3YlGMbtfv/c3/+2+9hvmPZPv+/pH1smvIrVvL7ZQpfIMrTV7fGzsacvvH0eX/+Qv6ff++Ll1LB39qVvftS/6J1a8s2s+GdXp+bX+Af9Bx58wehoaBVfN991S8cb+QJEYw5Pf0NwY2dnd28zkVp/3LP81cXVppZ4OBbf2PXORiOZnbX0zuRi2De1VOhIrcHnnwuuRnD70QePf+L8/J/f+YxlPzn+57/76BHhVazm888VukSWoa1ud/nuutae+tYnDW29je29TR1P73U+a+7qa77f13L/Of+gv9U90PZwoO3hiwMPXpuop67Wbf1Ku6WuAyE0723ydJzxdJwZ6jyz6GtACLXWt1t+rXwjqlv4Hh/98qvty1diF2pX7zbg6rYQST8fmrL2uqzS5KlkIpPTC6uhddx+WNH1r2//cTC8zbI3jp/5YUUX4XXANlBZxp24Z8ilPId4BCGkPEjY5PQCtd8GZkZuDbSL1jmW372aJcNAW90ePHkpvl5cCW9ubVNP1Hy/jzwUcNdK1HmiJkPdD3maKvV3HiCEhjvP7CVHBBvp+hgh1Phth1okhewJJqK6LZ6tzlz9W+Zv1zJXry2erY4lNkR1mw3FB17OUJxNlLhQ6jYdWAqtRXF77QT/b+98PBimD2yE0BvHz7x2gie8BHvhKuNynGikNLDKXrjKuBPNhlzKy8uF+MvLy0NrUeEFfoRq0wG1RfqtgXbX45u9kx59nR1w50aFoqwadT4gdbvfPbSwFBJs2DsTmF8R3+LW3EVTN3HAB9y1eR2zOPmeHwh9c+MhQuhp/R9Xhv4kWF/jaYTQnW+6mBFhXXFQHaELUd2Ct+4sf1kbvHx1+ULt8tUb+NptfDY4PRekOJsocaHULTC3HI7EcPvB8Yb//OUng+HtD/+39Ze/+fbN9678yzs1P/6Pz0WXN3/1fz843kB4hSMjrjKOKzvnkd5WNJJtLDPPX8u4XzUbchG1DOWWbMJr4SOWV2BuWaX3Dkzd9tFQiba6dX7n2d7eEWxuMZRKb4hvcbvX+YydmhDjQS1a8q9uVy89QgiteBu67/yh+84fuu+cnhy+gRC6du0BtX3AfWDSbpi+p/cEdUsvry5/dXHx7PmVG7ej88u4ur0YmYwlUhRnEyUulLrNLwQj63Hcvv/27bdOfqaydvv5e3/+/tu3Ca+hsw6urGpIfjB/NnTWwb3bYtQLFzgB4aCKy/wC7TaWQ1S3cEu7YLG5uUh3b7ilPdKt3KvaXt3aH70IrkUFG/PPLa6siW9xa9JQt+ybqKeu1u3x1NWK93lpy4bd+oWMxH0PPmmkzVDuqOyc+F7JHcB7Rum4j+3i89mJq09arj7lrzxre740hxC6cElatH590U31kq3d5D2klYtUV/GdhpfBvHq6+bHZ6PJaOpbcmllK+KbWxmejgo1Mr3tno2OB9aEJxv08DyVWL5ncyx2Qzo23UMt9cSm0Hk3g9upb15zv/2UwvP1JzcPf/aXtwzMNFb/75p0Pr/y04sIvPrqEEPrFB65X37om9xo9W8a925wgTiXY8FmHuF0V2wyfdXDv8vfelR9/WZXb2TrOvtR2F16LJ+HKqoZpAeBGCFx5ebl6+8WlkMpoGQ8Gunx9wtpt7cpNUdHC9S3q40NF3YiRgB9E8umsEhgVbXVreziQSm8INj27Eo0lxbe4NXU8ZacmTe+op65WfruXj2usL2plg1zMWTkNiHPiHYm3UTju56Zw9UnL7uZ3Oxvf7W51X+tvQwjV1PYihPyB5ZttYzfbRm+2jk5Mzyv8snMOn3A6ciFmelY7jHhp8/BR2/rW7t5Wem9nCyGU2d5Nbe0mNnfFtZtvZnGeNeLzU2J2yWReAbfUo7kTa+e+vBKOxZO4vfKziyc++utgeDsSTYfXU6FIcjWcCIbiK6vR4FoMIfTuf5975WcX5V5j5xxcRUuSOFUsnhypcnCO8yPC29HzZZzj3GjuOJd1ybWhnETNvaJVeFFWNSY1rmhVxiAawp61CZSXl6u0j8WTyythsfHpwetKGw8GrFc3vPriKCIGhHG01Y1/0B9PpgWbDCyF1+PiW9wov3fDdVd+71VmSHQG8UFuoOOLAOm05Fko6sZ2NPgw/GJXfe/UNcEuP6pHCJ270IsQutU+tpTKCHazdZThLfSIlKJmLopi6/bSnVfXg66dvd34RFtqrntjdWwrEUwlIri6eUYm6NtSlI8SG8mUeOqnr6bB1Ug8kcLtlZ/Wvvfb8yo70/f/p+aVn9bKvbxVDq6CTxGnUh5vqeAcVd54IjVa5eAq2rLHR6sd3MkW4SCXbaDP3VslLeyENV/1KBlD1pBC2gTKy8up7QULrkbElqcHrzdO9og2t76SL3UjlvQHpm7NXX1rkbhg45MLK6sR8S1uDVR1U4yy/Q19fOgqE9WpbqweEmaozv7rHh3+svHWhXu3Lty79WCmDyFUWfMMIXSp7nnnxJRgl+rUfvqnHpLiqJC6Yu5reBnIy+vzb4anYzPumZH70bGmve1McvRuIhkX1a1/aGxre4fubH2JjfQPTd00cw+Fo4lkGrdX3/z6g9Nf/Nefvvro4wtU+/Xvv3jt55cIr9HzDu5kG3EwkRyvcnAVrdIR/iTnOD9Oth+rdnCneKwNxwlemu5kAxUTpU14TXzJwPIKhaV64urmD80LR8aD2W7Vp27E3oNSyUKqW1Pns52dXcHml0LpzIb4Frf6tieU1DSGvvq2RbHnYXz5qEPdqI5Rj4fR81p8dm5QfP15dT9CaGwy+PXt3ot3nn5952lHD/EPLeB7LPWQKKUMuGvr6uponcHyMpbX1tbW+kjjkq+j6fKn6Xl3esmzm1yIT7lFdRvxTUfjSbpznkqss38o6qade2Q9nkplcGt46C11Xnn9+OXXj19+/filH+Xs9eOXcgevdHtmCa9Uqv0kx3En23NvfdWOU22pjLf6GOeo8QoHvTUO7li1N5MSjouNvTUO7lRbylddnT3SdpJzVPtSOtxlDdpOnWzLKALLmiBnwgv8CEJIPKK0yHpc7KvTg9fvjj8SDCE0MD9+evB6IJz9yUi4vmXtyk2EUHTcF3E/1hoeAXctdSAUVN0a23vnl0KCDY/NzMytiG9xq2/tUc2NCF7WitzbZJt5xL0JcfMnjlIXvUID4sEVeTrq1xY6+LRK+kb80/MD4utPzg7QmrOy1JNLNhtjPWAkr0xoMu5vTsx3DXR+vbP2ODx0Z29nM+VvE9Vteik07J3e29ujp2V1idVLpr1208o9GktmMpuELQRjUwuRyfnIsV9/+703zgn24/fvTi1EphYiy6GY0iWT2cxk/DXHxC3isRpf9nj7KcpBX80x7lRn1tH3xTHuvfbMZqb9vVzDL3wZve5SA/GENBN/uKt5ELdoTLqTnR68jhDyh+ZHlqcQQnfHHwlHsj05NRXpeLB2/U7E/Tg6Jf+xd7YK8hrIHjYwlveUpbs0nWn1VENb3er4nqaOp4I1tvc2dfSKb3G7y3dvbG4ZvTwLE3oNGGPdy2+t3E8v3R/rub4b/i4x2ZwO+XczUekXIaltz9j0xIzaz6AOEfF4amNjE7dkKvMPH9R979+rWPaPH9THEmnCq1gtHpeesZ4evO6ezD5meTIzfGOkC1c3+6OtbtF4amt7R9Oi8RT17r4/QN0OjJDn9ubS/d3Ik9UJfm+9Nz7ZlFjwIIR6n4/WNT/GLbhmqz+y2CfJZGZzcwuMZclkRuyr04PXb4x0PZkZRgjdGOkqQnUrCKBuB0Z6bSo4cGPVc1uw4IvbO5tJhNDm5tZ6LJFIpuKCJdLM7xYOFekM/efoYIKlMxtiX1F/EVLA2hnFpuoGAHliY3NrB2Bj4fOlggPqBhwttre3dwE229vM3/0dOkDdgKPF7u7uHsBmd3e30CWyDFA3AACKE1A3AACKE1A3AACKE1A3AACKE1A3AACKE1A3AACKE3uom7+yhCup9OfzErzT+BX8lSUcx3FOM/+N3wGkZhOOTqb6kfqEd5obRwcKq5TSJPJXlhyCfEDdmFhTQHvMeX9lCSsI3snJJFzqKEWXqZwF0TPNnpzplf1ccQ9RVit7p6G0tRGyILmSSv8+1Y0xWPdzh2acXgqRdl5z6kYfJlip8WvTWrCTlDoYb0M4SlHuT93soNwGYzA+MqwaS+bYR1fLXXIDQkXdGMJiUN1YAbD6kXfKdIp34q0Ul8IO2OOGQUOlWMbWbkyBsCBvrKN5p1ABvYXVVDetwYY1I7yxouaiUnOT2lAcxXRA3Sz0yAcm1S1be5VcCqRuzCHMuJbsvT1Ko8QydaN3tfVp586os7Ia6qY92MjTyFzF87G6Ee9DLHKlYy4d3ermryzJDkdsiYlppny9KFyGd2YP8U6upJLP6rqTlzwUfcU7uZLKSvmnSLoncAZikDfDP9Bx8ye3TGQA9FClThKnr2Zq+Lq6kii7rjTloSld8LFAz9S4utFyyWaqCIB6bVZAUmmIIU5VN2KYyXtMlha1kxXurCqrDF1F9LLOlFUfn5nqRaSdiug00kE2puW9SOkOLBDa5WTvqJMIayFcAju7hrpRtUs+ClWW++TYpDtmr6GpbtS1Jh4g2eWYGMg7SIxGWUHZIFAuOf2VTnItrSMG2eqAd1JSYBVdcVJqANRQc16is0ZqeJD+yhLlpNFKk7HIJw7lQd0UuUiX1bF201Y3IjLqzpQyzGQSiPU8rZMJd3aVVYauInqZDlDUTWcRaas9fOmkDJWysKJmJAtWVibK4ok1iXItFPMKqQ421qdEB7DPIEotJq1UR97JOXlVdSPypwZDf1ioEi3tNbHAkWrPXr1pxkD0kNp0oisc4aEIgBWqEI18Fctqrx2kZlfLL0e4aGWPzKzdiFwsUTdmaLhwKO9k1HNiM5DeyYw7A7PKrNeKK1IO5HLRW0SkrAxxTWaoynWYXBFyB9mXw1cIKl3npD9dUK0t40M9azfZ8jTXhOnIOzmn7rWbLA35lGMEYpm6kbdbmrppzh/a0Ne7dqMHUAh1Y44aIR3qnk7DlZhDxJZDh/DtS910yxvWj1pqQimxeidTZEC1yhapm64iUq4h72BKEkJ7qafYzaijntIxql3HlZRQn/Copcj6THacvTBWagrbkXdy+3juRpyFWLtSF+7m1E0+xhk7U2UMrP0IcRNgQp3LWAB0dRNHGG1nqmzPCJLmT0/TX1lJFsWMusm6Rr6uxTch5tVNsXwQvsojSiObqZpqwpM7U6kmzJ0pNU5Gla1QN71FJNJHstLQQxXaO50llCpJzejSIb8cfWdK6zra1kchOEy9po9ztW2WbA1B5qO4G+zz927ZlY8UGLH2tXZnKl2gxOkknmayY8B3AcoH9tqQY4MMgBIqL38wwTkV3yoo13rYuaUgsUJqpillKRuGhr9V4IkfvhEnZ55PqW7yANSvzcmDJ288+BjQoSaUM7I7mXTXrLIl6qa3iHj6itLQZ4RCbGjNFFtjeQ+QpWRMImULxu2MLkmI8qkULHM7hQdPy5J8zGCPX/MCArq2a9Zfkz2aLLqAiaRUlhoFieeAsT59PZc74KvmDVC3wuKvLKFu/Q4O6pLN4pObysq8/Ba+k02Q97uP8nKVup7cHEAkrDWmXkDdCg22Tyn8iCpWoJN1ktd73YED6gYAQHHCVLfLAAAAhxlYuwEAUJyw1Y3jwMDA9BpgP0DdwMCsMMB+aKkbAADqwEyxK6BuAGAOmCl2BdQNAMwBM8Wu6FI37FfDpS74LSQA4IC62RVtdfO7SqW//3WVgsABgAxQN7ticGfqd5UWzZ9pAIAlgLrZFVA3ADAHqJtdMaZusDMFABJQN7tiRN14J3ytAAAkoG52Rbe6kf8AJwAACCFQN/uiT938rlKQNgCgAupmV3SoG0gbAKgA6mZXNNVN0Db2fzQBAEccUDe7An+JBQDmgJliV0DdAMAcMFPsCqgbAJgDZopdAXUDAHPATLEroG4AYA6YKXYF1A0AzAEzxa6AugGAOWCm2BVQNwAwB8wUuwLqBgDmgJliVwyoG8cuIae7pc4GAHBoAHWzK8bWbixVwv9Ki3gruij/notoAACHElA3u6KhbpogTPKob7HzcZqvAeDwAepmV7TVTc3ZSFFB3YDiBNTNrlj5rYL60zfYmQLFCaibXdGlbnokSc8RPR8BwCED1M2u7GftRhUy8aEb69mc5vM7ADiUgLrZFcPqxlqjqa/dNDet+wgdAGwBqJtdseA701xzUuNA3YAjAaibXbHm9274R8oXCHamQBED6mZXrFc36hFYuwFFC6ibXdGrbpqLLOpKTU9jADjcgLrZFfgregAwB8wUuwLqBgDmgJliV0DdAMAcMFPsCqgbAJgDZopdAXUDAHPATLEroG4AYA6YKXblUKmb31Uq/tjEyZOf8k6O40pdfpUT8E6aI2AC3smp1ORIYMOZAiCEtNXN7yolRq3fVaqhIXnD7ypVmUFWq1tWS4tsyrLUSL2s2hp2hG8coG52pYjUTQe6pyDv5LhSl8tZXOomLyYvy45dVjUvCVA3wHaAutGbOXnEnsmHFEX2goYLpWSWVdVLpdnRAdTNrphVN/xRGDm8WdsZ3smVuvzYx3pnBUvdsAsxVhXMGFWxTN2EjJlh4hGKXet3lXJOl9C9kjPmaPSJF0V/MKFiqZu6l2q7owKom10xp27sIS33o2xuZNNK57zQWLtRoiFOjrUgNE+uLHigFqkbpkFydfC7SuUBZpsJ941Sl198gYXP7l5mXrR+xmrJUDcNL3mKoG6ArTCvbtQxrZgA+OAn7v36t7qG1Y08YnAKWqpuxKqLcVq5gBGyJH6o2r0MQN3yBaibXTH93A3bmmJHaSsImbrtayIYVTdF8LZUN/nmntOjbqrdy4CmU1ggBtSN2ougboDt0Py9G/WhMmu5pmPLqvWhGlau3Q58Z0pXN1mvIb1rN43FHz0vpVDp+VZB3YuZ4lEC1M2uaP+aV/GUSO1Rm+yZuPbuyyDGn7sRj811LHFIb5WvMfR/c6yhbsQTSW11M/KwkpmPsrD0hNS8mCkeJUDd7Iquv1WQrQewIUzsqYhBT+64ZBPESnWjLFeI5/S58HT+pESxV1TkZlDe1Ham+MVKXbwYoaq6UYLU16PUr2fpOTMeNDCSBnUDbMeh+0ssm8wgHX8YYVv2143GF85HBRvOFAAhBOq2P4SFji1C2Q/yr731arS6F6gbYDsOnboZ24jlAaPP3OyJ8Z9SM7zgr+jtOFMAhNAhUzcAsCEwU+wKqBsAmANmil0BdQMAc8BMsSugbgBgDpgpdgXUDQDMATPFroC6AYA5YKbYFVA3ADAHzBS7AuoGAOaAmWJXtNQNDAxMjwH2A9QNDMwKA+wHW90AAAAOM6BuAAAUJ6BuAAAUJ6BuAAAUJ6BuAAAUJ6BuAAAUJ6BuAAAUJ6BuAAAUJ6BuAAAUJ6BuAAAUJ/8PzhDib5/TVv4AAAAASUVORK5CYII=" alt="" />

-----------------------------------------------------------泛型类应用实例--------------------------------------------

package Test;
 
import org.junit.Test;
 
//可以有一个，也可以有多个
public class fanxinglei<T, T2> {
    // 泛型属性
    private T t1;
 
    public T getT1() {
        return t1;
    }
 
    public void setT1(T t1) {
        this.t1 = t1;
    }
 
    // 泛型方法
    public void testFanxing(T2 t2) {
        System.out.println(t2);
        System.out.println(this.getT1());
    }
 
    public static void main(String[] args) {
        fanxinglei<String, Integer> fanxinglei = new fanxinglei<String, Integer>();
        fanxinglei.setT1("泛型类");
        fanxinglei.testFanxing(4);
    }
}

测试:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXQAAACpCAIAAAC01lFBAAAPMElEQVR4nO3d3XMU15nH8f574nIl5cqNFF9slYZscrGVra3dKu+u43Kl7FEUgoC4cHm3kmycOHh37WQUEJKXlcG4qPgFR8DaDAKzlr0hMeElGjCSLAaweNMLssRISAxYVs5e9EzP6e5zemakfjRq+H7quZg502fmdJ+e35weSeCoelwZu+NV9thpt/FugxQs+stsGwBYBc79Fy4A1gLCBYAIwgWAiOWHi5cvhAuAMMIFgIgVhYt+cQQAupWGi5svRAyAgBjCRY8YiqIot2ILF4qiKL0IF4qiRIpwoShKpAgXiqJEKrZwqet5EuTEqUHqxKnBRs8DkieGcBEaWcN9dmX85Jnhk2eGP7syTrmHotFzgiRZabgIDavhRq9OnB4YGb06Qel1emCk0TODxFhRuAiNaS0YOHfhyrUJKlwD5y40enKQDISLwbUbN8+ev3jtxk0qXGfPX2z0/CAZlh8uQgNaCz4ZunxjbIqy1SdDlxs9RUgAwsVg8NPRsfHPKVsNfjra6ClCAhAuBsMjVyYmp/X639NX//onx9f92Fp/87M/nB4aD/S6X2t45EqjpwgJIBIuRw8c9m6/97v+SvvBbJ3Da4yR/NXJmzN6fWPL/30n/fLfPv2Srb7T+qu/eu6jQK/7tUbyVxs9RUgAkXA51HtUKXVt+H9yR7fmjm49+/7WGyMHlFKH9x9ZyVhXzcXL129O3dLr6+3H/v6pXwxML9rqsdatX28/Fui1ynUm0+Ksf7euLm1lXotSKtwYqIuXrzd6ipAAIuGyf98HSqlz72/9y/x5t84fe0EpdfCdo7YuhVxvj6s3V6hrTAIuj45NfV7Q65H12X94+oWB6UVbl8datz6yPhvo5dafO1qcsvUHDRvEVX/uaHHWv1dXl7a2Nnf8bW1tU58X3Bt6i7Euj46twiwg6UTC5a3ffqiUOrH/FxNnf+nWyYPPK6X2vXXMuH0h11vJlNH+/kZ/XTh6dXx6Zlavr7Ue+OcfvDgwvfjsvx/+wY/feWLznr97uvub//Sy1+WJH/7H11oPBHpNz5zvaHGclu25yt32g8FtYqvcb1qcH75XVxcvSlR5weLedh+y9Rq9Or7aU4IEEgmX13d/pJSaGD5wfN/Pj+/7+fF9z18891ul1N69Hxi3H+3vaXig6K5dn5y5NafXV596+8mNL0WsXL63+VdffertQK+z21JOS+dZf6Ncnd2WcjYcqreXni8utzGiy7Xrk8IzgPtBzOFy6sqF1/946PUT2T1/6js1dlUptXP3Se/RV3f1G3v5Vi6a0f6ewLVSIdfb05/L9fb09PSPjvb3aKHk3avSS1W/BrsxNnWrcFuvh5/cm37m1wPTiy92f/jTX/c9u/VA+0/fevrZPY+37/z+c7uVUt/f0vHwk3v9vQa3tTgb3rsdeCq3zm1LeddK3jbntqWcDdl3N/jbP+ksX1altn1Svbt723sSp6XznGkAegXypa2tLXr7G2NT1lMEKIs5XF7/46Gle7//8u7vl744vvd0n1Kqu+djpVR+dPyNvqE3+gbfODx44fK1UL/S211/rxdyvd7dQq5Xi4Vws1JqtL+nN1eot5fZ+MT07Ny8Xg99d9f6534zML04U7gzfWthamb+5vTtyam5iZuFyc9nlVIb/nX7Q9/d5e81tD3ltB+aDzzV7Nz8+c6Uk9px3r07uKPFSW0fLLc7pS7lbQxPEtW9/bB7o6VzqLJx++HwGLxS2vcsrra2tojtZ+fmxyemow4foJSKPVx2Hdv/8aW9br320X6l1PadHyul3jwyNLZQdOuNw7a/33fXHG4KVFYX+iIjEAzekqfcXnOvyC+OJ2/OzN1e0Ouhx3s2/2RHxGXRM//W/dDjPf5ew50ppz27EHiqcPuhdifVOTx3e2GwM+W095XaB7tSzsZDbqNT2qC27sOdlWWNu+LpGgyOoVQqlCyutrY24/ZuTd6csR0HwBNzuBwfPPdfB9/c+e6bO99984PPTiqlMt1/Ukrt7j31/oVLbu3ujfqvAvSYCK8vQq3ugsVbr9TYq9Szp8e8hJmaLtyev6PXw0+8uuX5V/7ll//93As7jfWjn73yyPd2B3oN7kg5G/sCjbfnP+1MOe2HKy3ZjU5qx6fB7Ye6Us6mrLaN47i9qnYPbhBRXrK4twPf79p6TU03/Ad6SACRL3Rf2j7g3X6567RSauji5Ktvf7xr34lX9504+ofAn9XqlzL+a5nQj5DCMTHa39Pb2+v7eqVKr0Iu57+UCpm5NbewUNTrwIfDzek9j7a+9mjra4+27v5GuR5t3V1u3HM8dyXQa2HhyEbHcTYeKd8d6Upt6lsoDnetc1Ldw27jcHfKWdc1XFxw272Nh7tTzqa+hZGurlJL30Yn1TWyUEN33wZ9mzb2FUMDK5WbJu4NvUUp5bWEa+bWXMTsAy6RcPnPzlzl9o4z3u0Xt50xba70L2H1t3ultRwNhjVIIdfrX4BU7+VtYbk0KszOF4v3AnV9cvbS9ZmL12bW/eidrzy23a1vPvO7S9dnLl2fGZ+aDXcpFu8Vi/nudd71ybrukVL7kU2GxpHudc6m90sdR15Z52w+UrxXPLK5vOErI8Vau1c28J7QVN7vy1Vt1KswOx8x+4CLvy0ymJtbuHv3nl7zC8Vvben9yj922urbW/bP3r4T6HW/1tzcQqOnCAlAuBjMzxfv3fuCstX8fLHRU4QEIFwM7hTvLi5+SdnqTvFuo6cICUC4GNy998WXsLt774tGTxESgHAxWFxcXILd4qL1930AD+FisLS09BfYLS0tNXqKkACECwARhAsAEYQLABGECwARhAsAEYQLABFJC5d8pslpyuQlXyKbrv8V8pkmx3Gc9Er+65Rl7lo2HfGyq3C4ZJX3biU7kviD0AiVgxZ5gkUiXELqD5d8pmllueI9yyqFSzbt+LJwOXlai3ymaYWJ27BwKR0ia7/S46GPlPChLH3wGLZdQ3yDdJoy+WWGi2/3pcMlnvfdytQ5hvrfaVLvzVpfvO4DHOwjtAP5TFNT08rmf9kfm3GceLbDkk37YiKb1rfKZ5r8nbSGtbuGijhc9U2BvvuESwjhEhP3PFv+qlqpNRku2XT0AiSYLr77DT1VIsQWLvruCoRLZS2sLR1Lr1dp0cM8nc2mS03ZtNOUyZbWaOlspUdp+8pByKadpkzG/6jyre9qHoN/M/2BGj5qguvj4ADMQ9UvGEpna9Vdq7xUUyaT1nZHv7zx74HlnIkKl+D4fYegcsewmwHls8z3ftKm29fX1q5fFkXvpn3SLX2Dl4XhA25MAls8+A+NdkyM4RI47W0DU5ZJD3W3nXURb6XQ6H3z6Dsb7Ufe8MqVnjGGS/lVgrHt39t8oN3t5R+9d60XHrBvn/VHy8c4XX6FygdM1TH4PouyacMuRL2JfE9qHIBxqOVeXucqu6YPMp9pckLhYtq1usPFNP5s4Jy27abtoISjS5sNbT9N7eFwCc1P1Um39a02QcsNl8DxNV4WGU5728BMkx7obj/rIt5KodHrgWwKl5pPsHKPmMLF+s2d9uL+xUF5xwOj03fAdDvw8V7ZVfvapeoYAqdL1NljDphAj9AAbEN1R+Nfw9m2tw6yPJPGXVvGyiVi/P5ni167WCYy/KluWJn4c9//uGV2oibd2tf4gDZBdYVLcCPtnd/kmxPDcbANzDrphnmNPOtst8OHItwQeYIFzmH/7gusXHyD9L+xDbMSa7gEw90ULlVPF9NM17pyMQ9gtcKlhnPG622eJPP4S89dGbplM/8rBBg/N+MIl6qTHhUu3id7zeFSc7po81ptYmwDqzFcqp91MYWLdb/d90jw6k/0O5fAoANXH8azbWXhEviINF8WhcdgW3z617p2xisAbQDmc9d7x5oui8Lb13JZFNq1msIlfKkWGL87inTa9K4zr+eC10re/dDJoaeaod18WeTNZsa/8DRPesRlkfnCLTpcAqeIUu5PiwKnii+Jq76ZIwZmvSwyZpPlrIsjXCwnWMbwTi/ttPjvuZQ+9/UrTd8yIN7LosoLNKXTvrMragz6B63+tVmtgpMbHIBhqNrZVD4fqq50tOc2f6Eb3rVq4ZIN/MKL5QCGMsS2mXY4/W3llnymyUmnQ9/bWtvD4aK/uBZMEZPuOwj6kkpvrCNczE8T/BzSz8lalpTGgdkm3bDQizzrYgkX83snG5608u4n7Zfo4KppbR7V23qNJ8uSdtb2hlrZQY5/l1Y2nlWWzxAuiZHPNPk+LVZymoUWLKsmMeGSrfIbujU+xwr3Kc5JX3VZwiU5tEVpok4yXWLCZa1I8qQTLgBExBAurwFACCsXACIIFwAiCBcAIggXACIIFwAiCBcAIkTCJd/R3KBfAAWwVkj8VXRHs9Pc3Ey4AA+02MMl39HsNHfkw38XC+CBEnO45DuaK/9eJ+ECPMDiDZdKpBAuwAMuznDx/RthhAvwYIsvXPxxQrgAD7jYwiX8LzK7mjsS9o9QAIiF1C/RsXIBHnCECwAR/Po/ABGECwARhAsAEYQLABGECwARhAsAEYQLABGECwARhAsAEbLh4v2FUY0b19gIYO2LM1y8IIjIlPBfNnod9e31pwrcAJAIMa9caokAW3AE+tpyB0AiCF4W2RIhOlzM/3CDf6UDYO2LLVxq+cbEFhasXID7j+x3LsblRi2XRXznAiSd+I+ibckS8VDV6ykAa5/4j6Ij7gYequXCCkBSCP60qGou2NKEL3SB+4DIdy4q8tKm9tTg21wguUR+WlRjKNR+lcSaBUic+L9zCYeC/iPnqpc8ETlCxAAJwh8uAhBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABBBuAAQQbgAEEG4ABDx/6fFRiNP4Ss8AAAAAElFTkSuQmCC" alt="" />

-----------------------------------泛型接口应用实例------------

public class Demo8 {
    public static void main(String[] args) {
        MyInter<String> my = new MyInter<String>();
        my.print("泛型");
 
        MyInter2 my2 = new MyInter2();
        my.print("只能传字符串");
    }
}
 
interface Inter<T> {
    void print(T t);
}
 
// 实现不知为何类型时可以这样定义
class MyInter<T> implements Inter<T> {
    public void print(T t) {
        System.out.println("myprint:" + t);
    }
}
//使用接口时明确具体类型。
class MyInter2 implements Inter<String> {
 
    @Override
    public void print(String t) {
        System.out.println("myprint:" + t);
 
    }
 
}

-----------------------------------泛型通配符应用实例------------------------

需求：

定义一个方法，接收一个集合对象(该集合有泛型)，并打印出集合中的所有元素。

例如集合对象如下格式:

Collection<Person> coll = new ArrayList<Person>();
        coll.add(new Person("jack", 20));
        coll.add(new Person("rose", 18));
        Collection<Object> coll2 = new ArrayList<Object>();
        coll2.add(new Object());
        coll2.add(new Object());
        coll2.add(new Object());
 
        Collection<String> coll3 = new ArrayList<String>();
        coll3.add("abc");
        coll3.add("ddd");
        coll3.add("eee");

分析,集合对象中的元素的类型是变化的,方法的形参的那么泛型类型就只能定义为Object类型.

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
 
public class Demo9 {
    public static void main(String[] args) {
        ArrayList<Object> arr = new ArrayList<Object>();
        arr.add(new Object());
        arr.add("String");
        print(arr);
 
        //将集合的泛型设置类String类型，是Object子类
        HashSet<String> hs = new HashSet<String>();
        hs.add("hello");
        hs.add("jack");
        //由于print方法接收的集合进行了元素限定，只接受限定为Object类型的集合,编译不通过
        //print(hs);
    }
 
    public static void print(Collection<Object> coll) {
        Iterator<Object> it = coll.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
    }
}

但是,由于print方法接收的集合进行了元素限定，只接受限定为Object类型的集合,编译不通过该问题如何解决？

可以把方法的形参的泛型去掉,那么方法中就把集合中的元素当做Object类型处理.

也可以使用使用泛型通配符

public class Demo9 {
    public static void main(String[] args) {
        ArrayList<Object> arr = new ArrayList<Object>();
        arr.add(new Object());
        arr.add("String");
        print(arr);
 
        // 将集合的泛型设置类String类型，是Object子类
        HashSet<String> hs = new HashSet<String>();
        hs.add("hello");
        hs.add("jack");
        // 使用泛型通配符，编译通过。
        print(hs);
    }
 
    public static void print(Collection<?> coll) {
        Iterator<?> it = coll.iterator();
        while (it.hasNext()) {
 
            Object next = it.next();
            System.out.println(next);
        }
    }
}

上述就使用了泛型通配符

通配符：？
public void show(List<?> list)
{
}
可以对类型进行限定范围。
？extends E: 接收E类型或者E的子类型。
? super E: 接收E类型或者E的父类型。

限定泛型通配符的边界

限定通配符的上边界：

extends

接收Number 类型或者Number的子类型

正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界

super

接收Integer 或者Integer的父类型

正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();

总结：

　　JDK5中的泛型允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定

注意：

　　泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

泛型的基本术语，以ArrayList<E>为例：<>念着typeof

　　ArrayList<E>中的E称为类型参数变量

　　ArrayList<Integer>中的Integer称为实际类型参数

　　整个称为ArrayList<E>泛型类型

　　整个ArrayList<Integer>称为参数化的类型ParameterizedType