##
RECTANGULOS

Los rectángulos, al igual que los óvalos, se definen por un punto de inicio de coordenadas `x` e `y` y el `ancho` y el `alto` de la caja que circunscribirá a la figura.

Para dibujar un rectángulo en pantalla, basta con llamar al método drawRect() indicando la posición en que deseamos colocar la esquina superior-izquierda del rectángulo y su ancho y alto. Por ejemplo, el código siguiente, Rect1.java, pinta un rectángulo alrededor del applet que lo contiene:

    import java.awt.*;
    import java.applet.Applet;

    public class Rect1 extends Applet {
        int ancho,alto;

        public void init() {
            Dimension d = size();    // devuelve el tamaño del applet
            ancho = d.width;
            alto = d.height;

            repaint();
            }

        public void paint( Graphics g ) {
            g.drawRect( 0,0,ancho-1,alto-1 );
            }
        }

En este caso hemos tenido que utilizar `ancho-1` y `alto-1`, para que fuese visible todo el rectángulo y no solamente la mitad, por causa de la referencia de coordenadas que utiliza Java con respecto a la pantalla.

El método drawRect() pinta un rectángulo abierto, si queremos un rectángulo relleno, tendremos que invocar al método fillRect(), que tiene idéntica sintaxis. El código siguiente, Rect2.java, pinta un rectángulo relleno en el centro del applet que lo contiene:

    import java.awt.*;
    import java.applet.Applet;

    public class Rect2 extends Applet {
        int apAncho;
        int apAlto;
        int x,y,ancho,alto;

        public void init() {
            Dimension d = size();
            apAncho = d.width;
            apAlto = d.height;
            ancho = apAncho/3;
            alto = apAlto/3;
            x = (apAncho - ancho)/2;
            y = (apAlto - alto)/2;

            repaint();
            }

        public void paint( Graphics g ) {
            g.drawRect( 0,0,apAncho-1,apAlto-1 );
            g.fillRect( x,y,ancho-1,alto-1 );
            }
        }

Si queremos pintar un montón de rectángulos en posiciones y de tamaños aleatorios, al estilo de Mondrian, también podemos hacerlo. Para ello utilizaremos el método Math.random() de la clase Math. Este método devuelve un doble entre 0.0 y 1.0. El método aleatorio() sería:

    private int aleatorio( int rango ) {
        double retornoMath;

        retornoMath = Math.random();
        return( (int)( retornoMath * rango ) );
        }

Este método fuerza a que el resultado sea un entero en el rango que nosotros indiquemos. El casting o moldeo se realiza de double a int. El casting en Java es mucho más seguro que en C u otros lenguajes que permiten castings arbitrarios. En Java solamente se pueden realizar castings que tengan sentido, por ejemplo entre un float y un int; y no podrían realizarse un casting, por ejemplo entre un int y un String.

Vamos también a pintar los rectángulos en diferentes colores, utilizando el método setColor() de la clase Graphics. El AWT predefine suficientes colores, con lo cual, además de pintar un rectángulo aleatorio, lo mostraremos en un color aleatorio. En el código, Rect3.java, que mostramos, se pinta un rectángulo con tamaño, posición y color aleatorios:

    import java.awt.*;
    import java.applet.Applet;

    public class Rect3 extends Applet {
        int apAncho,apAlto;
        int x,y,ancho,alto;
        Color color;

        public void init() {
            Dimension d = size();
            apAncho = d.width;
            apAlto = d.height;
            x = aleatorio( apAncho );
            y = aleatorio( apAlto );
            ancho = aleatorio( apAncho - x );
            alto = aleatorio( apAlto - y );
            color = new Color(
                aleatorio(255),aleatorio(255),aleatorio(255) );

            repaint();
            }

        public void paint( Graphics g ) {
            g.setColor( color );
            g.drawRect( 0,0,apAncho-1,apAlto-1 );
            g.fillRect( x,y,ancho-1,alto-1 );
            }

        private int aleatorio( int rango ) {
            double retornoMath;

            retornoMath = Math.random();
            return( (int)( retornoMath * rango ) );
            }
        }

Si se carga repetidas veces el applet, aparecerán diferentes rectángulos, con distintos colores y en distintas posiciones, así que vamos a automatizar ese proceso y a complicar del todo el ejemplo, permitiendo que se pinten multitud de rectángulos coloreados. Debido a que cada uno de los rectángulos va a ser diferente, tendremos que mover los cálculos de posición, tamaño y color de cada rectángulo al método paint(). Además, vamos a permitir especificar en el fichero HTML que lance el applet, el número de rectángulos que se van a dibujar. Para ello fijaremos un número por defecto y en caso de que se incluya el número de rectángulos como parámetro de la invocación al applet, utilizaremos este último. He aquí el código, Rect4.java, que realiza todo esto:

    import java.awt.*;
    import java.applet.Applet;

    public class Rect4 extends Applet {
        int apAncho,apAlto;
        int x,y,ancho,alto;
        Color color;
        int numRect = 100;

        public void init() {
            Dimension d = size();
            apAncho = d.width;
            apAlto = d.height;

            String s = getParameter( "Numero" );
            if( s != null )
                numRect = Integer.valueOf( s ).intValue();

            repaint();
            }

        public void paint( Graphics g ) {
            g.setColor( Color.black );
            g.drawRect( 0,0,apAncho-1,apAlto-1 );

            for( int i=0; i < numRect; i++ )
                {
                x = aleatorio( apAncho );
                y = aleatorio( apAlto );
                ancho = aleatorio( apAncho - x );
                alto = aleatorio( apAlto - y );
                color = new Color( aleatorio(255),aleatorio(255),
                    aleatorio(255) );

                g.setColor( color );
                g.fillRect( x,y,ancho-1,alto-1 );
                }
            }

        private int aleatorio( int rango ) {
            double retornoMath;

            retornoMath = Math.random();
            return( (int)( retornoMath * rango ) );
            }
        }

Los rectángulos redondeados necesitan dos parámetros adicionales, con respecto al método habitual, para controlar el arco con que se redondearán las esquinas del rectángulo. El método que pinta rectángulos tridimensionales todavía necesitan un parámetro más que indica si el rectángulo estará sobresaliendo o hundiéndose en la pantalla. En el applet siguiente, FigRectangulo.java, podemos ver y manipular los valores que pueden tomar estos métodos:

> Tu navegador no entiende la marca <APPLET>. La imagen siguiente es la reproducción de la apariencia del applet en pantalla:

|  | ##### [Anterior] [Indice] [Siguiente]