Dibujar objetos de colores

Con lo aprendido en la clase pasada he creado un pequeño programa de dibujo, esto gracias a la buena sugerencia de Elisa de hacer un programa parecido a Paint, donde pudiéramos crear lineas, rectángulos y elipses. Este programa me tomo tiempo terminarlo y perfeccionarlo para que no provocara errores en su ejecución y que además fuera agradable al usuario.

En esta imagen se puede apreciar la ventana resultante del programa en ejecución.

En el programa es posible dibujar lineas, rectángulos y elipses de tamaños definidos por el usuario mediante el uso del mouse. Además es posible seleccionar el color con que se desea dibujar el objeto.

En la parte superior de la ventana del programa se muestran cuatro botones con diferentes funciones.
El botón Predeterminado restaura los valores originales en el programa. Los valores provocan que el dibujo siguiente sea una línea y el color se establece como negro.
El botón Deshacer elimina el último dibujo realizado en el panel.
El botón Borrar limpia toda la pantalla, es decir elimina todos los objetos creados y además restablece los valores predeterminados.
El botón Salir simplemente cierra la ventana.

En la siguiente imagen se pueden observar los mismos objetos de la imagen anterior pero algunos ya se han eliminado con el botón deshacer y luego se crearon nuevos objetos.

Aquí algunas partes sobresalientes del código.

En la clase auxiliar agregue dos variables más, "COLOR" para guardar el color con que se dibujó el objeto y "SELECT" que guarda un número entero que indica si el objeto fue una línea(1), un rectángulo(2) o un elipse(3).

class Objeto {
 protected double m1, m2, m3, m4;
 protected Color COLOR;
 protected int SELECT;

 public Objeto(double V1, double V2, double V3, double V4,
       Color GUARDADO, int seleccion) {
  this.m1 = V1;
  this.m2 = V2;
  this.m3 = V3;
  this.m4 = V4;
  this.COLOR = GUARDADO;
  this.SELECT = seleccion;
 }
}

Para el botón Deshacer implemente algo sencillo. Sabemos que los valores de cada objeto se están guardando en un arreglo, así que para eliminar el último elemento de este arreglo primero obtuve la cantidad de elementos totales, y como los elementos en el arreglo empiezan desde 0, 1, 2... le reste 1 para obtener la posición del último elemento del arreglo y ya obtenida la posición basta con eliminarla. La condición es para que no provoque errores en el terminal, ya que si no hay elementos en el arreglo y se le pica a deshacer, este no podrá eliminar nada.

if (cmd.equals("DESHACER")) {
   int ultimo = this.objetos.size()-1;
   if (ultimo>=0) {
    this.objetos.remove(ultimo);
   }
   this.repaint();
   System.out.println(this.objetos.size() + " objetos");
  }

Esta fue una parte un tanto complicada e incluso un poco revuelta a primera vista. Lo que hago con esta sección del código es dibujar en la pantalla los objetos ya guardados y el que se esta dibujando actualmente.
El iterador va accediendo a los valores guardados en el arreglo. Uno de los valores es el del color y otro muy importante es el de la selección del objeto.
Algunas de las condiciones lo que hacen es establecer correctamente las posiciones X y Y, así como del ANCHO y ALTURA de los rectángulos y elipses, y que el programa las dibuje correctamente.
En pocas palabras lo que logre con esto fue que después de la selección del objeto rectángulo o elipse, independientemente de donde diera clic inicial y clic final para establecer las medidas del objeto, este se dibujara bien en cualquier posición.

