Modo gráfico en Java: Creando un lienzo propio

En este artículo aprenderás a utilizar el modo gráfico en Java, creando un lienzo propio. También veremos cómo dibujar líneas en el lienzo utilizando ciclos for.

Aprende a usar el modo gráfico en Java para dibujar líneas

Para comenzar a utilizar el modo gráfico en Java se utilizarán dos conjuntos de componentes gráficos de Java: AWT  y Swing.

Swing

Swing es un conjunto de clases y otros recursos para construir GUI’s (Interfaces de Usuario Gráficas). Es independiente de la plataforma (sistema operativo) sobre la que se ejecute. Con Swing podemos crear ventajas, contenedores, botones, etiquetas, campos de texto, listas desplegables, etc. La mayoría de sus clases comienzan con una J (por ejemplo, JFrame).

AWT

Significa Abstract Window Toolkit. Es dependiente de la plataforma, lo que quiere decir que la imagen que muestre un componente gráfico dependerá del sistema operativo en el que se ejecute.

Método g.drawLine

El método g.drawLine en Java imprime una línea, desde una coordenada x,y hasta una segunda coordenada x2,y2.

Es decir, si deseamos una línea vertical en la columna 100 de la pantalla, la instrucción sería:

g.drawLine(100,0,100,500), que nos imprime una línea vertical (los dos 100 representan la misma columna en x1 y x2) que va desde la línea 0 hasta la línea 500.

Dibujar líneas en modo gráfico en Java usando ciclos For

Deseamos dibujar la siguiente figura usando solo líneas y ciclos for.

Usando el modo gráfico en Java para dibujar líneas

Procedimiento

Paso 1. Crear un proyecto en Java.

Paso 2. Cree una clase dentro del proyecto, llamada Dibujo.

Paso 3. Escriba las bibliotecas de clases que necesitará

Paso 4. Defina la herencia

Paso 5. Redefina el método paintComponent.

Paso 5. Cree una ventana que utilice la clase Dibujo en el método main.

Código completo

Código de la clase Dibujo

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class Dibujo extends JPanel {
    public void paintComponent (Graphics g){
        super.paintComponent(g);
        int ancho, alto;
        int x2,y2, x1, y1;
        
        ancho = getWidth();
        alto = getHeight();
        
        
        g.setColor(Color.GRAY);
        x1=0;
        for (y2=alto/2; y2>=0; y2-=10){
            g.drawLine(x1, alto/2, ancho/2, y2);
            x1+=10;
        }
        x1=0;
        for (y2=alto/2; y2<=alto; y2+=10){
            g.drawLine(x1, alto/2, ancho/2, y2);
            x1+=10;
        }
        x2=ancho/2;
        for (y1=0; y1<=alto/2; y1+=10){
            g.drawLine(ancho/2, y1, x2, alto/2);
            x2+=10;
        }
        x2=ancho/2;
        for (y1=alto; y1>=alto/2; y1-=10){
            g.drawLine(ancho/2, y1, x2, alto/2);
            x2+=10;
        }
        
    }
}

Código con el método principal

import javax.swing.JFrame;

public class Grafico1 {


    public static void main(String[] args) {
        Dibujo lienzo = new Dibujo();
        JFrame ventana = new JFrame();
        ventana.add(lienzo);
        ventana.setSize(500,500);
        ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        ventana.setVisible(true);
    }
    
}

Explicación

Variables utilizadas

• ancho, alto; Para determinar las dimensiones de la ventana
• x1, y1, x2, y2;  Se utilizarán cuando los valores de x o y no sean fijos.

Código del Procedimiento

• ancho = getWidth();
• alto = getHeight();

Asigna los valores de ancho y alto de la ventana a las variables.

• g.setColor(Color.GRAY);  Las líneas a imprimir serán grises

A continuación comienza el primer cuadrante de lineas. Las variables que se modifican son x1 y y2.

x1=0;

for (y2=alto/2; y2>=0; y2-=10){

g.drawLine(x1, alto/2, ancho/2, y2);

x1+=10;

}

Explicación del código del método principal

• Dibujo lienzo = new Dibujo();  Se crea un objeto de clase Dibujo
• JFrame ventana = new JFrame(); Frame es una clase para crear una ventana donde ubicaremos los componentes gráficos
• ventana.add(lienzo); A esa ventana le añadimos el objeto lienzo que es de clase Dibujo
• ventana.setSize(500,500); Indicamos un tamaño inicial.
• ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Es la operación que va a realizar cuando se cierre el Frame (la ventana): Terminar con el programa.
• ventana.setVisible(true); Los Frames no se visualizan automáticamente, para volverlos visibles, se debe llamar a este método.

Bibliografía

Joyanes y Zahonero ( 2011). Programación en Java. Algoritmos, programación orientada a objetos e interfaz gráfica de usuario. Ed. Mc. Gran Hill.

Tu comentario

opiniones