一：前言

1.Java常用的類庫中，有幾個方法是需要重寫，在重寫之後，才能根據我們的需求操作。

2.需要重寫的類：toString()方法，equals()方法，ComparaTo()方法，Comparator()方法

二：開幹：

1.重寫toString()方法：

1.1）一個實體類要是想列印與該類有關的內容，必須重寫他，可以系統生成，也可以根據自己的需要重寫

1.2）程式碼演示：（這個超級簡單）

 1 public class Student {
 2     private String name;
 3     private int age;
 4     
 5     public
 
 Student(){};
 6 
 7     public Student(String name, int age) {
 8         this.name = name;
 9         this.age = age;
10     }
11 
12     @Override
13     public String toString() {
14         return "Student{" +
15                 "name='" + name + '\'' +
16                 ", age=" + age +
17                 '
 
}';
18     }
19 }

2.重寫equals()方法：

2.1）先來看下equals（)方法的底層原始碼

1  public static boolean equals(Object a, Object b) {
2         return (a == b) || (a != null && a.equals(b));
3     }

原始碼在底層也是用“==”來表示的。（在基本的資料型別中，==是用來判斷內容是否相同的，在引用資料型別中，==用來判斷兩個物件在堆記憶體中的地址是否相同，如果想要判斷物件的內容是否相等，就要按照自己的需求重寫該方法。

2.2）程式碼演示：

 1 public class Student {
 2      String name;
 3      int age;
 4 
 5     public Student(){};
 6 
 7     public Student(String name, int age) {
 8         this.name = name;
 9         this.age = age;
10     }
11     
12     @Override
13     public boolean equals(Object o) {
14         //首先比較兩個的地址是否相同，如果相同，則一定是同一個物件
15         if(this == o){
16             return true;
17         }
18         //如果傳進來的物件為空
19         if(o==null){
20             return false;
21         }
22         //在判斷傳進來的物件的型別是否是本類型別或者是他的子類
23         if(o instanceof Student){
24             //將物件轉換為Person類
25             Student student =(Student)o;
26             if(student.name.equals(name) && student.age==age){
27                 return true;
28             }
29         }
30         //建立來的不是學生物件，肯定也是false
31         return false;
32     }
33     
34 }

3.重寫compareTo()方法

3.1）該方法是用在集合排序時用的，如果你想如果你想按照自己定的規則排序，就要從寫該方法

3.2）要實現重寫compareTo()方法，該類就要實現Compareable介面

3.3）如果返回的為1，則表示當前物件大寫，按照升序排序；為-1，為降序；為0則相同

3.4）程式碼演示：

學生類：

 1 public class Student implements Comparable<Student> {
 2      String name;
 3      int age;
 4 
 5     public Student(){};
 6 
 7     public Student(String name, int age) {
 8         this.name = name;
 9         this.age = age;
10     }
11 
12 
13     @Override
14     public int compareTo(Student o) {
15         //現按年齡升序排序，年齡相同就按照名字字母排序
16         if(this.age>o.age){
17             return 1;
18         }
19         if(this.age<o.age){
20             return -1;
21         }
22         else{
23             return this.name.compareTo(o.name);
24         }
25     }
26 
27     @Override
28     public String toString() {
29         return "Student{" +
30                 "name='" + name + '\'' +
31                 ", age=" + age +
32                 '}';
33     }
34 }

主方法：

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.Iterator;
 4 
 5 public class Test {
 6     public static void main(String[] args) {
 7         ArrayList <Student> list = new ArrayList<>();
 8         Student student1 = new Student("張海夢",12);
 9         Student student2 = new Student("吳紅霞",12);
10         list.add(student1);
11         list.add(student2);
12         //先呼叫方法對集合排序
13         Collections.sort(list);
14         Iterator<Student> iterator = list.iterator();
15         while(iterator.hasNext()){
16             Student next = iterator.next();
17             System.out.println(next);
18         }
19     }
20 }

4.重寫Comparator()方法：

4.1）利用Comparator()方法，要新建一個類，該類繼承Comparator介面，泛型為我們要比較的實現類

4.2）實體類：

 1 public class Worker {
 2     private String name;
 3     private Integer age;
 4 
 5     public Worker() {
 6     }
 7 
 8     public Worker(String name, Integer age) {
 9         this.name = name;
10         this.age = age;
11     }
12 
13     public String getName() {
14         return name;
15     }
16 
17     public void setName(String name) {
18         this.name = name;
19     }
20 
21     public Integer getAge() {
22         return age;
23     }
24 
25     public void setAge(Integer age) {
26         this.age = age;
27     }
28 
29     @Override
30     public String toString() {
31         return "Worker{" +
32                 "name='" + name + '\'' +
33                 ", age=" + age +
34                 '}';
35     }
36 }

4.2）Comparator類

 1 import java.util.Comparator;
 2 
 3 /**
 4  * 編寫一個類，實現Comparator介面，泛型為工人類
 5  */
 6 public class WorkerComparator implements Comparator<Worker> {
 7     @Override
 8     public int compare(Worker o1, Worker o2) {
 9         if(o1.getAge()>o2.getAge()){
10             return 1;
11         }
12         if(o1.getAge()<o2.getAge()){
13             return -1;
14         }
15         else{
16             return o1.getName().compareTo(o2.getName());
17         }
18     }
19 }

4.3)測試類；

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

public class Test01 {
    public static void main(String[] args) {
        //建立集合儲存工人物件
        ArrayList<Worker>list = new ArrayList<>();
        list.add(new Worker("小夢",15));
        list.add(new Worker("大米",15));
        //建立一個comparator物件
        WorkerComparator comparator = new WorkerComparator();
        //呼叫方法對集合進行排序
        // Collections.sort(集合,比較類);
        Collections.sort(list,comparator);
        Iterator<Worker> iterator = list.iterator();
        while(iterator.hasNext()){
            Worker next = iterator.next();
            System.out.println(next);
        }

    }
}

三：總結：

以上就是重寫方法，加油！