Java类库中需要重写的方法

Posted 2021-06-17 白杨树&

一：前言

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);
        }

    }
}

三：总结：

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