_____________________________________________________________________________________
5.15 Escriba una aplicación que muestre los siguientes patrones por separado, uno debajo del otro. Use ciclos for para generar los patrones. Todos los asteriscos (*) deben imprimirse mediante una sola instrucción de la forma System.out.print("*"); la cual hace que los asteriscos se impriman uno al lado del otro. Puede utilizarse una instrucción de la forma System.out.println(); para posicionarse en la siguiente línea. Puede usarse una instrucción de la forma System.out.print(" "); para mostrar un espacio para los últimos dos patrones. No debe haber ninguna otra instrucción de salida en el programa. [Sugerencia: los últimos dos patrones requieren que cada línea empiece con un número apropiado de espacios en blanco].
* ********** ********** *
** ********* ********* **
*** ******** ******** ***
**** ******* ******* ****
***** ****** ****** *****
****** ***** ***** ******
******* **** **** *******
******** *** *** ********
********* ** ** *********
********** * * **********
_____________________________________________________________________________________
Solución:
En este programa se puede modificar la variable privada Tamano para generar un patrón diferente al presentado.
Este código debe guardarse con el nombre UsaDeitel_5_15.java
public class UsaDeitel_5_15
{ // Abre clase UsaDeitel_5_15
public static void main(String args[])
{ // Abre main
// Se crea el objeto miObjeto
Deitel_5_15 miObjeto = new Deitel_5_15();
// Se llama al metodo Imprime
miObjeto.Imprime();
} // Cierra main
} // Cierra clase UsaDeitel_5_15
Este código debe guardarse con el nombre Deitel_5_15.java
// En este programa solo se puede usar las siguientes
// instrucciones:
// System.out.print("*");
// System.out.println();
// System.out.print(" ");
public class Deitel_5_15
{ // Abre clase Deitel_5_15
private int Tamano = 10;
public void Imprime()
{ // Abre metodo Imprime
System.out.println("\n");
for ( int i = 1; i <= Tamano; i++ )
{ // Abre for
for ( int j = 1; j <= i; j++ )
System.out.print("*");
for ( int k = i + 1; k <= Tamano; k++)
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
for ( int l = 1; l <= Tamano + 1 - i; l++ )
System.out.print("*");
for ( int m = Tamano - 1 -i; m <= Tamano; m++)
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
for ( int n = 1; n < i; n++ )
System.out.print(" ");
for ( int p = i; p <= Tamano; p++ )
System.out.print("*");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
for ( int q = 1; q <= Tamano - i; q++ )
System.out.print(" ");
for ( int r = Tamano - i; r < Tamano; r++ )
System.out.print("*");
System.out.println();
} // Cierra for
System.out.println("\n");
} // Cierra metodo Imprime
} // Cierra clase Deitel_5_15
La ejecución de éste programa produce la salida mostrada arriba.
_____________________________________________________________________________________
Ahora vamos a revisar el programa línea por línea:
Lo primero que hay que ver es que éste programa está dividido en dos archivos. El primero es llamado UsaDeitel_5_15.java y el segundo Deitel_5_15.java. Es importante recordar que en java el nombre de los archivos no es indistinto. Se pueden cambiar, pero de tal manera que los cambios sean consecuentes con las llamadas a las clases que se harán posteriormente.Desde luego, puede parecer redundante tener dos archivos cuando podría todo el programa estar contenido en uno sólo. Sin embargo, me he acostumbrado a escribir por lo menos dos archivos para un proyecto, y ésto lo hago de manera automática. Esta es una buena práctica de programación.
public class UsaDeitel_5_15
Como su nombre lo indica, el primer archivo hace uso del segundo. Actúa como un administrador de los métodos de Deitel_5_15.java.
{ // Abre clase UsaDeitel_5_15
El cuerpo de las clases se delimita por llaves: { }. //Abre clase.... es un comentario. Se comenta esta llave simplemente por costumbre, como una buena práctica de programación. Cuando un programa se va haciendo cada vez más grande, puede ser difícil saber a qué cuerpo de instrucciones corresponde determinada llave.
public static void main(String args[])
Dentro de la clase solamente hay un método, el método main. main, como su nombre lo indica, es el método principal. Todos los programas tienen al menos ese método. La ejecución del programa empieza ahí. Los argumentos entre paréntesis deben incluirse siempre.
{ // Abre main
Como las clases, los métodos son cuerpos de instrucción delimitados por llaves.
// Se crea el objeto miObjeto
Deitel_5_15 miObjeto = new Deitel_5_15();
De la clase Deitel_5_15.java, se crea un nuevo objeto, llamado, por falta de un nombre mejor, miObjeto. La forma de crear un objeto es usar la palabra reservada new y a continuación el nombre de la clase, seguida por un par de paréntesis.
// Se llama al metodo Imprime
miObjeto.Imprime();
Una vez creado miObjeto, es posible llamar los métodos de dicho objeto. El primero, a partir del cual se llamarán los demás es Imprime, que no requiere argumentos. Con ésto pasamos el control del programa al siguiente archivo.
} // Cierra main
} // Cierra clase UsaDeitel_5_15
Éste par de líneas, como lo indican los comentarios, cierran los cuerpos de main y UsaDeitel_5_15, respectivamente.
Ahora vamos a considerar el siguiente archivo, Deitel_5_15.java
// En este programa solo se puede usar las siguientes
// instrucciones:
// System.out.print("*");
// System.out.println();
// System.out.print(" ");
Éstas líneas son un comentario. El comentario aclara que sólo es posible usar las instrucciones que ahí aparecen.
public class Deitel_5_15
{ // Abre clase Deitel_5_15
ÉStas líneas ya no son desconocidas. estamos declarando una clase pública a la que hemos llamado iguan que el archivo: Deitel_5_15. El cuerpo de dicha clase se limita por llaves. La primera llave aparece junto a un comentario que indica que se trata de la llave de apertura.
private int Tamano = 10;
Ésta variable de tipo entero, por ser private puede ser usada por todos los métodos de la clase. En éste caso sólo hay un método, Imprime. se establece en 10 porque es la altura y la anchura de los triángulos. Si se cambia ese número por, digamos, 15, el programa funciona exactamente igual, como se puede ver en la siguiente figura, generada al cambiar sólo ese valor:
* *************** *************** *
** ************** ************** **
*** ************* ************* ***
**** ************ ************ ****
***** *********** *********** *****
****** ********** ********** ******
******* ********* ********* *******
******** ******** ******** ********
********* ******* ******* *********
********** ****** ****** **********
*********** ***** ***** ***********
************ **** **** ************
************* *** *** *************
************** ** ** **************
*************** * * ***************
public void Imprime()
{ // Abre metodo Imprime
Aquí se define un método público llamado Imprime, y se abre el cuerpo de instrucciones. Imprime no recibe ni regresa argumentos.
System.out.println("\n");
Con ésta orden, estamos saltando una línea.
for ( int i = 1; i <= Tamano; i++ )
{ // Abre for
Este ciclo for controla el número de renglones, o altura, que tendrán los triángulos.
for ( int j = 1; j <= i; j++ )
System.out.print("*");
Éste primer ciclo for dibuja el primer triángulo. La anchura se corresponde con la altura, esto es, el ciclo corre a la par que el ciclo for externo.
for ( int k = i + 1; k <= Tamano; k++)
System.out.print(" ");
Éste ciclo for imprime un segundo triángulo, ahora de espacios vacíos, a partir del siguiente en el que queda el ciclo for anterior. Por ejemplo, en la primera línea (i = 1) se imprime un *. A partir de la posición 2 (i + 1) se imprimen espacios en blanco hasta alcanzar la variable Tamano.
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
Estas líneas son simples. Son los espacios entre cada cuadrado (formado por un par de triángulos, uno de * y uno blanco).
for ( int l = 1; l <= Tamano + 1 - i; l++ )
System.out.print("*");
Este ciclo imprime un triángulo invertido. En el renglón 1 (i = 1), se imprime un * desde la posición 1 hasta la posición Tamano(Tamano + 1 - 1). A partir de ahí, se empieza a imprimir un asterisco menos, hasta llegar a 1.
for ( int m = Tamano - 1 -i; m <= Tamano; m++)
System.out.print(" ");
Con éste ciclo for se imprime un triángulo en blanco que completa el cuadrado.
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
De nuevo, se imprimen cuatro espacios.
