泛型的基础

泛型

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

常见形式

• 泛型类
• 泛型接口
• 泛型方法

语法

• 一个参数： < T >
• 多个参数： <T，K，E…>
• 这些参数称为类型占位符，表示一种引用类型.
• 不能为基本类型.

泛型类

• 形式： class Generic < T >{ }

• 代码：

1. 创建一个泛型类

public class Generic<T>{
    //使用泛型T
    //1创建变量
    T t;

    //2泛型作为方法的参数
    public void show(T t){
        this.t=t;
       
        System.out.println(t);
    }

    //3泛型作为方法的返回值
    public T getT() {
        return t;
    }
}

2. 实现泛型类

public class TestGeneric {
    public static void main(String[] args) {
        Generic <String>generic=new Generic<String>();
                           //后一个<T>可写可不写，不会影响,但需要保持一致
        generic.show("坚持学习java");		//输出：坚持学习java
        System.out.println(generic.getT()); //输出：坚持学习java
    }
}

3. 注意点：

• 需要注意的是, T t=new T();是错误的，因为T是未知类型，千万不可以创建对象
• 泛型类中泛型可以用于声明变量，方法参数，方法返回值.

泛型接口

• 形式：interface GenericInter< T >
• 代码：

1. 泛型接口：

public interface GenericInter<T> {
    String name="小明"; //静态常量，接口特别属性
    T server(T t);  //抽象方法
}

2. 实现泛型接口方式:

• 方式1：当接口的类型确定时，直接实现给出泛型的值，例如GenericInteger< String >

public class GenericIntegerImp implements GenericInteger<String> {
    @Override
    public String server(String s) {
        return s;
    }

    public static void main(String[] args) {
        GenericIntegerImp gip=new GenericIntegerImp();
        System.out.println(gip.server("小明")); //输出：小明
    }
}

• 方式2：当接口类型任然不确定时，需要继续使用泛型，那么可以在类名后也加上泛型参数，同时，在另一个测试类中实现该类即可.例如： public class GenericIntegerImp< T > implements GenericInteger< T >

- public class GenericIntegerImp<T> implements GenericInteger<T> {
    @Override
    public T server(T t) {
    	System.out.println(t);
        return t;
    }
}

实现方式二泛型类：

GenericIntegerImp<Integer> gip= new GenericIntegerImp();
       gip.server(1000);  //输出：1000

3. 注意点：

• 泛型接口与泛型类定义大致相同
• 不同之处在于假如，实现接口时，接口类型还没有确定，那么则需要给实现接口的类也加上参数< T >, 让整个类成为泛型类，同时需要注意，接口中的< T >则由实现类中< T >决定.

泛型方法

• 形式： 返回值类型 方法名，例如 public < T > void show() { }
• 代码:

1. 泛型方法:

public class MyGenricMethod {
     public static <T> T show(T t){ //有点类似方法重载了，定义一个静态方法
        System.out.println(t);
        return t;
    }
}

2.实现泛型方法

    MyGenricMethod.show(100);    //输出结果：100
    MyGenricMethod.show("坚持学习java"); //输出结果：坚持学习java
    MyGenricMethod.show('A');     //输出结果：A

2. 注意点：

• 泛型方法的作用范围只在方法的允许范围内使用，其他方法不可以使用< T >来定义泛型.
• 泛型方法与泛型类中的方法是不一样的，其作用范围不一致.
• 实现泛型方法非常像方法重载，比重载更精简，可以用于简化代码.

泛型的好处

1. 提高代码的重用性.
2. 防止类型转换异常，提高代码的安全性.

泛型集合的使用

public class GenericUse {
    public static void main(String[] args) {
        //泛型集合
       Student s1=new Student("小明",18);
       Student s2=new Student("小芳",20);
       Student s3=new Student("小伟",24);
       ArrayList<String> arrayList= new ArrayList<String>();
       arrayList.add("java");
       arrayList.add("真香");
       arrayList.add("我爱java");
       //arrayList.add(2);,使用了泛型，不可以添加非String类型

        //使用for-each循环遍历
        for (String s : arrayList) {//可以看到接受量不是Object类型，是String
            System.out.println(s);  //所以不需要再进行强制类型转换
        }

        ArrayList<Student> arrayList2= new ArrayList();
        arrayList2.add(s1);
        arrayList2.add(s2);
        arrayList2.add(s3);
        //使用迭代器遍历
        Iterator<Student> iterator=arrayList2.iterator();//迭代器也是泛型，默认Studnet
        while(iterator.hasNext()){
            Student s=iterator.next();//可以看到不用再进行强制类型转换
            System.out.println(s);
        }
    }
}

输出结果：
java
真香
Student{name=‘小明’, age=18}
Student{name=‘小芳’, age=20}
Student{name=‘小伟’, age=24}

总结：
对集合使用泛型，可以防止防止类型转换的异常，提高代码的安全性.