Práctica Espirales

Ian Rai Medrano Saavedra

Universidad Católica Boliviana “San Pablo”
medranosaavedraianrai@gmail.com

Resumen- En este documento se resolverá un problema public void paintComponent(Graphics g) {

enfocado en la programación de objetos y clases en el lenguaje //iniciando el void paintComponent para graficos
Java. super.paintComponent(g);
//llamando a la superclase y mandandole g
int ancho = getWidth();
1. INTRODUCCIÓN //iniciando el ancho
Continuando el estudio del libro How to program Java, int alto = getHeight();
//iniciando la altura
se estudia la programación orientada a objetos, la
programación orientada a objetos es mucho más double dx= (double)ancho/(n);
//iniciando las variables double que seran los
eficiente para la construcción de programas complejos y espacios que se recorrera para el dibujo
grandes. double dy= (double)alto/(n);

double x = ancho/2;
2. EJERCICIO //iniciando los primeros
valores de x y y
double y = alto/2;
2.1. drawLine double yf = alto/2+dy;
Cree el diseño que se muestra en la captura de
pantalla, pero para n líneas ingresadas por teclado. double y2 = alto/2;

for (int i = 0; i<=n;i++) {

//contador se veces que se debe dibujar
g.drawLine((int)x,(int)y,
(int)x,(int)yf); //dibujando las líneas
de la figura
x=x+dx;
//realizando las sumas y/o restas por iteracion
para el dibujo
y=y-dy;
//realizando las sumas y/o restas por iteracion
para el dibujo
yf=yf+dy;}
double xx = ancho/2;
double x2 = ancho/2-dx;
double yf2 = alto/2+dy;
Fig. 1. Dibujo de una espiral con drawLine(izquierda) y for (int i = 0; i<=n;i++) {
drawArc (derecha). g.drawLine((int)x2,(int)yf2,
(int)xx,(int)yf2); //dibujando las
líneas de la figura
Primera figura x2=x2-dx;
//realizando las sumas y/o restas por
 Programa EspiralCuadrada iteracion para el dibujo
xx=xx+dx;
//realizando las sumas y/o restas por
import java.awt.Graphics; iteracion para el dibujo
yf2=yf2+dy;
import javax.swing.JPanel; }
public class EspiralCuadrada extends JPanel{
private int n; double x3 = ancho/2-dx;
//iniciando el atributo privado n double yf3 = alto/2+dy;
double yf33 = alto/2-dy;
public EspiralCuadrada(int n) { for (int i = 0; i<=n;i++) {
//introduciendo el dato de n en la g.drawLine((int)x3,(int)yf3,
variable privada n de esta clase (int)x3,(int)yf33); //dibujando las
this.n = n; líneas de la figura
} x3=x3-dx;
//realizando las sumas y/o restas por
iteracion para el dibujo
 ventana.add( panel );
//realizando las sumas y/o restas por iteracion //crear panel
para el dibujo ventana.setSize( 300, 300 );
yf3=yf3+dy; //delimitar la talla
yf33=yf33-dy; ventana.setVisible( true );
} //introduciendo la variable booleana
double x4 = ancho/2-dx; }
double yf4 = alto/2-dy; }
double xx3 = ancho/2+dx; }
for (int i = 0; i<=n;i++) {
g.drawLine((int)x4,(int)yf4,  Captura de pantalla
(int)xx3,(int)yf4); //dibujando las
líneas de la figura
x4=x4-dx;
//realizando las sumas y/o restas por
iteracion para el dibujo
xx3=xx3+dx;
//realizando las sumas y/o restas por
iteracion para el dibujo
yf4=yf4-dy;

}
}}

 Programa main EspiralCuadradaTest Fig. 2. Captura de la impresión del programa al ingresar

