Java partiendo de Cero - La clase Complejo

grabar como Complejo.java
compilar con "javac Complejo.java"
public final class Complejo extends Number {



}

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:


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.


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.


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).



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.


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!

Por ejemplo, la siguiente aplicación nos muestra cómo podemos usar algunos de estos métodos:

Archivo: Ejemplo5.java
Compilar con: javac Ejemplo5.java
Ejecutar con: java Ejemplo5
import java.io.*;

public class Ejemplo5 {

public static void main(String args[]) {
Complejo c1 = new Complejo(4,-3);
System.out.println(c1+"\tNorma="+c1.Norma());
Complejo c2 = new Complejo(-2,5);
System.out.println(c2+"\tNorma="+c2.Norma()+"\n");

System.out.println("("+c1+")/4 :"+Complejo.DivEscalar(c1,4));
System.out.println("Suma : "+Complejo.Suma(c1,c2));
System.out.println("Resta : "+Complejo.Resta(c1,c2).toString());
System.out.println("Multip: "+Complejo.Producto(c1,c2).toString());
System.out.println("Divis : "+Complejo.Cociente(c1,c2).toString());
}
}

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

Complejo c1 = new Complejo(4,-3);

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().