Comparable接口、泛型

2022.01.15每日总结

1.comparable接口

Comparable接口代码：

* @param   o the object to be compared.

public interface Comparable<T> {
    public int compareTo(T o);
}

任何实现Comparable接口的类都需包含compareTo方法，这个方法有一个Object参数，并且返回一个整数。

1.1为什么要实现Comparable接口？

假设希望使用Arrays类的sort方法对Employee对象数组进项排序，Employee类就必须实现Comparable接口。

主要原因在于Java是程序设计语言是一种强类型（strong typed）语言，在调用方法的时候编译器要能检查这个方法确实存在，在sort方法中可能会有下面的语句：

if(a[i].compareTo(a[j]) > 0)
{
  // rearrange a[i] and a[j]
  ...
}

编译器必须确认a[i] 一定有一个compareTo方法。

public class Employee implements Comparable<Employee>
{
   private String name;
   private double salary;

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

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   /**
    * Compares employees by salary
    * @param other another Employee object
    * @return a negative value if this employee has a lower salary than
    * otherObject, 0 if the salaries are the same, a positive value otherwise
    */
   public int compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
}

import java.util.*;

/**
 * This program demonstrates the use of the Comparable interface.
 * @version 1.30 2004-02-27
 * @author Cay Horstmann
 */
public class EmployeeSortTest
{
   public static void main(String[] args)
   {
      Employee[] staff = new Employee[3];

      staff[0] = new Employee("Harry Hacker", 35000);
      staff[1] = new Employee("Carl Cracker", 75000);
      staff[2] = new Employee("Tony Tester", 38000);

      Arrays.sort(staff);

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

1.2在Java 5中，Comparable接口已经提升为一个泛型类型。

 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
————————————————
版权声明：本文为CSDN博主「花未央D8023」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/romantic112/article/details/80513372

例如，在实现Comparable<Employee>接口的类中，必须提供以下方法

int compareTo(Employee other)，方法中有一个Object类型的参数，必须手动将compareTo方法的这个参数强制转换为所希望的类型。

public int compareTo(Object otherObject)
{
   Employee other = (Employee) otherObject;
   return Double.compare(salary, other.salary);
}

为泛型Comparable接口提供一个类型参数：

public class Employee implements Comparable<Employee>
{
    * @param other another Employee object
   public int compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
}