java 多泛型 java泛型实例

泛型（Generic）

介绍：泛型是JDK1.5中引入的一个新特性，其本质是把类型作为参数进行传递。

1.泛型的常见形式

1.1泛型类

例子：
泛型类如下：

public class Generic<T> {//T为类型占位符，表示一种引用类型，<T,E,B>可以是多个
    T t;
    
    public T show(T t) {
        System.out.println(t);
        this.t = t;
        return t;
    }
}

主函数调用如下：

public static void main(String[] args) {

        Generic<String> generic = new Generic<String>();
        generic.show("niwota");

        Generic<Integer> generic1 = new Generic<Integer>();
        generic1.show(1444);

    }

1.2 泛型接口

不多说了直接看例子

接口：

public interface Animal<T> {
    //接口里面不能 T t;
    T service(T t);
}

猫类：

public class Cat implements Animal<String> {
    @Override
    public String service(String t) {
        return "我是一只"+ t + "猫";
    }
}

狗类

public class Dog<T> implements Animal<T> {
    @Override
    public T service(T t) {
        return t;
    }
}

主函数：

Animal<String> animal = new Cat();
        System.out.println(animal.service("花"));

        Animal<String> dog = new Dog<String>();
        System.out.println(dog.service("做人好难，我想当狗"));

1.3 泛型方法

例子：

public class Pig {

    int age;
    String name;

    //返回值的前面加上<T>
    public <T> void show1(T t){
        System.out.println(t);
    }

    public <T> T show2(T t){
        return t;
    }
}

主函数：

Pig pig = new Pig();
        pig.show1(100);
        pig.show1("niwota");
        System.out.println(pig.show2("猪"));

2.好处

1. 提高代码重用性
2. 提高安全性

3.注意事项

1. 不能在类中声明静态属性和静态常量
2. 不能在类中初始化对象或者数组，但是可以声明二者。（不能确定类型，无法确定开辟空间）
3. 不能使用泛型声明参数个数相同的重载方法。如果有两个泛型<T,E>,则void show(T t); void show(E e); 是不可以的。
4. 使用不同实际类型创建出的泛型对象的引用不可以相互赋值。就是Integer创建的泛型，不能给String创建的泛型赋值，很显而易见的。

最后java里面所有的集合都使用了泛型。

4. 集合与泛型

4.1 简单的例子

泛型，集合都是使用泛型的，例子：

ArrayList<Pig> pigs = new ArrayList<Pig>();

        Pig pig1 = new Pig(1,"xiaomi");
        Pig pig2 = new Pig(2,"dami");

        pigs.add(pig1);
        pigs.add(pig2);

        Iterator<Pig> it = pigs.iterator();
        while (it.hasNext()){
            System.out.println(it.next().toString());
        }

都加上类型，更加规范。不加类型的时候，默认是Object

4.2 集合与泛型与“？”

public static void main(String[] args) {

        ArrayList<Pig> pigs = new ArrayList<Pig>();

        Pig pig1 = new Pig(1,"xiaomi");
        Pig pig2 = new Pig(2,"dami");

        pigs.add(pig1);
        pigs.add(pig2);

        ArrayList<String> list = new ArrayList<String>();
        list.add("ni");
        list.add("wo");
        list.add("ta");
        
    }

上述pigs和list是否可以通过一个函数进行遍历。如何实现？
方法如下：

public static void main(String[] args) {

        ArrayList<Pig> pigs = new ArrayList<Pig>();

        Pig pig1 = new Pig(1,"xiaomi");
        Pig pig2 = new Pig(2,"dami");

        pigs.add(pig1);
        pigs.add(pig2);

        ArrayList<String> list = new ArrayList<String>();
        list.add("ni");
        list.add("wo");
        list.add("ta");

        show(pigs);
        show(list);

    }

    public static void show(ArrayList<?> list){

        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

注：此处的“？”表示任何类型。

运行结果如下：

此处的"?"在使用的时候，还可以规定其上限以及下限。

1. 泛型的上限，? extend Pig ，"?"只能是pig以及Pig的子类
2. 泛型的下限，? super Pig ，"?"只能是Pig以及Pig的父类
   具体的使用代码如下：

public static void show1(ArrayList<? extends Pig> list){
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

主函数里的调用代码如下：

ArrayList<PetPig> petpigs = new ArrayList<PetPig>();
        petpigs.add(new PetPig(12,"dahuang"));
        show1(petpigs);