public void paint(Graphics gr) {
  super.paint(gr);
  Graphics2D g = (Graphics2D)gr;

  // Dimensiones actuales
  int ancho = super.getWidth();
  int altura = super.getHeight();

  g.setStroke(Dibujar.GROS);
  Iterator< Objeto > i = this.objetos.iterator();

  // Mientras haya mas elementos en el iterador
  while (i.hasNext()) {
   Objeto l = i.next();
   g.setColor(l.COLOR);
   double Ex = l.m1*ancho;
   double Ey = l.m2*altura;
   double Ea = l.m3*ancho;
   double Eb = l.m4*altura;

   if (l.SELECT == 1) {
    g.draw(new Line2D.Double(l.m1*ancho,
        l.m2*altura,
        l.m3*ancho,
        l.m4*altura));
   }
   if (l.SELECT == 2) {
    if (Ex < Ea && Ey < Eb) {
     g.draw(new Rectangle2D.Double(l.m1*ancho,
        l.m2*altura,
        l.m3*ancho-l.m1*ancho,
        l.m4*altura-l.m2*altura));
    }
    if (Ex > Ea && Ey > Eb) {
     g.draw(new Rectangle2D.Double(l.m3*ancho,
        l.m4*altura,
        l.m1*ancho-l.m3*ancho,
        l.m2*altura-l.m4*altura));
    }
    if (Ex < Ea && Ey > Eb) {
     g.draw(new Rectangle2D.Double(l.m1*ancho,
        l.m4*altura,
        l.m3*ancho-l.m1*ancho,
        l.m2*altura-l.m4*altura));
    }
    if (Ex > Ea && Ey < Eb) {
     g.draw(new Rectangle2D.Double(l.m3*ancho,
        l.m2*altura,
        l.m1*ancho-l.m3*ancho,
        l.m4*altura-l.m2*altura));
    }
   }
   if (l.SELECT == 3) {
    if (Ex < Ea && Ey < Eb) {
     g.draw(new Ellipse2D.Double(l.m1*ancho,
        l.m2*altura,
        l.m3*ancho-l.m1*ancho,
        l.m4*altura-l.m2*altura));
    }
    if (Ex > Ea && Ey > Eb) {
     g.draw(new Ellipse2D.Double(l.m3*ancho,
        l.m4*altura,
        l.m1*ancho-l.m3*ancho,
        l.m2*altura-l.m4*altura));
    }
    if (Ex < Ea && Ey > Eb) {
     g.draw(new Ellipse2D.Double(l.m1*ancho,
        l.m4*altura,
        l.m3*ancho-l.m1*ancho,
        l.m2*altura-l.m4*altura));
    }
    if (Ex > Ea && Ey < Eb) {
     g.draw(new Ellipse2D.Double(l.m3*ancho,
        l.m2*altura,
        l.m1*ancho-l.m3*ancho,
        l.m4*altura-l.m2*altura));
    }
   }
  }

  if (this.dibujando) {
   double Wx = startX*ancho;
   double Wy = startY*altura;
   double Wa = ahoraX*ancho;
   double Wb = ahoraY*altura;

   // Linea actual
   if (seleccion == 1) {
    g.setColor(this.GUARDADO);
    g.draw(new Line2D.Double(this.startX*ancho,
        this.startY*altura,
        this.ahoraX*ancho,
        this.ahoraY*altura));
   }
   // Rectangulo actual
   if (seleccion == 2) {
    if (Wx < Wa && Wy < Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Rectangle2D.Double(this.startX*ancho,
        this.startY*altura,
        this.ahoraX*ancho-startX*ancho,
        this.ahoraY*altura-startY*altura));
    }
    if (Wx > Wa && Wy > Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Rectangle2D.Double(this.ahoraX*ancho,
        this.ahoraY*altura,
        this.startX*ancho-ahoraX*ancho,
        this.startY*altura-ahoraY*altura));
    }
    if (Wx < Wa && Wy > Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Rectangle2D.Double(this.startX*ancho,
        this.ahoraY*altura,
        this.ahoraX*ancho-startX*ancho,
        this.startY*altura-ahoraY*altura));
    }
    if (Wx > Wa && Wy < Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Rectangle2D.Double(this.ahoraX*ancho,
        this.startY*altura,
        this.startX*ancho-ahoraX*ancho,
        this.ahoraY*altura-startY*altura));
    }
   }
   // Elipse actual
   if (seleccion == 3) {
    if (Wx < Wa && Wy < Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Ellipse2D.Double(this.startX*ancho,
        this.startY*altura,
        this.ahoraX*ancho-startX*ancho,
        this.ahoraY*altura-startY*altura));
    }
    if (Wx > Wa && Wy > Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Ellipse2D.Double(this.ahoraX*ancho,
        this.ahoraY*altura,
        this.startX*ancho-ahoraX*ancho,
        this.startY*altura-ahoraY*altura));
    }
    if (Wx < Wa && Wy > Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Ellipse2D.Double(this.startX*ancho,
        this.ahoraY*altura,
        this.ahoraX*ancho-startX*ancho,
        this.startY*altura-ahoraY*altura));
    }
    if (Wx > Wa && Wy < Wb) {
     g.setColor(this.GUARDADO);
     g.draw(new Ellipse2D.Double(this.ahoraX*ancho,
        this.startY*altura,
        this.startX*ancho-ahoraX*ancho,
        this.ahoraY*altura-startY*altura));
    }
   }
  }
  return;
 }

