Dibujando figuras en Java (awt).

Buen día,


En un tutorial de Java encontré un ejemplo muy bueno para aprender lo básico que se utiliza en la programación en Java: herencia, clases, interfaces, clases abstractas, polimorfismo, etc.


posteare este ejemplo que yo mismo probe en netbeans para que les sirva de apoyo a los que lo quieran.


Siguiendo los consejos de la programación en capas vamos a crear tres paquetes:

• abstractClasses
• classes
• interfaces

Lo primero que haremos es crear una clase abstracta, a la cual denominaremos Geometria, la cual dará vida a todas las demás clases. Esta clase será la única en el paquete abstractClasses.

package abstractClasses;

//@author ronald

//fichero Geometria.java

public abstract class Geometria {

//clase abstracta que no puede tener objetos

    

   public abstract double perimetro();

   public abstract double area();

}

Ahora, en el paquete interfaces crearemos una interfaz la cual denominaremos Dibujable.

package interfaces;

//@author ronald

//fichero Dibujable.java

import java.awt.Graphics;

public interface Dibujable {

    public void setPosicion(double x, double y);

    public void dibujar(Graphics dw);

}

Luego de tener nuestra clase abstracta y nuestra interfaz procederemos a crear algunas clases que contendrán nuestras variables.

En el paquete classes, crearemos una clase denominada Circulo;

package classes;

//Fichero Circulo.java 

//@author ronald

import abstractClasses.Geometria;

public class Circulo extends Geometria {

    static int numCirculos = 0;

    public static final double PI = 3.14159265358979323846;

    public double x, y, r;

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

        this.x = x;

        this.y = y;

        this.r = r;

        numCirculos++;

    }

    public Circulo(double r) {

        this(0.0, 0.0, r);

    }

    public Circulo() {

        this(0.0, 0.0, 1.0);

    }

    public double perimetro() {

        return 2.0 * PI * r * r;

    }

    public double area() {

        return PI * r * r;

    }

    //metodo de objeto para comparar circulos

    public Circulo elMayor(Circulo c) {

        if (this.r >= c.r) {

            return this;

        } else {

            return c;

        }

    }

    

    //metodo de clase para comparar circulos

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

        if (c.r >= d.r) {

            return d;

        } else {

            return d;

        }

    }

}//fin de la clase Circulo

La siguiente clase que crearemos será denominada Rectangulo y estará dentro del paquete classes también.

package classes;

//@author ronald

import abstractClasses.Geometria;

public class Rectangulo extends Geometria{

    //definicion de variables de la clase

    private static int numRectangulos = 0;

    protected double x1, y1, x2, y2;

    

    //constructores de la clase

    public Rectangulo(double p1x, double p1y, double p2x, double p2y){

        x1=p1x;

        x2=p2x;

        y1=p1y;

        y2=p2y;

        

        numRectangulos++;

        }

        public Rectangulo(){

            this(0,0, 1.0, 1.0);

             }

            //definicion de metodos

            public double perimetro(){

                return 2.0 * ((x1-x2)+(y1-y2));

            }

            public double area(){

                return (x1-x2)*(y1-y2);           

        }

    }

Ahora crearemos una clase denominada PanelDibujo, la cual contendra informacion referente a la creacion de las figuras (dibujo de las mismas).

package classes;

//Fichero PanelDibujo.java 

//@author ronald

import java.awt.*;

import java.util.ArrayList;

import java.util.Iterator;

import interfaces.*;

public class PanelDibujo extends Panel {

    //variable miembro

    private ArrayList v;

    

    //constructor

    public PanelDibujo(ArrayList va){

        super ( new FlowLayout());

        this.v = va;

    }

    

    //redefinicion del metodo paint()

    public void paint(Graphics g){

        Dibujable dib;

        Iterator it;

        it = v.iterator();

        while(it.hasNext()){

            dib = (Dibujable)it.next();

            dib.dibujar(g);

        }

    }

}//Fin de la clase PanelDibujo

Crearemos la clase VentanaCerrable, la cual implementará los métodos que utilizaremos para manipular la ventana, hereda de la clase Frame e implementa la interfaz WindowListener.

package classes;

//Fichero VentanaCerrable.java 

//@author ronald

import java.awt.*;

import java.awt.event.*;

public class VentanaCerrable extends Frame implements WindowListener {

    //constructores

    public VentanaCerrable(){

        super();

    }

    public VentanaCerrable(String title){

        super(title);

        setSize(500,500);

        addWindowListener(this);

    }

    

    //metodos de la interface WindowListener

    public void windowActivated(WindowEvent e){

        ;

    }

    public void windowClosed(WindowEvent e){

        ;

    }

    public void windowClosing(WindowEvent e){

        System.exit(0);

    }

