java泛型的作用

1，为什么需要泛型？

假设：如果我们要求一个数组中的最大值和最少值，我们要求一次遍历就要求出，现在给定数值是int类型。我们很容易写出下面代码。

//一次遍历求一个数据的最大值和最少值
public class Test {
    public static void main(String[] args) {
        int[] num={234,34,456,2,435,213};
        Pair pairMaxMin=Pair.findMaxMin(num);
        System.out.println("Max="+pairMaxMin.first+"  Min="+pairMaxMin.second);
    }
}
class Pair{
    int first;
    int second;;

    public Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }

    public int getFirst() {
        return first;
    }

    public void setFirst(int first) {
        this.first = first;
    }

    public int getSecond() {
        return second;
    }

    public void setSecond(int second) {
        this.second = second;
    }

}

class Tool{
    public Pair findMaxMin(int[] num){
        if(num.length==0) return null;
        int max=num[0];
        int min=num[0];
        for(int i=1;i<num.length;i++){
            if(max<num[i]) max=num[i];
            if(min>num[i]) min=num[i];
        }
        return new Pair(max,min);
    }
}

但是我们的需求变了，给定数组是String类型，那么我们的Pair类中的int是不是要换为String类型。如果没有接触过泛型，我们肯定会再次改Pair类中的代码。

2，介绍泛型
2.1下面我们来引出泛型：泛型意味着编写的代码可以对很多种不同类型的对象重用。
2.2首先我们看到class Pair<T>，这样T就是我们的类型，我们可以把它简单把T想为Int和String然后想往常那样定义。在我们使用时这样定义Pair<Integer> pair1，则把Pair类里的T定义为Integer类型。这样我们就可以存整型数字。而这样定义Pair<String> pair2就能存String类型的。

class Pair<T>{

    T first;
    T second;;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getSecond() {
        return second;
    }

    public void setSecond(T second) {
        this.second = second;
    }

}

然后我们再改变Tool类里面的代码：
我们可以看到<T extends Comparable>这样的意思的：T作为泛型的标识，T extends Comparable的意思是这个类型是可以排序的，（如果是自己定义的类就要接上Comparable接口，不然编译器就会报错）。Pair<T>是返回方法的类型。

class Tool{

    public  static<T extends Comparable> Pair<T> findMaxMin(T[] num){
        if(num.length==0) return null;
        T max=num[0];
        T min=num[0];
        for(int i=1;i<num.length;i++){
            if(max.compareTo(num[i])<0) max=num[i];//注意这里是对象间的比较用compareTo
            if(min.compareTo(num[i])>0) min=num[i];
        }
        return new Pair(max,min);
    }

}

整体代码，下面我来找整数型的最大和最小与字符串型的最大和最小。

package fan博客;
//一次遍历求一个数据的最大值和最少值
public class Test {
    public static void main(String[] args) {

        Integer[] num={234,34,456,2,435,213};//注意这里由int改为Interger类型了
        Pair numMaxMin=Tool.<Integer>findMaxMin(num);
        System.out.println("Max="+numMaxMin.first+"  Min="+numMaxMin.second);

        String[] strs={"ewgwe","weuiiu","efw","ncx","rew"};
        Pair strMaxMin=Tool.<String>findMaxMin(strs);
        System.out.println("Max="+strMaxMin.first+"  Min="+strMaxMin.second);
    }
}

class Pair<T>{
    T first;
    T second;;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getSecond() {
        return second;
    }

    public void setSecond(T second) {
        this.second = second;
    }

}
class Tool{

    public  static<T extends Comparable> Pair<T> findMaxMin(T[] num){
        if(num.length==0) return null;
        T max=num[0];
        T min=num[0];
        for(int i=1;i<num.length;i++){
            if(max.compareTo(num[i])<0) max=num[i];
            if(min.compareTo(num[i])>0) min=num[i];
        }
        return new Pair(max,min);
    }

}

3，应用

Find类里的Find是泛型方法，这里可以限定了T是 Employee 子类和包括 Employee 自身，并且这些类实现了comparable接口才能才fun1(）函数中使用compateTo。（不满足这些条件就报错）

import java.util.Collection;
import java.util.Comparator;
import java.util.Objects;

public class T3 {
    public static void main(String[] args) {

        pairPeopel<Employee> pair2= Find.fun1(
                new Employee("1",4300),
                new Employee("2",900),
                new Employee("3",4524),
                new Manager("1",5325,-32052)
        );
        System.out.println(pair2.getFirst().salary+"   "+pair2.getSecond().salary);


        pairPeopel<Manager> pair3=Find.fun1(
                new Manager("1",5325,-32052),
                new Manager("2",32,2354),
                new Manager("3",4654,235),
                new Manager("4",5325,324)
        );
        System.out.println(pair3.getFirst().bonus+pair3.getFirst().salary+"   "+(pair3.getSecond().bonus+pair3.getSecond().salary));
    }
}


class pairPeopel<T>{
    T first;
    T second;

    public pairPeopel(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getSecond() {
        return second;
    }

    public void setSecond(T second) {
        this.second = second;
    }
}
class Find{
    public static  <T extends Employee&Comparable> pairPeopel<T> fun1(T... people){
        if(people.length==0) return null;
        T max=people[0];
        T min=people[0];
        for(int i=1;i<people.length;i++){
            if(max.compareTo(people[i])<0) max=people[i];
            if(min.compareTo(people[i])>0) min=people[i];
        }
        return new pairPeopel(max,min);
    }

}
class Employee  implements Comparable{
    String name;
    double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }


    @Override
    public int compareTo(Object o) {
        Employee e=(Employee) o;
        return  Double.compare(salary, e.salary);

    }
}

class Manager extends Employee{

    double bonus;
    public Manager(String name, double salary) {
        super(name, salary);
    }
    public Manager(String name, double salary,double bonus) {
        super(name, salary);
        this.bonus=bonus;
    }

    @Override
    public int compareTo(Object o) {
        return Double.compare(bonus,((Manager) o).bonus);
    }

}