Descarga desde:
MediaFire: Dibujar.java

Juego con el teclado

Ahora en este programa lo que intente hacer fue un juego, este consiste en un círculo que debe ser introducido en un cuadrado, cada vez que el círculo este dentro del cuadrado se obtendrá un punto. No logre que hiciera lo que yo quería, pero espero lograr terminarlo bien en estos días.

Las teclas de dirección mueven el círculo dentro del panel.
Logre que el círculo cuando se encuentra el final de la ventana no desaparezca, este aparece de nuevo en el otro lado, dando una sensación de que se transporta de una orilla a la otra.

Los botones que se muestran en la parte inferior de la ventana hacen diferentes funciones:
El botón Reset, mueve el circulo a su posición inicial.
El botón Salir, cierra la ventana.
Los botones Color Café y Color Azul, cambian el color del panel donde se encuentran los objetos.

Aquí algunas imágenes del programa:

Aquí les dejo el código:

// Librerias usadas en el programa
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import java.awt.Color;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.*;

// Aqui comienza nuestra clase
public class Juego extends JPanel implements KeyListener,
                                  ActionListener {

 public void actionPerformed(ActionEvent e) {
  String cmd = e.getActionCommand();
  if (cmd.equals("RESET")) {
   System.out.println("Reset");
   this.reset();
      this.repaint();
   return;
  }
  if (cmd.equals("SALIR")) {
   System.out.println("Hasta pronto!");
   System.exit(1);
  }
  if (cmd.equals("COLOR1")) {
   System.out.println("Cambio de color");
   miPanel.setBackground(this.colorArena);
   return;
  }
  if (cmd.equals("COLOR2")) {
   System.out.println("Cambio de color");
   miPanel.setBackground(this.colorMar);
   return;
  }
    }

    private double x;
    private double y;
    private double ancho;
    private double altura;
    private static final double MOVER = 0.02;

    private JPanel miPanel;
    private Color colorMar, colorArena;

    private void dibujaObjeto(Graphics2D g, int ancho,
    int altura) {
  g.setColor(Color.ORANGE);
  g.fill(new Ellipse2D.Double(this.x*ancho, this.y*altura,
                   this.ancho*ancho, this.altura*altura));
  return;
    }

    public void paint(Graphics g) {
  super.paint(g);
  this.dibujaCuadro((Graphics2D)g, super.getWidth(),
                                   super.getHeight());
  this.dibujaObjeto((Graphics2D)g, super.getWidth(),
                                   super.getHeight());
  return;
    }

    // Dibujar un cuadro
 private double a;
 private double b;
 private double w;
    private double h;

    private void dibujaCuadro(Graphics2D r, int w, int h) {
  r.setColor(Color.BLACK);
  r.fill(new Rectangle2D.Double(this.a*w, this.b*h,
                                this.w*w, this.h*h));
  return;
    }

    private void medidas() {
  this.a = Math.random()*0.9;
  this.b = Math.random()*0.9;
  this.w = 0.1;
  this.h = 0.14;
  return;
 }
    // Termina intento

 private void reset() {
  this.x = 0.0;
  this.y = 0.0;
  this.ancho = 0.07;
  this.altura = 0.1;
  return;
    }

    public Juego(JPanel p){
  this.miPanel = p;
  this.colorMar = new Color(12, 90, 100);
  this.colorArena = new Color(100, 70, 10);
 }

    public Juego() {
  super();
  this.reset();
  this.medidas();
  System.out.println("Ahora mueve el objeto");
    }

 public void keyPressed(KeyEvent e) {
  int c = e.getKeyCode();
  switch (c) {
   case KeyEvent.VK_DOWN:
    this.y += Juego.MOVER;
    break;
   case KeyEvent.VK_UP:
    this.y -= Juego.MOVER;
    break;
   case KeyEvent.VK_LEFT:
    this.x -= Juego.MOVER;
    break;
   case KeyEvent.VK_RIGHT:
    this.x += Juego.MOVER;
    break;
   default:
    break;
  }

  if (this.x < -0.05) {
   this.x = 0.98;
  } else if (this.x > 0.98) {
   this.x = -0.05;
  }

  if (this.y < -0.08) {
   this.y = 0.98;
  } else if (this.y > 0.98) {
   this.y = -0.08;
  }

  if (this.x == this.a && this.y == this.b){
   System.out.println("Ganaste un punto!");
  }

  super.repaint();
  return;
    }

    public void keyReleased(KeyEvent e) {
  return;
    }

    public void keyTyped(KeyEvent e) {
  return;
    }

 // Metodo principal
    public static void main(String[] args) {

  System.out.println("Bienvenido al Juego");
  JFrame f = new JFrame();
  f.setSize(600, 500);
  f.setLocation(200, 80);
  f.setTitle("Ventana de Juego");
  f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  Juego t = new Juego();
  t.setBackground(Color.WHITE);
  Juego yo = new Juego(t);

  // Creamos paneles para agrupar elementos
  JPanel pArriba = new JPanel();
  JPanel pAbajo = new JPanel();
  JPanel pIzquierda = new JPanel();
  JPanel pDerecha = new JPanel();
  JPanel p = new JPanel();
  p.setFocusable(true);
  p.addKeyListener(t);

  // Administradores de acomodo a cada panel
  pAbajo.setLayout(new GridLayout(1, 2));
  pIzquierda.setLayout(new GridBagLayout());
  pDerecha.setLayout(new GridBagLayout());
  p.setLayout(new BorderLayout());

  // Asignar un color de fondo a cada panel
  pAbajo.setBackground(Color.GRAY);
  pIzquierda.setBackground(Color.CYAN);
  pDerecha.setBackground(Color.BLUE);
  p.setBackground(Color.GRAY);

  GridBagConstraints con = new GridBagConstraints();

  con.gridx = 1;
  con.gridy = 1;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bReset = new JButton("Reset");
  bReset.addActionListener(t);
  bReset.addKeyListener(t);
  bReset.setActionCommand("RESET");
  pIzquierda.add(bReset, con);

  con.gridx = 1;
  con.gridy = 4;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton salir = new JButton("Salir");
  salir.addActionListener(t);
  salir.setActionCommand("SALIR");
  pIzquierda.add(salir, con);

  // Botones para cambio de color
  con.gridx = 1;
  con.gridy = 1;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bColorOne = new JButton("Color Cafe");
  bColorOne.addActionListener(yo);
  bColorOne.addKeyListener(t);
  bColorOne.setActionCommand("COLOR1");
  pDerecha.add(bColorOne, con);

  con.gridx = 1;
  con.gridy = 4;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bColorTwo = new JButton("Color Azul");
  bColorTwo.addActionListener(yo);
  bColorTwo.addKeyListener(t);
  bColorTwo.setActionCommand("COLOR2");
  pDerecha.add(bColorTwo, con);

  // Acomodar los paneles
  p.add(t);
  p.add(pAbajo, BorderLayout.SOUTH);
  pAbajo.add(pIzquierda);
  pAbajo.add(pDerecha);

  // Colocar el panel en la ventana
  f.setContentPane(p);
  f.setVisible(true);
  return;
 }
}