    public void windowDeactivated(WindowEvent e){

        ;

    }

    public void windowDeiconified(WindowEvent e){

        ;

    }

    public void windowIconified(WindowEvent e){

        ;

    }

    public void windowOpened(WindowEvent e){

        ;

    }

    

}//Fin de clase VentanaCerrable

Luego de haber creado estas clases pasaremos a utilizar clases que si nos ayudaran a dibujar las figuras, crearemos dos clases que heredaran de Circulo, Rectangulo e implementarán la interfaz Dibujable.

Comenzamos creando la clase RectanguloGrafico, la cual permitirá dibujar Rectangulos.

package classes;

//Fichero RectanguloGrafico.java 

//@author ronald

import java.awt.Graphics;

import java.awt.Color;

import classes.*;

import interfaces.*;

public class RectanguloGrafico extends Rectangulo implements Dibujable {

   //nueva variable miembro

    Color color;

    

    //constructor

    public RectanguloGrafico(double x1, double y1, double x2, double y2, Color unColor){

        //llamada al constructor de Rectangulo

        super(x1, y1, x2, y2);

        this.color = unColor; //en este caso this es opcional

    }

    

    //metodos de la interface Dibujable

    public void dibujar(Graphics dw){

       dw.setColor(color); 

       dw.drawRect((int)x1, (int)y1, (int)(x2-x1), (int)(y2-y1));

    }

    

    public void setPosicion(double x, double y){

            ;//metodo vacio, pero necesario de definir

    }

        

}//fin de la clase RectanguloGrafico

Crearemos la clase CirculoGrafico, la cual nos permitira dibujar circulos.

package classes;

//Fichero CirculoGrafico.java 

//@author ronald

import java.awt.Graphics;

import java.awt.Color;

import interfaces.*;

import abstractClasses.*;

public class CirculoGrafico extends Circulo implements Dibujable {

    //Se heredan las variables y metodos de la clase Circulo

    

    Color color;

    //constructor

    public CirculoGrafico(double x, double y, double r, Color unColor) {

        //llamada al constructor de Circulo

        super(x, y, r);

        this.color = unColor;

    }

    //metodos de la interface Dibujable

    public void dibujar(Graphics dw) {

        dw.setColor(color);

        dw.drawOval((int) (x - r), (int) (y - r), (int) (2 * r), (int) (2 * r));

    }

    public void setPosicion(double x, double y){

        ;

    }

}//fin de la clase CirculoGrafico

Y bueno Cramos entonces nuestra clase principal, la cual correra la aplicación y nos mostrará el entrono gráfico de la misma, le llamaremos Ejemplo1. Esta clase posee el metodo main la que inicia la aplicación.

package classes;

 //@author ronald

//fichero Ejemplo1.java

import java.util.ArrayList;

import java.awt.*;

class Ejemplo1 {

  public static void main(String arg[]) throws InterruptedException{

      System.out.println("Comienza main()...");

      Circulo c = new Circulo(2.0, 2.0, 4.0);

      System.out.println("Radio = " + c.r + " unidades.");

      System.out.println("Centro = (" + c.x + "," + c.y + ") unidades.");

      Circulo c1 = new Circulo(1.0, 1.0, 2.0);

      Circulo c2 = new Circulo(0.0, 0.0, 3.0);

      c = c1.elMayor(c2);

      System.out.println("Elmayor radio es " +c.r +".");

      c= new Circulo(); // c.r = 0.0

      c= Circulo.elMayor(c1, c2);

      System.out.println("El mayor radio es " + c.r +".");

      

      VentanaCerrable ventana = 

              new VentanaCerrable("Ventana abierta al mundo...");

      ArrayList v = new ArrayList();

      

      CirculoGrafico cg1 = new CirculoGrafico(200, 200, 100, Color.red);

      CirculoGrafico cg2 = new CirculoGrafico(300, 200, 100, Color.blue);

      RectanguloGrafico rg = new RectanguloGrafico(50, 50, 450, 350, Color.green);

      

      v.add(cg1);

      v.add(cg2);

      v.add(rg);

      

      PanelDibujo mipanel = new PanelDibujo(v);

      ventana.add(mipanel);

      ventana.setSize(500, 400);

      ventana.setVisible(true);

      System.out.println("Termina main()...");

  }  //fin de main()

}//fin de class Ejemplo1()

Si nosotros quisieramos agregar nuevas figuras, un triangulo, un hexagono, un cuadrado, lo que sea que se os ocurra nastaria con hacer una clase con el nombre de la figura y crear la clase dibujable. Esto es lo que nos facilitan las clases abstractas y las interfaces.

Explicare mas sobre este tema. La corrida del programa queda de la siguiente manera: