TECNOLOGIA EN TELECOMUNICACIONES
NETBEANS
PROGRAMACION VISUAL
TABLA DE CONTENIDO
Graphics
15
24
30
35
40
45
50
55
NETBEANS
PROGRAMACION VISUAL
Graphics
La clase Graphics:
Casi todas las componentes y contenedores de Swing tienen un mtodo paint(g)
asociado que sirve para dibujarlos en pantalla. Java invoca este mtodo
automticamente cuando tiene que mostrar, de forma estndar, la componente o
contenedor en cuestin (esto es, sus bordes, su ttulo, si lo tiene, etc.)
El mtodo paint(g) se redefine cuando se quiere que estos elementos tengan un
aspecto particular, por ejemplo, cuando se quiere dibujar algo especfico sobre ellos.
El mtodo paint(g) es de la forma
public void paint(Graphics g) {
...
}
Donde g es un objeto de la clase abstracta Graphics. Todo contenedor o componente
que se pueda dibujar en pantalla tiene asociado un objeto g de esta clase, con la
informacin sobre el rea de la pantalla que el
contenedor o la componente cubre. Adems, el objeto g dispone de mtodos para
hacer grficos (dibujar crculos, rectngulos, lneas, etc.)
La clase Graphics se importa de awt:
import java.awt.*;
Cuando el mtodo paint(g) se ejecuta es porque ha sido invocado por otros mtodos,
nunca invocado por
nosotros, y el parmetro que usa corresponde a un objeto de la clase Graphics asociado
al contenedor o
componente que estemos manejando.
Cuando se redefine el mtodo paint(g), siempre se comienza con una invocacin
super.paint(g) al mtodo de la superclase, asegurando as que se dibuja la parte
estndar del contenedor o componente que estemos manejando.
Por ejemplo, vamos a dibujar una cara en un marco. Un marco es un elemento de la
clase JFrame y para dibujar en l procedemos as:
NETBEANS
PROGRAMACION VISUAL
NETBEANS
PROGRAMACION VISUAL
Por ejemplo, para dibujar la cara que pintamos antes, pero sobre un (j)panel en lugar
de sobre un marco, hacemos lo siguiente:
Se declara la clase PanelCara que extiende la clase JPanel, como clase (privada)
de la clase MarcoCara que habamos creado antes
Se redefine el mtodo paintComponent(g) usando las mismas instrucciones que
antes, pero llamando inicialmente a super.paintComponent(g)
public void paintComponent(Graphics g) {
super.paintComponent(g);...}
NETBEANS
PROGRAMACION VISUAL
Dibujar texto
La clase Graphics permite dibujar texto, como alternativa al texto mostrado en los
componentes JLabel, JTextField y JTextArea. El mtodo que permite graficar texto sobre
el JFrame es:
Clase Color
La clase java.awt.Color encapsula colores utilizando el formato RGB (Red, Green, Blue).
Las componentes de cada color primario en el color resultante se expresan con nmeros
enteros entre 0 y 255, siendo 0 la intensidad mnima de ese color y 255 la mxima. En
la clase Color existen constantes para colores predeterminados de uso frecuente: black,
white, green, blue, red, yellow, magenta, cyan, orange, pink, gray, darkGray, lightGray.
NETBEANS
PROGRAMACION VISUAL
Presentacin de imgenes
Java permite incorporar imgenes de tipo GIF y JPEG definidas en ficheros. Se dispone
para ello de la clase java.awt.Image. Para cargar una imagen hay que indicar la
localizacin del archivo y cargarlo mediante el mtodo getImage(). Este mtodo existe
en las clases java.awt.Toolkit.
Entonces, para cargar una imagen hay que comenzar creando un objeto (o una
referencia) Image y llamar al mtodo getImage() (de Toolkit); Una vez cargada la
imagen, hay que representarla, para lo cual se redefine el mtodo paint() para llamar al
mtodo drawImage() de la clase Graphics. Los objetos Graphics pueden mostrar
imgenes a travs del mtodo: drawImage(). Dicho mtodo admite varias formas,
aunque casi siempre hay que incluir el nombre del objeto imagen creado.
Clase Image
Una imagen es un objeto grfico rectangular compuesto por pixels coloreados. Cada
pixel en una imagen describe un color de una particular localizacin de la imagen.
A continuacin, algunos mtodos de la clase Image:
La clase Graphics provee el mtodo drawImage() para dibujar imagenes; este mtodo
admite varias formas:
- drawImage (Image i, int x, int y, ImageObserver o)
- drawImage (Image i,int x,int y,int width,int height,ImageObserver o)
Un ejemplo del metodo paint(Graphics G) para traer una imagen de la carpeta raiz es el
siguiente:
public void paint (Graphics g)
{
super.paint(g);
Toolkit t = Toolkit.getDefaultToolkit ();
Image imagen = t.getImage ("imagen1.jpg");
g.drawImage (imagen, 0, 0, this);
}
NETBEANS
PROGRAMACION VISUAL
3. public abstract void copyArea(int x, int y, int width, int height, int dx, int dy)
Copies an area of the component by a distance specified by dx and dy. From the point
specified by x and y, this method copies downwards and to the right. To copy an area of
NETBEANS
PROGRAMACION VISUAL
the component to the left or upwards, specify a negative value for dx or dy. If a portion
of the source rectangle lies outside the bounds of the component, or is obscured by
another window or component, copyArea will be unable to copy the associated pixels.
The area that is omitted can be refreshed by calling the component's paint method.
Parameters:
x - the x coordinate of the source rectangle.
y - the y coordinate of the source rectangle.
width - the width of the source rectangle.
height - the height of the source rectangle.
dx - the horizontal distance to copy the pixels.
dy - the vertical distance to copy the pixels.
4. public void draw3DRect(int x, int y, int width, int height, boolean raised)
Draws a 3-D highlighted outline of the specified rectangle. The edges of the rectangle
are highlighted so that they appear to be beveled and lit from the upper left corner.
The colors used for the highlighting effect are determined based on the current color.
The resulting rectangle covers an area that is width + 1 pixels wide by height + 1 pixels
tall.
Parameters:
x - the x coordinate of the rectangle to be drawn.
y - the y coordinate of the rectangle to be drawn.
width - the width of the rectangle to be drawn.
height - the height of the rectangle to be drawn.
raised - a boolean that determines whether the rectangle appears to be raised above
the surface or sunk into the surface.
5. public abstract void drawArc(int x, int y, int width, int height, int startAngle, int
arcAngle)
Draws the outline of a circular or elliptical arc covering the specified rectangle.
The resulting arc begins at startAngle and extends for arcAngle degrees, using the
current color. Angles are interpreted such that 0 degrees is at the 3 o'clock position. A
positive value indicates a counter-clockwise rotation while a negative value indicates a
clockwise rotation.
NETBEANS
PROGRAMACION VISUAL
The center of the arc is the center of the rectangle whose origin is (x, y) and whose size
is specified by the width and height arguments.
The resulting arc covers an area width + 1 pixels wide by height + 1 pixels tall.
The angles are specified relative to the non-square extents of the bounding rectangle
such that 45 degrees always falls on the line from the center of the ellipse to the upper
right corner of the bounding rectangle. As a result, if the bounding rectangle is
noticeably longer in one axis than the other, the angles to the start and end of the arc
segment will be skewed farther along the longer axis of the bounds.
Parameters:
x - the x coordinate of the upper-left corner of the arc to be drawn.
y - the y coordinate of the upper-left corner of the arc to be drawn.
width - the width of the arc to be drawn.
height - the height of the arc to be drawn.
startAngle - the beginning angle.
arcAngle - the angular extent of the arc, relative to the start angle.
PROGRAMACION VISUAL
7. public abstract void drawLine(int x1, int y1, int x2, int y2)
Draws a line, using the current color, between the points (x1, y1) and (x2, y2) in this
graphics context's coordinate system.
Parameters:
x1
y1
x2
y2
the
the
the
the
NETBEANS
PROGRAMACION VISUAL
10
11. public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth,
int arcHeight)
Draws an outlined round-cornered rectangle using this graphics context's current color.
The left and right edges of the rectangle are at x and x + width, respectively. The top
and bottom edges of the rectangle are at y and y + height.
Parameters:
x - the x coordinate of the rectangle to be drawn.
y - the y coordinate of the rectangle to be drawn.
width - the width of the rectangle to be drawn.
height - the height of the rectangle to be drawn.
arcWidth - the horizontal diameter of the arc at the four corners.
arcHeight - the vertical diameter of the arc at the four corners.
NETBEANS
PROGRAMACION VISUAL
11
13. public void fill3DRect(int x, int y, int width, int height, boolean raised)
Paints a 3-D highlighted rectangle filled with the current color. The edges of the
rectangle will be highlighted so that it appears as if the edges were beveled and lit from
the upper left corner. The colors used for the highlighting effect will be determined from
the current color.
Parameters:
x - the x coordinate of the rectangle to be filled.
y - the y coordinate of the rectangle to be filled.
width - the width of the rectangle to be filled.
height - the height of the rectangle to be filled.
raised - a boolean value that determines whether the rectangle appears to be raised
above the surface or etched into the surface.
14. public abstract void fillArc(int x, int y, int width, int height, int startAngle, int
arcAngle)
Fills a circular or elliptical arc covering the specified rectangle.
The resulting arc begins at startAngle and extends for arcAngle degrees. Angles are
interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a
counter-clockwise rotation while a negative value indicates a clockwise rotation.
The center of the arc is the center of the rectangle whose origin is (x, y) and whose size
is specified by the width and height arguments.
The resulting arc covers an area width + 1 pixels wide by height + 1 pixels tall.
The angles are specified relative to the non-square extents of the bounding rectangle
such that 45 degrees always falls on the line from the center of the ellipse to the upper
right corner of the bounding rectangle. As a result, if the bounding rectangle is
noticeably longer in one axis than the other, the angles to the start and end of the arc
segment will be skewed farther along the longer axis of the bounds.
Parameters:
x - the x coordinate of the upper-left corner of the arc to be filled.
y - the y coordinate of the upper-left corner of the arc to be filled.
width - the width of the arc to be filled.
height - the height of the arc to be filled.
NETBEANS
PROGRAMACION VISUAL
12
15. public abstract void fillOval(int x, int y, int width, int height)
Fills an oval bounded by the specified rectangle with the current color.
Parameters:
x - the x coordinate of the upper left corner of the oval to be filled.
y - the y coordinate of the upper left corner of the oval to be filled.
width - the width of the oval to be filled.
height - the height of the oval to be filled.
16. public abstract void fillPolygon(int[] xPoints, int[] yPoints, int nPoints)
Fills a closed polygon defined by arrays of x and y coordinates.
This method draws the polygon defined by nPoint line segments, where the first nPoint 1 line segments are line segments from (xPoints[i - 1], yPoints[i - 1]) to
(xPoints[i], yPoints[i]), for 1 i nPoints. The figure is automatically closed by drawing
a line connecting the final point to the first point, if those points are different.
The area inside the polygon is defined using an even-odd fill rule, also known as the
alternating rule.
Parameters:
xPoints - a an array of x coordinates.
yPoints - a an array of y coordinates.
nPoints - a the total number of points.
17. public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int
arcHeight)
Fills the specified rounded corner rectangle with the current color. The left and right
edges of the rectangle are at x and x + width - 1, respectively. The top and bottom
edges of the rectangle are at y and y + height - 1.
Parameters:
NETBEANS
PROGRAMACION VISUAL
13
NETBEANS
PROGRAMACION VISUAL
14
Paso 2:
Crea la siguiente interfaz grfica:
NETBEANS
PROGRAMACION VISUAL
15
Recuerda que para que el JFrame se muestre debes poner la lnea setVisible(true);
dentro del constructor de la clase, despus de la llamada al mtodo initComponents().
Una vez que hayas creado la ventana recuerda agregar la lnea new MainFrame() dentro
del mtodo main() de la clase Main.
Paso 4:
Nuestro programa va a calcular el rea de un anillo, que se calcula mediante restando el
rea del circulo interno del rea del circulo externo. Para poder hacer esto nuestro
programa debe calcular el rea del crculo interno y del crculo externo utilizando el
radio. Como esa operacin es repetitiva vamos a ponerla en un mtodo por separado.
El mtodo va a llamarse calculateArea(), va a recibir el radio (tipo double) y debe
regresar un valor tipo double que representa el rea. En cdigo podramos verlo como el
siguiente mtodo:
Paso 5:
Ahora s, vamos a crear el mtodo actionPerformed() de btnCalculate. En el modo de
diseo haz click derecho sobre el botn y selecciona Events -> Action ->
actionPerformed. Dentro del cdigo debemos obtener los valores de los radios, podemos
utilizar el siguiente cdigo para lograrlo:
NETBEANS
PROGRAMACION VISUAL
16
Paso 6:
Una vez que tengamos los datos debemos validar que el radio interior sea menor o igual
que el radio exterior. Esto podemos lograrlo mediante un if, y slo si son vlidos
debemos de calcular las reas y restarlas. El resultado final vamos a mostrarlo en el
JTextArea de la parte inferior. En cdigo podramos verlo como lo siguiente:
NETBEANS
PROGRAMACION VISUAL
17
NETBEANS
PROGRAMACION VISUAL
18
Paso 8:
Al terminar aparecer un error de que no puede pintar la forma porque no es un
JavaBean. Esto es porque todava no hemos programado cmo debe de pintarse el
JComponent y NetBeans todava no lo puede dibujar. Haz click en source y vete al
cdigo. Pon el cursor en algn lugar en blanco fuera de un mtodo, pero dentro de la
clase y presionar Ctrl+Space para que aparezca el dilogo de autocompletar. Ah debes
escribir paintComponent y se seleccionar la entrada que se ve en la fotografa:
Es muy importante que sea paintComponent (sin la s) y que a la derecha diga override.
Una vez que lo hayas encontrado presiona enter y se construir automticamente el
mtodo paintComponent() que tiene un parmetro de tipo Graphics con el que podemos
dibujar sobre el componente. Presiona Alt+Shift+F para resolver las dependencias
(Graphics todava no estaba incluido en los imports) y dentro de ese mtodo pon el
siguiente cdigo:
La palabra clave this se refiere a este componente. Una vez que creamos la instancia y
lo ponemos en la ventana this.getWidth() debe devolvernos el ancho de ese
NETBEANS
PROGRAMACION VISUAL
19
PROGRAMACION VISUAL
20
Nuestro control ya est dibujando un rectngulo, pero ahora lo que queremos hacer es
que dibuje los anillos interior y exterior. Para poder hacer esto es necesario modificar
RingBean. Primero vamos a crear un par de variables que guarden los valores de los
radios, despus debemos crear un mtodo que reciba los radios que se deben dibujar y
despus manden dibujar utilizando estos datos. Copia el siguiente cdigo dentro de
RingBean:
En este cdigo vamos a ver varias cosas interesantes. Primero que nada fjate que las
variables tienen el modificador private para que otros objetos no puedan acceder a sus
variables ms ntimas. Esto es por algo llamado encapsulacin que vamos a ver mucho
ms a profundiad al tocar el tema de programacin orientada a objetos. Adems es
importante notar que las variables son de tipo int, porque Graphics no puede manejar
los tipos de dato double. En el mtodo setRadius() podemos ver que utilizamos la
palabra clave this para referirnos a la variable del objeto, a diferencia de la variable
pasada como parmetro, esto tambin es un comportamiento que analizaremos ms
detalladamente al ver programacin orientada a objetos. En pocas palabras:
this.innerRadius == innerRadius de la clase
innerRadius == innerRadius el parmetro
Por ltimo podemos ver el mtodo repaint() que le dice al componente que ha sucedido
algo que amerita que vuelva a pintarse. Este mtodo se encarga de revisar qu fue lo
que sucedi y llamar los mtodos adecuados para volver a dibujar el componente.
Una vez que hemos echo esto debemos modificar el mtodo paintComponent() para
que utilice estos valores y dibuje dos crculos en lugar del rectngulo que dibuja
actualmente. Podemos lograr esto mediante el siguiente cdigo:
NETBEANS
PROGRAMACION VISUAL
21
Este mtodo puede parecer un poco complicado. Podemos ver que primero calculamos
el centro del componente (dividiendo el ancho entre dos y el largo entre dos). Una vez
que hemos echo eso vamos a poner el punto inicial en el centro menos el radio (con
esto estamos garantizando que el centro del crculo est a la mitad de la ventana
porque el crculo mide dos veces el radio) y por ltimo estoy poniendo el ancho y alto
como el doble del radio. Podemos verlo grficamente:
Por ltimo slo debemos mandar llamar el mtodo setRadius() dentro del
actionPerformed del botn btnCalculate. Podemos hacerlo de la siguiente manera:
NETBEANS
PROGRAMACION VISUAL
22
NETBEANS
PROGRAMACION VISUAL
23
En esta aplicacin vamos a utilizar Graphics y lo que hemos aprendido de ciclos para
crear estas tres figuras. Primero empecemos con el tablero de ajedrez. Como podemos
ver el tablero de ajedrez es una figura muy sencilla compuesta de 64 cuadros ordenados
en una cuadrcula de 8 x 8.
Vamos a analizar un poco ms a fondo cmo vamos a hacer esto:
NETBEANS
PROGRAMACION VISUAL
24
Nuestro tablero est formado por cuadros de 25 pixeles cada uno. Eso significa que la
esquina superior izquierda (el origen) de el quinto cuadro de la primera fila sera (4 x
25, 0) es decir (100, 0), el sexto cuadro estara en (5 x 25, 0) o (125, 0). Aqui podemos
ver un patrn que es muy improtante porque es la base con la que vamos a crear
nuestro ciclo. Veamos qu sucede para el quinto cuadro de la sexta fila (4 x 25, 5 x 25)
o (100, 125). Como podemos ver todas las posiciones estn en base a ((columna - 1) x
25, (fila - 1) x 25). Para evitar estar restando a las columnas y las filas podemos utilizar
un ndice que empiece de cero en lugar de uno.
Lo siguiente que debemos determinar es cules son los lmites de nuestro ciclo.
Podramos hacer un ciclo que cuente hasta el 64 y que utilice una divisin y su mdulo
para obtener el nmero de fila y columna respectivamente. Podemos verlo con el
siguiente cdigo:
NETBEANS
PROGRAMACION VISUAL
25
Fjate en el if. Lo que estamos haciendo es ver qu color haba en la celda anterior y
pintar la nueva celda con un color diferente. Esto nos sirve para hacer los cuadros
blancos y negros alternados. Ahora compila y corre el programa y vers la siguiente
imagen
Esto sucede porque los cuadros no siempre deben cambiar de color (como lo estamos
haciendo en nuestro programa) sino que al cambiar de fila utilizan el mismo color que
antes (si el ltimo de la fila anterior era negro el primero de la fila actual tambin es
negro). Podemos revisar con un if si estamos cambiando de fila (cuando col es igual a
cero, significa que estamos en una fila nueva). El if puede ser como el siguiente:
NETBEANS
PROGRAMACION VISUAL
26
Vuelve a probar tu programa y ahora deber dibujar el tablero de manera correcta (en
realidad casi correcta, el tablero tiene un cuadrado negro en la esquina inferior derecha
y debera ser blanco, puedes cambiar el color con el que empezamos a pintar para
corregir esto). Como puedes ver, puedes utilizar el mdulo y la divisin como
operaciones complementarias al utilizar ciclos, aunque este enfoque no es muy utilizado.
Ms adelante veremos una manera un poco ms sencilla de lograr esto mismo. Una vez
que hayas probado tu programa contina con el ejercicio del gusano
Aqui hay varias cosas importantes que tomar en cuenta. Primero que nada, las partes
del cuerpo van a estar alternando su posicin vertical entre 0 y 5. Puedes observar que
todas las partes del cuerpo nones van a estar arriba, mientras que las pares van a estar
abajo, podemos utilizar un if que revise si la parte del cuerpo es non o par y la ponga en
la posicin en y que le corresponde. Tambin podemos ver que la cabeza es diferente
de las dems partes del cuerpo, por lo que debemos pintarla por separado y fuera de un
ciclo. Por ltimo debemos definir cmo va a ser el ciclo que utilicemos para pintar todas
las partes del cuerpo.
La primera parte despus de la cabeza (primera parte del cuerpo) va a estar en la
posicin 1 x 10, la segunda parte va a estar en la posicin 2 x 10, la tercera parte va a
estar en la posicin 3 x 10. Ah est el patrn que necesitamos para empezar a pintar.
NETBEANS
PROGRAMACION VISUAL
27
Tomando esto en cuenta podemos utilizar un ciclo que empiece desde 1 (fjate que la
primera parte tiene un 1, a diferencia del problema anterior porque aqu la cabeza es
diferente).
Tomando en cuenta estas consideraciones podemos programar el siguiente cdigo:
NOTA: Recuerda que es muy importante aumentar el acumulador con la lnea pieces++.
Fjate en cmo vamos a dibujar 40 piezas empezando el contador (pieces) en 1 y
repitiendo el ciclo mientras que pieces sea menor o igual a cuarenta. Tambin fjate que
utilizamos una variable y que representa la posicin en y en que vamos a dibujar y el if
se va a encargar de cambiarla de 0 a 5 y viceversa segn sea necesario.
Compila y corre tu cdigo asegurndote de que se dibuje el gusano correctamente. Por
ltimo vamos a dibujar el camin.
En teora es muy similar al gusano, slo que ahora en lugar de tener un nmero fijo de
piezas del cuerpo tenemos un nmero variable que se encuentra guardado en la
variable boxes. Otro detalle importante es que las cajas van separadas unas de otras,
por lo que tendremos que poner un poco de separacin.
NETBEANS
PROGRAMACION VISUAL
28
Como podemos ver el mtodo es practicamente igual que el anterior, pero cambiamos
un poco la manera de dibujar los controles. Compila tu aplicacin y correla para probar
que funcione adecuadamente. Cambia el nmero de cajas que tiene el camin utilizando
la caja de texto (introduce el nmero y presiona enter).
Comprime tu carpeta de trabajo y mndala por correo.
NETBEANS
PROGRAMACION VISUAL
29
NETBEANS
PROGRAMACION VISUAL
30
NETBEANS
PROGRAMACION VISUAL
31
Paso 2:
Vamos al cdigo de PGraficoLineas y adicionamos el cdigo del paint en donde
realizamos el pintado de nuestras figuras
PROGRAMACION VISUAL
32
Paso 3:
Seleccionamos el Frame Fgraficolineas y arrastramos el panel que acabamos de crear,
hacia el frame, quedando de la siguiente forma:
NETBEANS
PROGRAMACION VISUAL
33
NETBEANS
PROGRAMACION VISUAL
34
NETBEANS
PROGRAMACION VISUAL
35
NETBEANS
PROGRAMACION VISUAL
36
Paso 2:
Vamos al cdigo de PGraficoLineas y adicionamos el cdigo del paint en donde
realizamos el pintado de nuestras figuras
NETBEANS
PROGRAMACION VISUAL
37
Paso 3:
Compilamos el programa, sleccionamos el Frame y arrastramos el panel que acabamos
de crear, hacia el frame, quedando de la siguiente forma:
NETBEANS
PROGRAMACION VISUAL
38
NETBEANS
PROGRAMACION VISUAL
39
NETBEANS
PROGRAMACION VISUAL
40
NETBEANS
PROGRAMACION VISUAL
41
Paso 2:
Vamos al cdigo de PGraficoPoligono y adicionamos el cdigo del paint en donde
realizamos el pintado de nuestras figuras
PROGRAMACION VISUAL
42
Paso 3:
Compilamos el programa, seleccionamos el Frame y arrastramos el panel que acabamos
de crear, hacia el frame, quedando de la siguiente forma:
PROGRAMACION VISUAL
43
Paso 4:
Ejecutamos el programa y nos dara lo siguiente:
NETBEANS
PROGRAMACION VISUAL
44
NETBEANS
PROGRAMACION VISUAL
45
NETBEANS
PROGRAMACION VISUAL
46
Paso 2:
Vamos al cdigo del panel y adicionamos el cdigo del paint en donde realizamos el
pintado de nuestras figuras
// dibujar figuras con la API Java2D
public void paint( Graphics g )
{
super.paint( g ); // llamar al mtodo paint de la superclase
Graphics2D g2d = ( Graphics2D ) g; // convertir g a Graphics2D
// dibujar elipse 2D rellena con un gradiente azul-amarillo
g2d.setPaint( new GradientPaint( 5, 30, Color.BLUE, 35, 100, Color.YELLOW, true ) );
g2d.fill( new Ellipse2D.Double( 5, 30, 65, 100 ) );
// dibujar rectngulo 2D en rojo
g2d.setPaint( Color.RED );
g2d.setStroke( new BasicStroke( 10.0f ) );
g2d.draw( new Rectangle2D.Double( 80, 30, 65, 100 ) );
// dibujar rectngulo 2D redondeado con fondo tamponado
BufferedImage buffImage = new BufferedImage( 10, 10,BufferedImage.TYPE_INT_RGB );
Graphics2D gg = buffImage.createGraphics();
gg.setColor( Color.YELLOW ); // dibujar en amarillo
gg.fillRect( 0, 0, 10, 10 ); // dibujar un rectngulo relleno
gg.setColor( Color.BLACK ); // dibujar en negro
gg.drawRect( 1, 1, 6, 6 ); // dibujar un rectngulo
gg.setColor( Color.BLUE ); // dibujar en azul
gg.fillRect( 1, 1, 3, 3 ); // dibujar un rectngulo relleno
gg.setColor( Color.RED ); // dibujar en rojo
NETBEANS
PROGRAMACION VISUAL
47
Los errores que aparecen son por la falta de importar las librerias, por lo cual damos clic
sobre los bombillos rojos e importamos las librerias.
Paso 3:
Compilamos el programa, seleccionamos el Frame y arrastramos el panel que acabamos
de crear, hacia el frame, quedando de la siguiente forma:
NETBEANS
PROGRAMACION VISUAL
48
NETBEANS
PROGRAMACION VISUAL
49
NETBEANS
PROGRAMACION VISUAL
50
NETBEANS
PROGRAMACION VISUAL
51
Paso 2:
Vamos al cdigo del panel y adicionamos el cdigo del paint en donde realizamos el
pintado de nuestras figuras
// dibujar rutas generales
public void paint( Graphics g )
{
super.paint( g ); // llamar al mtodo paint de la superclase
int puntosX[] = { 55, 67, 109, 73, 83, 55, 27, 37, 1, 43 };
int puntosY[] = { 0, 36, 36, 54, 96, 72, 96, 54, 36, 36 };
Graphics2D g2d = ( Graphics2D ) g;
GeneralPath estrella = new GeneralPath(); // crear objeto GeneralPath
// establecer la coordenada inicial de la ruta general
estrella.moveTo( puntosX[ 0 ], puntosY[ 0 ] );
// crear la estrella--esto no la dibuja
for ( int cuenta = 1; cuenta < puntosX.length; cuenta++ )
estrella.lineTo( puntosX[ cuenta ], puntosY[ cuenta ] );
estrella.closePath(); // cerrar la figura
g2d.translate( 200, 200 ); // trasladar el origen a (200, 200)
// girar alrededor del origen y dibujar estrellas en colores aleatorios
for ( int cuenta = 1; cuenta <= 20; cuenta++ ) {
g2d.rotate( Math.PI / 10.0 ); // girar el sistema de coordenadas
// establecer color de dibujo al azar
g2d.setColor( new Color( ( int ) ( Math.random() * 256 ),( int ) ( Math.random() * 256 ),( int ) ( Math.random() * 256 ) ) );
NETBEANS
PROGRAMACION VISUAL
52
Los errores que aparecen son por la falta de importar las librerias, por lo cual damos clic
sobre los bombillos rojos e importamos las librerias.
Paso 3:
Compilamos el programa, seleccionamos el Frame y arrastramos el panel que acabamos
de crear, hacia el frame, quedando de la siguiente forma:
PROGRAMACION VISUAL
53
Paso 4:
Ejecutamos el programa y nos dara lo siguiente:
NETBEANS
PROGRAMACION VISUAL
54
NETBEANS
PROGRAMACION VISUAL
55
NETBEANS
PROGRAMACION VISUAL
56
Paso 2:
Vamos al cdigo del panel y adicionamos el cdigo del paint en donde realizamos el
pintado de nuestras figuras
//Definimos variables globales para la ubicacin del baln
int Posx=0, Posy=0;
// dibujar fondo y balon
public void paint( Graphics g )
{
super.paint( g ); // llamar al mtodo paint de la superclase
// Crear un fondo amarrillo
g.setColor( Color.YELLOW );
g.fillRect( 0,0,getWidth(),getHeight());
if (Posx<0){
Posx=0;
}
if (Posy<0){
Posy=0;
}
if (Posx>getWidth()-10){
Posx=getWidth()-10;
}
if (Posy>getHeight()-10){
Posy=getHeight()-10;
}
// Crear un circulo de color rojo
g.setColor( Color.RED );
g.fillArc(Posx, Posy, 10, 10, 0, 360 );
NETBEANS
PROGRAMACION VISUAL
57
Paso 3:
Compilamos el programa, sleccionamos el Frame y arrastramos el panel que acabamos
de crear, hacia el frame, quedando de la siguiente forma:
NETBEANS
PROGRAMACION VISUAL
58
Ajustamos el panel al tamao en donde nos muestren las figuras. Debemos adicionar
cinco (5) botones, cuatro(4) para el movimiento y uno(1) para salir.
Paso 4:
Realizamos la programacin en cada botn de movimiento:
private void BArribaActionPerformed(java.awt.event.ActionEvent evt) {
pMoverfiguras1.Posy-=10;
pMoverfiguras1.repaint();
// TODO add your handling code here:
}
private void BDerechaActionPerformed(java.awt.event.ActionEvent evt) {
pMoverfiguras1.Posx+=10;
pMoverfiguras1.repaint();// TODO add your handling code here:
}
private void BIzquierdaActionPerformed(java.awt.event.ActionEvent evt) {
pMoverfiguras1.Posx-=10;
pMoverfiguras1.repaint();// TODO add your handling code here:
}
private void BAbajoActionPerformed(java.awt.event.ActionEvent evt) {
pMoverfiguras1.Posy+=10;
pMoverfiguras1.repaint();// TODO add your handling code here:
}
private void BSalirActionPerformed(java.awt.event.ActionEvent evt) {
dispose();
// TODO add your handling code here:
}
NETBEANS
PROGRAMACION VISUAL
59
Paso 5:
Ejecutamos el programa y nos dara lo siguiente:
Al dar clic en los botones (Arriba, Izquierda, Abajo y Derecha) el baln rojo se mueve.
NETBEANS
PROGRAMACION VISUAL
60