Ventana con botones

El programa que realice es sencillo. Como se puede ver en las siguientes imágenes incluí botones que cambian de color el panel de la parte superior, y otros dos botones más, uno que deja la ventana tal y como estaba al principio y el otro es el botón de salir.

Imágenes del programa:

Este es el código:

// Librerias usadas en el programa
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.GridLayout;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.Color;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

// Aqui comienza nuestra clase
public class Colores implements ActionListener {

 public void actionPerformed(ActionEvent e) {
  String cmd = e.getActionCommand();
  System.out.print("*");
  if (cmd.equals("PRE")) {
   this.miPanel.setBackground(Color.WHITE);
   this.miTexto.setText("Original");
   return;
  }
  if (cmd.equals("SAL")) {
   System.exit(1);
  }
  if (cmd.equals("CIAN")) {
   this.miPanel.setBackground(Color.CYAN);
   this.miTexto.setText("Cian");
   return;
  }
  if (cmd.equals("ROJO")) {
   this.miPanel.setBackground(Color.RED);
   this.miTexto.setText("Rojo");
   return;
  }
  if (cmd.equals("AMARILLO")) {
   this.miPanel.setBackground(Color.YELLOW);
   this.miTexto.setText("Amarillo");
   return;
  }
  if (cmd.equals("NARANJA")) {
   this.miPanel.setBackground(Color.ORANGE);
   this.miTexto.setText("Naranja");
   return;
  }
    }

