.
jueves, 1 de diciembre de 2016
ESTRUCTURA REPETITIVA DO WHILE
ESTRUCTURA REPETITIVA DO WHILE
La estructura do while es otra estructura repetitiva, la
cual ejecuta al menos una vez su bloque repetitivo, a diferencia del while o
del for que podían no ejecutar el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de
antemano que por lo menos una vez se ejecutará el bloque repetitivo.
La condición de la estructura está abajo del bloque a
repetir, a diferencia del while o del for que está en la parte superior.
Representación gráfica:
El bloque de operaciones se repite MIENTRAS que la condición sea Verdadera.
Si la condición retorna Falso el ciclo se detiene. En Java,
todos los ciclos repiten por verdadero y cortan por falso.
Es importante analizar y ver que las operaciones se ejecutan
como mínimo una vez.
Problema 1:
Escribir un programa que solicite la carga de un número
entre 0 y 999, y nos muestre un mensaje de cuántos dígitos tiene el mismo.
Finalizar el programa cuando se cargue el valor 0.
Diagrama de flujo:
estructura repetitiva do while
No hay que confundir los rombos de las estructuras
condicionales con los de las estructuras repetitivas do while.
En este problema por lo menos se carga un valor. Si se carga
un valor mayor o igual a 100 se trata de un número de tres cifras, si es mayor
o igual a 10 se trata de un valor de dos dígitos, en caso contrario se trata de
un valor de un dígito. Este bloque se repite hasta que se ingresa en la
variable valor el número 0 con lo que la condición de la estructura do while
retorna falso y sale del bloque repetitivo finalizando el programa.
Programa:
import
java.util.Scanner;
public
class EstructuraRepetitivaDoWhile1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int valor;
do {
System.out.print("Ingrese un valor entre 0 y 999 (0
finaliza):");
valor=teclado.nextInt();
if
(valor>=100) {
System.out.println("Tiene 3 dígitos.");
} else {
if
(valor>=10) {
System.out.println("Tiene 2 dígitos.");
System.out.println("Tiene 1 dígito.");
}
}
} while
(valor!=0);
}
}
ESTRUCTURA REPETITIVA WHILE
Hasta ahora hemos empleado estructuras SECUENCIALES y
CONDICIONALES. Existe otro tipo de estructuras tan importantes como las
anteriores que son las estructuras REPETITIVAS.
Una estructura repetitiva permite ejecutar una instrucción o
un conjunto de instrucciones varias veces.
Una ejecución repetitiva de sentencias se caracteriza por:
- La o las sentencias que se repiten.
- El test o prueba de condición antes de cada repetición,
que motivará que se repitan o no las sentencias.
Problema 1:
Escribir un programa que solicite la carga de un valor
positivo y nos muestre desde 1 hasta el valor ingresado de uno en uno.
Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los
números del 1 al 30.
Es de FUNDAMENTAL importancia analizar los diagramas de
flujo y la posterior codificación en Java de los siguientes problemas, en
varios problemas se presentan otras situaciones no vistas en el ejercicio
anterior.
solucion
import
java.util.Scanner;
public
class EstructuraRepetitivaWhile2 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int n,x;
System.out.print("Ingrese el valor final:");
n=teclado.nextInt();
x=1;
while (x<=n) {
System.out.print(x);
System.out.print(" - ");
x = x + 1;
}
}
miércoles, 30 de noviembre de 2016
ESTRUCTURA REPETITIVA FOR
ESTRUCTURA REPETITIVA FOR
Cualquier problema que requiera una estructura repetitiva se
puede resolver empleando la estructura while. Pero hay otra estructura
repetitiva cuyo planteo es más sencillo en ciertas situaciones.
En general, la estructura for se usa en aquellas situaciones
en las cuales CONOCEMOS la cantidad de veces que queremos que se ejecute el
bloque de instrucciones. Ejemplo: cargar 10 números, ingresar 5 notas de
alumnos, etc. Conocemos de antemano la cantidad de veces que queremos que el
bloque se repita. Veremos, sin embargo, que en el lenguaje Java la estructura
for puede usarse en cualquier situación repetitiva, porque en última instancia
no es otra cosa que una estructura while generalizada.
Problema 3:
Escribir un programa que lea 10 notas de alumnos y nos
informe cuántos tienen notas mayores o iguales a 7 y cuántos menores.
solución:
import
java.util.Scanner;
public
class EstructuraRepetitivaFor3 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int aprobados,reprobados,f,nota;
aprobados=0;
reprobados=0;
for(f=1;f<=10;f++) {
System.out.print("Ingrese la nota:");
nota=teclado.nextInt();
if
(nota>=7) {
aprobados=aprobados+1;
} else {
reprobados=reprobados+1;
}
}
System.out.print("Cantidad de aprobados:");
System.out.println(aprobados);
System.out.print("Cantidad de reprobados:");
System.out.print(reprobados);
}
}
INTERFACES VISUALES(COMPONENTES SWING)
Hasta ahora hemos resuelto todos los algoritmos haciendo las
salidas a través de una consola en modo texto. La realidad que es muy común la
necesidad de hacer la entrada y salida de datos mediante una interfaz más
amigables con el usuario.
En Java existen varias librerías de clase para implementar
interfaces visuales. Utilizaremos las componentes Swing.
Componentes Java Swing
Como se mencionó en la introducción a Java Swing, este
paquete nos brinda ciertas facilidades para la construcción de interfaces
graficas de usuario........ en esta entrada vamos a conocer a nivel general
algunos de los principales componentes que podemos usar en nuestras GUI's...
Hasta el momento hemos visto lo que es Swing, las
diferencias entre JFrame y JDialog así como un pequeño ejemplo sobre la
creación de Ventanas incluyendo también 2 componentes tales como los botones y
las etiquetas de texto.
En esta entrada enunciaremos algunos de los principales
componentes, tal vez no podamos trabajarlos todos pero es bueno saber que
existen, conociendo nuevas opciones para vincular en nuestros desarrollos...
¿Qué son Los Componentes Gráficos?
Como se ha mencionado, los componentes gráficos son estos
elementos que permiten brindar una interacción con el usuario del sistema.....
Cada componente corresponde a una clase en Java, por esta razón cuando
desarrollamos y queremos vincular uno de estos elementos simplemente
instan-ciamos la clase que necesitamos, es decir, si queremos un Área de texto
debemos crear un objeto de la clase JTextArea.
Problema 1:
Confeccionar el programa "Hola Mundo" utilizando
una interfaz gráfica de usuario.
import
javax.swing.*;
public
class Formulario extends JFrame{
private JLabel label1;
public Formulario() {
setLayout(null);
label1=new JLabel("Hola
Mundo.");
label1.setBounds(10,20,200,30);
add(label1);
}
public static void main(String[] ar) {
Formulario formulario1=new
Formulario();
formulario1.setBounds(10,10,400,300);
formulario1.setVisible(true);
}
}
Hasta ahora habíamos utilizado la clase Scanner para hacer
la entrada de datos por teclado. Dicha clase debemos importarla en nuestro
programa con la sintaxis:
import java.util.Scanner;
Otra sintaxis para importarla es:
import java.util.*;
Si disponemos un * indicamos que importe todas las clases
del paquete java.util.
Ahora bien las componentes Swing hay que importarlas del
paquete javax.swing. Cuando debemos importar varias componentes de un paquete
es más conveniente utilizar el asterisco que indicar cada clase a importar:
import
javax.swing.JFrame;
import
javax.swing.JLabel;
En lugar de las dos líneas anteriores es mejor utilizar la
sintaxis:
import javax.swing.*;
La clase JFrame encapsula el concepto de una ventana. Luego
para implementar una aplicación que muestre una ventana debemos plantear una
clase que herede de la clase JFrame:
public
class Formulario extends JFrame{
Con la sintaxis anterior estamos indicando que que la clase
Formulario hereda todos los métodos y propiedades de la clase JFrame.
Para mostrar un texto dentro de una ventana necesitamos
requerir la colaboración de la clase JLabel (que tiene por objetivo mostrar un
texto dentro de un JFrame)
Definimos luego como atributo de la clase un objeto de la
clase JLabel:
private JLabel
label1;
En el constructor de la clase llamamos al método heredado de
la clase JFrame llamado setLayout y le pasamos como parámetro un valor null,
con esto estamos informándole a la clase JFrame que utilizaremos
posicionamiento absoluto para los controles visuales dentros del JFrame.
public
Formulario() {
setLayout(null);
Luego tenemos que crear el objeto de la clase JLabel y
pasarle como parámetro al constructor el texto a mostrar:
label1=new
JLabel("Hola Mundo.");
Ubicamos al objeto de la clase JLabel llamando al método
setBounds, este requiere como parámetros la columna, fila, ancho y alto del
JLabel. Finalmente llamamos al método add (metodo heredado de la clase JFrame)
que tiene como objetivo añadir el control JLabel al control JFrame.
label1=new
JLabel("Hola Mundo.");
label1.setBounds(10,20,200,30);
add(label1);
}
Finalmente debemos codificar la main donde creamos un objeto
de la clase Formulario, llamamos al método setBounds para ubicar y dar tamaño
al control y mediante el método setVisible hacemos visible el JFrame:
public static void main(String[] ar) {
Formulario formulario1=new
Formulario();
formulario1.setBounds(10,10,400,300);
formulario1.setVisible(true);
}
Cuando ejecutamos nuestro proyecto tenemos como resultado
una ventana similar a esta:
martes, 29 de noviembre de 2016
Swing-JFrame (JAVA-ECLIPSE)
JFRAME EN JAVA
La clase JFrame implementa un objeto ventana, JFrame es una extensión de
la clase Frame del paquete AWT.
Para crear una ventana, existen dos formas principales de hacerlo:
Crear un objeto de la clase JFrame
Extender la clase JFrame
El último método es muy útil cuando se crean ventanas personalizadas que
se invocan repetidamente (como ventanas de error, o de información).
Crearemos una ventana con el primer método:
ventana = new JFrame();
Una vez creado una ventana JFrame, ésta obtiene el tamaño necesario para
mostrar los componentes que existen dentro de la aplicación, como en nuestro
ejemplo no existe componente, cambiaremos su tamaño inicial, con el método:
setSize(int ancho, int largo)
Después cambiaremos su título para que sea el nombre de nuestra
aplicación con el método: setTitle(String titulo)
ventana.setTitle("Hola mundo
Swing");
El objeto existe, pero no es mostrado por defecto, entonces se hace la
llamada a: setVisible(boolean)
ventana.setVisible(true);
La componente básica que requerimos cada vez que implementamos una
interfaz visual con la libraría Swing es la clase JFrame. Esta clase encapsula
una Ventana clásica de cualquier sistema operativo con entorno gráfico
(Windows, OS X, Linux etc.)
Hemos dicho que esta clase se encuentra en el paquete javax.swing y como
generalmente utilizamos varias clases de este paquete luego para importarla
utilizamos la sintaxis:
import javax.swing.*;
Podemos hacer una aplicación mínima con la clase JFrame:
import javax.swing.JFrame;
public class Formulario {
public static void main(String[] ar) {
JFrame f=new JFrame();
f.setBounds(10,10,300,200);
f.setVisible(true);
}
}
Como vemos importamos la clase JFrame del paquete javax.swing:
import javax.swing.JFrame;
y luego en la main definimos y creamos un objeto de la clase JFrame
(llamando luego a los métodos setBounds y setVisible):
public static void main(String[] ar) {
JFrame f=new JFrame();
f.setBounds(10,10,300,200);
f.setVisible(true);
}
Pero esta forma de trabajar con la clase JFrame es de poca utilidad ya
que rara vez necesitemos implementar una aplicación que muestre una ventana
vacía.
Lo más correcto es plantear una clase que herede de la clase JFrame y
extienda sus responsabilidades agregando botones, etiquetas, editores de línea
etc.
Entonces la estructura básica que emplearemos
para crear una interfaz visual será:
import javax.swing.*;
public class Formulario extends JFrame{
public Formulario() {
setLayout(null);
}
public static void main(String[] ar) {
Formulario
formulario1=new Formulario();
formulario1.setBounds(10,20,400,300);
formulario1.setVisible(true);
}
}
Importamos el paquete donde se encuentra la clase JFrame:
import javax.swing.*;
Planteamos una clase que herede de la clase JFrame:
public class Formulario extends JFrame{
En el constructor indicamos que ubicaremos los controles visuales con
coordenadas absolutas mediante la desactivación del Layout heredado (más
adelante veremos otras formas de ubicar los controles visuales dentro del
JFrame):
public Formulario() {
setLayout(null);
}
En la main creamos un objeto de la clase y llamamos a los métodos
setBounds y setVisible:
public static void
main(String[] ar) {
Formulario
formulario1=new Formulario();
formulario1.setBounds(10,20,400,300);
formulario1.setVisible(true);
}
El método setBounds ubica el JFrame (la ventana) en la columna 10, fila
20 con un ancho de 400 píxeles y un alto de 300.
Debemos llamar al método setVisible y pasarle el valor true para que se
haga visible la ventana.
Swing - JButton (JAVA-ECLIPSE)
Swing - JButton(JAVA-ECLIPSE)
El tercer
control visual de uso muy común es el que provee la clase JButton. Este control
visual muestra un botón.
El proceso
para añadir botones a un control JFrame es similar a añadir controles de tipo
JLabel.
Ahora
veremos la captura de eventos con los controles visuales. Uno de los eventos
más comunes es cuando hacemos clic sobre un botón.
Java
implementa el concepto de interfaces para poder llamar a métodos de una clase
existente a una clase desarrollada por nosotros.
Problema 1:
Confeccionar
una ventana que muestre un botón. Cuando se presione finalizar la ejecución del
programa Java.
Programa:
La mecánica
para atrapar el clic del objeto de la clase JButton se hace mediante la
implementación de una interface. Una interface es un protocolo que permite la
comunicación entre dos clases. Una interface contiene uno o más cabecera de
métodos, pero no su implementación. Por ejemplo la interface ActionListener
tiene la siguiente estructura:
interface ActionListener {
public void actionPerformed(ActionEvent e) {
}
Luego las
clases que implementen la interface ActionListener deberán especificar el
algorítmo del método actionPerformed.
Mediante el
concepto de interfaces podemos hacer que desde la clase JButton se puede llamar
a un método que implementamos en nuestra clase.
Para
indicar que una clase implementará una interface lo hacemos en la declaración
de la clase con la sintaxis:
public class Formulario extends JFrame implements ActionListener {
Con esto
estamos diciendo que nuestra clase implementa la interface ActionListener,
luego estamos obligados a codificar el método actionPerformed.
Definimos
un objeto de la clase JButton:
JButton boton1;
En el
constructor creamos el objeto de la clase JButton y mediante la llamada del
método addActionListener le pasamos la referencia del objeto de la clase
JButton utilizando la palabra clave this (this almacena la dirección de memoria
donde se almacena el objeto de la clase JFrame, luego mediante dicha dirección podemos
llamar al método actionPerformed):
public Formulario() { setLayout(null); boton1=new
JButton("Finalizar");
boton1.setBounds(300,250,100,30);
add(boton1);
boton1.addActionListener(this);
}
El método
actionPerformed (este método de la interface ActionListener debe implementarse
obligatoriamente, en caso de no codificarlo o equivocarnos en su nombre
aparecerá un mensaje de error en tiempo de compilación de nuestro programa.
El método
actionPerformed se ejecutará cada vez que hagamos clic sobre el objeto de la
clase JButton.
La
interface ActionListener y el objeto de la clase ActionEvent que llega como
parámetro están definidos en el paquete:
import java.awt.event.*;
Es decir
que cada vez que se presiona el botón desde la clase JButton se llama al método
actionPerformed y recibe como parámetro un objeto de la clase ActionEvent.
En el
método actionPerformed mediante el acceso al método getSource() del objeto que
llega como parámetro podemos analizar que botón se presionó:
public void actionPerformed(ActionEvent e) {
if (e.getSource()==boton1)
{
System.exit(0);
}
}
Si se
presionón el boton1 luego el if se verifica verdadero y por lo tanto llamando
al método exit de la clase System se finaliza la ejecución del programa.
La main no
varía en nada con respecto a problemas anteriores.
Suscribirse a:
Entradas (Atom)