un dato.
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class EspiralCuadradaTest {
public static void main(String[] args) {
//iniciando programa main
String num;

//iniciando el string num para almacenar el dato

do {
num =
JOptionPane.showInputDialog("Ingresar numero de
Lineas"); //peticion en ventana de
introducir dato
}while (num==null);
try {

// Convierte un valor de tipo String

a int
int n = Integer.parseInt(num);

} catch(Exception e) {

JOptionPane.showInputDialog(null, "ERROR: el Fig. 3. Captura de la impresión del programa con el

valor de tipo String contiene caracteres no numéricos");
//mostrando error si es que el numero ingresado dato introducido.
no es numerico
} Segunda figura
int n = Integer.parseInt(num);

if (n<2 || n>100)  Programa Espiral

//condicional para introducir numeros
mayores a 2 o menores a 100 para que el dibujo se vea
bien import java.awt.Graphics;

JOptionPane.showInputDialog(null, "Debe ser import javax.swing.JPanel;

mayor a 2"); public class Espiral extends JPanel{
else {
EspiralCuadrada panel = private int n;
new EspiralCuadrada(2*n); //creando el //iniciando el atributo privado n
objeto panel de la clase Espiralcuadrada, se pone *2n
porque el n que se manda al objeto es la suma de los public Espiral(int n) {
espacios mas las lineas //introduciendo el dato de n en la variable
JFrame ventana = new privada n de esta clase
JFrame(); //creando el objeto aplication this.n = n;
de la clase JFrame }
public void paintComponent(Graphics g) {
ventana.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE //iniciando el void paintComponent para graficos
); //salir del frame con la constante EXIT_ON_CLOSE super.paintComponent(g);
//llamando a la superclase y mandandole g
 int ancho = getWidth();
//iniciando el ancho // Convierte un valor de tipo String
int alto = getHeight(); a int
//iniciando la altura int n = Integer.parseInt(num);

double dx= (double)ancho/(n+1); } catch(Exception e) {

//iniciando las variables double que seran los
espacios que se recorrera para el dibujo JOptionPane.showInputDialog(null, "ERROR: el
double dy= (double)alto/(n+1); valor de tipo String contiene caracteres no numéricos");
//mostrando error si es que el numero ingresado
double x = ancho/2; no es numerico
//iniciando los primeros }
valores de x y y int n = Integer.parseInt(num);
double y = alto/2;
if (n<2 || n>100)
double anc = dx ; //condicional para introducir numeros
double alt = dy ; mayores a 2 o menores a 100 para que el dibujo se vea
bien

for (int i = 0; i<=n;i++) { JOptionPane.showInputDialog(null, "Debe ser

//contador se veces que se debe dibujar mayor a 2");
g.drawArc((int)x, (int)y, else {
(int)anc, (int)alt, 0, 180); //dibujando las líneas Espiral panel = new
de la figura Espiral(n+(n/2)); //creando el objeto
x=x-dx; panel de la clase Espiral se suma +(n/2) para que se vea
//realizando las sumas y/o restas por iteracion la cantidad exacta de espiras, porque el programa
para el dibujo tambien toma en cuenta los espacios entre espiras
y=y-dy; JFrame ventana = new
//realizando las sumas y/o restas por iteracion JFrame(); //creando el objeto aplication
para el dibujo de la clase JFrame
anc=anc+2*dx;
alt=alt+2*dy; ventana.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE
} ); //salir del frame con la constante EXIT_ON_CLOSE
ventana.add( panel );
double x1 = ancho/2-dx; //crear panel
//iniciando los primeros ventana.setSize( 300, 300 );
valores de x y y //delimitar la talla
double y1 = alto/2-(dy/2); ventana.setVisible( true );
//introduciendo la variable booleana
double anc1 = 2*dx; }
double alt1 = 2*dy; }
for (int i = 0; i<=n;i++) { }
//contador se veces que se debe dibujar
g.drawArc((int)x1, (int)y1,
(int)anc1, (int)alt1, 0, -180); //dibujando las líneas
de la figura
x1=x1-dx;
y1=y1-dy;//realizando las sumas
y/o restas por iteracion para el dibujo
anc1=anc1+2*dx;
//realizando las sumas y/o restas por iteracion
 Captura de pantalla
para el dibujo
alt1=alt1+2*dy;
}
}
}
}

 }Programa main EspiralTest

import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class EspiralTest { Fig. 4. Captura de la impresión del programa al ingresar
public static void main(String[] args) {
//iniciando programa main un dato.
String num;

//iniciando el string num para almacenar el dato

do {
num =
JOptionPane.showInputDialog("Ingresar numero de
Lineas"); //peticion en ventana de
introducir dato
}while (num==null);
try {
 Fig. 5. Captura de la impresión del programa con el
dato introducido.

3. Conclusiones

Los programas se ejecutaron con éxito mostrando las

formas de básicas de dibujo en Java usando drawLine y
drawArc, además se mostró que el método iterativo en
programación es más eficiente que usar la forma
analítica, y proporciona los mismos resultados.