Clase Circulo - II

La sentencia 4 (public static final double pi=3. 14159265358979323846,-) define también una variable static. pero contiene una palabra nueva: final. Una variable final tiene como característica el que su valor 110 puede ser modificado, o lo que es lo mismo, es una constante. Es muy lógico definir el número n como constante, y también es razonable que sea una constante static de la clase Circulo, de forma que sea compartida por todos los métodos y objetos que se creen. La sentencia 5 (public double x, y, r,-) define las variables miembro ele objeto, que son las coordenadas del centro y el radio del círculo.

La sentencia 6-9 define el constructor general de la clase Circulo. E11 este caso tiene una peculiaridad y es que el nombre de los argumentos (x, y, /•) coincide con el nombre de las variables miembro. Esto es un problema, porque como se verá más adelante los argumentos de un método son variables locales que sólo son visibles dentro del bloque {...} del método, que se destruyen al salir del bloque y que ocultan otras variables de ámbito más general que tengan esos mismos nombres. E11 otras palabras, si en el código del constructor se utilizan las variables (x, j. /•) se está haciendo referencia a los argumentos del método y 110 a las variables miembro. La sentencia 7 indica cómo se resuelve este problema. Para cualquier método no static de una clase, la palabra this es una referencia al objeto -el argumento implícito- sobre el que se está aplicando el método. De esta forma, this.x se refiere a la variable miembro, mientras que .v es el argumento del constructor.

Las sentencias 10-12 representan otros tres constructores de la clase (métodos sobrecargados), que se diferencian en el número y tipo de argumentos. Los tres tienen en común el realizar su papel llamando al constructor general previamente definido, al que se liace referencia con la palabra this (en este caso el significado de this no es exactamente el del argumento implícito). Al constructor de la sentencia 10 sólo se le pasa el radio, con lo cual construye un círculo con ese radio centrado en el origen de coordenadas. Al constructor de la sentencia 11 se le pasa otro objeto de la clase Circulo. del cual saca una copia. El constructor de la sentencia 12 es un constructor por defecto, al que no se le pasa ningún argumento, que crea un círculo de radio unidad centrado en el origen. 

Las sentencias 13 y 14 definen los métodos perimetro() y areaQ. declarados como abstract en la clase Geometría, de modo adecuado para los círculos.

Las sentencias 16-18 definen elMayorQ. que es 1111 método de objeto para comparar círculos.

Uno de los círculos le llega como argumento implícito y el otro como argumento explícito. En la sentencia 17 se ve cómo al radio del argumento implícito se accede en la forma this.r (se podría acceder también simplemente con r. pues no hay ninguna variable local que la oculte), y al del argumento explícito como c.r. donde c es el nombre del objeto pasado como argumento. La sentencia return devuelve una referencia al objeto cuyo radio sea mayor. Cuando éste es el argumento implícito se devuelve this.

Las sentencias 20-22 presentan la definición de otro método elMayorf). que en este caso es un método de clase (definido como static). y por tanto 110 tiene argumento implícito. Los dos objetos a comparar se deben pasar como argumentos explícitos, lo que hace el código muy fácil de entender. Es importante considerar que en ambos casos lo que se devuelve como valor de retomo 110 es el objeto que constituye el mayor círculo, sino una referencia (un nombre, por decirlo de otra forma). 

Clase Circulo - I

A continuación se presenta la definición de la clase Circulo. también derivada de Geometría. y que resulta bastante similar en muchos aspectos a la clase Rectángulo. Por eso. en este caso las explicaciones serán un poco más breves, excepto cuando aparezcan cosas nuevas.

1.      // fichero Circulo.java

2.     public class Circulo extends Geometria {

3.         static int numCirculos = 0;

4.         public static final double PI=3.14159265358979323846;

5.         public double x, y, r;

6.         public Circulo(double x, double y, double r) {

7.            this.x=x; this.y=y; this.r=r;

8.            numCirculos++;

9.         }

10.        public Circulo(double r) { this(0.0, 0.0, r); }

11.        public Circulo(Circulo c) { this(c.x, c.y, c.r); }

12.        public CirculoO { this(0.0, 0.0, 1.0); }

13.        public double perimetroO { return 2.0 * PI * r; }

14.        public double area() { return PI * r * r; }

15.        // método de objeto para comparar círculos

16.   public Circulo elMayor{Circulo c) {

17.      if (this.r>=c.r) return this; else return c;

18.   }

19.   // método de clase para comparar círculos

20.   public static Circulo elMayor(Circulo c, Circulo d) {

21.      if (c.r>=d.r) return c; else return d;

22.   }

23. } // fin de la clase Circulo