    // Atributos de la clase Colores
 private JPanel miPanel;
 private JLabel miTexto;

 // Constructor de Colores
 public Colores(JPanel p, JLabel t) {
  this.miPanel = p;
  this.miTexto = t;
    }

 // Metodo principal
    public static void main(String[] args) {

  System.out.println("Bienvenido al programa");
  JFrame f = new JFrame();
  f.setSize(600, 400);
  f.setLocation(300, 100);
  f.setTitle("Ventana de Esteban");
  f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  // Creamos paneles para agrupar elementos
  JPanel pArriba = new JPanel();
  JPanel pAbajo = new JPanel();
  JPanel pIzquierda = new JPanel();
  JPanel pDerecha = new JPanel();
  JPanel p = new JPanel();

  // Administradores de acomodo a cada panel
  pArriba.setLayout(new GridBagLayout());
  pAbajo.setLayout(new GridLayout(1, 2));
  pIzquierda.setLayout(new GridBagLayout());
  pDerecha.setLayout(new GridBagLayout());
  p.setLayout(new GridLayout(2, 1));

  // Asignar un color de fondo a cada panel
  pArriba.setBackground(Color.WHITE);
  pAbajo.setBackground(Color.WHITE);
  pIzquierda.setBackground(Color.GREEN);
  pDerecha.setBackground(Color.BLUE);
  p.setBackground(Color.GRAY);

  // Manejo del GridBagLayout
  GridBagConstraints con = new GridBagConstraints();

  JLabel aviso = new JLabel();
  Colores yo = new Colores(pArriba, aviso);

  con.gridx = 1;
  con.gridy = 2;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton boton = new JButton("Predeterminado");
  boton.addActionListener(yo);
  boton.setActionCommand("PRE");
  pIzquierda.add(boton, con);

  con.gridx = 1;
  con.gridy = 5;
  con.gridwidth = 2;
  con.gridheight = 2;
  pArriba.add(aviso, con);

  con.gridx = 2;
  con.gridy = 5;
  con.gridwidth = 1;
  con.gridheight = 1;
  JButton salir = new JButton("Salir");
  salir.addActionListener(yo);
  salir.setActionCommand("SAL");
  pIzquierda.add(salir, con);

  // Botones de seleccion de color
  con.gridx = 1;
  con.gridy = 1;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bAzul = new JButton("Cian");
  bAzul.addActionListener(yo);
  bAzul.setActionCommand("CIAN");
  pDerecha.add(bAzul, con);

  con.gridx = 1;
  con.gridy = 4;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bRojo = new JButton("Rojo");
  bRojo.addActionListener(yo);
  bRojo.setActionCommand("ROJO");
  pDerecha.add(bRojo, con);

  con.gridx = 1;
  con.gridy = 7;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bAmarillo = new JButton("Amarillo");
  bAmarillo.addActionListener(yo);
  bAmarillo.setActionCommand("AMARILLO");
  pDerecha.add(bAmarillo, con);

  con.gridx = 1;
  con.gridy = 10;
  con.gridwidth = 2;
  con.gridheight = 3;
  JButton bNaranja = new JButton("Naranja");
  bNaranja.addActionListener(yo);
  bNaranja.setActionCommand("NARANJA");
  pDerecha.add(bNaranja, con);

  // Acomodar los paneles creados
  p.add(pArriba);
  p.add(pAbajo);
  pAbajo.add(pIzquierda);
  pAbajo.add(pDerecha);

  // Colocar el panel en la ventana
  f.setContentPane(p);
  f.setVisible(true);
  return;
 }
}