La Clase Complejo

Como la practica hace al maestro, y la teoria aburre, que mejor que practicar un poco para entender mejor algunos conceptos.

Creamos un nuevo proyecto en Netbeans, llamlo como quieras, yo le puse jcomplejo (si, se que no es muy original). Ahora crea una nueva clase, llamala Complejo.java, escribe todo lo que ves aqui abajo. Compila presionando (F9) para asegurarte de que no tienes fallas.

clic para ampliar(+)

Podemos hacer algunos comentarios...
Primero: no hay include aquí, ya que la única biblioteca que usamos es java.lang y se incluye automáticamente.

Segundo: la clase es public final, lo que implica que cualquier clase en éste u otros paquetes puede utilizarla, pero ninguna clase puede heredarla (o sea que es una clase estéril...).

Hagamos un resumen de los atributos y métodos de la clase:

// atributos:
private float x;
private float y;
Siendo privados, no podemos acceder a ellos desde el exterior. Como además la clase es final, no hay forma de acceder a x e y. Además, al no ser static, cada instancia de la clase tendrá su propio x e y.

// constructores:
public Complejo()
public Complejo(float rx, float iy)

 

La clase tiene dos constructores, que se diferencian por su "firma" (signature), o sea por la cantidad y tipo de parámetros. El primero nos sirve para crear un objeto de tipo Complejo y valor indefinido (aunque en realidad el método lo inicializa en cero); con el segundo, podemos definir el valor al crearlo.

// métodos:
public final float Norma()
public final float Norma(Complejo c)
public final Complejo Conjugado()
public final Complejo Conjugado(Complejo c)

Estos métodos también son duales; cuando los usamos sin parámetros devuelven la norma o el conjugado del objeto individual (instancia):

v = miComplejo.Norma(); // por ejemplo

otroComplejo = miComplejo.Conjugado();

Con parámetros, en cambio, devuelven la norma o el conjugado del parámetro:

v = unComplejo.Norma(miComplejo);

otroComplejo = unComplejo.Conjugado(miComplejo);

Notar que lo siguiente es inválido:

otroComplejo = Complejo.Norma(miComplejo); // NO SE PUEDE!
...porque el método no es static, por lo tanto debe llamarse para una instancia en particular (en este caso, unComplejo).

// obligatorios (son abstractos en Number):
public final double doubleValue()
public final float floatValue()
public final int intValue()
public final long longValue()

Estos métodos es obligatorio definirlos, ya que en la clase madre Number son métodos abstractos, o sea que debemos implementarlos aquí.
Como todos los métodos de esta clase son final, o sea que no puede ser redefinido. No es importante en realidad puesto que la clase no puede tener descendientes...

public final String toString()

Este método nos sirve para representar el complejo como una cadena de caracteres, de la forma x+iy.

// Operaciones matemáticas
public static final Complejo Suma(Complejo c1, Complejo c2)
public static final Complejo Resta(Complejo c1, Complejo c2)
public static final Complejo Producto(Complejo c1, Complejo c2)
public static final Complejo DivEscalar(Complejo c, float f)
public static final Complejo Cociente(Complejo c1, Complejo c2)

Aquí definimos varias operaciones matemáticas. Notar que se han definido como static, o sea que los métodos son únicos independientemente de las instancias. Esto permite que los podamos ejecutar sobre una instancia o directamente sobre la clase:

miComplejo = unComplejo.Suma(comp1,comp2); // vale
miComplejo = Complejo.Suma(comp1,comp2); // TAMBIEN VALE!

Ahora implementaremos codigo para ver cómo podemos usar algunos de estos métodos, en el clase main, escribe esto:

Para ejecutar el programa, presiona F6

Hay varias cosas para notar: por ejemplo, que podemos declarar las variables a la vez que las creamos:

Complejo c1 = new Complejo(5,-2);

c1 y c2 son dos objetos (instancias) de la clase Complejo.

Notar también que no hace falta poner para imprimir:
System.out.println(c1.toString().......);
ya que println automáticamente usa el método toString() de la clase para imprimir. Basta con poner c1, como en el programa, aunque c1.toString() también es válido.

También se ve el uso de los métodos static, accediéndolos directamente por la clase, en:

System.out.println("Suma : "+Complejo.Suma(c1,c2));

Y tampoco aquí usamos toString(), aunque no está mal si se usa Complejo.Suma(c1,c2).toString().

Analicemos un poco ahora cómo implementamos los métodos de la clase Complejo.

public final int intValue() {
return (int)Norma();
}

Ya que no podemos convertir así nomás un complejo en un entero, para implementar estos métodos hemos elegido usar como valor de retorno la norma del complejo. En este caso, y dado que el método Norma() devuelve un float, usamos typecasting, es decir, lo convertimos en entero precediéndolo con (int).

public final String toString() {
if (y<0)
return x+"-i"+(-y);
else
return x+"+i"+y;
}

Aquí representamos el complejo en forma de cadena de caracteres. Hemos usado el if para representar adecuadamente el signo de la parte imaginaria. Noten también la asombrosa ayuda que nos brinda Java, al convertir automáticamente las variables x e y a String para la concatenación (mediante el signo "+")-

public static final Complejo Cociente(Complejo c1, Complejo c2) {
float x = c1.x*c2.x+c1.y*c2.y;
float y = -c1.x*c2.y+c1.y*c2.x;
float n = c2.x*c2.x+c2.y*c2.y;
Complejo r = new Complejo(x,y);
return DivEscalar(r,n);
}

Aquí tengan en cuenta que las variables x e y, definidas como float, no tienen nada que ver con las variables (atributos) de la clase que están definidas al principio de la misma, sino que son variables locales al método.
Podemos usar return DivEscalar(r,n), ya que DivEscalar es un método propio de la clase; no hace falta poner Complejo.DivEscalar.
Qué pasa con r, el new Complejo(x,y) que creamos? Nada; cuando un objeto no se usa más, el "recogedor de basura" de Java lo elimina automáticamente (tarde o temprano) de la memoria.

public final float Norma(Complejo c) {
return (float)Math.sqrt(c.x*c.x+c.y*c.y);
}

Aquí estamos usando otra clase, Math, que nos permite realizar varias operaciones matemáticas.