¿Qué es un buen patrón de diseño para el seguimiento de los problemas en una clase?

Jason:

Tengo una clase que tiene un método iguales personalizados (). Cuando comparo dos objetos usando este método es igual, no sólo estoy interesado en saber si son o no son iguales, pero si no son iguales, lo que era diferente en ellos. Por último, quiero ser capaz de recuperar las diferencias que surgen de una situación desigual.

Actualmente utilizo el registro en la pantalla donde mis objetos son desiguales. Esto funciona, pero que tienen un nuevo requisito de ser capaz de extraer los resultados reales de los iguales comprobar que la pantalla posterior. Sospecho que hay un patrón de diseño orientado a objetos para el manejo de este tipo de situación.

public class MyClass {
  int x;
  public boolean equals(Object obj) {
    // make sure obj is instance of MyClass
    MyClass that = (MyClass)obj;

    if(this.x != that.x) {
      // issue that I would like to store and reference later, after I call equals
      System.out.println("this.x = " + this.x);
      System.out.println("that.x = " + that.x);
      return false;
    } else {
      // assume equality
      return true
    }
  }
}

¿Hay buenas sugerencias de diseño de patrones donde se realiza algún tipo de trabajo, sino un objeto secundario recoge la información acerca de lo bien que el trabajo ya estaba hecho, que más tarde puede ser recuperado y visualizado?

Stephen C:

Su problema es que usted está tratando de utilizar la boolean equals(Object)API para algo que no fue diseñado. Creo que no hay ningún patrón de diseño que le permitirá hacer esto.

En su lugar, usted debe hacer algo como esto:

public class Difference {
    private Object thisObject;
    private Object otherObject;
    String difference;
    ...
}

public interface Differenceable {
    /** Report the differences between 'this' and 'other'. ... **/
    public List<Difference> differences(Object other);
}

A continuación, aplicar esto para todas las clases en las que desea la funcionalidad "differenceable". Por ejemplo:

public class MyClass implements Differenceable {
    int x;
    ...

    public List<Difference> differences(Object obj) {
        List<Difference> diffs = new ArrayList<>();
        if (!(obj instanceof MyClass)) {
             diffs.add(new Difference<>(this, obj, "types differ");
        } else {
             MyClass other = (MyClass) obj;
             if (this.x != other.x) {
                 diffs.add(new Difference<>(this, obj, "field 'x' differs");
             }
             // If fields of 'this' are themselves differenceable, you could
             // recurse and then merge the result lists into 'diffs'.
        }
        return diffs;
    }
}