La sentencia 3 (static int numcircuios = o,-) define una variable static o de clase análoga a la de la clase Rectángulo. En este caso no se ha definido como prívate. Cuando no se especifican permisos de acceso {public. prívate o protected) se supone la opción por defecto, que es package. Con esta opción la variable o método correspondiente puede ser utilizada por todas las clases del package y sólo por ellas. Como en este ejemplo no se ha definido ningún package. se utiliza el package por defecto que es el directorio donde están definidas las clases. Así pues, la variable mnnCirculos podrá ser utilizada sólo por las clases que estén en el mismo directorio que Circulo.

Clase Rectángulo - II

La sentencia 5 (protected double xi, yi, x2, y2;) define cuatro nuevas variables miembro, que representan las coordenadas de dos vértices opuestos del rectángulo. Las cuatro son de tipo clouble. El declararlas como protected indica que sólo esta clase, las clases que deriven de ella y las clases del propio package tienen permiso para utilizarlas. 

Las sentencias 7-14 definen los constructores de la clase. Los constructores son unos métodos 0 funciones miembro muy importantes. Como se puede ver. no tienen valor de retorno (ni siquiera 1 vid) y su nombre coincide con el de la dase. Los constructores son un ejemplo típico de métodos sobrecargados (overloaded): en este caso hay dos constructores, el segundo de los cuales 110 tiene ningún argumento, por lo que se llama constructor por defecto. Las sentencias 7-13 definen el constructor general. Este constructor recibe cuatro argumentos con cuatro valores que asigna a las cuatro variables miembro. La sentencia 12 incrementa en una unidad (esto es lo que hace el operador ++, típico de C y C++. de los que Java lo ha heredado) el número de rectángulos creados hasta el momento.

La sentencia 14 (public Rectángulo o { this < o, o, í.o, í.o); }) define un segundo constructor, que por 110 necesitar argumentos es 1111 constructor por defecto. ¿Qué se puede hacer cuando hay que crear un rectángulo sin ningún dato? Pues algo realmente sencillo: en este caso se ha optado por crear un rectángulo de lado unidad cuyo primer vértice coincide con el origen de coordenadas. Obsérvese que este constructor en realidad no tiene código para inicializar las variables miembro, limitándose a llamar al constructor general previamente creado, utilizando para ello la palabra this seguida del valor por defecto de los argumentos. Ya se verá que la palabra this tiene otro uso aún más importante en Java.

Las sentencias 16 (public double perimetroO { return 2.0 * ((xl-x2) + (yl-y2)) ; }) y 17 (public double area <) { return (xl-x2) * (yl-y2); }) COlltieiieil la definición de los métodos miembro perimetrof) y area(). La declaración coincide con la de la clase Geometría, pero aquí va seguida del cuerpo del método entre llaves {...}. Las fórmulas utilizadas son las propias de un rectángulo.

Clase Rectángulo - I

Según el diagrama de clases de la Figura 1.2 la clase Rectángulo deriva de Geometría. Esto se indica en la sentencia 2 con la palabra extends (en negrita en el listado de la clase).

1.     // fichero Rectángulo.java

2.     public class Rectángulo extends Geometría {

3.         // definición de variables miembro de la claes

4.        private static int numRectangulos = 0;

5.        protected double xl, yl, x2, y2;

6.         // constructores de la clase

7.         public Rectángulo(double plx, double ply, double p2x, double p2y) {

8.            xl = plx;

9.            x2 = p2x;

10.           yl = ply;

11.           y2 = p2y;

12.           numRectangulos++;

13.        }

14.       public Rectángulo(){ this(0, 0, 1.0, 1.0); }

15.        // definición de métodos

16.       public double perímetro() { return 2.0 * ((xl-x2)+(yl-y2)); }

17.       public double area() { return (xl-x2)*(yl-y2); }

18.     } // fin de la clase Rectángulo

La clase Rectángulo define cinco variables miembro. En la sentencia 4 (prívate static int numRectanguios = o,-) se define una variable miembro static. Las variables miembro static se caracterizan por ser propias de la clase y 110 de cada objeto. E11 efecto, la variable mimRectangulos pretende llevar cuenta en todo momento del número de objetos de esta clase que se lian creado. No tiene sentido ni sería práctico en absoluto que cada objeto tuviera su propia copia de esta variable, teniendo además que acmalizarla cada vez que se crea o se destruye un nuevo rectángulo. De la variable numRectángulos, que en la sentencia 4 se inicializa a cero, se mantiene una única copia para toda la clase. Además esta variable es privado {prívate), lo cual quiere decir que sólo las funciones miembro de esta clase tienen permiso para utilizarla.

Clase Geometría - II

