SoloCodigo

como nadie va a tener una sugerencia????

Hola...

Completamente cierto, su...

Para comparar dos objetos, necesitas usar Object.equals().

Mira si te funciona con eso.


Un saludo.



Silverfox

a pesar de ser cierto que el operador == no se utiliza para comparar instancias, esto es efectivo siempre y cuando se desee comparar el contenido de los objetos.

Este código demuestra que te equivocas completamente:


El operador == compara la posición en memoria de los objetos, mientras que equals() compara cada clase de la forma implementada por ella misma (ya que casi todas las clases sobreescriben éste método, generalmente, haciendo comparaciones campo por campo (si son primitivas), o llamando a los equals correspondientes (si son otros objetos).


Extraído de: http://www.devx.com/tips/Tip/12843

The == operator returns true if the two handles on the left and right sides refer to the same location in memory. The function Object.equals() is intended to return true if two handles refer to logically equivalent instances.

Extraído de: http://java.sun.com/mailers/techtips/corej...006/tt0822.html

Comparing with the == Operator

The == operator works on String object references. If two String variables point to the same object in memory, the comparison returns a true result. Otherwise, the comparison returns false, regardless whether the text has the same character values. The == operator does not compare actual char data. Without this clarification, you might be surprised that the following code snippet prints The strings are unequal.

String name1 = "Michèle";
String name2 = new String("Michèle");
if (name1 == name2) {
  System.out.println("The strings are equal.");
} else {
  System.out.println("The strings are unequal.");
}
      The Java platform creates an internal pool for string literals and constants. String literals and constants that have the exact same char values and length will exist exactly once in the pool. Comparisons of String literals and constants with the same char values will always be equal.

Comparing with the equals Method
The equals method compares the actual char content of two strings. This method returns true when two String objects hold char data with the same values. This code sample prints The strings are equal.

String name1 = "Michèle";
String name2 = new String("Michèle");
if (name1.equals(name2) {
  System.out.println("The strings are equal.");
} else {
  System.out.println("The strings are unequal.");
}

De todas formas, te funcionará bien, ya que en el fondo, estás comparando dos objetos idénticos, por ser ambos la misma referencia a memoria.


Un saludo.




Silverfox

Hola...

Sin embargo, un boton llamado "aceptar" es unico, asi lo declaras, no puedes tener dos botones en una misma clase llamados"aceptar".

¿Y qué? Lo que cuenta no es el nombre de la variable, sino la dirección de memoria a la que apunta. Naturalmente, no puedes hacer que una variable apunte a dos sitios distintos a la vez, pero sí que puedes tener dos variables apuntando al mismo sitio. Cuando tu Event hace referencia al objeto emisor, utiliza una referencia a memoria, no el nombre de la variable... Por eso funciona, en realidad, estás comparando dos direcciones de memoria, que da la casualidad de que son iguales y por eso te dí la razón.

A lo mejor es que no entendí tu primer razonamiento.

El equals devuelve un boolean, para comprobar si hablas de dos objetos iguales.

¿Qué quieres decir con iguales? Es que, lamentablemente, si haces algo como:

a y b no es que sean iguales, sino que apuntan al mismo sitio -> son el mismo objeto.

logicamente el if no sirve, porque apunta a una dirección de memoria, la cual seria distinta a pesar que el objeto tenga los mismos campos.

Lamentablemente, y en el caso del JButton en particular, entre muchos otros, un equals tampoco serviría para comprobar la igualdad entre los campos Ejecuta esto, para comprobarlo:

JButton a= new JButton("boton");
JButton b= new JButton("boton");
System.out.println((a==b )+"  "+a.equals(b ));

Por cierto, sí que puedes tener varias variables que se llamen igual, con distintos ámbitos. (aunque no como variables de clase ambas, claro)


Un saludo.



Silverfox

Hola...

Vamos a ver...

Código: Text

1.     public class Shadowing
2.     {
3.            
4.                private int x;
5.  
6.                public static void main(String[] args)
7.                {
8.                        
9.                           x = 6
10.                          
11.                           int x;// variable repetida
12.                           x = 5; // no existe error
13.                           System.out.println("x = " +x);
14.                 }
15.      }
16.  

Tu código no está enmascarando nada, supongo que lo habrás escrito de memoria. De hecho, tiene un error por el que no puede ni siquiera ser compilado. (Supongo que lo habrás escrito de memoria, pero la variable Shadowing.x no existe en el main y, de existir, ni siquiera se tendría acceso a ella, porque la definiste como privada. Cuestión de visibilidad).

Pero bueno, se ve bastante bien el ejemplo de enmascaramiento que querías mostrar.

Ciertamente, en tu aplicación existe ese efecto colateral (porque no es un error, en realidad, todo está bien). Por cierto... ¿para qué comparas en el evento con la fuente del mismo? ¿No es más fácil añadir un ActionListener a cada botón por separado, o es que se requiere lo que estás haciendo aquí?

Código: Text

1.  public class A
2.  {
3.  
4.     private String nombre;
5.     private String apellido;
6.  
7.     public A()
8.     {
9.  
10.         nombre = new String();
11.         apellido = new String();
12.     }
13.  
14.    public A(String nombre, String apellido)
15.    {
16.  
17.        this();
18.        this.nombre = nombre;
19.        this.apellido = apellido;
20.    }
21.  
22. }
23.  

Aquí estás generando 2 veces las variables de String... new String() genera una cadena vacía, y luego la estás sustituyendo por una constante, en el constructor con parámetros.
Naturalmente, son 2 objetos que tienen localizaciones de memoria diferentes, pero no veo en qué se diferencia este código de uno mío un poco más arriba en esta misma discusión.

Lo de equals lo comprendo, sé que compara referencias en la memoria.

No entendiste del todo:

Como todos habreis podido observar, el == siempre compara referencias en memoria de las variables, lo que significa que a==b significa, no que a y b sean dos objetos iguales, sino que son el mismo (como ya dije antes).

Por contra, el método equals() funciona de forma un poco diferente:
Object.equals(), JButton.equals() y otros, sí comparan referencias a memoria, porque es el comportamiento por defecto de equals(). Sin embargo, otras (como String, Integer y otras), comparan contenidos.
Por si a alguien le interesa saber cuáles sí y cuales no, echad un vistazo al interfaz Comparable. Lo habitual es que, si una clase implementa este interfaz, también tenga sobreescrito el método equals, según las especificaciones del API de Java (1.4.2 y 1.5.0, según he comprobado)



Un saludo.




Silverfox