Java Para Todos

Programas destacados de Tarea Ex Aula Programación II Ciclo I/09

2009-06-13T14:17:00.000-07:00

Tengo el agrado de mostrar los mejores trabajos que los alumnos de Programación II de la Universidad de El Salvador de la FMO entregaron como parte de las prácticas de dicha materia. Este trabajo valía 1 punto de la nota global.

Por cada clave, los mejores trabajos fueron los siguientes:

PROCESADOR DE TEXTO

El grupo de práctica No. 1 entregó dicha clave, y el mejor trabajo fue elaborado por:

Nelly Celinda Hernández González
José Guillermo Ruiz Vargas

Su trabajo puede ser descargado desde el siguiente link:

http://www.megaupload.com/?d=3YKTA547

INFORMACIÓN PERSONAL Y LLENADO DE JTABLES

El mejor programa de esta clave fueron los estudiantes:

Gabriel Enrique Carballo Portillo
Herber Oswaldo Gómez Arana

Pueden descargar su programa en este link:

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

Mención honorífica para:

María José Romualdo Villalta
Luis Mario Siguenza Cruz

Quedaron descalificados de esta mención Alberto Moreno y Wendy Chicas por haber dejado el CD en blanco.

PROGRAMA DE ENCUESTAS

El mejor fue el estudiante:

Edgardo Caleb Flores Brizuela

Puede descargarlo de este link:

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

Mención honorífica para:

Giovany Rosales Hernández
Julianne Michelle Polanco Aragón

GENERADOR DE NÚMEROS ALEATORIOS

El mejor trabajo fue presentado por los estudiantes:

Nefi José Cetino Velásquez
Juan Carlos Mendoza Dimas

Pueden descargarlo desde este link:

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

Además hubo otros trabajos muy buenos. Mención honorífica para:

Rafael Manfredo
Jorge Guerra Quant

Juan Carlos Arteaga Ortiz
Francisco Ovidio Castillo Lico

Pablo Oswaldo Portillo Alvarado
Karla Flor Grissel Chicas Blanco

CARRITO DE COMPRAS

Hubo triple empate en esta clave. Los mejores trabajos fueron de los siguientes autores:

Isaac Alexander Gómez Recinos

Kevin Garay Calderón
Neyson Ramírez Ascencio

Byron Ernesto Guerrero Landaverde
Oscar Gustavo Rodríguez Umaña

Los tres programas pueden ser descargados desde el siguiente link:

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

JUEGO DE MEMORIA

El mejor trabajo fue entregado por el alumno:

Edwin de Jesús Mendoza Granadino

Descarguen este juego desde el siguiente link:

http://www.megaupload.com/?d=40O19FYS

JUEGO DE EQUIS CERO

El mejor juego lo entregó:

Franklin Martínez

Descárguenlo desde este link:

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

Hubo otros buenos juegos. Menciones honoríficas para:

Denis Stanley Urbina Jiménez

César Ernesto Quezada Peñate

Elias Ricardo Zaldaña Herrera
Victor Manuel Rivera Barrera
Walter Ernesto Hernández Ramírez

Este su servidor se desliga de cualquier error que puedan tener dichos programas. Recuerden que todos son proyectos de Netbeans 6.1 o superior, utilizando JDK 1.6

Material para parcial 4 Programación II 2009

2009-06-13T13:38:00.000-07:00

Hola a todos!

El material para el cuarto y último examen parcial de Programación II del Ciclo I/09 se encuentra ya a su disposición para que lo descarguen a través del siguiente link:

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

Recuerden que el parcial será práctico. Dispondrán de 50 minutos para su elaboración. Quien disponga de una laptop para realizarlo no dude en llevarla.

Recuerde que al final tendrán que enviar su programa a la siguiente dirección de correo electrónico:

examenesytareas@gmail.com

Es por ello que les solicito que creen una cuenta en GMAIL de correo electrónico para enviar su examen y evitar los ya conocidos incidentes con hotmail. SI USTED NO LO ENVÍA AL FINALIZAR EL EXAMEN SE LE ADJUDICARÁ UNA NOTA DE 1.

Buena suerte!!!

Componentes avanzados en Swing de Java

2009-06-07T23:49:00.000-07:00

Programación II
Guía de Laboratorio 5: Componentes GUI avanzados de Swing
Desarrollo del 8 al 12 de junio de 2009
Auxiliar de Cátedra: Hugo Alejandro Barrientos

Esta guía está dedicada para manejar algunos de los componentes avanzados que provee Swing para aplicaciones Desktop. Esta guía consiste en elaborar un selector de color construyéndolo a partir del Modelo de Color RGB y con componentes Swing como JPanels, JSliders y JSpinners, entre otros. Además cambiaremos la apariencia de nuestras aplicaciones Swing de Java.

Modelo de Color RGB

El modelo de color RGB, del inglés Red, Green, Blue, hace referencia a la composición de colores en términos de la intensidad de los colores primarios con que se forma: el rojo, el verde y el azul. Es un modelo de color basado en la síntesis aditiva, con el que es posible representar un color mediante la mezcla por adición de los tres colores luz primarios. Indicar que el modelo de color RGB no define por sí mismo lo que significa exactamente rojo, verde o azul, razón por la cual los mismos valores RGB pueden mostrar colores notablemente diferentes en diferentes dispositivos que usen este modelo de color. Aunque utilicen un mismo modelo de color, sus espacios de color pueden variar considerablemente.

JSlider

Los objetos JSlider permiten al usuario seleccionar de entre un rango de valores enteros, La clase JSlider hereda de JComponent. Está compuesto por el indicador, con el que seleccionamos el valor deseado y las marcas, que nos muestran cuáles son los valores a escoger.

JSpinner

Los objetos JSpinner permiten al usuario seleccionar un número y recorrer la lista de los mismos.

Apariencia Visual Adaptable

Los componentes Swing por el hecho que son controles ligeros, es decir que no dependen de la plataforma para asumir una apariencia visual, se pueden adaptar a otras “pieles” o Look and Feels. Sehace con la clase UIManager. Para esta guía utilizaremos el Look and Feel Substance

Luego de esta introducción teórica, para empezar esta guía, construyamos una GUI con el Netbeans Designer que luzca así:

Consiste en:

3 JSlider
3 JSpinner
1 JPanel
3 JLabel
1 JButton (otra parte de la práctica)

Moviendo los JSliders o modificando la cantidad de los JSpinners debemos modificar el color que se muestra en el panel de la derecha. Para ello, crearemos un método en el cual le cambiaremos el color del panel con su método setBackground() crearemos un nuevo color con modelo RGB con la ayuda de los valores de cada JSlider o JSpinner:

public void cambiarColor()
{
colorJPanel.setBackground( new java.awt.Color(
JSliderRojo.getValue(), JSliderVerde.getValue(),
JSliderAzul.getValue() ) );
}

Cada JSlider y JSpinner debe modificar al control contrario pero que manejan el mismo color. En los eventos StateChange() de cada uno debe ir código similar a este:

//Codigo para JSlider y JSpinner del color ROJO

//codigo evento JSlider: modifica el valor de JSpinner y manda a modificar el color del JPanel
private void redJSliderStateChanged(javax.swing.event.ChangeEvent evt) {
this.spnRojo.setValue(this.JSliderRojo.getValue());
changeColor();
}

//codigo evento JSpinner: modifica el valor de JSlider y manda a modificar el color del JPanel
private void spnRojoStateChanged(javax.swing.event.ChangeEvent evt) {

this.JSliderRojo.setValue((Integer)spnRojo.getValue());
changeColor();
}

La aplicación debe lucir así:

Ahora le asignaremos el look and feel substance a nuestra aplicación. Descargamos el Jar que contiene el look and feel y lo colocamos en la carpeta lib del proyecto (si no existe, creamos una) y luego agregamos el Jar de la librería al proyecto. Creamos un botón que nos sirva para colocarle una nueva apariencia a la aplicación. En el códico del actionPerformed escribimos la siguiente línea:

UIManager.setLookAndFeel("org.jvnet.substance.skin.SubstanceCremeCoffeeLookAndFeel");

O esta otra:

SubstanceLookAndFeel.setSkin(new org.jvnet.substance.skin.BusinessSkin());

La aplicación debe lucir así:

Look and Feel Substance Creme Coffee

Así tiene otra apariencia en lugar del ya tradicional metálico.

Material para parcial 3 Programación II 2009

2009-05-28T17:04:00.000-07:00

El material incluye:

Guiones de clase y teoría
Programas de ejemplo

El link para descargar via MegaUpload es el siguiente:

http://www.megaupload.com/?d=1RO1Q5S4

BUENA SUERTE

Tareas Ex Aula Programación II Ciclo I-2009

2009-05-25T00:25:00.000-07:00

Estos son los enunciados de las tareas ex-aula para la cátedra de Programación II. Vale el 10% de la nota global de la materia. Estas son las indicaciones generales:

Es un enunciado por grupo de laboratorio. Son un total de 7 enunciados distintos con similar grado de dificultad.
Se formarán parejas del mismo grupo de laboratorio. Si el grupo de estudiantes es impar, solamente se permitirá un grupo de tres integrantes, siendo más severa la evaluación para dicho grupo.
Cada estudiante debe realizar la tarea del grupo en el cual está legítimamente inscrito según los listados del auxiliar.
La entrega constará en una revisión que el auxiliar realizará al código y la funcionalidad de dicha aplicación Java. También cada grupo deberá llevar su trabajo copiado en un CD debidamente rotulado con la información de cada integrante y al grupo de laboratorio que pertenecen.
Soluciones iguales tienen nota de 1 (uno).
Soluciones plagiadas de Internet tienen nota de 1 (uno).
Todas las aplicaciones deben de utilizar controles Swing.
Fecha de Entrega: Miércoles 10 de junio de 2009.

ENUNCIADOS

Grupo 1

Crear un editor de texto plano con controles Swing que permita crear un archivo de texto y guardarlo en el disco duro, y también que permita cargar un archivo txt, modificarlo y guardarlo, ya sea con el mismo nombre o con otro distinto.

Grupo 2

Crear un formulario de ingreso de datos de un persona con información de propósito general. Luego dicha información, debe quedar almacenada en un archivo de texto en el disco duro y también debe de mostrar un JDialog que contenga un JTable con toda la información que se ingresó de la persona a manera de una tabla resumen.

Grupo 3

Crear un formulario que albergue una encuesta con un mínimo de 15 preguntas. Deben de ser preguntas de contestar y selección múltiple. Si no puede mostrar todas las preguntas en un mismo JPane, puede utilizar un JTabbedPane para que las muestre ordenadas. Luego la información de cada encuesta debe quedar almacenada en un archivo de texto en el disco duro, y desplegarla a manera de resumen en un JDialog.

Grupo 4

Crear una aplicación Java que genere números aleatorios con la ayuda de JSliders y JSpinners que maneje rangos mínimos y máximos de dichos números. El rango mayor no debe de sobrepasar al menor y viceversa. Cada número generado debe ser registrado en un archivo de texto plano que sea el log de la aplicación.

Grupo 5

Diseñar un carrito de compras con productos y precios predeterminados por el desarrollador. La selección de productos y la cantidad de ellos puede realizarla s con la ayuda de JComboBoxes o JLists. Cada factura generada debe ser guardada en un archivo de texto plano en el disco duro.

Grupo 6

Diseñar un juego de Memory de pares de imágenes. Entre menos intentos fallidos, mejor será la puntuación. Al final de cada partida debe mostrar el resultado y la puntuación del jugador. Luego debe de guardar el top score del juego en un archivo de texto plano dentro del disco duro y modificarlo cada vez que haya un juego nuevo.

Grupo 7

Diseña un juego de Equis Cero dond jueguen dos personas unicamente. Modo de jugador vs. PC deshabilitado. Se deben definir dos jugadores y debe de contar el número de juegos que desean jugar. El puntaje se tomará como el jugador que gane más juego en una sesión contra otro jugador. El top score del juego debe ser guardado en un archivo de texto y modificarlo cada vez que haya un nuevo juego.

Mucha suerte

Programación de GUI con Componentens Swing en Netbeans

2009-05-24T23:19:00.001-07:00

Programación II Guía de Laboratorio 4: Creación de GUI con componentes Swing en Netbeans
Desarrollo del 25 al 29 de mayo de 2009
Auxiliar de Cátedra: Hugo Alejandro Barrientos

Esta guía está dedicada a crear aplicaciones de escritorio en Java con la ayuda de componentes Swing. El IDE de programación de esta cátedra ha sido Netbeans y este nos proporciona un diseñador para crear aplicaciones de una manera sencilla, sin preocuparnos demasiado del código que implica la forma de la GUI. Simplemente nos debemos de centrar en el funcionamiento de la misma. Sin embargo, el ejercicio está enfocado a realizar algunas partes de la guía de tal manera que debamos conocer el código propio de los componentes Swing, para que nos formemos como buenos programadores de ambientes de escritorio.

En el ejercicio se debe crear un Visor de Imágenes en formatos JPG y PNG. Para ello se crearán: la interfaz en donde el usuario escogerá la imagen que desea visualizar, una clase que administre los archivos seleccionados y una clase que manipule la imagen seleccionada, una clase que herede de un componente swing y agregarla a la paleta de Netbeans para tener un control personalizado y poderlo arrastrar y colocar como cualquier otro del IDE. La estructura de clases será como el siguiente:

Primero crearemos la clase que nos manipule la imagen que seleccionará el usuario. La clase MiImagen es nuestro propio formato personalizado para representar una imagen en la memoria del computador. Se puede pensar que MiImagen es un arreglo bidimensional de pixeles en el cual cada uno de ellos puede tener un color, que se definirá con java.awt.Color. El código sería muy similar a este:

import java.awt.Color;
import java.awt.image.BufferedImage;

public class MiImagen extends java.awt.image.BufferedImage
{
/**
* Crea una instancia de MiImagen a partir de una BufferedImage.
*/
public MiImagen(BufferedImage image){
super(image.getColorModel(), image.copyData(null), image.isAlphaPremultiplied(), null);
}
/**
* Crea una instancia de MiImagen.
*/
public MiImagen(int width, int height){
super(width, height, TYPE_INT_RGB);
}

/**
*Coloca un color en una posición específica
*/
public void setPixel(int x, int y, Color col){
int pixel = col.getRGB();
setRGB(x, y, pixel);
}

/**
* Obtiene el valor de color en una posición específica
*/
public Color getPixel(int x, int y){
int pixel = getRGB(x, y);
return new Color(pixel);
}
}

La clase AdminArchivos ofrece tres métodos: uno para leer desde el disco un archivo de imagen con nombre y devolverlo como una MiImagen, uno para grabar un archivo MiImagen en el disco y otro para abrir una caja de diálogo de selección de archivos que permite que el usuario seleccione la imagen que desea ver. Los formatos permitidos por filtro son JPEG y PNG. Con la creación de esta clase invocaremos código propio de un componente Swing y le daremos forma únicamente con sentencias dejando de lado el diseñador de Netbeans. El código sería muy similar a éste:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;

