Comparing objects with equals

I have a task to compare between two objects in java. One is a Date that has days, months and years. the second one extends it, DateT with hours and minutes. In order to to that:

• I can't use any function from Objects Class.
• I also can't use the Name of one Class in the other Class.
• But I can use instanceof.

The problem is that when I compare between Date date and Date dateT(the subclass object) I need to return false.

The problem is that date.equals(dateT) returns true. Do you have some suggestions?

public boolean equals(Object other) 
    if (!(other instanceof Date))
        return false;
    Date d = (Date) other;
    return day == d.day && month == d.month && year == d.year;

The answer should be that you shouldn’t design your software that way. Don’t look at bad examples, like Timestamp extending Date in an incompatible manner. Rather, look at examples like LocalDate and YearMonth, which implement common interfaces but are not subclasses of each other.

But since this is an assignment, here are two ways to solve this:

The problem is that the overridden method is invoked on the first object, which does not take into account that the second object might be a subclass. Therefore, split the comparison operation into two methods and invoke the second method on the second object:

class Date {
    …

    @Override
    public boolean equals(Object obj) {
        return obj instanceof Date && ((Date)obj).sameDate(this);
    }

    protected boolean sameDate(Date d) {
        return day == d.day && month == d.month && year == d.year;
    }
}
class DateT extends Date {
    …

    @Override
    public boolean equals(Object obj) {
        return obj instanceof DateT && ((DateT)obj).sameDate(this);
    }
  
    @Override
    protected boolean sameDate(Date d) {
        return d instanceof DateT && month == d.month && year == d.year;
    }
}

The overridable method equals delegates to the overridable method of the method argument, so if either this or the argument object is a DateT, at least one overridden method will be invoked, enforcing that both objects must be DateT to be equal.

There’s a small redundancy when both objects are DateT, as the this passed to sameDate is already known to be of type DateT but to avoid this check, the comparison logic would have to be extracted into a third method which is not worth the effort here.

The alternative is to consider that even if DateT doesn’t use the day field, each instance will have it, inherited from Day. So, initialize it with a value that can never be equal to a valid value of a Day instance and you’re done. E.g.

public class Date {
    final int day, month, year;

    public Date(int day, int month, int year) {
        if(day < 0) {
            throw new IllegalArgumentException("day = " + day);
        }
        this.day = day;
        this.month = month;
        this.year = year;
    }

    // only for subclasses, might be even more restricted than protected,
    // package-private or even private when using nested classes
    protected Date(int month, int year) {
        this.day = -1;
        this.month = month;
        this.year = year;
    }

    @Override
    public boolean equals(Object obj) {
        return obj instanceof Date d
            && day == d.day && month == d.month && year == d.year;
    }
}

public class DateT extends Date {
    public DateT(int month, int year) {
        super(month, year);
    }
}

This assumes that a day can never be negative and enforces this property in the constructor. Only the special constructor, which should only be accessible to subclasses, will initialize the day to -1 which can never match a valid day of a Date instance. This way, Date instances are never equal to DateT instances without the need for a special handling in the equals method.

If you have a mutable day field, additional measures must be taken to ensure that no method can change these invariants.

Assuming I understand the issue, I believe the following should enforce the symmetric and transitive requirements of your equals implementations.

You need to make sure that you only properly compare Date to Date and DateT to DateT. So have them each return their own class name in toString() and check to see that it matches the passed object's toString(). This is only needed in the Date class.

The following should meet your requirements as no Date* class mentions the other.

So in your DateT class, put

@Override
pubic String toString() { 
    return "DateT";
}
public boolean equals(Object date) {
        if (this == date) { // same object
           return true;
        if (date instanceof DateT d) { // d is now cast as dateT
            return <comparison using DateT values>
        }
        return false;
}

But since DateT is a subtype of Date, put this in your Date class

@Override
public String toString() {
    return "Date";
}

public boolean equals( Object date) {
  if( this == date) {  // same object
     return true;
  }
  if ((date instanceof Date d) && date.toString().equals("Date")) {
        return <comparison using Date values>
  }
  return false;
}

Note: As of Java 14 implied casting can be used as follows:

public boolean equals(Object foo) {
  if (foo instanceOf Foo f) { // if true f is now an instance of Foo and
                                  // can be used directly.
   ...
} 

</details>



# 答案3
**得分**: 0

这一行代码 `if (!(other instanceof Date))` 在你将 `DateT` 类型作为参数传递给 `equals` 方法时，将始终为假，因为 `DateT` 是 `Date` 的子类。因此，`return false;` 不会被执行，而会检查自定义比较。

在进行自定义比较之前，您需要执行两件事情：

1. 检查参数是否不是 `null`。`null` 可以传递给任何派生的数据类型变量。
2. 如果参数的规范名称与您的类名不匹配（我猜它是 `java.util.Date`），则返回 `false`。

这是如何检查相等性的方式：

```java
public boolean equals(Object date) {
    
    if (date == null)
        return false;
    
    else if (!date.getClass().getCanonicalName().equals("java.util.Date"))
        return false;
    
    else {
        Date d = (Date) date;
        return day == d.day && month == d.month && year == d.year;
    }
}

public boolean equals(Object date) {

	if(date == null)
		return false;
	
	else if(date.getClass().getCanonicalName() != "java.util.Date")
		return false;
	
	else {
		Date d = (Date) other;
	    return day == d.day && month == d.month && year == d.year;
	}
}

答案4

得分: 0

为了使用 DateT 类来否定比较，您可以首先检查 obj 参数是否是 DateT 的实例。

此外，在此处，您可以在 instanceof 语句中使用 模式变量。

class Date {
    int years, months, days;

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof DateT) return false;
        if (obj instanceof Date date) {
            return years == date.years
                && months == date.months
                && days == date.days;
        }
        return false;
    }
}

子类 equals 可以有两种实现方式，我不确定哪种更有效。从本质上讲，如果 DateT 类的 hours 和 minutes 都为 0，它 可能 是等效的。

在这种情况下，DateT 不等于 Date。

class DateT extends Date {
    int hours, minutes;

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof DateT date)) return false;
        return years == date.years
            && months == date.months
            && days == date.days
            && hours == date.hours
            && minutes == date.minutes;
    }
}

class Date {
    int years, months, days;

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof DateT) return false;
        if (obj instanceof Date date) {
            return years == date.years
                && months == date.months
                && days == date.days;
        }
        return false;
    }
}

class DateT extends Date {
    int hours, minutes;

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof DateT date)) return false;
        return years == date.years
            && months == date.months
            && days == date.days
            && hours == date.hours
            && minutes == date.minutes;
    }
}