result = (this.getX() == that.getX() && this.getY() == that.getY());

result = that.xEquals( getX() ) && that.yEquals( getY() );

result = that.equals( getX(), getY() );

@Override public boolean equals(Object other) {
    return other instanceof Point ? ((Point)other).equals( getX(), getY() ) : false;
}

result = that.canEqual( this ) && that.colorEquals( getColor() ) && super.equals( that );

    @Override public boolean equals(Object other) {
        boolean result = false;
 
        if (other instanceof ColoredPoint) {

    @Override public boolean canEqual(Object other) {
        return (other instanceof ColoredPoint);

    @Override public boolean equals(Object other) {
        boolean result = false;
        if( this.canEqual( other ) ) {
            ColoredPoint that = (ColoredPoint) other;
            result = that.colorEquals( getColor() ) && super.equals( that );
 
        }
        return result;
    }

    return this.canEqual( other ) ?
      ((ColoredPoint)other).colorEquals( getColor() ) && super.equals( that ) :
      false;

public final boolean equals(Object o) { return equalsImpl(o,true); }

protected boolean equalsImpl(Object o,boolean isFirstPass)
{
    // reject if not an object from the base class hierarchy 
    if (!(o instanceof Point))
        return false;
   	
    Point p = (Point) o;

    // delegate if it's the first pass/call of this method 
    // and the object belongs to one of the subclasses
    if (isFirstPass && !(p.getClass().isInstance(this)))
        return p.equalsImpl(this,false);

    // reached for all objects from the base class hierarchy
    // which classes just inherit Point.equalsImpl() method 
    return (x == p.x && y == p.y);
}

public class Point {
 
    private final int x;
    private final int y;
 
    // ................
 
    @Override public boolean equals(Object obj) {
        return (obj instanceof Point &&
                    ((Point)obj).fEquals(this));
    }
 
    protected boolean fEquals(Point obj) {
        return (this.x == obj.x && this.y == obj.y);
    }
 
    @Override public int hashCode() {
           // ................
}
 
public class ColoredPoint extends Point {
 
    private final Color color;
 
    // ................
 
    @Override public boolean equals(Object obj) {
        return (obj instanceof ColoredPoint &&
                    ((ColoredPoint)obj).fEquals(this));
    }
 
    protected boolean fEquals(ColoredPoint obj) {
        return (this.color.equals(obj.color) && super.fEquals(obj));
    }
 
    @Override protected boolean fEquals(Point obj) {
        return false;
    }
 
    @Override public int hashCode() {
           // ................
}

        Point p1  = new Point(1, 1);
        Point p2  = new ColoredPoint(1, 1, Color.PINK);
        ColoredPoint cp1 = new ColoredPoint(1, 1, Color.PINK);
        
        System.out.println("p1.equals(p2) is " + (p1.equals(p2)));
        System.out.println("p2.equals(p1) is " + (p2.equals(p1)));
        System.out.println("p1.fEquals(p2) is " + (p1.fEquals(p2)));
        System.out.println("p2.fEquals(p1) is " + (p2.fEquals(p1)) + "\n");
        
        System.out.println("p1.equals(cp1) is " + (p1.equals(cp1)));
        System.out.println("cp1.equals(p1) is " + (cp1.equals(p1)));
        System.out.println("p1.fEquals(cp1) is " + (p1.fEquals(cp1)));
        System.out.println("cp1.fEquals(p1) is " + (cp1.fEquals(p1)) + "\n");
        
        System.out.println("p2.equals(cp1) is " + (p2.equals(cp1)));
        System.out.println("cp1.equals(p2) is " + (cp1.equals(p2)));
        System.out.println("p2.fEquals(cp1) is " + (p2.fEquals(cp1)));
        System.out.println("cp1.fEquals(p2) is " + (cp1.fEquals(p2)));

p1.equals(p2) is false
p2.equals(p1) is false
p1.fEquals(p2) is true
p2.fEquals(p1) is false

p1.equals(cp1) is false
cp1.equals(p1) is false
p1.fEquals(cp1) is true
cp1.fEquals(p1) is false

p2.equals(cp1) is true
cp1.equals(p2) is true
p2.fEquals(cp1) is false
cp1.fEquals(p2) is false

@Override
public boolean equals( Object other ) {
    Point that;
    return this == other || (
        canEqual( other ) && ( that = ( Point )other ).canEqual( this ) &&
        getX() == that.getX() && getY() == that.getY()
    );
}

@Override
public boolean equals( Object other ) {
    C cOther;
    return this == other || (
        eqPrereq( this, other ) && // for direct subclasses of Object
//      super.equals( other ) && // otherwise
        nullSafeEquals( this.getProp1(), ( cOther = ( ( C )other ) ).getProp1() ) &&
        nullSafeEquals( this.getProp2(), cOther.getProp2() ) && ...
    );
}

return oOther != null && getEqualsClass( oThis ).equals( getEqualsClass( oOther ) );

  public boolean equals (final Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (this.getClass() != obj.getClass()) {
      return false;
    }
    final Point other = (Point) obj;
    if (this.x != other.x) {
      return false;
    }
    if (this.y != other.y) {
      return false;
    }
    return true;
  }

  public boolean equals (final Object obj) {
    if (this == obj) {
      return true;
    }
    if (!super.equals(obj)) {
      return false;
    }
    if (this.getClass() != obj.getClass()) {
      return false;
    }
    final ColoredPoint other = (ColoredPoint) obj;
    if (this.color == null) {
      if (other.color != null) {
        return false;
      }
    } else if (!this.color.equals(other.color)) {
      return false;
    }
    return true;
  }

...
    if (this.getClass() != obj.getClass()) {
      if (obj.getClass().isAssignableFrom(this.getClass())) {
        return obj.equals(this);
      }
      if (!this.getClass().isAssignableFrom(obj.getClass())) {
        return false;
      }
    }
...

@Override public boolean canEqual(Object other) {
        return (other instanceof this.getClass());
    }

    @Override public boolean equals(Object other) {
        boolean result = false;
        if (other instanceof ColoredPoint) {
            ColoredPoint that = (ColoredPoint) other;
            result = (this.color.equals(that.color) && super.equals(that));
        }
        else if (other instanceof Point) {
            Point that = (Point) other;
            result = that.equals(this);
        }
        return result;
    }

   public boolean canEqual(Object other) {
      return other instanceof Point;
   }
 
   @Override
   public boolean equals(Object other) {
      if (other == this)
         return true;
 
      if (!canEqual(other))
         return false;
 
      // Assuming canEqual() is overridden to check for a
      // subclass of this one, the following assignment
      // must work:
      Point that = (Point) other;
 
      // Check that that.canEqual(this) AND invariants match. 
      return that.canEqual(this) && x == that.x & y == that.y;
    }

   @Override
   public boolean canEqual(Object other) {
      return other instanceof ColoredPoint;
   }
 
   @Override public boolean equals(Object other) {
      if (other == this)
         return true;
 
      if (!super.equals(other))
         return false;
 
      // We now know that 'other' must be a ColoredPoint
      // because the 2nd check in the top-level equals() 
      // method will have called OUR canEqual() method.
      // So, the following assignment must work:
      ColoredPoint that = (ColoredPoint) other;
 
      // We now only need to check invariants because 
      // super.equals(other) can't return true unless
      // other.canEqual(this).
      // So...
      return color.equals(that.color);