1. Curso de Java
Cápsulas Formativas
Modo gráfico. Dibujando en Java
Texto y fuentes.
Ahora que podemos crear una ventana, vamos a empezar por escribir un texto en
ella. Crearemos una clase MiFrame que herede de JFrame. Para ello, además de
los métodos anteriores, también tendremos que sobrescribir el método
paint(Graphics g) que se hereda de java.awt.Component y allí especificaremos
lo que queremos dibujar, o escribir.
El método paint(Graphics g) es el encargado de pintar los componentes en la
pantalla, de tal manera que será el método que se invoque cada vez que nuestra
aplicación necesite ser redibujada. Por ejemplo, cuando pongamos otra ventana
encima y luego la quitemos, el trozo destruido de nuestra aplicación (el trozo
ocultado por la otra ventana) necesitará ser redibujado. De esto se encarga
siempre dicho método.
La particularidad de este método es que no lo llamaremos directamente mediante
una invocación corriente, sino que lo haremos a través de una llamada al método
repaint(), que será el encargado de hacer los cálculos pertinentes para reparar la
zona de pantalla que ha sido destruida y hacer así que sólo se redibuje lo
necesario; ganando así en velocidad de refresco y evitando efectos de parpadeo.
La manera de escribir texto (y dibujar) consiste en manipular el parámetro de tipo
Graphics que recibe. Por ejemplo
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class MiFrame extends JFrame {
public MiFrame() {
super("¡Hola mundo con ventanas!");
setBackground(Color.orange);
setSize(300,300);
setVisible(true);
}
public void paint(Graphics g) {
g.drawString("Tenemos el mejor profe de Java",40,160);
}
public static void main(String args[]) {
MiFrame mf = new MiFrame();
mf.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent evt ){
System.exit( 0 );}
});
}
}
Jesús Cáceres Tello Pág. 1 - 7

2. Curso de Java
Cápsulas Formativas
Ejecución de la clase MiFrame
El método drawString(...) tiene tres parámetros, el String, y las coordenadas x e
y. Estas coordenadas se consideran a partir de la esquina superior izquierda. Cada
vez que se tiene que refrescar la pantalla, Java llama al método update() (de la
clase Component), que borra la pantalla y luego éste llama a paint(), que es donde
definimos usualmente lo que deseamos dibujar.
Cuando escribimos con la llamada a drawString(...), la fuente usada es la que esté
activa. Podemos definir una fuente con el tipo de letra, el estilo y el tamaño.
Luego asignaremos esta fuente al entorno gráfico.
Font f = new Font("Times Roman", Font.BOLD + Font.ITALIC, 12);
g.setFont(f);
Los estilos permitidos, definidos como constantes estáticas de la clase Font, son:
• Font.PLAIN,
• Font.BOLD,
• Font.ITALIC
• Font.BOLD + Font.ITALIC
Una vez hemos definido la fuente que utilizamos, podemos recurrir a la clase
FontMetrics para averiguar el tamaño que ocuparán las letras en nuestra ventana
(en pixels).
FontMetrics fm = g.getFontMetrics(f);
Los métodos que encontraremos en la clase FontMetrics:
Jesús Cáceres Tello Pág. 2 - 7

3. Curso de Java
Cápsulas Formativas
• int getAscent (): distancia baseline basta la altura de las mayúsculas.
• int getDescent (): distancia baseline hasta profundidad de los caracteres
que descienden.
• int getLeading(): espacio mínimo entre líneas.
• int qetHeighc(): distancia entre dos líneas (descent + leading + ascent).
• int getMaxAscent(): ascent máximo.
• int getMaxDescent(): descent máximo.
• int stringWidth(String st): anchura de un string dado.
Resultado de seleccionar un tipo de letra para el objeto Graphics
Líneas.
Las líneas en Java se dibujan con el método drawLine(...). En el ejemplo anterior
sólo habría que añadir una instrucción al método paint().
g.drawLine(5, 10,30,50);
Los parámetros son cuatro valores enteros (int) que corresponden respectivamente
a las coordenadas x e y iniciales y finales.
Rectángulos.
También existe un método específico para los rectángulos (hay que recordar que el
cuadrado es un caso particular del rectángulo).
g.drawRect (x,y, anchura,altura);
Las variables x e y determinan la esquina superior izquierda y las otras dos la
anchura y altura del rectángulo. Los cuatro valores son de tipo int. Hay otros
métodos que dibujan un rectángulo con las esquinas redondeadas, rectángulo en
tres dimensiones y para que el rectángulo aparezca relleno.
• void drawRoundRect(int x, int y, int width, int height, int arcwidtri, int
arcHeight)
• void draw3DRect(int x, int y, int width, int heiqht, boolean raised)
• void fillRect(int x, int y, int width, int heiqht)
• void fillRoundRect(int x, int y, int widch, int heiqht, int arcwidth, int
arcHeight)
void fill3DRect(int x, int y, int width, int height, boolean raised)
Jesús Cáceres Tello Pág. 3 - 7

