Ejemplos creando JFrame y JOptionPane

Es muy útil que nos vayamos introduciendo al mundo del ambiente gráfico en Java. Para ello hoy en día se utiliza el popular paquete de javax.swing. Las librerías swing nos aportan una serie de componentes y contenedores para realizar aplicaciones de escritorio.

Como ya en varios ejercicios se ha estado utilizando la famosa clase estática JOptionPane, ahora veremos las diferencias y cómo instanciar un nuevo formulario, que en el Swing es llamado JFrame. Así podremos ver las diferencias y podemos aprender a crear nuestros primeros formularios en Java.

Lo haremos utilizando el ejercicio que se usó en un parcial. Que se calcularan los factoriales de los números impares menores que 2 y se mostraran al usuario. Se hará de dos formas: con un JOptionPane y con un JFrame.

Antes que nada creamos la clase factorial que nos devolverá el factorial del número que se le ingrese:


package factoriales21;
/** * * @author Hugol */
public class factorial {


private int numero;
private double resultado;

//Constructor
public factorial(int num){
this.numero=num;
this.resultado=1;
}

//Devuelve el factorial
public double devolverFactorial(){
for (int i=1; i<=this.numero;i++){
this.resultado*=i;
}
return this.resultado;
}
}


Ahora, dentro de la clase Main instanciaremos nuestro JFrame y el JOptionPane, para que muestre los factoriales debidos. Se hace de esta manera. Note que el código está debidamente documentado:


package factoriales21;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;

/** * * @author Hugol */

public class Main {

public static void main(String[] args) {

//Creamos un nuevo JTextArea
JTextArea area = new JTextArea();

//Instanciamos un nuvo JFrame, pasándole como argumento, el título
JFrame form = new JFrame("Este es un JFrame");

//Variable para almacenar la salida en pantalla
String salida = "Los factoriales de los numeros impares menores que 21 son:\n";

for (int i=1;i<=21;i++){
if(i%2 != 0){
factorial obj=new factorial(i);
salida = salida + String.valueOf(obj.devolverFactorial()) +", ";
}
}

//La salida en pantalla se la asignamos como texto al JTextArea
area.setText(salida);

//Llamamos un nuevo JOptionPane
JOptionPane.showMessageDialog(null, area, "Este es un JOptionPane", JOptionPane.INFORMATION_MESSAGE);

//Con esta sentencia declaramos que cuando se cierre el JFrame la aplicación se cierra también form.setDefaultCloseOperation(javax.swing.WindowConstants.
EXIT_ON_CLOSE);

//Añadimos el componente JTextArea al JFrame
form.add(area);

//Le asignamos como posición del JFrame, el centro de la pantalla
form.setLocationRelativeTo(null);

//Con esta sentencia, le asignamos el tamaño de lo que contiene al JFrame
form.pack();

//Colocamos visible al usuario el formulario
form.setVisible(true);
}
}

Y ahi tenemos la aplicación. Se tiene que ver muy parecido a esto:

Resoluciones de ejercicios de Primeros Parciales Programación II

Para que no nos suceda esto, practiquemos más...

Buenas!

Luego de los resultados del primer parcial en todos los grupos teóricos, hemos decidido entre los encargados de impartir la cátedra, que haremos un pequeño refuerzo a todos los estudiantes para lograr nivelar los conocimientos de todos en miras hacia los siguientes parciales y evaluaciones de laboratorio.

Es por esto que la semana previa a vacaciones resolveremos los ejercicios evaluados en este pasado parcial. Aunque algunos de Uds. ya los resolvieron, añado mis soluciones en el siguiente link:

http://www.mediafire.com/download.php?5u0mwzo2ldg

El presente archivo en formato RAR consta de las siguientes soluciones:

• Dibujar un histograma a partir de un vector de enteros.
• Descomponer una cantidad de dinero en el número mínimo de billetes que se puede tener.
• Encontrar el mayor y el menor de 4 números ingresados por el usuario con la ayuda de la clase Math.
• Obtener el factorial de los números impares menores de 21 y mostrarlos en un JTextArea.

Al descargar el RAR conseguirá los proyectos en Netbeans de cada uno de esos problemas.

Cualquier duda o sugerencia hacérmela llegar a mi correo o por comentario a esta entrada.

Mi correo es: hugol.barrientos@gmail.com

Saludos y suerte en las evaluaciones venideras

Herencia Múltiple en Java, ¿Conveniente o no?

Todos sabemos que la herencia es un mecanismo propio de la programación orientada a objetos POO. Nos permite crear clases a partir de otra, las cuales las unen vínculos sumamente estrechos, casi de familia. Es por ello que se llama herencia.

Si buscamos modelar nuestras clases u objetos como propios de la realidad, todos los conceptos de la orientación a objetos nos serán muy fácil de implementar mientras programamos.

Implementando herencia tenemos las siguientes ventajas:

• Modelado de la realidad
• Evitar redundancias en el código
• Facilita la reutilización del código, así como reduce el número de líneas a escribir
• Sirve como el soporte o la base para el polimorfismo

Es muy sencilo implementar la herencia de clases en Java. Basándonos en el diagrama de arriba, si queremos crear la clase gallina solo debemos de interponer la palabra reservada extends. Por lo tanto la declaración de la clase quedaría constituida de la siguiente manera:

public class Gallina extends Ave{
}

Ahora podemos tener dentro de gallina, todos los atributos y métodos propios de una Ave.

Esta forma de herencia es llamada herencia simple, ya que solamente hay una clase padre o superclase. Existe una forma de herencia definida dentro de los conceptos de la programación orientada a objetos en la cual una clase puede heredar de dos o más clases padres o superclases. Se llama Herencia Múltiple.

La herencia múltiple en java no es soportada nativamente. Sin embargo muchos autores y desarrolladores la simulan utilizando la palabra reservada implements e interfaces, que sirve para implementar o cubrir una clase con respecto a otra.

Supongamos el siguiente escenario:


Un alumno de la cátedra de Programación II además que es una persona consagrada, también es un hijo de familia que debe responder con buenas notas en su travesía por la universidad. Es decir que una clase alumno debería de heredar de ambos objetos. Hacer este pequeño diagrama UML en código Java no se puede nativamente hablando, solamente con una simulación. La manera de realizarla es la siguiente:

public class Persona {

}


public class Hijo{
}
interface iHijo{
//La interface pertenece a la clase Hijo
}


public class Alumno extends Persona implements iHijo{
}

Con la ayuda de las interfaces simulamos la herencia múltiple. Una interface no es más que la implementación de los métodos de una clase. Con la ayuda de éstos podemos accesar a los métodos de la clase Hijo y heredar directamente todo lo que pertenece a Persona. Fácil, pero a la vez confuso, ¿No?

Conclusión: ¿Se debe utilizar la herencia múltiple? A mi forma de pensar, si no está implementada nativamente, se debería de evitar el uso de una simulación que va en contra de la naturaleza del lenguaje. Además pienso que todo problema que o esquema de clases se pueden llegar a plantear de forma que solamente utilicemos la herencia simple, ya que es más sencilla y es más natural que se herede de un solo padre.

Como ejercicio al lector, le pido que plantee el esquema de clases para el ejemplo utilizado en la simulación de la herencia múltiple. ¿Cómo lo plantearía con herencia simple?

Clases, métodos, herencia, constructores y POO

Guía de Laboratorio 2: Métodos, Constructores y Herencia

Auxiliar de Cátedra: Hugo Alejandro Barrientos


Esta guía de práctica es una continuación de la número 1 en donde se realizó un programa básico en modo consola, llamado cariñosamente “Silabario para programadores principiantes”. Ahora, lo diseñaremos en base a clases bien encapsuladas, que contengan sus métodos y propiedades, getters y setters, además de la implementación de la herencia simple, la única soportada nativamente en Java.

Además, como un refuerzo se explicará la función super(), propia de nuestro lenguaje de programación.


SUPER()
Si se necesita llamar al método padre dentro de una clase que ha reemplazado ese método, se puede hacer referencia al método padre con la palabra clave super().

