EstructurasControl1.java
1 /*
2 * To change this template, choose Tools | Templates
3 * and open the template in the editor.
4 */
5
6 package estructurasControl;
7
8 import java.awt.FlowLayout;
9 import java.util.Calendar;
10 import java.util.GregorianCalendar;
11 import javax.swing.JFrame;
12 import javax.swing.JLabel;
13 import javax.swing.JOptionPane;
14
15 /**
16 *
17 * @author iAlexander
18 */
19 public class EstructurasControl1 {
20 public static int menu(){
21 int opcion = 0;
22 String menu = "\nMenu:"
23 + "\n1. ejemplo 1 11. ejemplo 11"
24 + "\n2. ejemplo 2 12. ejemplo 12"
25 + "\n3. ejemplo 3"
26 + "\n4. ejemplo 4"
27 + "\n5. ejemplo 5"
28 + "\n6. ejemplo 6"
29 + "\n7. ejemplo 7"
30 + "\n8. ejemplo 8"
31 + "\n9. ejemplo 9"
32 + "\n10. ejemplo 10"
33 + "\n13. salir"
34 + "\ndigite una opcion: ";
35 opcion = Integer.parseInt(JOptionPane.showInputDialog(menu));
36 return opcion;
37 }
38
39 public static void main(String[] args) {
40 int opcion = 0;
41 do{
42 opcion = menu();
43 switch(opcion){
44 /*
45 * ESTRUCTURAS DE CONTROL:
46 * Hoy toca hablar acerca de las estructuras de control, se asemeja a la
47 * vida, cuando se toman decisiones o cuando realizamos una tarea mas
48 * de una vez...
49 *
50 * Por lo general, las sentencias o también llamadas instrucciones,
51 * remontándonos al modelo de programación estructurada nos dice que
52 * varias instrucciones se ejecutan una despues de otra, en el orden
53 * que se establecieron también es llamado proceso de ejecución secuencial.
54 *
55 * Aquí algo que nos dice wikipedia
56 * es un paradigma de programación orientado a mejorar la claridad,
57 * calidad y tiempo de desarrollo de un programa de computadora,
58 * utilizando únicamente subrutinas y tres estructuras: secuencia,
59 * selección (if y switch) e iteración (bucles for y while), considerando
60 * innecesario y contraproducente el uso de la instrucción de
61 * transferencia incondicional (GOTO), que podría conducir a
62 * "código espagueti", que es mucho más difícil de seguir y de mantener,
63 * y era la causa de muchos errores de programación.
64 *
65 * en java se tienen 3 tipos de estructuras de control:
66 * 1. Secuencia
67 * 2. Selección {if, if - else, switch}
68 * 3. Repetición {while, do - while, for}
69 */
70
71 /*
72 * 1. Secuencia
73 * Las sentencias se ejecutan de forma secuencial
74 * Ejem:
75 */
76 //creamos un objeto de tipo JFrame, los objetos creados a partir de
77 //esta clase tendrán el aspecto de una ventana y se establece
78 //un titulo para la ventana
79
80 case 1: //Ejemplo 1
81 JFrame jFrame = new JFrame("Titulo");
82 //le proporcionamos un administrador de diseño
83 jFrame.setLayout(new FlowLayout());
84 //agregamos un objeto de tipo JLabel, una etiqueta... con el texto
85 //"Hola Mundo :D"
86 jFrame.getContentPane().add(new JLabel("Hola Mundo :D"));
87 //Luego se le proporciona un tamaño a la ventana
88 jFrame.setSize(300, 100);
89 //La ventana aun permacene en memoria, asi que invocamos al metodo
90 //setVisible() enviando como parametro el valor boolean = true
91 //este metodo permite que nuestra ventana creada se muestre en el
92 //monitor
93 jFrame.setVisible(true);
94 //Invocar a este método da como resultado que nuestra ventana se
95 //posicione en la parte central del monitor
96 jFrame.setLocationRelativeTo(null);
97 //Por ultimo llamar a este método hace que termine la aplicación
98 jFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
99 break;
100 /*
101 * Selección
102 * if - Simple
103 * Se determina si la condición es true o false, si condición == true
104 * se ejecuta bloque de código establecido dentro de las llaves. Si
105 * condicion == false, el bloque de código no es ejecutado.
106 *
107 * if(condicción){
108 * ...
109 * }
110 *
111 * dentro de este tipo de estructuras puede haber cero, una o más
112 * sentencias, en el caso de que no haya sentencias se coloca el
113 * punto y coma (;), no es necesario colocar llaves cuando se va a
114 * ejecutar una sentencia.
115 *
116 * Solo tenemos un camino cuando la condiccion es verdadera o falsa
117 * se hace una sola cosa.
118 * ejemplo:
119 */
120 //primero hacemos que el ususario digite un número, el número
121 //es almacenado en un la variable calificación.
122 //el método showInputDialog(String cadena) de la clase JOptionPane
123 //al momento de ser ejecutado muestra una ventana con un cuadro de
124 //entrada y dos botones, es por ese cuadro de entrada por donde
125 //el usuario debera digitar el numero, luego se llama al método
126 //parseInt(String cadena) de la clase Integer para que convierta a
127 //entero el parametro que recibe.
128
129 case 2: //ejemplo 2
130 int calificacion = Integer.parseInt(JOptionPane.showInputDialog(
131 "Digite una calificación: "));
132 //condición if-simple
133 //evalua la calificación que sea mayor a 10, si es verdadero
134 //se muestra un cuadro de dialogo con el mensaje: "Aprobaste el curso!"
135 //si esta condición es falsa, es ignorada y pasa a ejecutarse la
136 //siguiente sentencia o termina el programa
137 if(calificacion > 10)
138 JOptionPane.showMessageDialog(null, "Aprobaste el curso!");
139 break;
140
141 /*
142 * if...else
143 * de selección doble, permite especificar una acción a realizar, cuando
144 * la condicción es verdadera, y otra distinta cuando la condición es
145 * falsa.
146 *
147 * if(codicion){
148 * ...
149 * }else{
150 * ...
151 * }
152 * Dentro de este tipo de estructuras puede haber cero, una o más
153 * sentencias, en el caso de que no haya sentencias se coloca el
154 * punto y coma (;), no es necesario colocar llaves cuando se va a
155 * ejecutar una sentencia.
156 *
157 * Aqui cambia la cosa, si una condicion es verdadera o falsa, se realiza
158 * una algo, caso contrario se ejecuta otra tarea.
159 * ejemplo:
160 */
161
162 case 3: //ejemplo 3
163 int cantidad = Integer.parseInt(JOptionPane.showInputDialog(
164 "Cuánto desea retirar: "));
165 int saldo = 2000;
166 if(cantidad < saldo){
167 saldo = saldo - cantidad;
168 JOptionPane.showMessageDialog(null, "Cantidad retirada: "+cantidad
169 +"\nLe quedan S/." + saldo);
170 }else{
171 JOptionPane.showMessageDialog(null, "No cuenta con saldo "
172 + "suficiente para esta operación");
173 }
174 break;
175 /*
176 * Un operador tenario [(boolean condición)?sentencia 1:sentencia 2;]
177 * java cuenta con el operador codicional (?:) que no es nada del otro
178 * mundo, que en ocaciones puede utilizarse en lugar de una instrucción
179 * if...else.
180 * por ejemplo:
181 */
182 //ejemplo a
183
184 case 4: //ejemplo 4
185 int numero = Integer.parseInt(JOptionPane.showInputDialog(
186 "Numero par?: "));
187 JOptionPane.showMessageDialog(null, (numero%2==0)?"Es Par":"No es Par");
188 break;
189
190 //ejemplo b
191
192 case 5: //ejemplo 5
193 //instanciando una fecha de tipo GregorianCalendar
194 //invocando a su constructor que inicializa a fecha
195 //con valores actuales del sistem
196 GregorianCalendar fecha = new GregorianCalendar();
197 //declaración de variables a utilizar
198 int dia, mes, año, hora, min;
199 //tomando los parámetros que se utilizaran de la fecha
200 dia = fecha.get(Calendar.DAY_OF_MONTH);
201 mes = fecha.get(Calendar.MONTH)+1;
202 año = fecha.get(Calendar.YEAR);
203 hora = fecha.get(Calendar.HOUR_OF_DAY);
204 min = fecha.get(Calendar.MINUTE);
205 //formato de fechas usando el operador ternario ?:
206 JOptionPane.showMessageDialog(null, "Fecha actual: " +
207 (dia<10?"0"+dia:dia) + "/" + (mes<10?"0"+mes:mes) + "/" +
208 año + "\nHora actual: " + (hora<10?"0"+hora:hora) + ":"
209 + (min<10?"0"+min:min));
210 break;
211 /*
212 * Instrucciones if-else anidadas
213 * una instrucción if-else dentro de otra instrucción if-else
214 * ejemplo:
215 */
216
217 case 6: //ejemplo 6 utilización de if-else anidado
218 int calificación = Integer.parseInt(JOptionPane.showInputDialog(
219 "Ingrese calificación"));
220 if(calificación >= 90)
221 JOptionPane.showMessageDialog(null, "Nota: A");
222 else{
223 if(calificación >= 80)
224 JOptionPane.showMessageDialog(null, "Nota: B");
225 else{
226 if(calificación >= 70)
227 JOptionPane.showMessageDialog(null, "Nota: C");
228 else{
229 if(calificación >= 60)
230 JOptionPane.showMessageDialog(null, "Nota: D");
231 else
232 JOptionPane.showMessageDialog(null, "Nota: F");
233 }
234 }
235 }
236 break;
237 /*
238 * El ejemplo anterior se puede transcribir de esta forma
239 */
240
241 case 7: //ejemplo 7 otra forma de escribir if-else anidado
242 int calif = Integer.parseInt(JOptionPane.showInputDialog(
243 "Ingrese calificación"));
244 if(calif >= 90)
245 JOptionPane.showMessageDialog(null, "Nota: A");
246 else if(calif >= 80)
247 JOptionPane.showMessageDialog(null, "Nota: B");
248 else if(calif >= 70)
249 JOptionPane.showMessageDialog(null, "Nota: C");
250 else if(calif >= 60)
251 JOptionPane.showMessageDialog(null, "Nota: D");
252 else
253 JOptionPane.showMessageDialog(null, "Nota: F");
254 break;
255
256 /*
257 * Estructura de Selección Múltiple - switch
258 * parecido al if-else anidado. utiliza casos para la seleción
259 * de caminos, todos los casos tienen una sentencia de salto (break)
260 * que hace que termine la ejecución de esa parte de codigo. puede
261 * también tener un caso por defecto (default)
262 * ejemplo
263 */
264 case 8: //ejemplo 8
265 GregorianCalendar fechaA = new GregorianCalendar();
266 int d = fechaA.get(Calendar.DAY_OF_MONTH);
267 int m = fechaA.get(Calendar.MONTH);
268 int a = fechaA.get(Calendar.YEAR);
269 String month = "";
270 switch(m){
271 case 0:
272 month = "enero";
273 break;
274 case 1:
275 month = "febrero";
276 break;
277 case 2:
278 month = "marzo";
279 break;
280 case 3:
281 month = "abril";
282 break;
283 case 4:
284 month = "mayo";
285 break;
286 case 5:
287 month = "junio";
288 break;
289 case 6:
290 month = "julio";
291 break;
292 case 7:
293 month = "agosto";
294 break;
295 case 8:
296 month = "setiembre";
297 break;
298 case 9:
299 month = "octubre";
300 break;
301 case 10:
302 month = "noviembre";
303 break;
304 case 11:
305 month = "diciembre";
306 break;
307 }
308 JOptionPane.showMessageDialog(null, "Fecha Actual \n"
309 + (d<10?"0"+d:d) + "-" + month + "-" + a);
310 break;
311
312 /*
313 * Repetición - while
314 * Una estructura de repetición, tambien llamada (estructura de
315 * ciclo) permite al programador especificar que un programa debe
316 * repetir una acción mientras cierta condición sea verdadera o que
317 * una sentencia break termine el bucle.
318 * las estructuras while contienen una condicción que es necesaria
319 * para que se ejecute el bloque de código que esta contiene, un
320 * una sentencia que hace que la condición tome el valor false en
321 * algún momento.
322 * ejemplos
323 */
324 case 9: //ejemplo 9
325 //calcula la primera potencia de 2 que sea mayor a 1000
326 int producto = 2;
327 while(producto <= 1000)
328 producto = 2 * producto;
329 JOptionPane.showMessageDialog(null, "Producto:\n"+producto);
330 break;
331 /*
332 * Formas de controlar una estructura de repetición
333 */
334 case 10: //repetición controlada por un contador
335 double nota = 0;
336 int i = 1; //los contadores se declaran fuera del while
337 while(i<=5)
338 //como solo es una sentencia no es necesario colocar entre llaves
339 nota += Double.parseDouble(JOptionPane.showInputDialog(
340 "Ingrese nota "+(i++)+": "));
341 //i++ es el incremento, en algún momento la condición del
342 //while dejará de ser verdadera
343 JOptionPane.showMessageDialog(null, "Promedio: "+(nota/5.0));
344 break;
345 case 11: //repetición controlada por un centinela
346 int total = 1;
347 double calf = 0.0;
348 double sum = Double.parseDouble(JOptionPane.showInputDialog(
349 "Ingrese Calificación "+(total)+": "));
350 while(calf != -1){
351 sum += calf;
352 calf = Double.parseDouble(JOptionPane.showInputDialog(
353 "Ingrese Calificación "+(++total)+": "));
354 }
355 JOptionPane.showMessageDialog(null, "Promedio: "+sum/(total-1));
356 break;
357 case 12: //con ruptura break y usando un centinela
358 int suma = 0;
359 int num = 0;
360 while(true){
361 suma += num;
362 num = Integer.parseInt(JOptionPane.showInputDialog(
363 "Ingrese numero: "));
364 if(num == -1) break;
365 }
366 JOptionPane.showMessageDialog(null, "La Suma es: " + suma);
367 break;
368 }
369 }while(opcion>0 &&opcion<13);
370 }
371 }
372
373
No hay comentarios:
Publicar un comentario