4. Curso de Java
Cápsulas Formativas
Polígonos.
Existe una función drawPolygon(...), pero no es tan sencilla de usar como los
rectángulos ya que el parámetro que recibe es un polígono o los arrays con las
coordenadas.
• void drawPolygon(Polygon P).
• void drawPolygon(int[] xCoords, int [] yCoords, int n)
xCoords son las coordenadas x de los vértices, yCoords son las coordenadas y de
los vértices y n es el número de vértices.
Se dibujarán líneas de tal manera que queden con los puntos (xCoords[i],
yCords[i]) de punto incial y de punto final (xCoords[i+1], yCords[i+1]).
El polígono es un conjunto de segmentos que se cierra automáticamente. Con esto
quiero decir que para dibujar un triángulo, por ejemplo, sólo hay que dar las
coordenadas de los tres vértices y el sistema ya sabe que tiene que interpretar el
último par de coordenadas y el primer par de coordenadas dados como el inicio y el
fin respectivamente del segmento que cierra el polígono.
Para definir un polígono usamos el constructor y luego añadimos los puntos uno a
uno.
Polygon p = new Polygon();
p.addPoint(x,y)
También encontramos una función fillPolygon(...) con el mismo comportamiento
que las que hemos visto para los rectángulos.
Óvalos.
Existe un método para dibujar elipses (y circunferencias), aunque Java las
denomina óvalos.
void drawOval(int x, int y, int anchura, int altura)
Los cuatro parámetros del óvalo son las que delimitan el rectángulo que
circunscribe la elipse. También existe el método fillOval(...).
Arcos.
La última forma geométrica que nos permite dibujar Java son los arcos.
Jesús Cáceres Tello Pág. 4 - 7

5. Curso de Java
Cápsulas Formativas
void drawArc(int x, int y, int anchura, int altura, int anguloInicial,int
arcoAngulo)
Los cuatro primeros valores definen el rectángulo como en los óvalos, los dos
últimos son el ángulo inicial y el ángulo del arco (relativo al ángulo inicial). El
rectángulo es donde se encuadra el arco, el parámetro de anguloInicial indica
posición desde qué posición se empieza a dibujar el arco y el arcoAngulo indica la
porción de arco que hay que dibujar.
Por ejemplo, para dibujar una semicircunferencia, el rectángulo deberá ser un
cuadrado, a continuación fijar el ángulo inicial y luego decirle que dibuje 180
grados.
Cuando usamos el método fillArc(...), la figura rellenada es el sector de la elipse
delimitado por el arco y las líneas imaginarias que irían desde el centro de la elipse
hasta los extremos del arco.
Colores.
El texto que escribimos o las formas y figuras que dibujamos aparecen en el color
que haya definido. Este color lo podemos modificar a nuestro gusto gracias al
método setColor(...) de la clase Graphics, que recibe un parámetro de tipo Color.
Hay unas constantes en la clase Color que tienen definidos los valores black , blue,
cyan, darkGray, gray, green, lightcray, magenta, orange, pink, red, white y yellow.
Si estos colores no nos bastan, podemos crear nuestro propio color a partir de sus
valores RGB.
Color o = new Color(r,g,b)
Podemos cambiar el color de escritura de nuestra variable de gráficos y el color de
fondo de nuestro contenedor (en nuestro ejemplo el Frame).
g.setColor(Color.red)
setBackground(Color.white);
Jesús Cáceres Tello Pág. 5 - 7

6. Curso de Java
Cápsulas Formativas
import javax.swing.*;
import java.awt.*;
public class MiFrame extends JFrame {
public MiFrame() {
super("¡Hola mundo con ventanas!");
setSize(300,300);
setVisible(true);
}
public void paint(Graphics g) {
// Cambiamos el color del fondo del framse
getContentPane().setBackground(Color.white);
// Dibujamos texto
Font f = new Font("Arial", Font.BOLD + Font.ITALIC, 14);
g.setFont(f);
g.drawString("Tenemos los mejores profes de Java",24,160);
// Dibujamos líneas
g.setColor(Color.red);
g.drawLine(24,135,265,135);
g.setColor(Color.blue);
g.drawLine(24,175,265,175);
// Dibujamos un rectángulo
g.setColor(Color.black);
g.drawRect(12,119,265,70);
// Dibujamos un triángulo (polígono)
int[] xCoords = new int[4];
int[] yCoords = new int[4];
xCoords[0]=150;
yCoords[0]=35;
xCoords[1]=100;
yCoords[1]=100;
xCoords[2]=200;
yCoords[2]=100;
g.setColor(Color.green);
g.drawPolygon(xCoords,yCoords,3);
// Dibujamos óvalos
g.setColor(Color.orange);
g.fillOval(107,200,85,85);
g.setColor(Color.black);
g.drawOval(120,220,20,10);
g.drawOval(158,220,20,10);
// Dibujamos un arco
g.drawArc(128,235,40,35,190,160);
}
public static void main(String args[]) {
MiFrame mf = new MiFrame();
mf.repaint();
mf.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent evt ){
System.exit( 0 );}
});
}
}
Jesús Cáceres Tello Pág. 6 - 7

7. Curso de Java
Cápsulas Formativas
El código anterior tiene un error, encuéntralo y subsánalo para que la salida sea tan
espectacular con la que se muestra a continuación.
Ejecución del código anterior
Jesús Cáceres Tello Pág. 7 - 7