E11 este ejemplo sólo se van a dibujar rectángulos y círculos. De la clase Geometría van a derivar las clases Rectángulo y Circulo. Estas clases tienen en común que son "geometrías", y como tales tendrán ciertas características comunes como un perímetro y un área. Un aspecto importante a considerar es que no va a haber nunca objetos de la clase Geometría, es decir "geometrías a secas". Una clase de la que 110 va a haber objetos es una clase abstracta, y como tal puede ser declarada. A continuación se muestra el fichero Geometria.jara en el que se define dicha clase:

1.   // fichero Geometría.java

2.   public abstract cíass Geometría {

3.       // clase abstracta que no puede tener objetos

4.      public abstract double perímetro();

5.      public abstract double area();

6.   }

La clase Geometría se declara como public para permitir que sea utilizada por cualquier otra clase, y como abstract para indicar que 110 se permite crear objetos de esta clase. Es característico de las clases tener variables y funciones miembro. La clase Geometría 110 define ninguna variable miembro, pero sí declara dos métodos: perímetroQ y areaQ. Ambos métodos se declaran como public para que puedan ser llamados por otras clases y como abstract para indicar que 110 se da ninguna definición -es decir ningún código- para ellos. Interesa entender la diferencia entre declaración (la primera línea o header del método) y definición (todo el código del método, incluyendo la primera línea). Se indica también que su valor de retorno -el resultado- va a ser un double y que 110 tienen argumentos (obtendrán sus datos a partir del objeto que se les pase como argumento implícito). Es completamente lógico que 110 se definan en esta clase los métodos perimetro() y areaQ: la forma de calcular un perímetro o un área es completamente distinta en un rectángulo y en un círculo, y por tanto estos métodos habrá que definirlos en las clases Rectángulo y Circulo. E11 la clase Geometría lo único que se puede decir es cómo serán dichos métodos, es decir su nombre, el número y tipo de sus argumentos y el tipo de su valor de retomo.

Clase Geometría - I

En este apartado se describe la clase más importante de esta aplicación. Es la más importante 110 en el sentido de lo que hac|e. sino en el de que las demás clases "derivan" de ella, o por decirlo de otra forma, se apoyan o cuelgan de ella. La Figura 1.2 muestra la jerarquía de clases utilizada en este ejemplo. La clase Geometría es la base de la jerarquía. En realidad 110 es la base, pues en Java la clase base es siempre la clase Object. Siempre que 110 se diga explícitamente que una clase deriva de otra, deriva implícitamente de la clase Object (definida en el package java.lang). De las clases Rectángulo y Circulo derivan respectivamente las clases RectanguloGrafico y Circulo Gráfico.  En ambos casos está por en medio un elemento un poco especial donde aparece la palabra Dibujable. E11 términos de Java. Dibujable es una interface. Más adelante se verá qué es una interface.

Se suele utilizar la nomenclatura de super-clase y sub-clase para referirse a la clase padre o hija de una clase determinada. Así Geometría es una super-clase de Circulo, mientras que CirculoGrafico es una sub-clase.

UN EJEMPLO COMPLETO COMENTADO - VI

En la sentencia 28 (?ar.eiD:.bu₃© ir.i_Panei = new PaneiDibujoívi;) se crea un objeto de la clase PanelDibujo, definida en el Apartado 1.3.8. Por decirlo de alguna manera, los objetos de dicha clase son paneles, esto es superficies en las que se puede dibujar. Al constructor de PanelDibujo se le pasa como argumento el vector v con las referencias a los objetos a dibujar. La sentencia 29 (v encana.add(mipanel) _;) añade o incluye el panel (la superficie de dibujo) en la ventana; la sentencia 30 (ventana. secsise ísoo, 4ooj ,) establece el tamaño de la ventana enpixels: finalmente, la sentencia 31 (v encana.sesVisible(truel; ) hace visible la ventana creada.

¿Cómo se consigue que se dibuje todo esto? La clave está en la serie de órdenes que se han ido dando al computador. La clase PanelDibujo deriva de la clase Container a través de Panel, y redefme el método paintf) de Container. En este método, explicado en el Apartado 1.3.8. se realiza el dibujo de los objetos gráficos creados. El usuario no tiene que preocuparse de llamar al método paint(). pues se llama de modo automático cada vez que el sistema operativo tiene alguna razón para ello (por ejemplo cuando se crea la ventana, cuando se mueve, cuando se minimiza o maximiza. cuando aparece después de haber estado oculta, etc.). La Figura 1.1 muestra la ventana resultante de la ejecución del programa main() de la clase Ejemplol. Para entender más a fondo este resultado es necesario considerar detenidamente las clases definidas en los apartados que siguen