继承关系的两个类的自然排序方法问题

杨佳名

本帖最后由 jacoblx 于 2014-11-1 06:31 编辑

假设一个父类Person，一个子类Student，两者可以拥有不同的自然排序方法compareTo吗？比如Person类按姓名排序，Student类按成绩排序。

如果可以的话，子类如何实现compareTo方法？需要再次实现Comparable接口吗？泛型怎么写？

先谢过了

例如

public class Person implements Comparable<Person>{

private String name;

private int age;

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

@Override

public int compareTo(Persono) {

int margin = this.name.compareTo(o.name);

return margin == 0 ? this.age - o.age : margin;

}

public class Student extends Person /*这里需要再次实现Comparable接口吗？*/{

private int mark;

public Student(String name, int age, int mark) {

super(name, age);

this.mark = mark;

}

//这里没办法覆盖父类的comparaTo方法，因为参数类型不一样

public int compareTo(Studento) {

int margin = this.mark - o.mark;

return margin == 0 ? super.compareTo((Person)o): margin;

}

D.reamJA · D.reamJA

可以new一个Collator，复写 int compare(Object o1, Object o2) ，写一个单独的比较规则

jacoblx · jacoblx

D.reamJA 发表于 2014-11-1 06:39
可以new一个Collator，复写 int compare(Object o1, Object o2) ，写一个单独的比较规则 ...

当然用比较器可以解决问题。难道在父子类上分别实现不同的自然排序方法是不可行的吗？

Eagle · Eagle

没试过，楼主可以试试子父类都实现Comparable。复写CompareTo方法，
实践才是检验真理的唯一方法

游泳的猫 · 游泳的猫

楼主可以试试把泛型改成“？ extends Person ”， student的方法传入参数仍为 Person o，我没试过，期待你试过的结果。。。。。:D

jacoblx · jacoblx

Eagle 发表于 2014-11-1 09:16
没试过，楼主可以试试子父类都实现Comparable。复写CompareTo方法，
实践才是检验真理的唯一方法 ...

这个不行
提示：
The interface Comparable cannot be implemented more than once with different arguments: Comparable<Person> and Comparable<Student>

jacoblx · jacoblx

游泳的猫发表于 2014-11-1 09:49
楼主可以试试把泛型改成“？ extends Person ”， student的方法传入参数仍为 Person o，我没试过，期待你 ...

谢谢。
这样的话，Student就不能按分数排序了，因为Person类没这个属性的。。。

游泳的猫 · 游泳的猫

jacoblx 发表于 2014-11-1 22:03
谢谢。
这样的话，Student就不能按分数排序了，因为Person类没这个属性的。。。 ...

你好，我弄错了，我又重新做了一次，我测试结果是满足，你看看行不？。。。。。。。import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {
public static void main(String[] args){
TreeSet<Student> ts=new TreeSet<Student>();
ts.add(new Student("lisi01",04,98));
ts.add(new Student("lisi02",03,85));
ts.add(new Student("lisi03",02,72));
ts.add(new Student("lisi04",01,88));
for (Iterator it=ts.iterator();it.hasNext() ; )
{
Student s=(Student)it.next();
System.out.println(s.getName()+"....."+s.getAge()+"....."+s.getMark());
}
}

}
class Person implements Comparable{
private String name;
private int age;
public Person(String name, int age) {
         super();
         this.name = name;
         this.age = age;
}
@Override
public int compareTo(Object obj){
Person person=(Person)obj;
int margin = this.name.compareTo(person.name);
      return margin == 0 ? this.age - person.age : margin;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}

}

class Student extends Person/*这里需要再次实现Comparable接口吗？我没有覆盖*/{
private int mark;
public Student(String name, int age, int mark) {
         super(name, age);
         this.mark = mark;
}
  //这样覆写了
public int compareTo(Object obj) {
Student stu=(Student)obj;
         int margin = this.mark - stu.mark;
         return margin == 0 ? super.compareTo((Person)stu): margin;
}
public int getMark() {
return mark;
}

}

jacoblx · jacoblx

游泳的猫发表于 2014-11-1 23:06
你好，我弄错了，我又重新做了一次，我测试结果是满足，你看看行不？。。。。。。。import java.util.Ite ...

我试了下，确实可以，谢谢

不过没用泛型会有警告，开发的时候这样使不太好吧。

我觉得最终可能只有父类使用实现Comparable的方法，而子类如需要特殊比较方式，使用比较器是比较稳妥的方法。

郑飞 · 郑飞

应该是可以的你在比较传入的元素之前做一个类型判断是学生就用A数学比较是老师就用B数学比较

游泳的猫 · 游泳的猫

jacoblx 发表于 2014-11-2 08:47
我试了下，确实可以，谢谢

不过没用泛型会有警告，开发的时候这样使不太好吧。

对，确实不安全，还是比较器靠谱一些{:3_57:}

郑飞 · 郑飞

可以用泛型的进了比较方法再按类型区分对待

package com.itheima.io;
import java.util.TreeSet;
class Test
{
public static void main(String[] args)
{
TreeSet<Student> stu = new TreeSet<Student>();
stu.add(new Student("stu3",21));
stu.add(new Student("stu2",22));
stu.add(new Student("stu1",23));
System.out.println(stu);
TreeSet<Person> per = new TreeSet<Person>();
per.add(new Person("per3",21));
per.add(new Person("per2",22));
per.add(new Person("per1",23));
System.out.println(per);
}
}
class Person implements Comparable<Person>
{
String name;
int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Person p)
{
// if(p.getClass()==Person.class)
if(p.getClass()==Student.class)
return this.name.compareTo(p.name);
else
return this.age - p.age;
}
public String toString()
{
return name+"="+age;
}
}
class Student extends Person
{
String name;
int age;
Student(String name,int age)
{
super(name,age);
this.name = name;
this.age = age;
}
public String toString()
{
return name+"="+age;
}
}

复制代码

zhangyangLengen · zhangyangLengen

可以
public class TreeSetDemo {

public static void main(String[] args) {

TreeSet<Person> treeSet=new TreeSet<Person>(/*new CompareByAge()*/);
treeSet.add(new Person("zhangSan",21));
treeSet.add(new Person("wangWu",29));
treeSet.add(new Person("zhaoliu",21));

TreeSet<Student> treeSet2=new TreeSet<Student>(/*new CompareByAge()*/);
treeSet2.add(new Student("zhangSan2",12,100));
treeSet2.add(new Student("wangWu3",29,30));
treeSet2.add(new Student("zhaoliu4",21,50));

boolean bool=treeSet.addAll(treeSet2);
System.out.println(bool);
System.out.println("size:"+treeSet.size());
//进行迭代
Iterator it=treeSet2.iterator();

while(it.hasNext())
{
System.out.println(it.next());
}
}

}

package day16_17.cn.itcast.bean;

import java.util.Comparator;

public class Person implements Comparable<Person>{
protected String name;
protected int age;

public Person() {
super();
// TODO 自动生成的构造函数存根
}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

@Override
public int compareTo(Person o) {

//比较年龄
int temp=this.age-o.getAge();
//如果年龄相同，就比较姓名
return temp==0?this.name.compareTo(o.getName()):temp;
}

@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}

package day16_17.cn.itcast.bean;

public class Student extends Person{
private int mark;

public Student() {
super();
// TODO 自动生成的构造函数存根
}

public Student(String name, int age,int mark) {
super(name, age);
this.mark=mark;
}

public int getMark() {
return mark;
}

public void setMark(int mark) {
this.mark = mark;
}

public int compareTo(Student o){
int temp=this.mark-o.getMark();
return temp==0?super.compareTo(o):temp;
}

@Override
public String toString() {
return "Student [mark=" + mark + ", name=" + name + ", age=" + age
+ "]";
}

}

jacoblx · jacoblx

本帖最后由 jacoblx 于 2014-11-4 00:15 编辑

zhangyangLengen 发表于 2014-11-2 19:56
可以
public class TreeSetDemo {

谢谢

你的代码中学生的比较仍然是使用从Person类继承来的compareTo方法，是按年龄排序的，你把第一个学生的年龄改为25就可以看出来，排序就变了。

wf111sxwf · wf111sxwf

子类不需要写实现Compareble借口因为父类已经实现了你已经继承了父类，如果你需要子类有特殊的比较方法只需要覆写 compareTo方法即可

zhangyangLengen · zhangyangLengen

可能应该单独的写个Comparatpr <Student> 的实现类

zhangyangLengen · zhangyangLengen

子类明明就覆盖了，怎么就没有调用子类的啊

jacoblx · jacoblx

wf111sxwf 发表于 2014-11-4 13:43
子类不需要写实现Compareble借口因为父类已经实现了你已经继承了父类，如果你需要子类有特殊的比较方法 ...

问题就在于如何覆盖，因为父类传入的比较参数是Person类型，而子类需要比较的是自己特有的属性，需要传入Student类型的参数，参数不一样就没办法覆盖。我目前想到的比较好的方法是子类使用比较器来实现。

jacoblx · jacoblx

zhangyangLengen 发表于 2014-11-4 23:19
可能应该单独的写个Comparatpr 的实现类

不错，我也是这个想法，comparaTo方法是没办法覆盖父类的。

jacoblx · jacoblx

zhangyangLengen 发表于 2014-11-4 23:20
子类明明就覆盖了，怎么就没有调用子类的啊

谢谢。

因为参数表不一样，所以没有覆盖，而是重载了。

帐号		自动登录	找回密码
密码			加入黑马

继承关系的两个类的自然排序方法问题

评分

22 个回复

评分

黑马骑士勋章