Cuando se declara una clase heredando explícitamente de otra como en el código siguiente:


class base {
int datoBase;

public base() {
System.out.println( "Dentro del Constructor de la clase base" );
System.out.println( "Asignando a datoBase 100" );
datoBase = 100;
}
}


class hijoBase extends base {
int datoSubClase;

// Constructor de la Subclase
public hijoBase() {
// Llamada al constructor de la clase base
super();
System.out.println( "Dentro del Constructor de la subclase" );
System.out.println( "Asignando a datoSubClase 200" );
datoSubClase = 200;
}

El programa también utiliza super para invocar al constructor de la superclase desde el constructor de la subclase.

PREGUNTA: Si instanciamos la clase hijoBase, ¿Cuál es la impresión en consola de la porción de código de arriba?

También sirve para llegar a atributos de las superclases. De la siguiente manera:

class ave{

String nombre;
String colorPlumas;
}

class pato extends ave{

public pato(){
super.colorPlumas=”Blanco”;
}
}
Instanciando la clase pato podemos acceder a la propiedad colorPlumas, que está definida como propiedad de un ave.

Pregunta: ¿Existe la herencia múltiple en Java? ¿Por qué?

Esta guía se encargará de fortalecer los conceptos de clases, métodos, propiedades o atributos, herencia, constructores y acerca de los métodos Get y Set. Todo esto con ayuda del programa realizado en la guía anterior con nuestro “Silabario para programadores”. El trabajo estructurado de la semana pasada ahora lo traslademos a una aplicación, siempre en el ambiente consola, en la cual definamos con un alto grado de encapsulamiento, las clases que harán posible la realización de la aplicación y llevarán definida todo el funcionamiento, o lo que es mismo, la capa de negocios del programa.


El ejemplo es sencillo. El Silabario lo que realiza es una serie de operaciones básicas que resuelven 4 tipos de problemas distintos: El factorial de número, la tabla de multiplicar de un número, la clasificación de la edad del usuario y la elección de la estación del año favorita del usuario. El silabario además, tiene la característica que el programador escogerá la sentencia o instrucción básica que brinde la solución más sencilla y óptima para cada uno de los problemas.

Para efectos de esta práctica, y porque creo que es la mejor manera de poder apreciar las clases y objetos de este ejercicio, definiremos cada clase como una clase “Operación”, que es la que facilitará y tendrá las herramientas necesarias para efectuar la resolución de cada uno de los problemas.

Un objeto operación necesita de propiedades o atributos. Una operación necesita de operadores, uno, dos ó más. Es por eso que definiremos dos atributos para realizar dichas operaciones. Con dos bastarán para este ejercicio.
Los métodos de esta clase son muy variados. Cada una de las operaciones realizará uno diferente, por lo tanto no cabe dentro de la percepción de un objeto “Operación” básico, la definición de cada uno de los métodos.
Los métodos que sí se necesitarían son los populares métodos GET y SET, que nos sirven para leer y cambiar los valores de una propiedad específica. Como hemos definido propiedades, éstas necesitan de sus getters y setters. La clase de una Operación Básica para el silabario quedará así:


public class operacionBase {

protected int operador;

public operacionBase(){
this.operador=0;
}

public void setOperador(int o){
this.operador=o;
}

public int getOperador(){
return this.operador;
}
}

Declaramos la propiedad con visibilidad protected por motivos de seguridad, para que solamente los miembros de esa clase y los que heredan de ella, es decir las subclases, puedan accesar a estos atributos.

Como hemos definido ya una clase base, ahora podremos definir el resto de clases que podrán heredar de la clase base. Cabe destacar que no siempre se podrá hacer una clase base y con respecto a esta empezar a heredarles a otras. Esto depende de la naturaleza de cada aplicación, y de la manera de cómo el programador diseñe su capa de negocios.

Para realizar la clase que nos devuelva el factorial de un número, el programador puede escoger la instrucción While. Por lo tanto el programador debe desarrollar el método que reciba como parámetro el número del que se desee el factorial y que devuelva el resultado esperado. Heredando de la clase base, tenemos ya garantizados los atributos y métodos propios de la misma, por lo tanto, la clase para realizar el factorial del número podría quedar así:


public class operacionFactorial extends operacionBase{


public operacionFactorial(){
super();
}

public int devolverFactorial(){
int factorial=1;
int cont=1;

while (cont <= this.operador) { factorial *= cont; cont++; } return factorial;
}
}

El diagrama UML nos ayudará a comprender mejor la herencia y estructura de estas clases:


Como puede observar el programador, se utiliza la propiedad “operador” cuya definición pertenece a la clase base. Sin embargo, como la clase “operacionFactorial” hereda todos los atributos y métodos de la clase básica, podemos hacer un llamado a dicha propiedad con la ayuda de la sentencia “this”.

PREGUNTAS: ¿Trabajaría igual el constructor si se suprime la sentencia super()? ¿Cómo capturo las variables que el usuario ingresa y se las transmito a la función devolverFactorial()?


Ejercicio:

Realizar la siguiente aplicación utilizando clases, herencia, métodos, propiedades, constructores y los métodos GET y SET:

• Desarrollar un ecosistema, en donde se puedan crear tener distintos animales de todas las clasificaciones: mamíferos, aves, reptiles y anfibios.
• Se deben de crear clases para cada tipo de especie, y para las especies más comunes que el programador quiera definir.
• El usuario final debe tener la potestad de crear todos los animales (instancias) que desee, y diferenciarlas de acuerdo a algún identificador. Se deben de poder plasmar en la consola la lista de animalitos creados

Ejercicios propuestos:

Desarrollar un programa en Java con todos los elementos vistos en este laboratorio que maneje las disciplinas deportivas que se practican en unos juegos olímpicos, con la misma dinámica del ejercicio anterior.

Programa para manejar las instrucciones básicas en JAVA

Este programa es funciona como un "Silabario para programadores principiantes" en Java. Así será llamado cariñosamente este ejercicio. Lo que se busca es que el programador utilice la instrucción más adecuada para resolver 4 problemas distintos:

* Factorial de un número
* Tabla de multiplicar de un número
* Clasificar la edad del usuario
* Escoger la estación del año favorita del usuario y se muestre un mensaje alusivo.

Así, cada programador logrará discernir sobré cuá instrucción le sirve para resolver cada problema específico.

Este es mi programa para este enunciado. He escogido resolver cada uno de esos problemas con una instrucción distinta. Es claro que pueden haber muchas más soluciones, cada una diferente y correcta. Espero que les sirva:


package basico;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
*
* @author Hugol
*/

public class Main {

public static void main(String[] args) {


BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

String s = null;
char car= ' ';
int opcion = 10, op=0;

do{
System.out.println("Programa que nos muestra las sentencias básicas dentro de Java");
System.out.println("Elija una Opción:\n 1. Sentencia If-Else\n 2. Sentencia While\n 3. Sentencia Do-While\n 4. Sentencia For\n 5. Sentencia Switch\n 0. Salir");

try{
try {
s = in.readLine();
opcion = Integer.parseInt(s);

switch (opcion){

case 0:
break;

case 1:
System.out.println("Ingresa una edad: ");
s = in.readLine();
int edad = Integer.parseInt(s);

String mensaje="";

if (edad<=18) mensaje="Estas joven aún";
else
if (edad<=30) mensaje="Eres un adulto"; else

mensaje="Estás para el tigre";

System.out.println(mensaje);

s = in.readLine(); //Engaño al compilador y detengo la ejecución esperando que el usuario ingrese una tecla para observar la respuesta

break;

case 2:
System.out.println("Factorial de un Número con While. Ingrese un número: ");
s = in.readLine();
int factor = Integer.parseInt(s);
int factorial=1;
int cont=1;

while (cont <= factor) { factorial *= cont; cont++; } System.out.println("El Factorial de "+factor+" es "+factorial); s = in.readLine(); //Engaño al compilador y detengo la ejecución esperando que el usuario ingrese una tecla para observar la respuesta
break;

case 3:
System.out.println("Factorial de un Número con Do-While. Ingrese un número: ");
s = in.readLine();
int factor2 = Integer.parseInt(s);

int factorial2=1;
int cont2=0;

do{
cont2++;
factorial2*=cont2;

}while(cont2 < = factor2); s = in.readLine(); //Engaño al compilador y detengo la ejecución esperando que el usuario ingrese una tecla para observar la respuesta
break;

case 4:
System.out.println("Ingrese un número para generar su tabla de multiplicar: ");
s = in.readLine();
int multiplo = Integer.parseInt(s);

String tabla="";
int parcial=0;

for (int i=1; i<=10; i++){
parcial = i*multiplo;
tabla += i + " x " + multiplo + " = " + parcial +"\n";
}

System.out.println(tabla);
s = in.readLine(); //Engaño al compilador y detengo la ejecución esperando que el usuario ingrese una tecla para observar la respuesta
break;

case 5:
System.out.println("¿Qué estación del año prefieres? Ingresa una opción:\n p. Primavera\n v. Verano\n o. Otoño\n i. Invierno\n ");
s = in.readLine();

if (s.length()==1)
car=s.charAt(0);
else
car='e';

String mens=" ";

switch(car){

case 'p': mens="SPRING BREAK";
break;

case 'v': mens="SUMMER VACATIONS";
break;

case 'o': mens="RED LEAVES";
break;

case 'i': mens="WHITE SNOW";
break;

default: mens="¿Tecla incorrecta?";
break;
}

System.out.println(mens);
s = in.readLine(); //Engaño al compilador y detengo la ejecución esperando que el usuario ingrese una tecla para observar la respuesta
break;

default: System.out.println("Opción inválida");
break;
}
} //FIN TRY
catch (NumberFormatException e) {
System.out.println("Opción inválida");
s = in.readLine();
} //FIN CATCH
} //FIN TRY
catch(IOException ex){
System.out.println("Error de entrada de datos");
} //FIN CATCH

}while (opcion!=0 );

} //FIN MAIN

} //FIN CLASS


El proyecto en Netbeans de dicho código lo encontrarán bajo esta dirección:

http://www.megaupload.com/?d=I72K0LLN

El libro de Java, Cómo Programar de Deitel y Deitel en su Quinta Edición lo pueden descargar desde este link:

http://rs180.rapidshare.com/files/53060913/Como52157486.rar. Pesa 100 Mb

Recuerden que es la Quinta edición. Si tiene la posibilidad de adquirir la Séptima, no lo duden en hacerlo.

Cambiar la versión de JDK para ejecutar archivos JAR en Debian Linux

Cuando cambiamos de versión del JDK en nuestro Debian y queremos ejecutar como si nada ha pasado nuestros archivos jar con el comando "java -jar", tenemos ciertos problemas, ya que el vínculo hacia el JDK viejo o si se carecía del mismo no hará efecto al JDK nuevo. Más si se ha instalado en otra ubicación.

Eso no importa. aquí está esta pequeña guía para hacerlo:


Solicitamos primero la versión actual del JDK:

hugo:/home/hugol/Desktop# java -version

java version "1.4.2"
gij (GNU libgcj) version 4.1.2 20061115 (prerelease) (Debian 4.1.1-20)

Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Vemos que la actual versión es java version "1.4.2". Tenemos que cambiar a la última, que es la versión 1.6.0. Se hace con el comando update-alternatives, al cual se le pasa la dirección del comando, el comando y la nueva ubicación a la que hará referencia dicho comando. Se hace de la siguiente manera:

hugo:/home/hugol/Desktop# update-alternatives --install /usr/bin/java java /usr/share/java/jdk1.6.0_11/bin/java 120

Ahora pedimos de nuevo la versión del JDK, para cerciorarnos que los cambios han tenido efecto:

hugo:/home/hugol/Desktop# java -version
java version "1.6.0_11"
Java(TM) SE Runtime Environment (build 1.6.0_11-b03)
Java HotSpot(TM) Client VM (build 11.0-b16, mixed mode, sharing)

Sencillo programa con sentencias básicas

Guía de Laboratorio 1: Sentencias Básicas en Java.

Auxiliar de Cátedra: Hugo Alejandro Barrientos

En esta guía se pondrán en uso todas las sentencias e instrucciones básicas de la programación para el lenguaje Java, utilizando el popular IDE Netbeans 6.1 para Debian. Las instrucciones que se tomarán en cuenta para realizar estos sencillos ejemplos son:

IF-ELSE
WHILE
DO-WHILE
FOR
SWITCH

También se explicará brevemente otro bloque importante y propio de los lenguajes orientados a objetos: la sentencia TRY-CATCH:

TRY-CATCH es una instrucción básica en la programación dentro de Java y que se utiliza fundamentalmente para el manejo de errores y excepciones.

Su sintaxis es así:

try{

//código del programa
}
catch (NombreDeExcepcion obj){

//código de contingencia para tratar el error
}

Dentro de las llaves del TRY se escribe todo el código del programa y que es susceptible a cualquier tipo de error. Dentro del catch, y definiendo el tipo de excepción que se puede dar, se escriben las líneas que tratarán de paliar dicho error.

Un ejemplo de esta sentencia:

String s = “a”;
try{
char car=s.charAt(0);
}
catch(IndexOutOfBoundsException e){
e.printStackTrace();
}

Preguntas: ¿Cuál es la esencia de esta porción de código? ¿Entra esa porción de código al CATCH? ¿Por qué?

El objetivo de esta guía es realizar un programa en ambiente consola para cimentar las bases de los programadores en la utilización de las instrucciones básicas. El programa debe estar diseñado para que el usuario ingrese seleccione mediante una opción la rutina que quiere ejecutar, y que debe de ser implementada por alguna de las instrucciones básicas mencionadas al principio de esta guía.

Los casos o rutinas que debe desarrollar el programador son:
• El factorial de un número
• La tabla de multiplicar de un número
• Clasificar la edad del usuario
• Seleccionar la estación del año favorita del usuario y que muestre un mensaje alusivo a la misma.

El programador debe ser capaz de seleccionar la instrucción o sentencia básica idónea para cada caso.

Ejemplo:

Se empezará por obtener el factorial de un número. Conociendo el procedimiento de tal operación, se escogerá realizarlo mediante las sentencias WHILE y DO-WHILE, en vista que el programador pueda verificar ambos procesos para una misma operación:


Factorial utilizando WHILE

int factorial=1; //acumulador
int cont=1; // contador
int valor=10; //número del que queremos el factorial

while (cont <= valor) { factorial *= cont; cont++; }

Factorial utilizando DO-WHILE

int factorial=1; //acumulador
int cont=0; // contador
int valor=10; //número del que queremos el factorial

do{
cont++;
factorial*=cont;
}while(cont < valor)

Pregunta: ¿Puede ver la diferencia entre ambos bucles? ¿Dónde radica la diferencia entre ambos?


Ejercicios:

1. Se le pide al programador que realice las porciones de código restantes, utilizando su buen criterio para utilizar las instrucciones básicas restantes. Los ejercicios restantes son:

• La tabla de multiplicar de un número
• Clasificar la edad del usuario
• Seleccionar la estación del año favorita del usuario y que muestre un mensaje alusivo a la misma.

2. Realice una aplicación Java en modo consola en Netbeans en donde el usuario pueda escoger cualquiera de las porciones de código creadas por Ud. para que se ejecuten. Puede utilizar cualquiera de las sentencias básicas para la creación de su aplicación.

3. Se solicita que su aplicación también se pueda desarrollar todas las veces que el usuario desee.

4. Debe además manejar los tipos de excepciones que se le presenten.


Algunos consejos:

• Para ingreso de datos mediante teclado, puede utilizar la clase BufferedReader de java.io

• No se preocupe por la orientación a objetos. Trabaje de forma estructurada POR ESTA VEZ.

• Trate de leer toda la información que el IDE le brinda. El tipo de datos que los métodos utilizan, los que devuelven, las excepciones que generan, etc.

• Es útil la conversión entre tipos de datos. Si no conoce cómo hacerlo, favor pregunte a su instructor.