public class AdminArchivos {

private static final String IMAGE_FORMAT = "jpg";
private static JFileChooser fileChooser = new JFileChooser();
private static FileNameExtensionFilter filter = new FileNameExtensionFilter("JPG & PNG", "jpg", "png");

public static MiImagen obtenerImagen() throws IOException {
fileChooser.setFileFilter(filter);
fileChooser.setCurrentDirectory(null);
int returnVal = fileChooser.showOpenDialog(null);

if(returnVal != JFileChooser.APPROVE_OPTION) {
return null; // Presiona cancelar
}
File selectedFile = fileChooser.getSelectedFile();

return cargarImagen(selectedFile);
}
public static MiImagen cargarImagen(File imageFile) throws IOException
{
try {
BufferedImage image = ImageIO.read(imageFile);
if(image == null || (image.getWidth(null) <>
return null; //por si ocurre un error al cargar la imagen
}
return new MiImagen(image);
}
catch(IOException exc) {
return null;
}
}

public static void guardarImagen(MiImagen image, File file)
{
try {
ImageIO.write(image, IMAGE_FORMAT, file);
}
catch(IOException exc) {
return;
}
}
}

El elemento Swing que utilizamos para escoger las imágenes es JFileChooser. Creamos un atributo estático para que se puedan seleccionar las imágenes y le asignamos por defecto la carpeta de usuario para cualquier sistema operativo. Ponga mucha atención a la variable estática de tipo FileNameExtensionFilter, ya que es la que nos permite que en el control JFileChooser de Swing solo nos aparezcan imágenes de tipo JPG. Se pueden definir otro tipo de filtros también.

Por último la clase ImagePanel implementa un componente Swing personalizado para mostrar nuestra imagen. Los componentes Swing personalizados pueden crearse fácilmente escribiéndolos como una subclase de algún componente existente, y, como tal, puede insertarse en un contenedor Swing y mostrarse en la GUI como cualquier otro. Nuestro objeto será creado y lo insertaremos en la paleta de Netbeans. Primero debemos crear la clase, con un código como éste:

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JComponent;

public class ImagePanel extends JComponent
{
private int width, height;

private MiImagen panelImage;

public ImagePanel()
{
width = 360; // Tamaño arbitrario para la instancia vacía de ImagePanel
height = 240;
panelImage = null;
}

public void setImage(MiImagen image)
{
if(image != null) {
width = image.getWidth();
height = image.getHeight();
panelImage = image;
repaint();
}
}

public void clearImage()
{
if(panelImage != null) {
Graphics imageGraphics = panelImage.getGraphics();
imageGraphics.setColor(Color.LIGHT_GRAY);
imageGraphics.fillRect(0, 0, width, height);
repaint();
}
}

// Los siguientes métodos son redefiniciones
// de métodos heredados de las superclases.

@Override
public Dimension getPreferredSize()
{
return new Dimension(width, height);
}

@Override
public void paintComponent(Graphics g)
{
Dimension size = getSize();
g.clearRect(0, 0, size.width, size.height);
if(panelImage != null) {
g.drawImage(panelImage, 0, 0, null);
}
}
}

Luego de escrita la clase, construimos el proyecto para que nos genere una JAR. Así podremos añadir nuestro componente personalizado a la paleta de Netbeans. Nos vamos al menú Tools y en la opción Palette damos click a Add Swing/AWT Components.

Seleccionamos la opción Add from JAR. Buscamos el JAR generado de nuestro proyecto y lo seleccionamos. Luego volvemos a seleccionar entre una lista de las clases de dicho JAR y damos click a la clase del componente, en este caso es ImagePanel. Seleccionamos la categoría de Swing Components y damos por finalizada la inserción a la paleta.

Ahora crearemos un nuevo JFrame Form con ayuda del diseñador de Netbeans. En el paquete de source code lo creamos y colocaremos los siguientes elementos:

• 1 JMenuBar
o 3 JMenuItem. Las opciones serán: Abrir, Limpiar y Salir
o A cada JMenuItem se le deberá asignar un evento ActionPerformed
• El Layout será BorderLayout
• 2 JLabels. Uno tendrá colocación PAGE_START y el otro PAGE_END
• 1 ImagePanel, con colocación de Layout CENTER. Nombre de instancia: “panelI”.
• En el constructor, asignamos el título de la ventana como “Visor de Imágenes”
• También en el constructor, Colocamos la posición relativa en “null”
• Si se quiere la ventana maximizada desde el principio, se hace con la siguiente sentencia:
this.setExtendedState(javax.swing.JFrame.MAXIMIZED_BOTH);

La ventana en modo diseño debe lucir como la siguiente:

Ahora para que nos muestre una imagen, debemos agregar las sentencias necesarias en el método que desencadena la acción de ActionPerformed en el JMenuItem para abrir imagen. Las sentencias podrían ser similares a éstas:

try {
MiImagen img = AdminArchivos.obtenerImagen();
panelI.setImage(img);

this.lblNombreImg.setText(img.getClass().getName());
this.lblEstado.setText("Imagen cargada con éxito");
this.setLocationRelativeTo(null);
this.pack();

panelI.repaint();

} catch (IOException ex) {
Logger.getLogger(visor.class.getName()).log(Level.SEVERE, null, ex);
}

La aplicación debe lucir así:

Polimorfismo en Java

2009-05-03T17:24:00.000-07:00

Guía de Laboratorio 3: Polimorfismo y Librerías de Clases

Auxiliar de Cátedra: Hugo Alejandro Barrientos

Polimorfismo

El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general, en lugar de hacerlo en forma específica. En general nos sirve para programar objetos con características comunes y que todos estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la superclase. Esto nos simplifica la programación.

Recuerde el ejemplo del ecosistema, en donde todos los objetos de las distintas especies heredaban de una superclase llamada Animal, que brindaba la información general de cualquier animal, independiente de su especie. Sin embargo, cada especie hace un uso particular de cada uno de los métodos u operaciones de la clase Animal. El método comer() no se ejecutará de la misma manera en un León() o en un Pavo(). Lo mismo ocurre para métodos moverse() en objetos de tipo Tiburón() o Gallina(), aunque todas las especies realicen estos métodos. A la sobrescritura o implementación específica de métodos es la clave del polimorfismo.

Para poner en práctica se hará un ejemplo bastante sencillo. Se hará una librería de clases que represente figuras tridimensionales y bidimensionales, y su respectiva jerarquía de clases. Las clases deben ser capaces de tener funcionamiento bastante básico, como obtener áreas, volúmenes y perímetros de la figura correspondiente.

La representación de la jerarquía sería como ésta:

Click a la imagen para verla más grande...

La superclase de dicha jerarquía podría ser muy parecida a ésta:

public abstract class figura {

protected String nombre;
protected int color;
protected int grosorBorde;

public String getNombre(){
return this.nombre;
}
public void setNombre(String n){
this.nombre=n;
}

public int getColor(){
return this.color;
}

public void setColor(int c){
this.color=c;
}

public int getGrosorBorde(){
return this.grosorBorde;
}

public void setGrosorBorde(int g){
this.grosorBorde=g;
}

public abstract void dibujar();
}

Las siguientes clases en el nivel de la jerarquía podrían quedar muy parecidas a éstas:

public abstract class figura2D extends figura {

public abstract int calcularArea();

public abstract int calcularPerimetro();
}

public abstract class figura3D extends figura {

public abstract int calcularVolumen();
}

Se le pide que forme las clases de la parte inferior de la jerarquía y que representarían los objetos a instanciarse.

Además, debe de realizar una implementación de esta librería, en donde el usuario pueda crear nuevas figuras y que éstas se almacenen en un arreglo de figuras.

Ejercicios:

Realice una jerarquía de clases en donde se representen un cuadrilátero.

Mediante esa superclase, realice las clases rectángulo, cuadrado, paralelogramo y trapezoide; que heredarán de ella, convirtiéndose prácticamente en objetos cuadrilátero (superclase).

Dividir Cadenas en Java

2009-04-28T15:09:00.000-07:00

Pareciera algo sencillo y simple, que no es digno para un artículo, sin embargo la división de cadenas de carácteres da algunos problemas, más que todo a los programadores principiantes. Este artículo explicará esta tarea con dos formas: con el método split() de la clase String y con la clase Tokenizer.

Este sencillo código realiza la separación de la cadena "Políticas de Calidad" en los espacios en blanco que se encuentren:

String cad = "Politicas de Calidad";

/*Primero lo realizaremos con Tokenizer. Hay que crear una nueva instancia de Tokenizer. Por defecto separa con cada espacio en blanco que encuentre de la cadena que se le manda como parámetro*/

StringTokenizer tokens = new StringTokenizer(cad);

//Mientras encuentre más tokens, es decir separaciones, que imprima cada token con nextToken():

while(tokens.hasMoreTokens()){
System.out.println(tokens.nextToken());
}

System.out.println("\n\n");

/*Ahora lo haremos con split(). Con los patrones \\ indicamos cuál es la condición para la separación. En este caso es el espacio en blanco. Recuerde que el resultado de split devuelve un arreglo de String */

String [ ] palabra = cad.split("\\ ");

int j=0;
while(j <= palabra.lenght-1){
System.out.println(palabra [ j ]);
j++;
}

Espero que este artículo ayude a muchos.

Librerías de Clases en Java y Netbeans

2009-04-26T18:54:00.000-07:00

Guía de Laboratorio 3: Polimorfismo y Librerías de Clases

Auxiliar de Cátedra: Hugo Alejandro Barrientos

Esta guía está dedicada para poner en práctica los conocimientos aprendidos en las prácticas anteriores, tales como manejo de clases, métodos, instancias, herencia getters y setters. Además aprenderemos a manejar el polimorfismo, concepto de la programación orientada a objetos, para diseñar nuestras aplicaciones bajo un esquema de jerarquías de herencia, dentro del ámbito de Java con Netbeans, y aprenderemos además a crear nuestras propias librerías con clases y a añadirlas a un proyecto de Netbeans agregando a las referencias de librerías el respectivo Jar contenedor de la librería.

Operador instanceof

El operador instanceof sirve para consultar si un objeto es una instancia de una clase determinada, o de su padre. Pareciera absurdo tratar de conocer cuál es la clase que da lugar a una instancia específica, sin embargo es de mucha utilidad cuando se trabaja con interfaces y herencia a la vez. Veamos un ejemplo:

public class primo {

private int numero;
private int vectorPrimos[];
private int tamañoV;

public primo(){
this.tamañoV=25;
this.vectorPrimos= new int [this.tamañoV];
this.numero=0;
}
}

public class Main {
public static void main(String[] args) {

primo p = new primo();

if (esPrimo(p)){
System.out.println("ES INSTANCIA DE PRIMO");
}
}
public static boolean esPrimo(primo p) {
return (p instanceof primo);
}
}

Lo que realiza este sencillo ejemplo es comprobar si la instancia llamada “p” corresponde a la clase primo, definida anteriormente, con la ayuda del método estático “esPrimo” que verifica con el operador instanceof si la instancia que se traslada por el parámetro es de la clase que se evalúa. El resultado de dicha operación es true o false.

Librerías de Clases

Ahora aprenderemos a crear nuestras propias librerías de clases. Estas nos sirven para tener un conjunto de clases que nos sirven para realizar funciones específicas, creadas por el programador y que podremos importar hacia otras aplicaciones Java e implementar dicha funcionalidad.

Cabe mencionar que debemos tener una gran capacidad de análisis, para lograr abstraer las clases y crear objetos que funcionen de una manera adecuada.

Para crear nuestra librería, debemos crear un nuevo proyecto Java en Netbeans, escogiendo la opción de Java Class Library:

Como pueden leer en la descripción dentro de la imagen, una Class Library no contiene una clase Main para que se pueda correr o implementar las clases que se escriban dentro de la misma. Recuerde que la librería dará insumos a sus aplicaciones para realizar tareas a otras aplicaciones o programas.

Crearemos una librería que nos servirá para encontrar algunas familias o sucesiones de números. Empezaremos con la sucesión de números Fibonacci y los famosos números Primos. Se crearán clases para encontrar dichas sucesiones de números, conocer el Fibonacci que desee el usuario, evaluar si un número es primo o no, entre otras operaciones. Además, la clase para los fibonacci debe de facilitar métodos y atributos para encontrar los fibonacci que a la vez son primos.

A medida que el programador vaya escribiendo y concibiendo sus clases, la librería debe lucir de la siguiente manera:

Para implementar esta librería, basta con construir el proyecto, para generar un Jar que contenga las clases. Luego creamos una nueva aplicación Java que llamaremos ImplementarNumeros:

Ahora, con el proyecto creado, hacemos click derecho sobre el nombre del proyecto en el apartado de proyectos de Netbeans y nos dirigimos a las propiedades del mismo:

Nos dirigimos a la categoría de Libraries. Dentro de ella, agregamos un compilado, que puede ser un proyecto de Netbeans, un folder, una Class Libraryo un Jar. En este caso, agregaremos un Jar, así que presionamos el botón de Add JAR/Folder y buscamos el Jar de nuestra Class Library (Se encuentra en la carpeta dist dentro del folder del proyecto creado por Netbeans).

Al agregarlo, luego dentro del Main del proyecto, importamos las librerías de esta manera:

import numeros.fibonacci;
import numeros.primo;

Y ya podremos utilizar toda la funcionalidad de nuestras clases dentro de un proyecto e implementarlas.

La implementación podría ser muy parecida a esta:

public static void main(String[] args) {

fibonacci f = new fibonacci();
f.encontrarFibos();
int v[]=f.getFibos();

for(int i=0;i<25;i++)
System.out.println(v[i]);
}

Ejercicios:

Alimente su librería de clases con las familias de números:

Números Perfectos: Son números naturales que son iguales a la suma de sus divisores propios positivos sin incluirse a él mismo.

Números Compuestos: Es todo número natural no primo, a excepción de 1, se denomina compuesto, es decir que tiene uno o más divisores distintos a 1 y sí mismo.

Agregar JPanel en un JFrame en Java y Netbeans

2009-04-19T11:21:00.000-07:00

Muchos compañeros me han pedido ejemplos para agregar o instanciar JFrames o JPanels dentro de otro JFrame. Existe un control Swing llamado Internal Frame que se utiliza para agregar Frames dentro otro. Sin embargo, debemos recordar que un Frame tiene propiedades tales como la barra de títulos, los botones de maximizar, minimizar y cerrar, coloca un nuevo ítem en la barra de tareas en Windows, KDE y Gnome, entre otras propiedades. Cabe destacar que muchas veces estos atributos no serán necesarios y entorpecerían el accionar de la aplicación. Muchas veces necesitamos unicamente un pequeño recuadro e insertarlo en uno u otro JFrame. Así que para esos efectos están los JPanels. Realizaremos un pequeño ejemplo con éstos.

Vamos a realizar una pequeña aplicación, que consiste en realizar dos de las operaciones básicas: sumas y restas. Para realizar cada una de ellas, el JFrame añade entre sus componentes a dos JPanels, uno para cada operación respectivamente.

Antes de mostrar cómo crear los JPanels, debemos de cambiar el layout al JFrame que utilizaremos. El Layout es una propiedad de los contenedores Swing para colocar todos los elementos que se contienen dentro de él. Como Java es multiplataforma, y en cada una de ella se disponen de manera distinta el orden de los elementos o componentes. Por lo tanto, Swing lo realiza con la ayuda de los layouts. En modo diseño del JFrame, hacemos click derecho a la opción Set Layout y le asignamos Null Layout, ya que nosotros colocaremos otro tipo de layout diferente al del diseño libre que nos brinda el editor de diseño de Netbeans. De esta forma:

Ahora sí, creamos dos JPanels desde el navegador de proyectos, uno llamado panelHijoSuma y otro panelHijoResta. Deben quedar de la siguiente manera:

Vean que el último TextBox se encuentra deshabilitado para que sea modificado por el usuario. Este solo presentará el resultado y el usuario jamás lo podrá tocar.

Al JFrame, tal y como lo observaron al inicio de este artículo solo le agregamos una Menu Bar, y un par de ítems para que luzca así:

Ahora, dentro del JFrame, en su constructor, y luego de la inicialización de componentes, vamos a establecer el layout a utilizar. Para este ejercicio, escogí el FlowLayout, que dispone un orden de los elementos horizontal uno tras otro y con cierto espaciado que podemos asignar.
El código dentro del constructor deberá ser el siguiente:

//Constructor
public framePadre() {

//llamo al constructor padre y le mando el nombre del título de la ventana
super("Operaciones Básicas");

//Función de inicialización de componentes. Netbeans la coloca por defecto
initComponents();

//Colocamos el nuevo tipo de layout que queremos que tenga nuestro JFrame
this.setLayout(new FlowLayout());
}

También creamos dos atributos al JFrame, para más facilidad. Serán dos atributos del tipo de datos de cada uno de los JPanel.

private panelHijoSuma hs;
private panelHijoResta hr;

Ahora, en cada una de los ítems de la barra de menú, para mostrar el JPanel deseado, colocamos el siguiente código:

//Nombre evento
private void nSumaActionPerformed(java.awt.event.ActionEvent evt) {

//Si ya está el otro Jpanel añadido al contenedor, entonces se elimina
try{
this.remove(hr);
}
catch(Exception e){
}

//Creamos una nueva instancia de panelHijoSuma
hs = new panelHijoSuma();

//Agregamos la instancia al JFrame, con un layout al centro
this.add(hs, BorderLayout.CENTER);

//Hacemos que el JFrame tenga el tamaño de todos sus elementos
this.pack();
}

Este código debe de ser similar en los restantes ítems de la Menu Bar, siempre con el evento ActionPerformed.

Ahora, la parte final de este artículo. Realizaremos cada una de las operaciones dentro del evento de los TextBox, KeyReleased(). De esta forma:

Ahi agregaremos el siguiente código:

//Nombre del evento. Lo genera Netbeans
private void txtnum1KeyReleased(java.awt.event.KeyEvent evt) {

//Asignamos el texto del textBox a una variable Integer
int num1 = Integer.parseInt(this.txtnum1.getText());

//Si el otro TextBox no esta vacio, entonces se debe realizar la operación
if (!this.txtnum2.getText().equals("")){

int num2 = Integer.parseInt(this.txtnum2.getText());

//Se realiza la operación, y se coloca en el TextBox del resultado
this.txtresultador.setText(String.valueOf(num2+num1));
}
}

La aplicación debe lucir así:

El mismo JFrame con uno y otro JPanel

Espero que les sea útil este código.

Código alojado en el Aula Virtual de la UES-FMO, dentro del curso de Programación II.

Emisión de certificados SSL con Apache Tomcat, Java, JSP y Netbeans

2009-04-05T10:41:00.000-07:00

Un buen amigo mio necesitaba emitir certificados SSL (Secure Socket Layers) para la admisión de usuarios a sitios con protocolo http seguro (HTTPS) para un proyecto de una materia de la universidad. Como el novato que aun soy, empecé a leer al respecto y encontré una forma de hacerlo. Logré implementarla y traigo para Uds. este pequeño y sencillo tutorial para emitir este tipo de certificados utilizando Apache Tomcat, Java, JSP y Netbeans, todo sobre un sistema operativo Windows Vista.

Las versiones que se tienen instaladas son:

JDK 1.6.0_05

Netbeans 6.5

Apache Tomcat 6.0.18

Ahora, para generar el certificado SSL utilizaremos la herramienta incluida en el Java Development Kit, JDK llamada KeyTool. Para acceder a ella tenemos que acceder al directorio que contiene la versión del JDK. En Windows, es la siguiente ruta:

%JAVA_HOME%\bin\keytool.exe -genkey -alias tomcat -keyalg RSA

Con este comando y sus argumentos, estamos ordenando que generaremos un nuevo certificado o una nueva key, con el alias tomcat. Luego nos pedirá una serie de datos que son los que conformarán el almacén de claves. La clave que viene por defecto con el alias de tomcat es:

changeit

Por el momento si estás aprendiendo conserva esta clave y así no tendrás problemas para crear más certificados. Cuando termines de ingresar toda la información digita OK para que se valide. Para mantener la misma clave (es decir changeit) solo debes de presionar Enter.

Al finalizar este paso el KeyTool genera un archivo que almacena la lleva, es decir un .keystore. Es un poco problemático encontrar en donde lo guarda, sin embargo el keytool lo aloja siempre en la carpeta de usuario, en mi caso en Windows Vista se alojó en:

C:\Users\miNombreUsuario

En Windows XP sería:
C:\Documents and Settings\miNombreUsuario

En Ubuntu sería
/home/miNombreUsuario

Ahora debemos configurar el servidor Tomcat para aceptar y habilitar el puerto SSL, que por defecto es el 8443. Dentro de la carpeta del apache-tomcat-6.0.18 localizamos el archivo server.xml y descomentamos unas líneas que aparecen por defecto con carácter de comentarios y es el conector del puerto 8443. Le quitamos los comentarios unicamente y le agregamos un atributo para indicar cuál sera el keystore, de esta manera:

Iniciamos ahora el servidor Tomcat de esta manera:
C:\Servidorapache-tomcat-6.0.18\bin\startup.bat

Y ahora digitamos en el navegador https://localhost:8443/ y ya accederemos al index de localhost pero con protocolo http seguro, de esta manera:

Se añade la excepción en el certificado y ya se podrá ver como la imagen superior. Aprecien también en la barra de direcciones el protocolo del sitio (HTTPS) y en la barra de estado de Firefox vean que tiene un pequeño candado, denotando que es un sitio seguro.

El tercer y último paso es crear una aplicación web con JSP y Netbeans, utilizando Tomcat como servidor de dicha aplicación. La creamos con Netbeans, y modificamos el archivo web.xml agregando estas etiquetas, todas dentro del cierre de la etiqueta web-app. De esta manera:

<security-constraint>

<web-resource-collection>

<web-resource-name>Entire Application</web-resource-name>

<url-pattern>/*</url-pattern>

</web-resource-collection>

<user-data-constraint>

<transport-guarantee>CONFIDENTIAL</transport-guarantee>

</user-data-constraint>

</security-constraint>

Y es todo! Ahora este sitio se podrá ser accedido desde protocolo HTTPS. La prueba luciría así. Noten el protocolo en la barra de direcciones, así como el pequeño candado:

Muchas gracias a Armando Díaz y su Blog Ubuntu de El Salvador, ya que este tutorial está basado en su artículo.

Utilizando JTextArea y JOptionPane en Netbeans

2009-04-02T21:31:00.001-07:00

JTextArea es un componente básico del Swing de Java y su función principal es la de capturar texto ingresado desde teclado por el usuario. Sin embargo, entre sus métodos está el de asignarle texto para mostrarlo además. Ahora explicaré un poco su uso con la ayuda de un pequeño ejemplo, el cual sería un pequeño bosquejo de un proyecto llamado Librería, en el cual estará para este ejemplo unicamente la clase Libro.

La construiremos de esta manera: Unicamente con tres atributos básicos, un constructor que los inicialice con valores constantes, y con los respectivos get y set de cada atributo. El código de dicha clase quedaría de la siguiente manera:

package libreriajtextarea;

// @author Hugol

public class libro {

private String nombre;
private String autor;
private int numPags;

public libro(){
this.nombre="Cómo Programar en C/C++";
this.autor="Joyanes Aguilar";
this.numPags=500;
}

public String getNombre(){
return this.nombre;
}

public void setNombre(String n){
this.nombre=n;
}

public String getAutor(){
return this.autor;
}

public void setAutor(String a){
this.autor=a;
}

public int getNumPags(){
return this.numPags;
}

public void setNumPags(int n){
this.numPags=n;
}
}

Ahora en la clase Main la implementaremos para que podamos utilizar, tanto los JTextArea como los JOptionPane en nuestra introducción al Swing. El código del Main es así:

public class Main {

public static void main(String[] args) {

//se crea un nuevo JTextArea
JTextArea salida = new JTextArea();
String cadSalida = "";

//se crea un nuevo libro
libro book = new libro();

//Se coloca texto al JTextArea
salida.setText("El libro "+ book.getNombre()+ " tiene "+book.getNumPags()+ " paginas");

//Se muestra el texto en un JOptionPane
JOptionPane.showMessageDialog(null, salida, "Libreria", JOptionPane.INFORMATION_MESSAGE);

//Se limpia el JTextArea
salida.setText("");

//Se le asigna un tamaño de ancho y alto al JTextArea
salida.setSize(50, 50);

//Se le pide al usuario que escriba dentro del JTextArea en un JOptionPane
JOptionPane.showMessageDialog(null, salida, "Escribe el Editorial del libro JTextArea", JOptionPane.INFORMATION_MESSAGE);

//Se le asigna el texto escrito en el JTextArea a un String
cadSalida = salida.getText();

//Se imprime el String en un JOptionPane, demostrando q el JTextArea se puede utilizar tanto para recibir información como para mostrarla
JOptionPane.showMessageDialog(null, "Editorial de libro: " + cadSalida, "Libreria", JOptionPane.INFORMATION_MESSAGE);

}

}

Cabe mencionar que ya la clase JOptionPane proporciona un método de entrada de datos, el ya conocido showInputDialog(), sin embargo para fines didácticos se agrega un JTextArea para el ingreso de datos. La aplicación luce así:

Se muestra el JTextArea dentro JOptionPane.

El usuario digita dentro del JTextArea la editorial del libro.

Se muestra la respuesta.

Ejemplos creando JFrame y JOptionPane

2009-03-30T11:31:00.000-07:00

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

2009-03-27T22:43:00.000-07:00

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?

2009-03-23T21:22:00.001-07:00

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

2009-03-21T00:10:00.000-07:00

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

2009-03-20T18:06:00.000-07:00

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

2009-03-16T21:48:00.000-07:00

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

2009-03-13T00:15:00.000-07:00

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.