Manejo Ide Netbeans Con Objetos

ROGERIO ORLANDO BELTRAN CASTRO
INGENIERIA DE SISTEMAS
Contenido
TALLER INICIAL NETBEANS ............................................................................................................. 2
Características de los objetos ............................................................................................................... 17
Instanciación de objetos ..................................................................................................................... 19
Llamada al método contructor .......................................................................................................... 19
Compilación de aplicación con varios archivos java .............................................................................. 19
Llamada al método constructor con parámetros .................................................................................. 20
Instanciación de objetos de clases Java.............................................................................................. 20
Paquetes e import ........................................................................................................................... 21
Declaración de Clases ......................................................................................................................... 23
Estructura básica de una clase en Java .............................................................................................. 23
Declaración de atributos .................................................................................................................. 23
Declaración de métodos ................................................................................................................... 24
Creación de nueva clase en NetBeans ................................................................................................ 25
Clases de objetos............................................................................................................................. 36
Protección de miembros .................................................................................................................. 46
Relaciones entre clases ................................................................................................................... 56
Clases anidadas e interiores ............................................................................................................ 72
Interface List. Clase LinkedList api java. Ejercicio diferencias entre ArrayList y LinkedList. .......................... 78
Herencia ....................................................................................................................................... 133
Sobreescribir Métodos ................................................................................................................ 134
Polimorfismo ............................................................................................................................... 143
PROGRAMACION ORIENTADA A OBJETOS 1

TALLER INICIAL NETBEANS
El objetivo de este tutorial es de mostrar cómo trabajar con Netbeans IDE 7.2 orientado a las tareas de
programación con lenguaje Java.
En este capítulo vamos a ver.
1. Crear un proyecto de aplicación Java con Netbeans
2. Ejecutar una aplicación Java con Netbeans
3. Creación de Paquetes y Clases
Y aplicar el estándar de codificación Java. Este estándar define como nombrar los paquetes, clases,
propiedades o atributos, constantes, métodos o funciones.
Ya que este tutorial trata de ilustrar el manejo y mostrar las prestaciones de Netbeans IDE 7.2, este tema del
estándar de codificación no será tratado aquí, sin embargo todos los ejemplos seguirán disciplinadamente este
estándar.
Crear un proyecto de aplicación Java con Netbeans
¡NetBeans IDE 7.2 iniciado y corriendo!
Para crear un proyecto iniciamos en el menú seleccionando en: File > New Project…

Luego veremos un cuadro con una amplia colección de tipos de proyectos organizados por categorias.
Seleccionamos: Java > Java Application.
Luego le damos en: Next >, y veremos el siguiente cuadro donde ingresaremos un nombre para el proyecto.
Nota: La creación de un proyecto Java en Netbeans trae seleccionado por defecto la opción: Create Main
Class, esto creará un paquete y una clase que contiene la función especial de Java llamado main(), el cual
hace que la clase sea ejecutable.
Luego de darle en: Finish el proyecto “tutorial” quedará listo parar trabajar.
Inicialmente podrás notar dos elementos importantes del IDE, que son:
• El explorador de Proyectos
• El Editor de Código

Ejecutar una aplicación Java con Netbeans
Agregando 1 línea en la Clase Turorial.java, generado por Netbeans quedaría así.
1 public static void main(String[] args) {

2 // TODO code application logic here
3 System.out.println("Hola mundo...");
4}
Ahora hay varias formas de ejecutar el proyecto con Netbeans.
Primera forma, seleccionamos el proyecto, y la opción Run.
Segunda forma, seleccionamos el proyecto y luego en el botón Run de la barra de herramientas.

Ahora veremos un tercer elemento importante de Netbeans IDE que es:
• La consola de salida de Java (Output)
La consola de salida (Output) es donde veremos el resultado de la ejecución del Proyecto.
Creación de Paquetes y Clases
Los paquetes, el estándar de nombrado de paquetes dice que se utilicen únicamente minúsculas y además
utilizar como raíz el nombre del proyecto, en nuestro caso “tutorial”.
Es posible que el proyecto sea parte de una compañía u organización, en este caso se puede anteponer el
nombre del dominio, como por ejemplo:
• org.heyma.tutorial
• com.google.tutorial
Nota: La estructura de paquetes es simplemente una estructura de directorios de archivos, por lo tanto, la
estructura “com/google/proyecto” en java se escribirá “com.google.proyecto”.
En nuestro proyecto tenemos el paquete “tutorial” y vamos a anteponer el nombre de dominio de nuestra
organización.

Seleccionamos el paquete “tutorial”, luego: Refactor > Rename…
Cambiamos de “tutorial” a“org.heyma.tutorial” tal como se muestra en la siguiente imagen.
Para agregar paquetes tan solo seleccionamos el paquete raíz. Seleccionar: New > Java Package… Colocar
el nombre siguiendo la regla de ingresar en minúsculas únicamente y listo.
Las Clases, se nombran utilizando el patrón “PascalCase“, como por ejemplo: Persona, ServiciosCliente,
ControladorDePagos, etc. Inician siempre con la primera letra en mayúscula.
Para agregar clases se procede igual a los paquetes. Seleccionar paquete: New > Java Class… Nombrar
como especifica la regla y listo.

Con esto finalizamos este capítulo. En los siguientes veremos muchas más prestaciones que tiene el Netbeans
IDE 7.2.

El Editor de Netbeans IDE 7.2
En este capítulo veremos las prestaciones más importantes del Editor de Netbeans IDE. Sobre todo para agilizar
las tareas más rutinarias en la práctica real en el desarrollo de aplicaciones Java.
En este capítulo veremos:
• Codificación de clases
• Resolver Importaciones (imports)
• Los Getters y Setters
Codificación de clases
El diseño del sistema genera el primer trabajo de los programadores: Construir la arquitectura del sistema.
Todos los paquetes, clases e interfaces deben ser creados.
Antes de codificar el cuerpo de las clases es bueno iniciar por la estructura de paquetes y luego crear las 2027
clases del sistema :D.
En el capítulo anterior vimos cómo crear paquetes y clases dentro de un proyecto en Netbeans. Ahora
codificaremos el cuerpo la una clase <Entity> Persona, mientras vemos algunas de las prestaciones del Editor
de Netbeans.
Luego de crear la clase Persona el Editor nos mostrara lo siguiente
01 /*
02 * To change this template, choose Tools | Templates
03 * and open the template in the editor.
04 */
05 package org.heyma.tutorial.model;
06
07 /**
08 *
09 * @author John
10 */
11 public class Persona {
12

13 }
La mayor carga de trabajo en el desarrollo de las clases tipo entidad está en la transcripción de las propiedades,
sin embargo es bastante sencillo y no es necesario un test funcional.
Transcribiendo las propiedades de la clase Persona.
En este caso ha generado errores y el icono en la barra de numeración lo indica. Si no eres un principiante
de programación en Java sabes que son las importaciones de Date y List lo que hace falta.
Resolver Importaciones (imports) Ctrl + Shift + I
Para resolver el error de dependencias o imports la opción se encuentra en el menú: Source > Fix imports ó
Ctrl + Shift + I. Pero la manera más ágil antes que una combinación de teclas es de la siguiente forma:
seleccionar dentro el editor señalando un lugar vacío y luego la opción: Fix imports.
Si se encuentran ambigüedades Netbeans mostrará el siguiente cuadro para seleccionar las Clases Correctas.

Otra Opción está en seleccionar el icono que además de mostrar el error tiene una sugerencia.
Luego las importaciones se agregarán al código y los errores en la barra de numeración desaparece.
Finalmente este tipo de clases <Entidad> debe encapsular sus propiedades, usar métodos para asignar u
obtener valores. Estos métodos se llaman: Getters y Setters.
Los Getters y Setters – Alt+Insert
Para ello seleccionamos dentro el editor señalando un lugar vació o a continuación de la última propiedad y
luego la opción: Insert Code… ó Alt + Insert.

Según los requerimientos selecciona las propiedades que tendrán Getter y Setter y luego presiona en el botón
Generate.
Con esto gran parte de código se habrá generado sin mucho esfuerzo.
La mayor parte de las opciones que tiene Netbeans están basadas en estándares y paradigmas de
Programación.
En el siguiente capítulo veremos cómo crear interfaces y clases de implementación y agilizar este trabajo con
Netbeans IDE 7.2

En este capítulo veremos más de las prestaciones que tiene Netbeans IDE 7.2.
Transcribiendo interfaces
Otra parte importante que proporciona el diseño de una aplicación en la que participaron arquitectos o analistas
son las interfaces, o servicios funcionales del sistema. Estos servicios implementan la lógica de negocio del
sistema, además estas clases requerirán pruebas unitarias de funcionalidad.
Los programadores ahora deben transcribir las 3200 interfaces del sistema que se está construyendo. :D
La mayor carga de trabajo está en la transcripción de los métodos de la interfaz y muchos métodos o funciones
reciben o retornan objetos de las clases entidad <Entity> del sistema. Es por eso que todas las clases entidad
ya deben estar codificadas.
Crear una interfaz
En un capítulo anterior vimos cómo crear paquetes y clases en un proyecto de aplicación Java con Netbeans.
Ahora utilizando el mismo procedimiento crearemos las interfaces dentro los paquetes que corresponda. Según
el diseño de la arquitectura del sistema.
Para ello selecciona el paquete. Luego: New > Java Interface...
Luego de crear las interfaces ahora hay que transcribir los métodos. Será necesario agregar los imports (Ctrl +
Shift + I) correspondientes para que queden como se muestra a continuación.
Interfaz ModuloClientes.java
01 package org.heyma.tutorial.services;
02
03 import java.util.List;
04 import org.heyma.tutorial.model.Cliente;

05
06 /**
07 *
08 * @author John
09 */
10 public interface ModuloClientes {
11
12 public void registrarCliente(Cliente cliente);
13
14 public void actualizarDatos(Cliente cliente);
15
16 public void eliminarCliente(Cliente cliente);
17
18 public Cliente buscarCliente(int id);
19
20 public List listarClientes();
21 }
Interfaz ModuloBanco.java
01 package org.heyma.tutorial.services;
02
04
05 /**
06 *
07 * @author John
08 */
09 public interface ModuloBanco {
10
11 public void abrirCuenta(Cliente cliente);
12
13 public void cerrarCuenta(Cliente cliente);
14 }
Implementación de las Interfaces
Para implementar una interfaz se debe crear una clase y agregar a continuación del nombre la instrucción
implements seguido del nombre de la interfaz a implementar. Esto requerirá el import de la Interfaz.

Esto provocará un error en la Clase referida a que se deben implementar los métodos de la Interfaz. Ahora
utilizando las opciones del editor de Netbeans vamos a generar código.
Como en el anterior capítulo vamos a utilizar la opción de: Insert code… (Alt + Insert) o seleccionando en un
lugar vacío del cuerpo de la clase, es decir, entre las llaves { … }. Luego seleccionamos la opción:
Implement Method…
Luego debemos seleccionar todos los métodos a menos que la Clase esté definida como Abstracta.

Luego presionamos el botón Generate, y veremos la Clase como se muestra a continuación.
01 package org.heyma.tutorial.services.impl;
02
03 import java.util.List;
05 import org.heyma.tutorial.services.ModuloClientes;
06
07 /**
08 *
09 * @author John
10 */
11 public class ModuloBancoImpl implements ModuloClientes {
12
13 @Override
14 public void registrarCliente(Cliente cliente) {
15 throw new UnsupportedOperationException("Not supported yet.");
16 }
17
18 @Override
19 public void actualizarDatos(Cliente cliente) {
21 }
22
23 @Override
24 public void eliminarCliente(Cliente cliente) {
26 }
27
28 @Override
29 public Cliente buscarCliente(int id) {
31 }
32
33 @Override
34 public List listarClientes() {

36 }
37 }
Finalmente quedará sustituir las líneas con:

Por los algoritmos o la lógica funcional. Tarea propia de los programadores.
Nota: El uso de la programación contra interfaces ayuda de gran manera al trabajo en equipo. Por ejemplo:
Hay dos clases de servicios y asignadas a distintos programadores. Cuando una clase hace la llamada a métodos
de la otra clase pero ninguna clase esta implementada, él programador no necesita esperar la implementación
de la clase que necesita, puede utilizar su Interfaz que ya está disponible.
Ya que este tutorial trata de cómo utilizar Netbeans IDE, no entraremos en el tema del uso de los paradigmas y
las técnicas de programación.
Formatear el código (Alt + Shift + F)
No todos los programadores transcriben el código con el mismo estilo, pero una de las opciones que tiene el
editor de Netbeans, es el formateo del código.
Esta opción está seleccionando en un lugar vacío del editor. Luego: Format o Alt + Shift + F

Características de los objetos

Una clase es la descripción de un tipo de objetos. Por ejemplo, podemos definir la clase Mesa como la
descripción de ese tipo de objetos. Todas las mesas tienen una serie de características en común que permiten
definir las características de cada una de ellas. Podríamos utilizar como características que definen las mesas las
siguientes: color, alto, ancho, largo, material, ubicación. Esas características se van a denominar atributos o
propiedades de los objetos de la clase.
Clase Mesa:
• color (cadena de caracteres)

• alto (numérico entero)
• ancho(numérico entero)
• largo (numérico entero)
• material (cadena de caracteres)
• ubicación (cadena de caracteres)
De una determinada clase se pueden crear una serie de objetos, que serán instancias de esa clase. Objeto,
instancia de clase o instancia son sinónimos. Siguiendo el ejemplo de la clase "Mesa", se pueden crear
diversas mesas cada una de ellas con sus propios atributos, aunque pueden tener valores iguales en algunos
casos. Cada objeto (mesa) creado tendrá un nombre exclusivo de lo identifica.
• mesa01: "Blanco", 100, 120, 60, "Madera", "Aula1"

• mesa02: "Verde", 100, 100, 50, "Plástico", "Aula1"
• mesa03: "Blanco", 100, 120, 60, "Madera", "Aula2"
• mesa04: "Rojo", 100, 120, 60, "Plástico", "Aula2"
• mesa05: "Verde", 100, 100, 50, "Plástico", "Aula2
Cada clase tendrá definida una serie de operaciones que se pueden realizar sobre los objetos creados de esa
clase. Esas operaciones se denomina métodos. Siempre habrá un método para crear los objetos de la clase que
se denomina método constructor. En el ejemplo de la clase "Mesa" se tendrá un método para crear las mesas,
y se pueden definir otros que permitan realizar una serie de operaciones, por ejemplo:
• moverMesa: Permitiría cambiar la ubicación de una determinada mesa, por ejemplo, del Aula1 al Aula2.
• pintarMesa: Permitiría cambiar el color de una determinada mesa, indicando el nuevo color que tendría.
• dameAncho: Permitíría conocer el ancho de la mesa.
Algunos métodos necesitarán alguna información para efectuar su acción. Por ejemplo, si tenemos al método
moverMesa habría que indicarle dónde se debe colocar, o el método pintarMesa que debe conocer el color de la
pintura a aplicar.
También hay métodos que nos pueden dar (retornar) alguna información, además de llevar a cabo alguna
acción.
Por ejemplo el método dameAncho nos proporciona un dato numérico sobre la medida del ancho de la mesa.
Cualquier aplicación en Java se compone de un conjunto de clases, de las que se pueden crean objetos que
interactúen entre sí. El programador puede instanciar (crear) objetos de las clases definidas por él, o bien, de
las clases incluidas en el lenguaje Java.
Los nombres de las clases en Java empiezan, por convenio, en mayúscula, y los nombres de los objetos y
de los métodos empiezan por minúscula, usando la misma estructura que los nombres de variables. Así por
ejemplo, hablarías de la clase Mesa (empieza en mayúsculas) y del objeto mesa1 (empieza en minúscula).
Las clases que incorpora el lenguaje Java por defecto se encuentran declaradas en la API de Java. Esta
documentación es la fuente de información principal para conocer las distintas clases de las que podemos
disponer como programadores, así como de su uso.

La API de Java está estructurada en tres secciones. En la parte superior izquierda se encuentran
los paquetes, que son los que contienen las clases. Una vez que se selecciona un determinado paquete,
las clases que contiene se muestran en la parte inferior izquierda. Si seleccionamos una de esas clases, en la
parte central aparecerá toda la información que nos ofrece la API referente a esa clase para ayudarnos en su
uso. En la imagen anterior se está mostrando la información de la clase String.
Es por tanto, una documentación que siempre debe estar a mano del programador Java.

Instanciación de objetos
Llamada al método contructor

Para instanciar (crear) objetos de una determinada clase (estándar de Java, creada por nosotros, o por un
tercero) podemos encontrarnos con distintas formas que debemos aplicar. La más habitual de ellas es utilizar la
palabra reservada new, siguiendo el siguiente formato:
new NombreDeLaClase()
Esto sería una llamada al método constructor de la clase. Este tipo de llamada nos devuelven una instancia u
objeto de dicha clase. Una vez creado el objeto, podemos guardarlo en una variable o utilizarlo dentro de
cualquier expresión compatible con la clase del objeto creado.
Para declarar una variable que pueda contener un objeto de una determinada clase se actúa de forma similar a
la declaración de las variables habituales, es decir, siguiendo la estructura:
NombreDeLaClase nombreDeLaVariable;
Es muy habitual que a la vez que se declara una variable, se cree un objeto de su misma clase y se le asigne a
dicha variable, formando una sentencia completa de la siguiente forma:
NombreDeLaClase nombreDeLaVariable = new NombreDeLaClase();
Para ver todo esto sobre un ejemplo, vamos a utilizar la clase Ficha, cuyo código fuente
puedes descargar aquí. En el archivo que se descarga puedes comprobar que contiene una carpeta
llamada javadoc que contiene la documentación sobre la clase Ficha en formato web (abre el archivo
index.html o Ficha.html).
Con esta clase de ejemplo, podrías crear una serie de objetos de esa clase utilizando el formato comentado
anteriormente:
01.public class EjemploCreaObjetos {
02.public static void main(String args[]) {
03.//Ejemplo de declaración de variable y creación de objeto en dos pasos
04.Ficha ficha1;
05.ficha1 = new Ficha();
06.//Ejemplos de declaración de variable y creación de objetos en un paso
07.Ficha f = new Ficha();
08.Ficha fichaRoja = new Ficha();
09.}
10.}
Compilación de aplicación con varios archivos java

Para poder compilar sin errores una aplicación que formada por varias clases guardadas en más de un archivo
.java diferente, debes utilizar el comando de compilación javac con todos los nombres de archivos java que
contienen las clases que formen parte de la aplicación.
javac NombreClase1.java NombreClase2.java NombreClase3.java
Por ejemplo, en el caso anterior la compilación se realizaría así (considerando que los dos archivos se
encuentran en la misma carpeta):
javac EjemploCreaObjetos.java Ficha.java

La ejecución se realiza llamando al comando java indicando el nombre de la clase que contiene el método main.
En el ejemplo se haría:
java EjemploCreaObjetos
Llamada al método constructor con parámetros

Algunas clases ofrecen la posibilidad de crear objetos indicando una serie de valores al método constructor para
que sean tomados en cuenta en el momento de instanciar el objeto. Esos valores que se pasan al método
contructor reciben el nombre de parámetros y se indican dentro de los paréntesis. De esta forma, la llamada al
método constructor de la clase debería seguir el formato:
new NombreDeLaClase(parámetro1, parámetro2, parámetro3)
El número y tipo de dato de los parámetros debe estar indicado en la documentación del método
constructor de la clase. En el momento de hacer la llamada al método constructor hay que cumplir el número de
parámetros que admite así como sus tipos de dato.
Hay que tener en cuenta que una misma clase puede tener varios métodos constructores, todos ellos con el
mismo nombre que la clase, pero variará el número y/o tipo de datos de los parámetros.
En la documentación de la clase de ejemplo Ficha, puedes encontrar dos métodos constructores que vienen
declarados de la siguiente manera:
Podemos ver que existe un método constructor sin parámetros y otro con 3 parámetros que deben ser de los
siguientes tipos: (char, int, int). Debe mantenerse el orden indicado, y hay que tener en cuenta que los nombres
mostrados para los parámetros sólo son indicativos. En el momento de llamar al método constructor se pueden
indicar como parámetros tanto valores literales, como variables o cualquier tipo de expresión siempre que se
cumpla con el requisito de que debe respetarse el tipo de dato.
Como ejemplo podríamos tener:
1.int posX=5;
2.Ficha fichaColocada = new Ficha('@', posX, posX-3);
Observa que el primer parámetro que debía ser un char, se ha indicado con un valor literal. Para el segundo
parámetro se ha utilizado como ejempo una variable de tipo int, ya que es el tipo de dato requerido en ese
caso. En el tercer parámetro se ha utilizado el resultado de una expresión aritmética que resulta un valor int,
como es requerido.
Instanciación de objetos de clases Java

El lenguaje Java dispone de una gran cantidad de clases predefinidas que pueden ser utilizadas libremente
por el programador para dar más funcionalidades a sus aplicaciones. Recuerda que la lista de clases disponibles,
así como su documentación sobre su uso la puedes encontrar en la API de Java.
La manera en que deben crearse los objetos de dichas clases puede variar de una clase a otra. La forma exacta
de instanciar un objeto de una clase Java debe consultarse en la API.
Generalmente se hace de igual manera que la vista anteriormente.
Por ejemplo, podemos crear un objeto de la clase java.util.Random que utiliza Java para crear números
aleatorios:
1.java.util.Random numeroAleatorio = new java.util.Random();

Pero hay clases que no disponen del método constructor de forma pública, sino que ofrecen un método para
obtener instancias, como el método getInstance que usan muchas clases Java, sobre todo aquellas afectadas
de alguna manera con la localización geográfica. Por ejemplo, la clase java.util.Calendar que permite trabajar
con fechas y horas, o la clase java.text.NumberFormat, que permite trabajar con distintos formatos de números,
incluyendo en de moneda.
En la API de Java de ese tipo de clases podemos comprobar que los métodos constructores están declarados
como protected, por lo que no pueden ser usados por otra clase externa. En la introducción de la
documentación también podemos encontrar infromación sobre cómo se debe instanciar los objetos, como indica
para la clase Calendar:
La forma de usarlo sería similar, aunque se usa la llamada al método getInstance detrás del nombre de la
clase y no se usa la palabra new.
1.java.util.Calendar fechaActual = java.util.Calendar.getInstance();
Paquetes e import
Las clases de Java están organizadas en paquetes. En la API de Java se puede comprobar esa
organización con la sección que se muestra en la parte superior izquierda. Seleccionando un paquete, se
muestran en la parte inferior todas las clases contenidas en el paquete elegido.
También se puede saber a qué paquete pertenece una clase observando la parte superior de su documentación.

Cada vez que se hace uso de una clase, hay que hacer referencia al paquete en el que se encuentra. Hay que
tener en cuenta que el mismo nombre de clase se puede encontrar en distintos paquetes y su funcionamiento
será totalmente distinto, por lo que hay que dejar bien claro a qué paquete pertenece la clase con la que
queremos trabajar.
Por ejemplo, la clase Random se encuentra en el paquete java.util, por lo que cuando la usemos debemos
indicar que es la clase java.util.Random.
La palabra import nos puede ahorrar tener que escribir siempre delante del nombre de una determinada clase
el paquete en el que se encuentra. Si indicamos en la parte inicial del código fuente (antes de la declaración de
la clase) las clases de Java que se van a utilizar, en el resto del código sólo hay que indicar el nombre de la
clase.
Por ejemplo, si la aplicación que estamos desarrollando va a hacer uso de las clases Random y Calendar,
podríamos escribir en la parte inicial:
1.import java.util.Random;
2.import java.util.Calendar;
Con esto conseguirmos que cada vez que hagamos referencia a una de esas clase, no hay que indicar el
paquete en el que se encuentran. Por ejemplo, al instanciar los objetos sólo hay que indicar:
1.Random numeroAleatorio = new Random();
2.Calendar fechaActual = Calendar.getInstance();
Incluso se puede utilizar el carácter comodín * que permite importar todas las clases de un determinado
paquete. Por ejemplo:
1.import java.util.*;
Eso evitaría escribir cada uno de los import del paquete java.util.

Declaración de Clases
Estructura básica de una clase en Java
/**
* Estructura básica de una clase en Java
*/
class NombreDeClase {
//Declaración de los atributos de la clase
tipoDato atributo1;
tipoDato atributo2;
tipoDato atributo3;
//Declaración de los métodos de la clase
método1(argumentos) {
//Declaración de las variables propias del método1
//Sentencias de ejecución del método
}
método2(argumentos) {
//Declaración de las variables propias del método2
//Sentencias de ejecución del método
}
}
Declaración de atributos
Los atributos son las características propias de cada clase. Cada objeto creado de una determinada clase
tendrá una serie de valores asignados en dichos atributos, por tanto, permiten guardar información de cada
objeto. Se declaran de la misma manera que las variables.
Ejemplo para la clase Alumno:
class Alumno {
String nombre;
String apellidos;
int añoDeNacimiento;
int númeroPersonal;
String grupo;
String turnoHorario = "Mañana";
//Declaración de los métodos

...
}
Como se puede observar en el atributo turnoHorario, se puede dar un valor inicial en la declaración de los
atributos.

Declaración de métodos
Los métodos de una clase definen el comportamiento y los valores de los atributos de un determinado objeto de
esa clase.
El formato básico de declaración de los métodos es:
tipoDatoRetorno nombreMétodo(tipoDato parámetro1, tipoDato parámetro2, ...) {

//Declaración de variables propias del método
//Sentencias con las acciones que debe realizar el método
return valorQueDebeRetornar;
}
Los métodos pueden retornar un valor tras ejecutar las sentencias que contiene, o bien no retornar nada.
Dicho valor de retorno es entregado a la línea de código que realiza la ejecución del método, como se verá más
adelante.
Si va a retornar un valor, se debe especificar el tipo de dato en la declaración delante del nombre. El valor
que vaya a ser devuelto se indica con la sentencia return, y debe ser del mismo tipo que el indicado en la
declaración del método. Por ejemplo, para retornar un String:
String nombreMétodo() {
//Sentencias del método
return valorQueDebeRetornar;
}
Hay que tener en cuenta que la sentencia return termina la ejecución del método, por lo que debe
escribirse en el lugar donde no deba ejecutarse posteriormente ninguna otra sentencia.
Siguiendo el ejemplo de la clase Alumno, se puede declarar un método dameGrupo que obtenga el grupo en el
que se encuentra un determinado alumno:
String dameGrupo() {
return grupo;
}
El valor retornado puede ser un atributo de la misma clase o cualquier otro dato, por ejemplo, un valor booleano
que indique si el alumno es mayor de edad:
boolean esMayorEdad() {
int añoActual = 2011;
if(añoActual - añoDeNacimiento >= 18) {

return true;
}
else {
return false;
}
}
Si el método no va a retornar ningún valor, se debe indicar con la palabra void delante del nombre, y no se
emplea la sentencia return:

void nombreMétodo() {
//Sentencias del método
}
Por ejemplo, se puede declarar un método que únicamente muestre por pantalla el grupo al que pertenece un
alumno, sin que retorne ningún otro valor.
void muestraGrupo() {
System.out.println("El alumno: " + nombre + " " + apellidos);
System.out.println("Pertenece al grupo: " + grupo);
}
En la declaración del método se debe informar de los parámetros que puede aceptar el método, indicando el
tipo de dato y un nombre para dicho parámetro que se utilizará como una variable dentro del mismo. Se
escriben después del nombre del método, entre paréntesis y separados por comas. En los parámetros se
indicarán los datos que el método puede necesitar para realizar las operaciones que tiene encargadas.
Por ejemplo, un método que asigne a un objeto de la clase Alumno sus datos, debe conocer cuál es el nombre
del alumno, sus apellidos, año de nacimiento, número personal, grupo y turno. Por tanto, el método debe tener
los parámetros necesarios para indicarle esos datos:
void asignaValores(String nom, String ape, int añoNac, int num,

String gru, String turno) {
//En este ejemplo, los valores recibidos en los parámetros se
// asignan directamente a los atributos de la clase correspondientes.
nombre = nom;
apellidos = ape;
añoDeNacimiento = añoNac;
númeroPersonal = num;
grupo = gru;
turnoHorario = turno;
//Mostrar mensaje informativo
System.out.println("Valores asignados correctamente");
}
Creación de nueva clase en NetBeans

Dentro de un mismo archivo ".java" se pueden crear varias clases, aunque suele ser más claro y cómodo crear
un nuevo archivo para cada clase.
Desde NetBeans se puede crear fácilmente una nueva clase Java desde el menú contextual del paquete de
fuentes, o desde el menú "Archivo > Archivo Nuevo", seleccionado la opción "Clase Java".

Taller 1.
Creamos un nuevo proyecto en netbeans
Seleccionamos Java-Java Application

Colocamos el nombre del proyecto
Damos clic en terminar

En el paquete damos clic derecho, seleccionamos nuevo-Java Class
Creamos la clase alumno

Ya creada la clase nos aparece el codigo en donde la definimos
La clase alumno va ha tener las siguientes caracteristicas:
Nombre: nombres.
Apellidos: apellidos .
añoDeNacimiento: año de nacimiento
númeroPersonal: Identificación del alumnos
grupo: Grupo de clase
turnoHorario: Jornada de estudio es “Mañana” o “Tarde”
Igualmente vamos a tener los siguiente métodos:
cambiaGrupo: Cambia el grupo del alumno.

asignaValores: Asigna la información del objeto alumno.
muestraGrupo: Muestra el grupo del alumno.
dameGrupo: Presenta el grupo.
esMayorEdad: Identifica si el alumno es mayor de edad o no.
Lo primero que se realiza es la definición de los atributos en la clase:

Creamos la clase Alumno
public class alumno implements Serializable {

private String nombre;
private String apellidos;
private int añoDeNacimiento;
private int númeroPersonal;
private String grupo;
private String turnoHorario = "Mañana";
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

this.nombre = nombre;
}
public String getApellidos() {

return apellidos;
}
public void setApellidos(String apellidos) {

this.apellidos = apellidos;
}
public int getAñoDeNacimiento() {

return añoDeNacimiento;
}
public void setAñoDeNacimiento(int añoDeNacimiento) {

this.añoDeNacimiento = añoDeNacimiento;
}
public int getNúmeroPersonal() {

return númeroPersonal;
}
public void setNúmeroPersonal(int númeroPersonal) {

this.númeroPersonal = númeroPersonal;
}
public String getGrupo() {

return grupo;
}
public void setGrupo(String grupo) {

this.grupo = grupo;
}
public String getTurnoHorario() {

return turnoHorario;
}
public void setTurnoHorario(String turnoHorario) {

this.turnoHorario = turnoHorario;
}
void cambiaGrupo(String nuevoGrupo) {

grupo = nuevoGrupo;
}
void asignaValores(String nom, String ape, int añoNac, int num, String gru, String turno) {
//Asignación de valores a los atributos de la clase
nombre = nom;
apellidos = ape;

añoDeNacimiento = añoNac;
númeroPersonal = num;
grupo = gru;
turnoHorario = turno;
//Mostrar mensaje informativo
JOptionPane.showMessageDialog(null,"Valores asignados correctamente");
JOptionPane.showMessageDialog(null,"El alumnos es: " + this.nombre+" "+this.apellidos+" y es del Año: "+this.añoDeNacimiento);
}
void muestraGrupo() {
JOptionPane.showMessageDialog(null,"El alumno: " + nombre + " " + apellidos+" Pertenece al grupo: " + grupo);
}
String dameGrupo() {
return grupo;
}
boolean esMayorEdad() {
int añoActual = 2015;
if(añoActual - añoDeNacimiento >= 18) {

return true;
}
else {
return false;
}
}
}

Ya creado la clase alumno, pasamos a la creación de la forma:
En ella vamos a realizar la progrmación de los botones:
Guardar
Buscar
Cambiar.
Lo primero que realizamos es definir el forma global el objeto con el cual vamos a trabajar.
alumno alumno1 = new alumno();
Esto lo colocamos al iniciar nuestra programación:
El botón guardar realiza los eventos de asignaValores que es la encargada de darle información a cada uno de
los atributos de los objetos, luego realiza el salvar el objeto y por ultimo limpia los textfield la programación del
botón guardar es:

private void BGuardarActionPerformed(java.awt.event.ActionEvent evt) {

alumno1.asignaValores(
txtNombres.getText(),
TxtApellidos.getText(),
Integer.parseInt(TxtNacimiento.getText()),
Integer.parseInt(TxtNumero.getText()),
TxtGrupo.getText(),
TxtJornada.getText());
try {
// Se salva el objeto con el nombre del DNI
ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(alumno1.getNúmeroPersonal()+".alu"));
salida.writeObject(alumno1);
salida.close();
txtNombres.setText("");
TxtApellidos.setText("");
TxtGrupo.setText("");
TxtJornada.setText("");
TxtNacimiento.setText("");
TxtNumero.setText("");
// TODO add your handling code here:
} catch (Exception ex) {
JOptionPane.showMessageDialog(this,"No se guardo correctamente el alumno."+ ex);
}
Apartir de la información registrada en el campo de texto de busqueda realiza la consulta sobre los objetos
salvados, al encontrar el objeto asocia la información a las casillas de datos, la programación del Botón buscar
alumno es:
private void BBuscarActionPerformed(java.awt.event.ActionEvent evt) {

try {
ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(TxtBuscarNumero.getText()+".alu"));
alumno1=(alumno)entrada.readObject();
entrada.close();
txtNombres.setText(alumno1.getNombre());
TxtApellidos.setText(alumno1.getApellidos());
TxtGrupo.setText(alumno1.getGrupo());
TxtJornada.setText(alumno1.getTurnoHorario());
TxtNacimiento.setText(""+alumno1.getAñoDeNacimiento());
TxtNumero.setText(""+alumno1.getNúmeroPersonal());

JOptionPane.showMessageDialog(this, "Error:"+ex);
} // TODO add your handling code here:
}

Se debe realizar la busuqedad del alumno para realizar el cambio del grupo, la programación del botón Cambiar
el grupo del alumno es:
private void BCambiarActionPerformed(java.awt.event.ActionEvent evt) {

alumno1.cambiaGrupo(TxtNvoGrupo.getText());
try {
ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(alumno1.getNúmeroPersonal()+".alu"));
salida.writeObject(alumno1);
salida.close();
txtNombres.setText("");
TxtApellidos.setText("");
TxtGrupo.setText("");
TxtJornada.setText("");
TxtNacimiento.setText("");
TxtNumero.setText("");
JOptionPane.showMessageDialog(this,"No se guardo correctamente la cuenta."+ ex);
}
La programación del botón salir
private void BSalirActionPerformed(java.awt.event.ActionEvent evt) {
this.dispose();

Ejercicio:
1. Crear una clase llamada profesor que contega los siguientes atributos:
a. Documento
b. Nombre
c. Apellido
d. Año
e. Profesión
2. Adicionar a la clase profesor los siguiente métodos.
a. asignarProfesor.
b. cambiarProfesion.

Clases de objetos
Las clases de objetos son los elementos básicos de la programación orientada a objetos y
representan conceptos o entidades significativos de un problema determinado. Una clase viene
descrita por dos tipos de elementos:
Atributos (o variables de clase). Describen el estado interno de cada objeto
Operaciones (o métodos). Describen lo que se puede hacer con el objeto, los servicios
que proporciona
Una clase de objetos describe las características comunes a un conjunto de objetos. Durante la ejecución de
la aplicación se producirá la instanciación de esta clase, es decir, la creación de los objetos que representan
cada uno de los individuos con sus características propias, es decir, valores específicos para sus atributos

La implementación de esta clase en Java se realizaría en un fichero con nombre Cuenta.java, y su contenido sería
el siguiente:
Los atributos pueden ser de cualquiera de los tipos básicos de Java: boolean, char, byte, short, int, long, float y
double, Referencias a otros objetos o arrays de elementos de alguno de los tipos citados.
En Java la implementación de las operaciones se realiza en el interior de la definición de la clase, justo tras su
declaración:
El acceso a los atributos de la clase desde la implementación de las operaciones se realiza de forma directa. Los
atributos u operaciones estáticas (static) son aquellos que pertenecen a la clase en sí, y no a los objetos. De un
atributo estático no se genera una copia por cada objeto que se crea. Existe una única copia compartida por
todos los objetos de la clase. Una operación estática únicamente puede acceder a miembros estáticos. El
atributo nOp mantiene una cuenta global del número de operaciones realizadas en las cuentas del banco, para
la realización de estadísticas. La operación leerNOperaciones () permite leer este contador. La operación
eurosAPesetas () es una operación auxiliar de la clase Cuenta para ser usada cuando sea necesaria una
conversión de moneda


Taller Práctico 02:
Vamos a crear un proyecto en donde se crea la clase cuenta y podamos visualizar la información corrspondiente
de las operaciones
Seleccionamos un proyecto de java.
Seleccionamos el nombre y la ubicación del programa

Ya creado el proyecto
Luego creamos la clase cuenta.
Se coloca un nombre a la clase en nuestro caso es Cuenta

Adicionamos las propiedades y evento de la clase Cuenta.
public class Cuenta implements Serializable{
long numero;
String titular;
float saldo;
float interesAnual;
// Contador de operaciones
static int nOp = 0;
static int leerNOperaciones(){
return nOp;
}
//Operación estática auxiliar de conversión
static float eurosAPesetas (float euros){

return euros*166.386f;
}
void ingreso (float cantidad){

saldo += cantidad;
++nOp;
}
void retiro (float cantidad) {

saldo -= cantidad;
++nOp;
}

La clase Cuenta queda:
Ahora vamos a realizar la forma del manejo de la cuenta, para ello creamos una frame de nombre FCuenta y le
adicionamos los componentes necesarios para su trabajo:

Primero definimos un objeto global de tipo cuenta:
Cuenta nvacuenta = new Cuenta();
el objeto de llama nvacuenta con el cual se realiza toda la programación
La programación de Botón Crear la cual realiza la asociación de la información directamente a los campos por
que estos son públicos luego slava el objeto y limpia los textfield para seguir ingresando cuentas es:
private void BCrearActionPerformed(java.awt.event.ActionEvent evt) {

try {
nvacuenta.numero = Integer.parseInt(txtnumero.getText());
nvacuenta.saldo = Float.parseFloat(txtSaldo.getText());
nvacuenta.titular = txttitulas.getText();
nvacuenta.interesAnual = Float.parseFloat(txtinteres.getText());

ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(nvacuenta.numero+".cta"));
salida.writeObject(nvacuenta);
salida.close();
txtSaldo.setText("");
txtnumero.setText("");
txttitulas.setText("");
txtinteres.setText("");
}
}

El botón buscar realizar las tares de busqueda de la cuenta apartir de la información registrada en la casilla de
número si no la encuentra envia un mensaje de error y si la encuentra presenta la información en cada casilla.
La programación es:

try {
ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(txtbuscarnumero.getText()+".cta"));
nvacuenta=(Cuenta)entrada.readObject();
entrada.close();
txtinteres.setText(""+nvacuenta.interesAnual);
txtnumero.setText(""+nvacuenta.numero);
txttitulas.setText(""+nvacuenta.titular);
txtSaldo.setText(""+nvacuenta.saldo);

}
}
El botón Retirar realiza la operación sobre la cuenta que se encuentra activa y realiza el retiro, lo que implica
que se debe buscar antes de retirar, la programación del botón es:
nvacuenta.retiro(Float.parseFloat(txtretiro.getText()));
try {
salida.close();
}
El botón Consignar realiza la operación sobre la cuenta que se encuentra activa y realiza la consignación, lo que
implica que se debe buscar antes de consiganr, la programación del botón es:
private void BConsignarActionPerformed(java.awt.event.ActionEvent evt) {

nvacuenta.ingreso(Float.parseFloat(txtConsignacion.getText()));
try {
salida.close();
}

El programa lo ejecutamos y realizamos las tareas de creación, busqueda, retiro y consignación.

Protección de miembros
El principio de ocultación de información se plasma en los lenguajes OO en diversos mecanismos de protección
de los miembros de la clase.
UML permite asociar tres niveles de protección diferentes a cada miembro de la clase:
Miembros públicos (+). Sin ningún tipo de protección especial
Miembros privados (-). Inaccesibles desde el exterior de la clase
Miembros protegidos (#). Similares a los privados aunque se permite su acceso desde las clases descendientes.
En Java un miembro se etiqueta como público colocando el identificador public delante de su declaración Para
los miembros privados utilizaremos el identificador private
Los miembros no etiquetados son accesibles por parte de clases amigas. En C++ y otros lenguajes OO las clases
amigas a una dada pueden indicarse explícitamente.
En Java se consideran amigas todas aquellas que forman parte del mismo paquete.
• Un fichero fuente java forma en sí un paquete y por tanto todas las clases incluidas en él son amigas.
• Las clases incluidas en varios ficheros fuente pueden agruparse en un único paquete indicando el
nombre de paquete al principio de cada fichero mediante el indicador package
En este ejemplo, las clases Cuenta y Banco son amigas al pertenecer al mismo fichero fuente. El acceso a los
atributos de los objetos de la clase Cuenta almacenados en el vector interno de Banco queda así garantizado. El
atributo saldo puede mantenerse como privado puesto que existe una operación que permite obtener su valor.

Atención: todas las clases que no se declaren como pertenecientes a ningún paquete de forma explícita,
pertenecen a un paquete “por defecto” y por tanto son amigas.
Un paquete crea un espacio de nombres propios. Esto significa que la clase pasa a tener como prefijo el propio
nombre del paquete. A la hora de utilizarla tenemos tres opciones:
• Utilizar su nombre completo: prueba.A
• Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del código fuente
mediante import prueba.A
• Importar directamente todas las clases del paquete, que se usarían sin prefijo: import prueba.*

Taller 3. Protección de Clases y Constructor.
Vamos a crear una clase cuenta
Como los atributos son privados vamos utilizar la forma automatica de crear los get y set asi como el constructor
para ello vamos a la cuenta damos clic derecho y nos muestra el menu contextual
Seleecionamos la opción Insert Code.. que es la que me permite crear los eventos.

Primero seleccionamos crear los get y los set
Seleccionamos la opción y nos permite escoger que atributos tiene las opciones, para nuestr casos son todos:
Damos clic en generate y me crea las funciones y procedimientos get y set por atributo

Luego procedemos a crear el constructor vamos por el menu contextual y seleccionamos constructor
Seleccionamos que campos van en el constructur, en este caso seleccionamos todos:

Damos clic en Generate y me crea el constructor

Lo siguiente es crear las fuciones y procedimientos adicionales:
El código generado y construido será al final el siguiente:
private int numero;

private double saldo;
private int transacciones;
private String Clave;
// Código Generado
public Cuenta(int numero, double saldo, int transacciones, String Clave) {

this.numero = numero;
this.saldo = saldo;
this.transacciones = transacciones;
this.Clave = Clave;
}
public int getNumero() {
return numero;
}
public void setNumero(int numero) {

}
public double getSaldo() {

return saldo;
}
public void setSaldo(double saldo) {

this.saldo = saldo;
}
public int getTransacciones() {

return transacciones;
}
public void setTransacciones(int transacciones) {

}
public String getClave() {

return Clave;

public void setClave(String Clave) {

this.Clave = Clave;
}
// Código construido por nosotros
String Ver_Informacion(){
return "La cuenta # "+numero+" tiene saldo de "+saldo+" en "+transacciones+" transacciones y tiene clave "+Clave;
}
void consignacion(double valor){

saldo+=valor;
transacciones++;
}
void retiro(double valor){

if (saldo-valor<0){
JOptionPane.showMessageDialog(null,"La cuenta tiene de saldo "+saldo);
} else {
saldo-=valor;
transacciones++;
}
}
El siguiente paso es crear la forma para el manejo de la cuenta:
Lo primero que realizamos es definir el objeto en forma global

Aqui no creamos la opción de Cuenta nvacuenta= new Cuenta(); dado que tenemos un constructor creado por
lo cual debemos de dejar sola la definición del objeto Cuenta nvacuenta; y al momento de ingresar la
información es cuando creamos el objeto con información. Dicha programación la tiene el botón crear:

nvacuenta = new Cuenta(
Integer.parseInt(txtnumero.getText()),
Double.parseDouble(txtSaldo.getText()),
Integer.parseInt(txttransac.getText()),
txtclave.getText());
try {
ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(nvacuenta.getNumero()+".cta"));
salida.close();
txttransac.setText("");
txtclave.setText("");
}
La programación de buscar se realiza a partir de la información digita el realiza la busqueda por el código si
encuentra la cuenta la presenta si no envia un mensaje de no existencia de la cuenta la programación es la
siguiente:

try {
entrada.close();
txtclave.setText(""+nvacuenta.getClave());
txtnumero.setText(""+nvacuenta.getNumero());
txttransac.setText(""+nvacuenta.getTransacciones());
txtSaldo.setText(""+nvacuenta.getSaldo());

}
}

El procedimiento retiro lo realiza a partir de la cuenta buscada y encontrada aplica el evento retirar definido en
la clase el código es el siguiente:
private void BRetiroActionPerformed(java.awt.event.ActionEvent evt) {

nvacuenta.retiro(Double.parseDouble(txtretiro.getText()));
try {
salida.close();
}
El procedimiento consignación lo realiza a partir de la cuenta buscada y encontrada aplica el evento consignar
definido en la clase el código es el siguiente:

nvacuenta.consignacion(Double.parseDouble(txtConsignacion.getText()));
try {
salida.close();
}
El programa terminado realiza la siguiente ejecución:

Relaciones entre clases

Un conjunto de objetos aislados tiene escasa capacidad para resolver un problema. En una
aplicación útil los objetos colaboran e intercambian información, mantienen distintos tipos de
relaciones entre ellos.
A nivel de diseño, podemos distinguir entre 5 tipos de relaciones básicas entre clases de objetos:
dependencia, asociación, agregación, composición y herencia.
La dependencia es la relación menos importante. Simplemente refleja que entre dos clases de objetos
existe una posible colaboración temporal con algún propósito. Una dependencia puede indicar la
utilización de un objeto de una clase como argumento de una operación de otra o en su
implementación.
Como vimos anteriormente, la clase Cuenta requiere las clases FileOutputStream y
ObjectOutputStream de la librería de clases de Java para la implementación de la operación salvar.
En cambio, la asociación es la relación más importante y más común. Refleja una relación entre dos
clases independientes que se mantiene durante la vida de los objetos de dichas clases o al menos
durante un tiempo prolongado. En UML suele indicarse el nombre de la relación, el sentido de dicha
relación y las cardinalidades en los dos extremos. Vamos a sustituir el atributo titular por una
asociación con una nueva clase Cliente completa
Una asociación se implementa en Java introduciendo referencias a objetos de la clase destino de la

relación como atributos de la clase origen. Si la relación tiene una cardinalidad superior a uno
entonces será necesario utilizar un array o una estructura de datos dinámica del paquete java.util
como Vector o LinkedList. Normalmente la conexión entre los objetos se realiza recibiendo la
referencia de uno de ellos en el constructor u otra operación similar del otro.

La agregación es un tipo especial de asociación donde se añade el matiz semántico de que la clase de
donde parte la relación representa el “todo” y las clases relacionadas “las partes”. Realmente Java y la
mayoría de lenguajes orientados a objetos no disponen de una implementación especial para este tipo
de relaciones. Básicamente se tratan como las asociaciones ordinarias.
La composición es un tipo de agregación que añade el matiz de que la clase “todo” controla la
existencia de las clases “parte”. Es decir, normalmente la clase “todo” creará al principio las clases
“parte” y al final se encargará de su destrucción. Supongamos que añadimos un registro de
movimientos a la clase Cuenta, de forma que quede constancia tras cada ingreso o reintegro.

Las composiciones tienen una implementación similar a las asociaciones, con la diferencia de que el
objeto principal realizará en algún momento la construcción de los objetos compuestos.

TALLER PRACTICA 04
Creamos un proyecto con nombre Taller04 y creamos las clases Cliente y Cuenta, con la siguiente estructura.
Crear la clase Cliente con la siguiente información:
public class Cliente implements Serializable{

private int Documento;
private String Nombre;
private String Ciudad;
public Cliente(int Documento, String Nombre, String Ciudad) {

this.Documento = Documento;
this.Nombre = Nombre;
this.Ciudad = Ciudad;
}
public int getDocumento() {

return Documento;
}
public void setDocumento(int Documento) {

this.Documento = Documento;
}

return Nombre;
}
public void setNombre(String Nombre) {

this.Nombre = Nombre;
}
public String getCiudad() {

return Ciudad;
}
public void setCiudad(String Ciudad) {

this.Ciudad = Ciudad;
}
Se crea la forma en donde ingresamos la información del cliente:
La programación de los botones es:

Recuerde definir en forma global la variable en donde almacenamos la información:
Crear:

NvoCliente = new Cliente(
Integer.parseInt(txtDocumento.getText()),
txtNombre.getText(),
txtLocalidad.getText());
try {
ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(NvoCliente.getDocumento()+".cli"));
salida.writeObject(NvoCliente);
salida.close();
txtDocumento.setText("");
txtNombre.setText("");
txtLocalidad.setText("");

JOptionPane.showMessageDialog(this,"No se guardo correctamente el cliente."+ ex);
}
}
Buscar:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

try {
ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(txtBuscar.getText()+".cli"));
NvoCliente=(Cliente)entrada.readObject();
entrada.close();
txtDocumento.setText(""+NvoCliente.getDocumento());
txtNombre.setText(""+NvoCliente.getNombre());
txtLocalidad.setText(""+NvoCliente.getCiudad());
}
}

Vamos a crear una clase cuenta
Como los atributos son privados vamos utilizar la forma automatica de crear los get y set asi como el constructor
para ello vamos a la cuenta damos clic derecho y nos muestra el menu contextual
Seleecionamos la opción Insert Code.. que es la que me permite crear los eventos.

Primero seleccionamos crear los get y los set
Seleccionamos la opción y nos permite escoger que atributos tiene las opciones, para nuestr casos son todos:
Damos clic en generate y me crea las funciones y procedimientos get y set por atributo

Luego procedemos a crear el constructor vamos por el menu contextual y seleccionamos constructor
Seleccionamos que campos van en el constructur, en este caso seleccionamos todos:

Damos clic en Generate y me crea el constructor
Lo siguiente es crear las fuciones y procedimientos adicionales:

El código generado y construido será al final el siguiente:
public Cuenta(int numero, double saldo, int transacciones, Cliente Titular, String Clave) {
this.saldo = saldo;
this.Titular = Titular;
this.Clave = Clave;
}
private int numero;
private double saldo;
private int transacciones;
private Cliente Titular;
private String Clave;
public int getNumero() {

return numero;
}
public void setNumero(int numero) {

}
public double getSaldo() {

return saldo;
}
public void setSaldo(double saldo) {

this.saldo = saldo;
}
public int getTransacciones() {

return transacciones;
}
public void setTransacciones(int transacciones) {

}
public Cliente getTitular() {

return Titular;
}
public void setTitular(Cliente Titular) {

this.Titular = Titular;

public String getClave() {

return Clave;
}
public void setClave(String Clave) {

this.Clave = Clave;
}
// Código construido por nosotros
String Ver_Informacion(){
return "La cuenta # "+numero+" tiene saldo de "+saldo+" en "+transacciones+" transacciones y tiene clave "+Clave;
}
void consignacion(double valor){

saldo+=valor;
transacciones++;
}
void retiro(double valor){

if (saldo-valor<0){
JOptionPane.showMessageDialog(null,"La cuenta tiene de saldo "+saldo);
} else {
saldo-=valor;
transacciones++;
}
}
El siguiente paso es crear la forma para el manejo de la cuenta:

Lo primero que realizamos es definir los objetos en forma global
Aqui no creamos la opción de Cuenta nvacuenta= new Cuenta(); dado que tenemos un constructor creado por
lo cual debemos de dejar sola la definición del objeto Cuenta nvacuenta e igulamente realizamos con
NvoCliente; y al momento de ingresar la información es cuando creamos el objeto con información. Antes de
crear la cuenta se debe cerciorar que el cliente existe para ello realizamos el procedimiento de buscar el titular
la programación es:
try {
ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(txtBuscarTitular.getText()+".cli"));
NvoCliente=(Cliente)entrada.readObject();
entrada.close();
txtNombreTitular.setText(""+NvoCliente.getNombre());
}
Con esta busqueda nos trae la información del titular y lo asocia al objeto NvoCliente que es global
Dicha programación la tiene el botón crear:

nvacuenta = new Cuenta(
Integer.parseInt(txtnumero.getText()),
Double.parseDouble(txtSaldo.getText()),
Integer.parseInt(txttransac.getText()),
NvoCliente,
txtclave.getText());
try {
salida.close();
txtBuscarTitular.setText("");
txtNombreTitular.setText("");
}
}
La programación de buscar se realiza a partir de la información digita el realiza la busqueda por el código si
encuentra la cuenta la presenta si no envia un mensaje de no existencia de la cuenta la programación es la
siguiente:


try {
entrada.close();
txtclave.setText(""+nvacuenta.getClave());
txtnumero.setText(""+nvacuenta.getNumero());
txttransac.setText(""+nvacuenta.getTransacciones());
txtSaldo.setText(""+nvacuenta.getSaldo());
NvoCliente = nvacuenta.getTitular();
txtBuscarTitular.setText(""+NvoCliente.getDocumento());
txtNombreTitular.setText(NvoCliente.getNombre());
}
El procedimiento retiro lo realiza a partir de la cuenta buscada y encontrada aplica el evento retirar definido en
la clase el código es el siguiente:
private void BRetiroActionPerformed(java.awt.event.ActionEvent evt) {

nvacuenta.retiro(Double.parseDouble(txtretiro.getText()));
try {
salida.close();
}
El procedimiento consignación lo realiza a partir de la cuenta buscada y encontrada aplica el evento consignar
definido en la clase el código es el siguiente:

nvacuenta.consignacion(Double.parseDouble(txtConsignacion.getText()));
try {
salida.close();
}
Para realizar el llamado de los clientes y de las cuentas debemos crear una forma para realizar el llamado de las
formas en este caso creamos un forma principal con un menu para llamar a la formas:

Se debe realizar el cambio de forma pricipal del proyecto esta la forma de cuenta ahora debe quedar la forma
del Menú, igualmente se debe realizar el llamado de cada forma en su respectivo item menu.

El programa terminado realiza la siguiente ejecución:
Menú Principal:
Tiene para Administrar Cuentas y Clientes, antes de crear una cuenta se debe crear un cliente.
Opción de Cliente:
Opción de Cuenta: Recuerde buscar el cliente antes de crear la cuenta:
Se busca el cliente digitando la cedula y da clic en el botón de titular:
Si existe el cliente aparece el nombre del cliente:

Luego si ingresamos los demas datos:
Realizamos pruebas.
Taller ahora deseamos crear la clase localidad con los atributos de codigo de tipo entero y nombre de tipo String
realizar los cambios necesarios del proyecto para crear ciudades y estas ser asociadas al titular.

Clases anidadas e interiores

Java y algunos otros lenguajes OOP permiten la definición de una clase de objetos dentro de otra, con una
doble utilidad:
1. Organizar mejor el código. Empaquetar en una clase principal otras que no tienen utilidad o sentido
fuera del contexto de ésta
2. Evitar colisiones de nombres. La clase principal define un espacio de nombres al que pertenecen las
anidadas
Al igual que cualquier otro miembro de una clase, una clase anidada puede ser estática o no estática y utilizar
los niveles de protección public, private y protected.
El tipo de clase anidamiento más sencillo es aquel en que la clase contenida se declara como estática.
Desde el punto de vista de la organización del código, tendría mucho más sentido introducir la clase Movimiento
en el interior de Cuenta. Al ser declarada como privada, se impediría su utilización desde el exterior.
Cuando la clase anidada no es estatica, se denomina clase interior y tiene caracteristicas especiales:
1. •Pueden ser creadas unicamente dentro de la clase continente
2. •Tiene acceso completo y directo a todos los atributos y operaciones del objeto que realiza su creacion
Los objetos de la clase interior quedan ligados permanentemente al objeto concreto de la clase continente que
realizo su creación.
No debe confundirse este elemento con la relacion de composicion, aunque en muchos casos es posible utilizar
clases interiores para la implementacion de este tipo de relaciones.
Implementando la clase Movimiento como una clase interior es posible copiar el valor del saldo actual de la
cuenta que realiza el movimiento de manera directa.


Cuando la clase anidada no es estática, se denomina clase interior y tiene características especiales:
• Pueden ser creadas únicamente dentro de la clase continente
• Tiene acceso completo y directo a todos los atributos y operaciones del objeto que realiza su creación
• Los objetos de la clase interior quedan ligados permanentemente al objeto concreto de la clase continente
que realizó su creación
• No debe confundirse este elemento con la relación de composición, aunque en muchos casos es posible
utilizar clases interiores para la implementación de este tipo de relaciones
Implementando la clase Movimiento como una clase interior es posible copiar el valor del saldo actual de la
cuenta que realiza el movimiento de manera directa


Autoreferencias
• En ocasiones es necesario obtener una referencia en la implementacion de una operacion al propio
objeto sobre el que ha sido invocada la operacion
• Esta referencia se obtiene en C++ y Java mediante el operador this
• Cuando encontremos this en una expresion, podremos sustituirlo mentalmente por “este objeto”
• Aunque no es necesario, podemos utilizar this para llamar desde la implementacion de una operacion a
otra operacion del mismo objeto
La llamada a la operación ingreso desde ingresoInteresMes() puede realizarse utilizando this como
referencia del objeto sobre el que se invoca la operación
En este ejemplo, el uso de this es realmente útil. Nos permite implementar la operación
transferirDesde() llamando a una operación transferirHasta(), previamente implementada
En este ejemplo, el uso de this es realmente útil. Nos permite implementar la operación
transferirDesde() llamando a una operación transferirHasta(), previamente implementada
• Otra utilidad de this en Java es realizar una llamada a un constructor desde otro constructor

Pero atención: un constructor no es una operación ordinaria. Únicamente puede llamarse a un

constructor desde otro constructor y debe ser la primera instrucción dentro de la implementación

Interface List. Clase LinkedList api java. Ejercicio diferencias entre

ArrayList y LinkedList.
INTERFACE LIST
Vamos a continuar el estudio de la interface List del api de Java, pero esta vez usaremos la clase LinkedList
como forma de instanciar la interface. También veremos las características más importantes de LinkedList, las
diferencias que tiene con ArrayList y haremos un ejemplo a modo de ejercicio.
LINKEDLIST
La clase LinkedList implementa la interface List. Eso quiere decir que tendrá una serie de métodos propios de
esta interface y comunes a todas las implementaciones. Así utilizando siempre que se pueda declaración de
objetos del tipo definido por la interface podemos cambiar relativamente fácil su implementación (por ejemplo
pasar de ArrayList a LinkedList y viceversa) y conseguir mejoras en el rendimiento de nuestros programas con
poco esfuerzo.
Ahora centrándonos en la clase LinkedList, ésta se basa en la implementación de listas doblemente enlazadas.
Esto quiere decir que la estructura es un poco más compleja que la implementación con ArrayList, pero… ¿Qué
beneficios nos aporta si la estructura es más compleja?.
¿Rapidez?, pues no mucha la verdad, de hecho ArrayList es la favorita para realizar búsquedas en una lista y
podríamos decir que ArrayList es más rápida para búsquedas que LinkedList. Entonces, ¿qué interés tiene
LinkedList?. Si tenemos una lista y lo que nos importa no es buscar la información lo más rápido posible, sino
que la inserción o eliminación se hagan lo más rápidamente posible, LinkedList resulta una implementación muy
eficiente y aquí radica uno de los motivos por los que es interesante y por los que esta clase se usa en la
programación en java.
La clase Linkedlist no permite posicionarse de manera absoluta (acceder directamente a un elemento de la lista)
y por tanto no es conveniente para búsquedas pero en cambio sí permite una rápida inserción al inicio/final de

la lista y funciona mucho más rápido que Arraylist por ejemplo para la posición 0 (imaginemos que en un
ArrayList deseamos insertar en la posición 0 y tenemos muchos elementos, no solo tendremos que realizar la
operación de insertar este nuevo elemento en la posición 0 sino que tendremos que desplazar el elemento que
teníamos de la posición 0 a la 1, el que estaba anteriormente en la posición 1 a la 2 y así sucesivamente… Si
tenemos un gran número de elementos la operación de inserción es más lenta que en la implementación
LinkedList, donde el elemento simplemente “se enlaza” al principio, sin necesidad de realizar desplazamientos en
cadena de todos los demás elementos).
NO SÉ QUE IMPLEMENTACION UTILIZAR ¿ARRAYLIST O LINKEDLIST?
Es posible que en un programa tengamos que usar una lista pero no sepamos si es más conveniente usar
ArrayList ó LinkedList. En este caso podemos hacer lo siguiente:
Si a priori pensamos que es mejor utilizar una implementación con ArrayList porque pensamos que las
búsquedas van a ser la mayoría de las operaciones, entonces pondremos algo así: List listaObjetos = new
ArrayList();
Por el contrario si pensamos a priori que la mayoría de las operaciones sobre esta lista de objetos van a ser
inserciones o eliminaciones sobre listas grandes escribiremos: List listaObjetos = new LinkedList();
Aquí queda reflejada la utilidad que tiene el uso de interfaces, porque usando los mismos métodos, podemos
tener varias implementaciones que nos permitirán un mejor rendimiento dependiendo del uso que demos a
nuestra aplicación.
EJERCICIO COMPARATIVO ARRAYLIST VS LINKEDLIST
Vamos a realizar a continuación un ejercicio comparativo, donde vamos a observar y medir el tiempo que tarda
en realizarse una inserción en una lista ArrayList y en otra lista LinkedList.
Para ello y basándonos en la clase Persona que hemos venido utilizando a lo largo del curso, escribiremos este
código en nuestro editor:

/* Ejemplo Interface List aprenderaprogramar.com */
public class Persona{
public int idPersona;
public String nombre;
public int altura;
public Persona(int idPersona, String nombre, int altura) {
this.idPersona = idPersona;
this.altura = altura;}
@Override
public String toString() {
return "Persona-> ID: "+idPersona+" Nombre: "+nombre+" Altura: "+altura+"\n";
Y nuestra clase con el método main:
/* Ejemplo Interface List aprenderaprogramar.com */
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Programa {
public static void main(String arg[]) {
List<Persona> listaarray = new ArrayList<Persona>();
List<Persona> listalinked = new LinkedList<Persona>();
long antes;
for(int i=0;i<10000;i++)

listaarray.add(new Persona(i,"Persona"+i,i)); // En este ejemplo cada persona lleva

datos ficticios
listalinked.add(new Persona(i,"Persona"+i,i));
System.out.println("Tiempo invertido en insertar una persona en listaarray (en

nanosegundos):");
antes = System.nanoTime();
listaarray.add(0,new Persona(10001,"Prueba",10001)); // Inserción en posicion 0 de una

persona
System.out.println(System.nanoTime()- antes);
System.out.println("Tiempo invertido en insertar una persona en listalinked (en

nanosegundos):");
antes = System.nanoTime();
listalinked.add(0,new Persona(10001,"Prueba",10001)); // Inserción en posicion 0 de

una persona
System.out.println(System.nanoTime()- antes);
Nuestro diagrama de clases es el siguiente:

Como podemos observar en el código de la clase Programa, creamos 2 listas, una basada en la implementación
ArrayList y otra basada en LinkedList. A continuación declaramos una variable de tipo long para contar el tiempo
invertido en cada inserción.
Previamente a esto, cargamos en las listas respectivamente 10.000 personas lo cual no es ni mucho menos una
gran cantidad (piensa por ejemplo en una empresa de telefonía móvil, puede tener muchos miles de clientes),
pero tampoco queremos alargar mucho el proceso de carga en este ejemplo.
Bien, pues una vez cargadas nuestras listas: listaarray y listalinked, medimos el periodo de tiempo que consume
una inserción en la posición 0 en cada implementación y obtenemos los siguientes resultados.
Obtenemos la siguiente salida por consola:
Como vemos el tiempo invertido en insertar una persona en la posición inicial en una lista implementada con
ArrayList es mayor que el empleado en una LinkedList. Si este proceso tuviéramos que hacerlo repetitivamente,
el coste en tiempo podría ser significativamente diferente y motivo suficiente para usar una implementación u
otra.
Ahora cambiaremos el código de programa, para insertar a la nueva persona en la posición 5000 en vez de en la
posición 0, lo que hacemos con este código (listaarray.add(5000,new Persona(10001,"Prueba",10001)); y
listalinked.add(5000,new Persona(10001,"Prueba",10001)); ) y tras ejecutar de nuevo el programa obtendremos
una pantalla algo similar a la siguiente:

Vemos que en esta ocasión el tiempo en insertar con listaarray es más o menos el mismo que en el anterior
ejemplo, pero que con listalinked insertar en la posición media de la lista es tremendamente más lento. Esto es
debido a que para insertar en esa posición la implementación con linkedlist debe recorrer parte de la lista hasta
llegar a esa posición, mientras que con arraylist tenemos acceso directo a una posición determinada. Todo esto
está relacionado con la forma en que está implementado el código del api de Java, aspectos que no tenemos
por qué conocer pero que afectan al rendimiento o idoneidad de una clase u otra. Aunque no tengamos que
conocer el código del api Java, sí debemos ser conscientes de las ventajas e inconvenientes que puede tener el
uso de una u otra clase como programadores.
Ahora para finalizar vamos a utilizar el método add sin una posición determinada, pero que por defecto añade el
nuevo elemento en la última posición.
Por tanto volvemos a modificar el código de la clase Programa y sustituiremos las líneas listaarray.add(5000,new
Persona(10001,"Prueba",10001)); por listaarray.add(new Persona(10001,"Prueba",10001)); y
listalinked.add(5000,new Persona(10001,"Prueba",10001)); por listalinked.add(new
Persona(10001,"Prueba",10001));
Obteniendo un resultado como este:

En donde vemos que los tiempos de inserción han disminuido en ambos casos tanto en la implementación con
arrays como con listas enlazadas. En este último caso espectacularmente (en nuestro caso tan solo 962
nanosegundos, aunque estos valores dependen del ordenador que estemos utilizando), lo que nos indica que
LinkedList es muy eficiente en las inserciones en posición inicial y final de una lista.
CONCLUSIONES
Este ejemplo nos ha servido para sacar unas claras conclusiones ya no solo acerca del uso de ArrayList y
LinkedList, sino sobre el uso de interfaces a modo general para saber qué implementación nos puede convenir
utilizar en función del tipo de procesos que vayan a ser más habituales.
En cuanto a ArrayList y LinkedList vemos que las inserciones en posiciones iniciales o finales son por regla
general más rápidas con LinkedList. Igualmente pasaría con las eliminaciones o borrados. Aunque observamos
que las búsquedas o las inserciones en posiciones intermedias de una lista con gran número de elementos es
más rápida en el caso de ArrayList. Esto es debido a que ésta accede a la posición de manera directa.
Para finalizar esta comparación vemos que el método add por defecto sin posición es más rápido que insertar en
posiciones iniciales o intermedias en ambas implementaciones.

Curso de Java. Estructuras de datos: ArrayList y LinkedList

En la entrega de hoy, hablaremos sobre los ArrayList y LinkedList. Hablaremos sobre sus métodos y
cuales son sus diferencias hablando en cuanto a eficiencia en el manejo de los datos.
Vamos a empezar con una breve introducción de cada uno de ellos.
Ambas implementan una interfaz genérica, la interfaz List
ArrayList: lista implementada con un array
• Acceso posicional eficiente
• Inserción y extracción costosas menos en la última posición que es instantánea
• Cuando se supera el tamaño del array, se crea uno nuevo más grande y se copian en él los elementos
del antiguo
LinkedList: lista doblemente enlazada
• Acceso posicional costoso
• Inserción y extracción costosas
• Menos en la primera y última posición que es inmediato
• Tamaño ilimitado

Uso de ArrayList y LinkedList
Debe importarse el paquete java.util:
1 import java.util.*;
Son clases genéricas
El constructor crea una lista vacía
1 LinkedList<MiClase> lista=new LinkedList<MiClase> ();

Con las colecciones se puede usar el lazo for-each
1 for(MiClase elem: lista) {

2
3 ... utiliza elem ...
4
5}
En las operaciones que se muestran en las transparencias siguientes la clase E es el parámetro genérico.
• Operaciones de modificación de la interfaz List

Las operaciones que usan index pueden lanzar IndexOutOfBoundsException si el valor de index no es válido.
Los métodos contains, indexOf y lastIndexOf utilizan el método equals para localizar el objeto.
• Operaciones específicas de LinkedList

getFirst(), getLast(), removeFirst() y removeLast() lanzan NoSuchElementException si la lista está vacía.
En la entrega de hoy, vamos a ver un ejemplo de utilización del LinkedList, para posteriormente plantear
un ejercicio del mismo, del cual, daremos la solución la próxima semana.
Vamos por lo tanto con el primero de los ejemplos, en este caso, el de LinkedList.
La implementación de las colas en Java es la LinkedList, que implementa la interfaz Queue
• Las operaciones de inserción y extracción son eficientes.
Puede ser conveniente hacer nuestra propia implementación para conseguir más sencillez y eficiencia.
Escribir una clase para controlar el acceso de clientes a un servicio.
• Se guardará una cola de espera de clientes y otra cola de clientes ya atendidos.
Cada cliente tiene un nombre, un número de móvil.
• Junto al cliente se guarda su fecha y hora de llegada, y su fecha y hora de atención.
Operaciones

• añadir un cliente
• atender a un cliente
• obtener el tiempo medio de espera de los clientes que aún no han sido atendidos
• obtener el tiempo medio de espera de los clientes ya atendidos
• mostrar el estado de las colas
Escribir también un programa de prueba. Para la fecha y hora usar la clase predefinida Calendar.
Vamos a implementar la clase Reloj, que nos dará una medida para calcular el tiempo que tarda en ser atendido
un paciente:
1 import java.util.Calendar;
2 /**
3 * Clase que permite obtener la fecha y hora actual,
4 * en milisegundos desde la época
5 */
6 public class Reloj
7{
8 public static long ahora()
9 {
10 return Calendar.getInstance().getTimeInMillis();
11 }
12 }
Ahora vamos a implementar la cola de espera, propiamente dicha:
2 public class ColaEspera {
3 /** Clase interna para almacenar todos los
4 * datos de un cliente
5 */
6 private static class DatosCliente {
7 String nombre;
8 long entrada, salida; // milisegundos
9 /** Constructor; pone la hora de entrada*/

10 DatosCliente (Cliente c) {
11 this.c=c;
12 entrada=Reloj.ahora();
13 }
14
15 void atiende() {
16 salida=Reloj.ahora();
17 }
18 }
19 // colas del servicio
20 private Queue<DatosCliente> colaEspera;
21 private Queue<DatosCliente> colaAtendidos;
22 /**Constructor de ColaEspera */
23 public ColaEspera() {
24 colaEspera=new LinkedList<DatosCliente>();
25 colaAtendidos=new
26 LinkedList<DatosCliente>();
27 }
28
29 /**
30 * Nuevo cliente; se mete en la cola de espera
31 */
32 public void nuevoCliente(Cliente c)
33 {
34 DatosCliente datos=new DatosCliente(c);
35 colaEspera.add(datos);
36 }
37
38 /**
39 * Atender cliente: se saca de la cola de
* espera y se mete en la de
40
atendidos;
41 * retorna el cliente atendido
42 */
43 public Cliente atenderCliente()
44 throws NoSuchElementExceptio

n
45 {
46 DatosCliente datos=colaEspera.remove();
47 datos.atiende();
48 colaAtendidos.add(datos);
49 return datos.c;
50 }
51
52 public double tiempoEsperaAtendidos()
53 {
54 long tiempo=0;
55 int num=0;
56 for (DatosCliente datos: colaAtendidos) {
57 tiempo=tiempo+datos.salida-datos.entrada;
58 num++;
59 }
60 if (num==0) {
61 return 0.0;
62 } else {
63 return (((double) tiempo)/num)/1000.0;
64 }
65 }
66 }
Como parte opcional, se puede hacer un programa principal que prueba el funcionamiento de esta cola, creando
un main y añadiendo clientes y extrayéndolos, y comprobando el tiempo que ha tardado en ser atendido.
Como podéis ver el funcionamiento de las LinkedList es sencillo, y los métodos que hereda de la interfaz List nos
facilitan muchos las cosas. Ahora vamos a proponeros un ejercicio ara que practiquéis.
Ejercicio
Se pide implementar una lista que gestione la lista de espera de un taller mecánico. El taller tendrá una lista de
fichas de vehículos que serán dados de alta en el momento de su llegada al taller, donde se le asignará la hora
de entrada. Una vez resuelto el problema del coche se le asignará una fecha de resolución de la avería y sólo
cuando el técnico venga a buscarlo, se le dará una fecha de salida y el borrado de la lista de espera. Es

recomendable crear tres listas, una para los no arreglados, otra para los arreglados y están pendientes de
retirar.
Lo primero de todo vamos a dar solución al ejercicio de la semana pasada que si acordáis, estaba relacionado
con un taller de reparación de coches.
Vamos con la primera de las clases de nuestro ejercicio, la clase Reloj, que únicamente será la encargada de
proporcionarnos una fecha y una hora para las fichas de nuestros vehículos del taller.
1 import java.util.Calendar;
2 /**
3 * Clase que permite obtener la fecha y hora actual,
4 * en milisegundos desde la época
5 */
6 public class Reloj
7{
8 public static long ahora()
9 {
10 return Calendar.getInstance().getTimeInMillis();
11 }
12 }
Se trata de la misma implementación que en el ejemplo que o pusimos, por lo que podéis copiar y pegar tal cual
está.
Ahora vamos con la primera de las clases que nos interesa, la clase FichaVehiculo. Se encargará de recoger
todos los datos referidos a los vehículos que entre en el taller. Estará forma principalmente por observadores de
atributos, que poseen visibilidad privada.
1 public class FichaVehiculo

2{
3 private long entrada, reparacion, salida;
4 private String modelo;
5 private String matricula;
6

7 /**Constructor*/
8 public FichaVehiculo(String m, String ma, long e)
9 {
10 modelo=m;
11 matricula=ma;
12 entrada=e;
13 reparacion=0;
14 salida=0;
15
16 }
17
18 public String matricula()
19 {
20 return matricula;
21 }
22
23 public String modelo()
24 {
25 return modelo;
26 }
27
28 public void modificaFechaEntrada(long fecha_entrada)
29 {
30 entrada=fecha_entrada;
31 }
32
33 public void modificaFechaSalida(long fecha_salida)
34 {
35 entrada=fecha_salida;
36 }
37
38 public void modificaFechaReparacion(long fecha_reparacion)
39 {
40 entrada=fecha_reparacion;

41 }
42
43 public boolean estaArreglado()
44 {
45 if(reparacion!=0)
46 {
47 return true;
48 }else{
49 return false;
50 }
51 }
52
53 /****************Observadores de las fechas de reparación y salida****/
54
55 public long fechaReparacion()
56 {
57 return reparacion;
58 }
59
60 public long fechaSalida()
61 {
62 return salida;
63 }
64
65 }
Esta clase no tiene mayores complicaciones. Si se quiere, se pueden añadir más datos a tener en cuenta a la
hora de registrar un vehículo, ya que esto, sólo se trata de un modelo básico.
Vamos con la clase GestionReparaciones, que implementará la gestión de vehículos de nuestro taller.
2 public class GestionReparaciones
3{
4 //Atributos

5 private LinkedList<FichaVehiculo> lista = new LinkedList<FichaVehiculo>();

6
7 /**Metodo que añade un vehiculo para ser arreglado con una fecha
8 * de entrada
9 * @param nombre
10 * @param matricula
11 */
12 public void anadeVehiculo(String nombre, String matricula)
13 {
14 long f= Reloj.ahora();
FichaVehiculo fich = new FichaVehiculo(nombre, matricula, f);//creamos un nuevo
15
vehículo
16 lista.add(fich);//añadimos
17 }
18
19 /**Metodo que añade una fecha de reparacion a un vehiculo
20 *
22 */
23 public void reparado(String matricula)
24 {
25 boolean encontrado =false;
26 int i=0;
27
28 while(!encontrado && i<lista.size())
29 {
30
31 //condiciones que ha de cumplir(todas)
32 if(lista.get(i).matricula().equals(matricula) && lista.get(i).fechaReparacion()==0)
33 {
34
35 lista.get(i).modificaFechaReparacion(Reloj.ahora());
36 encontrado=true;
37 }else{

38 i++;
39 }
40 }
41
42 if(encontrado==true)
43 {
44 System.out.println("Fecha de reparación modificada correctamente");
45 }else{
46 System.out.println("Error al modificar la fecha de reparación del vehículo "+ matricula);
47 }
48 }
49
50 /**Metodo que añade una fecha de salida a un vehiculo
51 *
53 */
54 public void fechaSalidaTaller(String matricula)
55 {
56 boolean encontrado =false;
57 int i=0;
58
59 while(!encontrado && i<lista.size())
60 {
61
62 //condiciones que ha de cumplir(todas)
if(lista.get(i).matricula().equals(matricula) && lista.get(i).fechaSalida()==0 &&
63
lista.get(i).estaArreglado())
64 {
65
66 lista.get(i).modificaFechaSalida(Reloj.ahora());
67 encontrado=true;
68 }else{
69 i++;
70 }

71 }
72
73 if(encontrado==true)
74 {
75 System.out.println("Fecha de salida modificada correctamente");
76 }else{
77 System.out.println("Error al modificar la fecha de salida del vehículo "+ matricula);
78 }
79 }
80
81 /**Borramos la primera fiche de un vehiculo
82 *
83 * @return
84 */
85 public boolean eliminarPrimerRegistro()
86 {
87 if(lista.isEmpty())
88 {
89 return false;
90 }else{
91 lista.removeFirst();
92 return true;
93 }
94 }
95
96 }
Se pueden añadir más métodos si queréis practicar, ya que yo sólo he implementado el funcionamiento básico
descrito en el enunciado del ejercicio.
Y un pequeño programa de prueba para verificar que todo funciona bien.
1 public class Clase

2{
3 public static void main (String[]args)

4 {
5 //Atributos
6 GestionReparaciones taller = new GestionReparaciones();
7 String matricula1="12345";
8 String modelo1="Leon";
9
11 String modelo2="Mondeo";
12
14 String modelo3="Laguna";
15
16 //Añado dos vehiculos al taller
17 taller.anadeVehiculo(modelo1, matricula1);
18 taller.anadeVehiculo(modelo2, matricula2);
19
20 //Voy a fijar una fecha de reparacion a un vehiculo que no existe en el taller, dara error
21 taller.reparado(matricula3);
22
23 //Este funcionara bien
24 taller.reparado(matricula1);
25
//Este dará error, no esta reparado, por lo que no puede salir, es una condicion que
26
hemos puesto en el if
27 taller.fechaSalidaTaller(matricula2);
28
29 }
30 }
Hasta aquí la solución del ejercicio. Si habéis tenido algún problema, o duda de implementación, no dudéis en
preguntarlo.
Vamos con el ejemplo de los ArrayList de Java. Vamos a hacer un ejemplo sencillo con la baraja española.

2 public class Baraja

3{
4 // constantes estáticas
5 private static String[] palo={"Bastos", "Copas", "Oros", "Espadas"};
6
private static String[]
7
carta={"As", "Dos", "Tres", "Cuatro", "Cinco","Seis", "Siete", "Sota", "Caballo","Rey"};
8
9 // la baraja es una lista de cartas
10 private ArrayList<String> mazo;
11
12 /**
13 * Constructor de la baraja
14 */
15 public Baraja()
16 {
17 mazo= new ArrayList<String>(40);
18 for (String p: palo) {
19 for (String c: carta) {
20 mazo.add(c+" de "+p);
21 }
22 }
23 }
24
25 /**
26 * Repartir num cartas
27 */
28 public List<String> repartir(int num)
29 {
30
31 int numCartas=mazo.size();
32 List<String> vistaDeMano = mazo.subList(numCartas - num,numCartas);
33 List<String> mano = new ArrayList<String>(vistaDeMano);
34 vistaDeMano.clear();

35 return mano;
36 }
37 }
Como podéis ver la mecánica de programación es similar a la de las LinkedList.
Como el ejercicio anterior que os propusimos tiene mucho juego, os vamos a proponer que en vez de utilizar las
LinkedList para su programación, lo implementéis utilizando los ArrayList. Y en la próxima entrega los
corregiremos y hablaremos además de las Pilas de datos y sus funciones y como se pueden
implementar.

TALLER PRACTICA 05
Realizar la administración de notas de un alumno por materia.
Creamos un proyecto en java:
Eliminamos la opción de creación de la clase principal

Creamos un paquete pEjemploObjetoGrfico

Creamos los objetos en este caso vamos a creas las clases Alumno y Materia.
Clase Alumno
public class Alumno implements Serializable{

private String nombre,direccion;
private int telefono,cedula;
public Alumno(String nombre, String direccion, int telefono, int cedula) {

this.direccion = direccion;
this.telefono = telefono;
this.cedula = cedula;
}

return nombre;
}

}
public String getDireccion() {

return direccion;
}
public void setDireccion(String direccion) {

this.direccion = direccion;
}
public int getTelefono() {

return telefono;
}
public void setTelefono(int telefono) {

this.telefono = telefono;
}
public int getCedula() {

return cedula;
}
public void setCedula(int cedula) {

this.cedula = cedula;
}

Clase Materia
public class Materia implements Serializable {

private long codigo;
private String nombre;
private Alumno Estudiante;
private float creditos;
private float definitiva;
private float porcentajeAcumulado;
private LinkedList notas; // Lista de notas
// Constructor general
public Materia(long codigo, String nombre, Alumno Estudiante, float creditos, float definitiva, float
porcentajeAcumulado, LinkedList notas) {
this.codigo = codigo;
this.Estudiante = Estudiante;
this.creditos = creditos;
this.definitiva = definitiva;
this.porcentajeAcumulado = porcentajeAcumulado;
this.notas = notas;
}
// Nueva implementación de ingreso de notas

public void ingresonota(double aporcentaje, double valor) {
double DefinitivaParcial=0;
if (porcentajeAcumulado+aporcentaje<=100){
porcentajeAcumulado+=aporcentaje;
DefinitivaParcial=(valor*(aporcentaje/100));
definitiva+=DefinitivaParcial;
notas.add(new Nota(new Date(),aporcentaje, valor,DefinitivaParcial));
JOptionPane.showMessageDialog(null,"El Alumno: "+Estudiante.getNombre()+" en la materia: "+
getNombre()+" Tiene Acumulado: "+getPorcentajeAcumulado()+"% con Nota: "+getDefinitiva());
} else {
JOptionPane.showMessageDialog(null,"El valor del porcentaje supera el 100%, tiene hasta el momento
el "+getPorcentajeAcumulado()+"%. Por Favor Verifique sus valores.");
}
}
public void verificanota(){

if (definitiva>=3){
getNombre()+" Paso con Nota: "+getDefinitiva());
} else {
getNombre()+" Perdio con Nota: "+getDefinitiva());
}
}
public LinkedList getNotas() {

return notas;
}
public void setNotas(LinkedList notas) {

this.notas = notas;
}
Alumno leerEstudiante() {
return Estudiante;
}
long leerMateria() {
return codigo;
}

return nombre;
}
public float getCreditos() {

return creditos;
}
public long getCodigo() {

return codigo;
}
public float getPorcentajeAcumulado() {

return porcentajeAcumulado;
}
public float getDefinitiva() {

return definitiva;
}
public Alumno getEstudiante() {

return Estudiante;
}
public void setEstudiante(Alumno Estudiante) {

this.Estudiante = Estudiante;
}

Clase Nota
public class Nota implements Serializable{

Date fecha;
double porcentaje;
double nota;
double definitivaparcial;
public Nota(Date fecha, double porcentaje, double nota, double definitivaparcial) {

this.fecha = fecha;
this.porcentaje = porcentaje;
this.nota = nota;
this.definitivaparcial = definitivaparcial;
}
public Date getFecha() {

return fecha;
}
public void setFecha(Date fecha) {

this.fecha = fecha;
}
public double getPorcentaje() {

return porcentaje;
}
public void setPorcentaje(double porcentaje) {

this.porcentaje = porcentaje;
}
public double getNota() {

return nota;
}
public void setNota(double nota) {

this.nota = nota;
}
public double getDefinitivaparcial() {

return definitivaparcial;
}
public void setDefinitivaparcial(double definitivaparcial) {

this.definitivaparcial = definitivaparcial;
}

Luego pasamos a crear un JFrame en donde trabajamos el proceso del manejo de alumno, materia y notas.
Primero definimos en forma global las siguientes varibles:
Alumno Estudiante1;
Materia Materia1;
LinkedList notas= new LinkedList();
La programación que tiene el botón guarda matería sería:

private void bGuardarMateriaActionPerformed(java.awt.event.ActionEvent evt) {
Estudiante1 = new Alumno(

tNombre.getText(),
tDireccion.getText(),
Integer.parseInt(tTelefono.getText()),
Integer.parseInt(tfCedula.getText())
);
try {
ObjectOutputStream salida;
salida = new ObjectOutputStream(new FileOutputStream(Estudiante1.getCedula()+".est"));
salida.writeObject(Estudiante1);
salida.close();
JOptionPane.showMessageDialog(rootPane,"El Estudiante se guardo en forma correcta.");
JOptionPane.showMessageDialog(rootPane,"No se pudo salvar el estudiante. "+ex);
}
Materia1 = new Materia(

Long.parseLong(tCodigoMateria.getText()),
tNombreMateria.getText(),
Estudiante1,
Integer.parseInt(tCredito.getText()),
0,
0,
notas
);
try {
salida = new ObjectOutputStream(new FileOutputStream(Materia1.getCodigo()+".mat"));
salida.writeObject(Materia1);
salida.close();
JOptionPane.showMessageDialog(rootPane,"La materia se guardo en forma correcta.");
tNombre.setText("");
tDireccion.setText("");
tTelefono.setText("");
tfCedula.setText("");
tCodigoMateria.setText("");
tNombreMateria.setText("");
tCredito.setText("");
JOptionPane.showMessageDialog(rootPane,"No se pudo salvar la materia. "+ex);
}

La ejecución del programa daría lo siguiente:
Al momento de guardar materia el programa guardara tambien el estudiante y enviara los siguiente mensajes:
Hasta aquí tenemos la opción de gurdar la materia nos faltaria realizar la función de buscar la materia para
realizar modificaciones y salvar dicha información para ello vamos a adicionar un textfield en donde digitaremos
el código de la materia recuerde que con este valor es que almacenamos la información y a su vez adicionamos

un botón para realizar la consulta esta busqueda se utiliza el constructur de la clase que utiliza el llamado
mediante el código de la materia.
La foma modificada queda de la siguiente forma:
Adicionamos un label, un
textfield y un button
La programación del botón buscar es:
private void bBuscarMateriaActionPerformed(java.awt.event.ActionEvent evt) {
DecimalFormat formato = new DecimalFormat("#,###0.00");

SimpleDateFormat formatoFecha = new SimpleDateFormat("'A las' hh:mm 'del' EEEE d 'de' MMMM 'de' YYYY");
try {
ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(tCodigoMateria1.getText()+".mat")
);
Materia1 = (Materia) entrada.readObject();
entrada.close();
tNombre.setText(Materia1.leerEstudiante().getNombre());
tDireccion.setText(Materia1.leerEstudiante().getDireccion());
tTelefono.setText(""+Materia1.leerEstudiante().getTelefono());
tfCedula.setText(""+Materia1.leerEstudiante().getCedula());
tCodigoMateria.setText(""+Materia1.getCodigo());

tNombreMateria.setText(Materia1.getNombre());
tCredito.setText(""+Materia1.getCreditos());
tDefinitiva.setText(""+formato.format(Materia1.getDefinitiva()));
String titulos[]={"NOTA","% Nota","Definitiva","Fecha"};
DefaultTableModel m = new DefaultTableModel(null,titulos);
LinkedList calificaciones = new LinkedList();
calificaciones = Materia1.getNotas();
for (int i=0;i<=calificaciones.size()-1;i++){
String fila[]=new String[4];
Nota Valor = (Nota) Materia1.getNotas().get(i);
fila[0]=""+Valor.nota;
fila[1]=""+Valor.porcentaje;
fila[2]=""+formato.format(Valor.definitivaparcial);
fila[3]=""+formatoFechaPersonal.format(Valor.fecha);
m.addRow(fila);
}
tNotas.setModel(m);
}
catch (Exception e){
JOptionPane.showMessageDialog(this,"Imposible recuperar materia. "+e);
}
}
Ejecutamos el programa recuerde que se debe crear primero el alumnos y luego la materia.
Adicionamos otro:

Ahora vamos a realizar la búsqueda de la matería para eso digitamos el código 101 y damos clic en Buscar
Materia

Nos trae toda la información.
Vamos a realizar el procedimiento de almacenar las notas y presentarlas en la tabla para ello el código sería:
private void bGuardarNotaActionPerformed(java.awt.event.ActionEvent evt) {

DecimalFormat formato = new DecimalFormat("#,###0.00");
SimpleDateFormat formatoFechaPersonal = new SimpleDateFormat("'A las' hh:mm 'del' EEEE d 'de' MMMM 'de'
YYYY");
try {
Materia1.ingresonota(Double.parseDouble(tPorNota.getText()),Double.parseDouble(tNota.getText()));
String titulos[]={"NOTA","% Nota","Definitiva","Fecha"};
DefaultTableModel m = new DefaultTableModel(null,titulos);
LinkedList calificaciones = new LinkedList();
calificaciones = Materia1.getNotas();
for (int i=0;i<=calificaciones.size()-1;i++){
String fila[]=new String[4];
Nota Valor = (Nota) Materia1.getNotas().get(i);
fila[0]=""+Valor.nota;
fila[1]=""+Valor.porcentaje;
fila[2]=""+formato.format(Valor.definitivaparcial);
fila[3]=""+formatoFechaPersonal.format(Valor.fecha);
m.addRow(fila);
}
tNotas.setModel(m);
tDefinitiva.setText(""+formato.format(Materia1.getDefinitiva()));
try {
salida = new ObjectOutputStream(new FileOutputStream(Materia1.getCodigo()+".mat"));
salida.writeObject(Materia1);
salida.close();
JOptionPane.showMessageDialog(rootPane,"La materia se guardo en forma correcta.");


JOptionPane.showMessageDialog(rootPane,"No se pudo salvar la materia.");
}
}
catch (Exception e){
JOptionPane.showMessageDialog(this,"Imposible recuperar cuenta");
}
}
En este procedimiento se adiciona una nota y se ingresa en la tabla.
Digitamos la nota y el porcentaje de la misma

nos envía un mensaje con la validadción
Y nos confirma que la nota ya fue almacenada
Y adiciona la nota a la tabla


Formateo de números
La clase NumberFormat de Java permite dar formato a valores numéricos para poder mostrarlos de
forma más adecuada. Por ejemplo, puede limitar el número de decimales de una valor real, permite mostrar los
valores con separadores de miles, con símbolo de moneda o valores porcentuales.
Dispone de varios métodos que permiten instanciar objetos de su clase en función del tipo de formato que se
desea aplicar:
• public static final NumberFormat getCurrencyInstance()
o Permite dar formato de moneda
• public static final NumberFormat getIntegerInstance()
o Permite dar formato de valor numérico sin decimales
• public static final NumberFormat getNumberInstance()
o Permite dar formato de número
• public static final NumberFormat getPercentInstance()
o Permite dar formato de valor porcentual
• public static final NumberFormat getInstance()
o Permite dar formato genérico
Todos esos métodos de instancia disponen de una segunda modalidad en la que se puede indicar un
parámetro de la clase Locale. De esa manera se puede obligar que el formateo se realice siguiendo las
características del país que se indique en el parámetro. Si no se utiliza ese parámetro, se utiliza la configuración
de país que se dispone en el sistema.
La manera más sencilla de crear objetos de la clase Locale se hace indicando como parámetro el código
del idiomasiguiendo el estándar ISO 639-1. opcionalmente se puede indicar un segundo parámetro con
el código de la regiónusando el estándar ISO 3166-1-alpha-2.
Por ejemplo, las siguientes líneas crean objetos Locale para el idioma español, el idioma inglés de Estados
Unidos, o inglés de Gran Bretaña:
Locale español = new Locale("es");

Locale inglesUS = new Locale("en","US");
Locale inglesGB = new Locale("en","GB");
El método format es el que retorna como String el valor numérico al que se ha aplicado el
formato correspondiente en función del método usado para instanciar el objeto. Este método se utiliza pasando
por parámetro el valor numérico al que se le quiere aplicar el formato, el cual puede ser de
tipo double o long: y retorna en cualquier caso unString con el valor formateado:

• public final String format(double number)
• public final String format(long number)

Para establecer el número de decimales que se quieren obtener, en el caso de manejar valores de
tipo double, se dispone de los siguientes métodos que limitan el número máximo y mínimo de decimales que se
obtendrán al aplicar el formato correspondiente. En el parámetro nuevoValor se debe indicar el número de
decimales a aplicar en cada caso:
• public void setMaximumFractionDigits(int nuevoValor)
• public void setMinimumFractionDigits(int nuevoValor)

Ejemplos de conversiones de valores numéricos a cadenas de tipo String siendo mostradas por la salida
estándar:
double importe = -1234.56;

NumberFormat formatoImporte = NumberFormat.getCurrencyInstance();
//Si se desea forzar el formato español:
//formatoImporte = NumberFormat.getCurrencyInstance(new Locale("es","ES"));
System.out.println(formatoImporte.format(importe));
//Muestra -1.234,56 €
double porcentaje = 1.6345;

NumberFormat formatoPorcentaje = NumberFormat.getPercentInstance();
System.out.println(formatoPorcentaje.format(porcentaje));
//Muestra 163%
formatoPorcentaje.setMinimumFractionDigits(2);
System.out.println(formatoPorcentaje.format(porcentaje));
//Muestra 163,45%
double numero = 4874647.0/3;

NumberFormat formatoNumero = NumberFormat.getNumberInstance();
System.out.println(formatoNumero.format(numero));
//Muestra 1.624.882,333
formatoNumero.setMaximumFractionDigits(1);
System.out.println(formatoNumero.format(numero));
//Muestra 1.624.882,3

También se puede utilizar la clase DecimalFormat que es una subclase de NumberFormat comentada
anteriormente. Con ella se puede crear un formato totalmente personalizado utilizando un patrón de
tipo String.
Tras crear un objeto de dicha clase indicando el patrón, se puede utilizar el método format se da formato al
valor que se pase como parámetro, retornando un objeto String con el valor formateado.
Ejemplo:
//Creación de un formato con separadores de decimales y millares, con 2 decimales

DecimalFormat formato = new DecimalFormat("#,###.00");
String valorFormateado = formato.format(123456.789);
//Muestra en pantalla el valor 123.456,79 teniendo en cuenta que se usa la puntuación
española
System.out.println(valorFormateado);
Algunos ejemplos de patrones:
Valor Patrón Salida Descripción

El carácter (#) equivale a un dígito, la coma es el lugar para el
123456.789 #,###.### 123,456.789 separados de miles, y el punto indica el lugar para el separador de
decimales.
El valor tiene tres dígitos en la parte decimal, pero el patrón sólo
123456.789 #.## 123456.79 tiene 2, por lo que el método format hace un redondeo del valor
hacia arriba.
El patrón especifica los ceros que se deben utilizarse en la parte
123.78 000000.000 000123.780 entera y en la parte decimal, al utilizar el carácter 0 en lugar de #.
El primer carácter del patrón es el signo dólar, por lo que se

12345.67 $#,###.### $12,345.67 muestra precediendo al valor en la salida formateada.
El patrón especifica el símbolo de la moneda japonesa Yen (¥)

12345.67 \u00A5#,###.### ¥12,345.67 usando el valor Unicode 00A5.
El carácter ¤ del patrón indica el lugar en el que se muestra el

12345.67 #,###.### ¤ 12.345,67 € carácter de la moneda usada en el país que tiene configurado el
sistema operativo
Estos son los caracteres que se pueden utilizar para dar formato con el patrón:
Símbolo Descripción
0 Un dígito obligado aunque sea 0
# Un dígito
. Lugar para el sepador de decimales
, Lugar para el separador de miles
E Separa la mantisa y el exponente para formatos exponenciales

; Separa formatos
- Prefijo por defecto para valores negativos
% Multiplica el valor por 100 y lo muestra como porcentaje
? Multiplica el valor por 1000 y lo muestra como por miles
¤ Símbolo de moneda
otro Cualquier carácter puede usarse en el prefijo o sufijo del valor
' Usado para citar caracteres especiales en el prefijo o sufijo del valor

Formato de fecha
La clase DateFormat de Java permite dar formato habitual a objetos Date que almacenan valores de tiempo,
lo cual posibilita mostrar en pantalla fechas y horas con una estética adecuada.
Esta clase dispone de los métodos getDateInstance y getTimeInstance para instanciar

objetos DateFormat:
• public static final DateFormat getDateInstance(int style)
• public static final DateFormat getTimeInstance(int style)

En cualquiera de los dos casos puedes observar que se debe pasar un parámetro de tipo int para indicar el
formato que se quiere aplicar a las fechas u horas. Para ello, esta misma clase DateFormat ofrece una serie de
propiedades constantes estáticas que facilitan su uso:
• SHORT: Formato de fechas: 6/10/12, y formato de horas: 21:47
• MEDIUM: Formato de fechas: 06-oct-2012, y formato de horas: 21:47:32
• LONG: Formato de fechas: 6 de octubre de 2012, y formato de horas: 21:47:32 CEST
• FULL: Formato de fechas: sábado 6 de octubre de 2012, y formato de horas: 21H47' CEST
Sobre los objetos DateFormat se puede utilizar el método format para obtener como String la fecha y
hora a la que se desea dar formato. En su formato más sencillo, al método format hay que pasarle como
parámetro un objeto Date, que se puede obtener a partir de un objeto Calendar usando
el método getTime de esa clase Calendar.
Class DateFormat
String format(Date date)
Class Calendar
Date getTime()
//Obtener la fecha y hora actual

Calendar cal = Calendar.getInstance();
//Fecha en formato SHORT: 6/10/12

DateFormat formateadorFechaCorta =
DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(formateadorFechaCorta.format(cal.getTime()));
//Fecha en formato MEDIUM: 06-oct-2012

DateFormat formateadorFechaMedia =
DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println(formateadorFechaMedia.format(cal.getTime()));

//Fecha en formato LONG: 6 de octubre de 2012

DateFormat formateadorFechaLarga =
DateFormat.getDateInstance(DateFormat.LONG);
System.out.println(formateadorFechaLarga.format(cal.getTime()));
//Fecha en formato FULL: sábado 6 de octubre de 2012

DateFormat formateadorFechaCompleta =
DateFormat.getDateInstance(DateFormat.FULL);
System.out.println(formateadorFechaCompleta.format(cal.getTime()));
//Hora en formato SHORT: 21:47

DateFormat formateadorHoraCorta =
DateFormat.getTimeInstance(DateFormat.SHORT);
System.out.println(formateadorHoraCorta.format(cal.getTime()));
//Hora en formato MEDIUM: 21:47:32

DateFormat formateadorHoraMedia =
DateFormat.getTimeInstance(DateFormat.MEDIUM);
System.out.println(formateadorHoraMedia.format(cal.getTime()));
//Hora en formato LONG: 21:47:32 CEST

DateFormat formateadorHoraLarga = DateFormat.getTimeInstance(DateFormat.LONG);
System.out.println(formateadorHoraLarga.format(cal.getTime()));
//Hora en formato FULL: 21H47' CEST

DateFormat formateadorHoraCompleta =
DateFormat.getTimeInstance(DateFormat.FULL);
System.out.println(formateadorHoraCompleta.format(cal.getTime()));
//Fecha en formato FULL estadounidense: Saturday, October 6, 2012

DateFormat formateadorFechaUS = DateFormat.getDateInstance(DateFormat.FULL,
new Locale("US"));

System.out.println(formateadorFechaUS.format(cal.getTime()));
Como puedes observar en las últimas líneas del ejemplo, el método getDateInstance admite un segundo
parámetro en el que se debe indicar un objeto Localeque haga referencia al idioma o país sobre el que se
quiere obtener el formato de fecha y hora.
Para un control más personalizado del formato deseado, se puede utilizar la clase SimpleDateFormat de
Java, que es una extensión de la clase DateFormatcomentada anteriormente. La clase SimpleDateFormat utiliza
en el método constructor una cadena de caracteres como patrón para establecer el formato de fecha y
hora.
Para ello se dispone de una lista de caracteres asociados a cada uno de los posibles campos de fecha y hora.
Por ejemplo, el caracter 'd' hace referencia al día, o 'y' que hace referencia al año.
En función de la repetición que se haga de esos caracteres del patrón, se obtienen distintos formatos para un
mismo dato. Así si se indica como parte del patrón "yy" se mostrará el año con 2 dígitos, mientras que se
escribe como "yyyy" se mostrará en año con 4 dígitos.

Además puedes introducir cualquier texto dentro del patrón para que forme parte del formato final. Para ello
simplemente debes encerrar entre comillas simples el texto literal.
Por ejemplo, para obtener la fecha en formato "Son las 21:47 del sábado 6 de octubre de 2012" se usaría el
siguiente trozo de código fuente:
Calendar cal = Calendar.getInstance();

//Mostrar hora y fecha con formato: "Son las 21:47 del sábado 6 de octubre de 2012"
String patron = "'Son las' hh:mm 'del' EEEE d 'de' MMMM 'de' YYYY";
SimpleDateFormat formatoFechaPersonal = new SimpleDateFormat(patron);
System.out.println(formatoFechaPersonal.format(cal.getTime()));

Herencia
La herencia es un mecanismo de la OOP que permite construir una clase incorporando

de manera implícita todas las características de una clase previamente existente. Las
razones que justifican su necesidad son variadas:
1. Modelado de la realidad. Son frecuentes las relaciones de especialización/generalización entre

las entidades del mundo real, por tanto es lógico que dispongamos de un mecanismo similar
entre las clases de objetos
2. Evitar redundancias. Toda la funcionalidad que aporta una clase de objetos es
adoptada de manera inmediata por la clase que hereda, por tanto evitamos la
repetición de código entre clases semejantes
3. Facilitar la reutilización. Una clase no tiene por qué limitarse a recibir una serie de
características de otra clase por herencia de forma pasiva. También disponen de cierto
margen de adaptación de estas características
4. Soporte al polimorfismo
Sea una clase A. Si una segunda clase B hereda de A entonces decimos:

A es un ascendiente o superclase de B. Si la herencia entre A y B es directa
decimos además que A es la clase padre de B
B es un descendiente o subclase de A. Si la herencia entre A y B es directa decimos además que
B es una clase hija de A
En Java, Eiffel, Smalltalk y otros lenguajes orientados a objetos puros, todas las clases heredan
automáticamente de una superclase universal. En Java esta superclase se denomina Object
Existen diferentes situaciones en las que puede aplicarse herencia:

Especialización. Dado un concepto B y otro concepto A que representa una especialización de
A, entonces puede establecerse una relación de herencia entre las clases de objetos que
representan a A y B. En estas situaciones, el enunciado “A es un B” suele ser aplicable

Extensión. Una clase puede servir para extender la funcionalidad de una superclase sin que
represente necesariamente un concepto más específico
Especificación. Una superclase puede servir para especificar la funcionalidad mínima común de
un conjunto de descendientes. Existen mecanismos para obligar a la i mplementación de una
serie de operaciones en estos descendientes
Construcción. Una clase puede construirse a partir de otra, simplemente porque la hija
puede aprovechar internamente parte o toda la funcionalidad del padre, aunque
representen entidades sin conexión alguna
Ejemplos de herencia:
Distintos tipos de cuentas bancarias:

Elementos de una interfaz de usuario

Estructuras de datos
Vamos a estudiar la implementación de la herencia en Java mediante el ejemplo de un conjunto de

tareas programables: TPReloj (actualizar un reloj digital cada segundo), TPAviso (mostrar un aviso
periódicamente) y TPEjecucion (ejecución de un comando cada cierto tiempo).
La clase TareaPeriodica tiene las características comunes a los tres tipos de tarea: periodo de
ejecución en segundos, hora de la última ejecución y bandera de estado activo/inactivo

Para que una clase herede de otra, utilizaremos el indicador extends en la declaración de la
clase

Todas las clases en Java heredan en última instancia de Object. Incluso si creamos una clase
independiente, Java la hace heredar implícitamente de Object
Esto hace que las clases formen una jerarquía con Object como raíz
En la implementación de una operación de la subclase no existe diferencia aparente entre un

atributo u operación propia de la clase y un atributo u operación heredados

Ahora podemos crear y usar objetos de cualquiera de las clases anteriores. Desde el exterior
tampoco existen diferencias aparentes entre la llamada a una operación heredada o propia de la
clase:
La inicialización de los atributos de una superclase en el constructor de una subclase

presenta varios inconvenientes serios:
1. Resulta redundante. La superclase tiene ya un constructor que hace ese trabajo. ¿Por
qué repetir código entonces?
2. Si la clase tiene una larga lista de ascendientes, entonces el constructor sería muy
largo
3. La superclase puede tener una inicialización compleja, y la inclusión del código de
inicialización en la subclase puede requerir un conocimiento excesivo de la superclase
por parte del implementador
El procedimiento correcto consiste en realizar una llamada al constructor de la superclas para que
realice la inicialización de los atributos heredados
En Java esta llamada al constructor de la superclase se realiza con la operacion super() seguida
de los parámetros de inicialización de alguno de los constructores del padre de la clase
La implementación correcta del constructor de la clase TPAviso sería por tanto la siguiente:

Y de las otras dos subclases:
Únicamente debe llamarse explícitamente a un constructor del ascendiente inmediato.
El constructor de este último realizará a su vez una llamada a un constructor de su ascendiente

inmediato y así sucesivamente hasta inicializar todos los atributos heredados
Para terminar, es posible impedir la herencia a partir de una clase declarándola como final.

Sin embargo, esta es una característica que debe ser utilizada con prudencia, ya que puede
restringir en exceso la extensión y reutilización de las clases del sistema en el futuro.

Herencia
Las clases se pueden derivar desde otras clases. La clase derivada (la clase que proviene
de otra clase) se llama subclase. La clase de la que está derivada se denomina superclase.
Una subclase es una clase que desciende de otra clase. Una subclase hereda el estado y el
comportamiento de todos sus ancestros. El término superclase se refiere a la clase que es el ancestro más
directo, así como a todas las clases ascendentes.
De hecho, en Java, todas las clases deben derivar de alguna clase. La clase más alta, la
clase de la que todas las demás descienden, es la clase Object, definida en java.lang. Object
es la raíz de la herencia de todas las clases.
Las subclases heredan el estado y el comportamiento en forma de las variables y los métodos de su
superclase. La subclase puede utilizar los ítems heredados de su superclase tal y como son, o puede
modificarlos o sobreescribirlos. Por eso, según se va bajando por el árbol de la herencia, las clases se convierten
en más y más especializadas.
Una clase Java sólo puede tener una superclase directa. Java no soporta la herencia multiple.
class SubClass extends SuperClass {
...
}
La palabra extends indica que Subclase es extendida de Superclase. Una subclase hereda todas las
variables miembros de su superclase que puedan ser accesibles desde la subclase (a menos que la variable
miembro esté oculta en la subclase).
Las subclases heredan variables miembro declaradas:
public
•
• protected
• sin especificador de acceso siempre que la subclase esté en el mismo paquete
que la clase.
Las subclases NO heredan variables miembro declaradas:

• con el mismo nombre que en la superclase. La variable miembro de la subclase se dice
que oculta a la variable miembro de la superclase.
• private
Como se mencionó anteriormente, las variables miembros definidas en la subclase ocultan

las variables miembro que tienen el mismo nombre en la superclase.
Como esta característica del lenguaje Java es poderosa y conveniente, puede ser una
fuente de errores: ocultar una variable miembro puede hacerse deliberadamente o por
accidente. Entonces, cuando nombres tus variables miembro se cuidadoso y oculta sólo las
variables miembro que realmente deseas ocultar.

Una característica interesante de las variables miembro en Java es que una clase puede
acceder a una variable miembro oculta a través de su superclase. Considere esta pareja de
superclase y subclase.
class Base{
int unNumero;
}
class Derivada extends Base { // declaracion de una clase derivada

Float unNumero;
}
La variable unNumero de Derivada oculta a la variable unNumero de Base. Pero se puede

acceder a la variable de la superclase utilizando. super.unNumero
super es una palabra clave del lenguaje Java que permite a un método referirse a las
variables ocultas y métodos sobreescritos de una superclase; es decir, permite referenciar los
atributos y/o metodos de la clase base;
La regla que especifica los métodos heredados por una subclase es similar a la de las variables miembro.
Constructores en herencia
Los constructores de la clase base se invocan antes del constructor de la clase derivada, los
constructores no se heredan. El constructor de la clase derivada debe incluir la llamada al constructor de la
clase base, utilizando super(); y enviando los argumentos requeridos.
Sobreescribir Métodos
La habilidad de una subclase para sobreescribir un método de su superclase permite a una clase heredar
de su superclase aquellos comportamientos "más cercanos" y luego suplementar o modificar el comportamiento
de la superclase.
Ventajas de la herencia
• Fácil modificación de código
• Reutilización de código existente
• Adaptación de programas para trabajar en situaciones similares pero diferentes
• Extracción de elementos comunes de clases diferentes
• Organización de objetos en jerarquías
Ejemplos de Herencias
Ejercicio 1
Vamos A crear un proyecto en java llamado taller7.

Creamos un paquete pTaller07
Creamos una clase empleados con la siguiente estructura:

empleados
-DNI
-Nombre
-Posición
-Salario
+MuestraEmpleado()
public class empleados implements Serializable {
private int DNI;

private String nombre,posicion;
private double salario;
public empleados(int DNI,String nombre, String posicion, double salario) {

this.DNI = DNI;
this.posicion = posicion;
this.salario = salario;
}
public String muestraEmpleado(){

String Mensaje = "Empleado "+nombre + " Posicion " + posicion + " Salario " + salario;
return Mensaje;
}
public int getDNI() {

return DNI;
}
public void setDNI(int DNI) {

this.DNI = DNI;
}

return nombre;
}

}
public String getPosicion() {

return posicion;
}
public void setPosicion(String posicion) {

this.posicion = posicion;
}
public double getSalario() {

return salario;
}
public void setSalario(double salario) {

this.salario = salario;
}
}
Ahora vamos a efectura herencias de la tabla empleados la primera es crear la clase gerente. Creamos la clase
gerente que nace de la clase Empleados
empleados
-DNI
-Nombre
-Posición
-Salario
+MuestraEmpleado()
gerente
-bono
-auto
+MostarGerente()

El decir el gerente tiene dos nuevos atributos y un método que muestra la información. Como el gerente es una
herencia de empleados se coloca el termino extends y de que clase de origino.
Igualmente el constructor del gerente tiene la setencia super dado que se debe crear un empleado antes de
crear un gerente. La función super se utiliza para llamar los atributos y métodos de la clase padre en la clase
hija.
public class gerente extends empleados implements Serializable{

private double bono;
private String auto;
public gerente(int DNI, String nombre, String posicion, double salario,double bono, String auto) {
super(DNI, nombre, posicion, salario);
this.bono=bono;
this.auto=auto;
public String muestraGerente(){

String Mensaje = super.muestraEmpleado()+". Bono"+this.bono+" Auto:"+this.auto;
return Mensaje;
}
public double getBono() {

return bono;
}
public void setBono(double bono) {

this.bono = bono;

public String getAuto() {

return auto;
}
public void setAuto(String auto) {

this.auto = auto;
}
}
En el programa principal realizamos el llamado de los objetos, para ello creamos un frame en donde
construremos nuestros gerentes y los buscaremos.
Crearemos el frame con la información que necesitamos adicionar.

Se realiza la programación de los tres botonos:
Crear Objeto: Permite crear los objetos con la información digitado los objetos y almacenarlos en memoria. La
programación es la siguiente:
private void bCrearActionPerformed(java.awt.event.ActionEvent evt) {
// Se crea el objeto con la información.
gerente prueba = new gerente(Integer.parseInt(tfDni.getText()),

tfNombre.getText(),
tfPosicion.getText(),
Double.parseDouble(tfSalario.getText()),
Double.parseDouble(tfBono.getText())
, tfAuto.getText());
try {
// Se crea limpia los campos de la información suministrada
tfDni.setText("");
tfNombre.setText("");
tfPosicion.setText("");
tfSalario.setText("");
tfBono.setText("");
tfAuto.setText("");
ObjectOutputStream salida = new ObjectOutputStream(new
FileOutputStream(prueba.getDNI()+".obj"));
salida.writeObject(prueba);
salida.close();
JOptionPane.showMessageDialog(this, prueba.muestraGerente());
} catch (IOException ex) {
}
}
Salir: Cierra el programa.

private void bSalirActionPerformed(java.awt.event.ActionEvent evt) {

this.dispose(); // TODO add your handling code here:
}
Buscar: Se ingresa el DNI del objeto a buscar y se trae la información

try {
ObjectInputStream entrada = new ObjectInputStream(new
FileInputStream(tfDNIBuscar.getText()+".obj"));
gerente buscar;
buscar = (gerente) entrada.readObject();
entrada.close();
tfDni.setText(""+buscar.getDNI());
tfNombre.setText(""+buscar.getNombre());
tfPosicion.setText(""+buscar.getPosicion());
tfSalario.setText(""+buscar.getSalario());
tfBono.setText(""+buscar.getBono());
tfAuto.setText(""+buscar.getAuto());

}

Realizar los siguientes ejercicios
Ejercicio 1:
Realizar la creación de las clases según el siguiente modelo:
Producto
+PLU
+Nombre
+Precio
Libro CD
+Editorial +Genero
Se debe de cumplir las siguientes condiciones:
Todas las propiedas son privadas.

Todas las propiedas se pueden leer (get) o escribir (set).
Crear los siguientes Objetos:
LIBRO
PLU NOMBRE PRECIO EDITORIAL
EL INGENIOSO HIDALGO DON QUIJOTE DE LA
1 MANCHA (ED. ESPECIAL) $ 200,000.00 ESPASA LIBROS
2 ODISEA $ 100,000.00 GREDOS
3 LAZARILLO DE TORMES (4ª ED.) $ 80,000.00 CATEDRA
CD
PLU NOMBRE PRECIO GENERO
4 TRILOGÍA EL HOBBIT (DVD) $ 150,000.00 ESPASA LIBROS
5 CORAZONES DE ACERO (DVD) $ 40,000.00 GREDOS
6 ESCALOFRIO EN LA NOCHE (BLU-RAY) $ 50,000.00 CATEDRA
Permitir realizar la consulta de los productos.

Polimorfismo
• Son dos mecanismos relacionados que otorgan a la OOP una gran

potencia frente a otros paradigmas de programación
• Únicamente tienen sentido por la existencia de la herencia
• El polimorfismo (o upcasting) consiste en la posibilidad de que una referencia a
objetos de una clase pueda conectarse también con objetos de
descendientes de ésta
El sentido del polimorfismo es realizar una generalización, olvidar los detalles concretos
de uno o varios objetos de distintas clases y buscar un punt o común a todos ellos en un
ancestro.
La mayoría de las veces, las conexiones polimorfas se realizan de manera implícita en el

paso de argumentos a una operación. De esta maneraes posible escribir operaciones
polimorfas que reciban objetos de múltiples clases

Otra aplicación muy útil es la construcción de estructuras de datos que puedan

mantener objetos de distintas clases.
Vamos a implementar una nueva clase GestorTareas que va a contener una lista de
tareas a realizar. La llamada a chequearEjecutar() realizará la comprobación y ejecución de
las tareas que lo requieran.

Pero siempre debe quedar claro que tras la conexión polimorfa únicamente podemos
acceder a las operaciones pertenecientes a la clase asociada a la referencia. El resto
de operaciones del objeto no son accesibles a través de esta referencia.

En Java, una referencia a Object puede ser conectada a cualquier objeto, puesto que
como sabemoses un ancestro de todas las clases
Además, las interfaces implementadas por una clase también pueden ser utilizadas para
realizar conexiones polimorfas

Taller 08 Polimorfismo.
Creamos un proyecto con el nombre Taller08.
Seleccionamoes le tipo de aplicación:
Colocamos el nombre del proyecto en este caso Taller08
Ya creado el proyecto procedemos a crear el paquete ptaller08

Creamos el paquete ptaller08
Ya creado el paquete:
Se crea una clase animal

Con la siguiente estructura:

public class animal {
public void hablar(){
System.out.print("No se hablar.");
}
}

Creamos una clase llamada pollo y creamos dos llamados de hablar uno normal y otro repetido, es
decir con el mismo procedimiento se puede realizar dos tareas diferentes, el código queda de la
siguiente manera:
public class pollo extends animal{

public void hablar(){
System.out.print("Pio Pio \n");
}
public void hablar(int repetir){

for (int i=0;i<=repetir;i++){
System.out.print("Pio Pio \n");
}
}
}
El programa principal queda de la siguiente forma:
public class Taller08 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
animal Animal = new animal();
Animal.hablar();
pollo pollito = new pollo();
pollito.hablar();
pollito.hablar(5);
}
}

Ejecutamos el programa y nos da el siguiente resultado:

Ejercicios:
1. Qué es herencia?
La herencia es un mecanismo de reutilización de software que permite crear nuevas clases que
adquieren los atributos y métodos de alguna clase predefinida, es decir, una clase ya hecha.
Algunas de las propiedades de las clases heredadas:

• Permite manipular las semejanzas entre objetos mediante una jerarquía
• Cuando una clase hereda de otra se dice que la subclase hereda de la superclase.
• Cuando la subclase hereda de la superclase, la primera hereda todos los métodos y variables de
la superclase.
En java se indica herencia entre clases mediante la palabra reservada extends
Supongas que tenemos una clase llamana Persona y que tiene como atributos: nombre y edad
public class Persona{

private int edad;
private String edad;
public Persona(int edad, String nombre){

this.edad = edad;
}
public String datosGenerales(){

return "la edad es: " + edad + " y el nombre es: " + nombre;
}
}
Si necesitamos hacer mas clases que sean tan parecidas a la clase Persona entonces es donde
debemos usar la herencia, la cual se hace de la siguiemnte forma.
public class Estudiante extends Persona{

private int carnet;
public Persona(ind edad, String nombre, int carnet){
super(edad, nombre);
this.carnet= carnet;
}
public String datosEspecificos(){

return “la edad es: ” + edad + “, el nombre es: ” + nombre + ” y el carnet es: ” + carnet;
}
}
El uso de public class Estudiante extends Persona hace que la clase Estudiante tenga los mismo
atributos en que la su clase superior Persona.
Noten que el constructor de Persona recibe la edad y el nombre, por lo tanto, si queremos accesar al
constructor de la clase superior debes llamarlo con la palabra super seguidamente pasando los
parametros respectivos
2. 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:
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).

Manejo Ide Netbeans Con Objetos

Cargado por

Copyright:

Formatos disponibles

También podría gustarte

Manejo Ide Netbeans Con Objetos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manejo Ide Netbeans Con Objetos

Cargado por

Copyright:

Formatos disponibles

ROGERIO ORLANDO BELTRAN CASTRO

PROGRAMACION ORIENTADA A OBJETOS 1

TALLER INICIAL NETBEANS

En este capítulo vamos a ver.

1. Crear un proyecto de aplicación Java con Netbeans

2. Ejecutar una aplicación Java con Netbeans

3. Creación de Paquetes y Clases

Crear un proyecto de aplicación Java con Netbeans

¡NetBeans IDE 7.2 iniciado y corriendo!

PROGRAMACION ORIENTADA A OBJETOS 2

PROGRAMACION ORIENTADA A OBJETOS 3

Ejecutar una aplicación Java con Netbeans

Agregando 1 línea en la Clase Turorial.java, generado por Netbeans quedaría así.

1 public static void main(String[] args) {

Primera forma, seleccionamos el proyecto, y la opción Run.

Segunda forma, seleccionamos el proyecto y luego en el botón Run de la barra de herramientas.

PROGRAMACION ORIENTADA A OBJETOS 4

Ahora veremos un tercer elemento importante de Netbeans IDE que es:

• La consola de salida de Java (Output)

La consola de salida (Output) es donde veremos el resultado de la ejecución del Proyecto.

Creación de Paquetes y Clases

PROGRAMACION ORIENTADA A OBJETOS 5

Seleccionamos el paquete “tutorial”, luego: Refactor > Rename…

Cambiamos de “tutorial” a“org.heyma.tutorial” tal como se muestra en la siguiente imagen.

PROGRAMACION ORIENTADA A OBJETOS 6

PROGRAMACION ORIENTADA A OBJETOS 7

El Editor de Netbeans IDE 7.2

En este capítulo veremos:

• Resolver Importaciones (imports)

• Los Getters y Setters

Luego de crear la clase Persona el Editor nos mostrara lo siguiente

PROGRAMACION ORIENTADA A OBJETOS 8

Transcribiendo las propiedades de la clase Persona.

Resolver Importaciones (imports) Ctrl + Shift + I

PROGRAMACION ORIENTADA A OBJETOS 9

Los Getters y Setters – Alt+Insert

PROGRAMACION ORIENTADA A OBJETOS 10

PROGRAMACION ORIENTADA A OBJETOS 11

Crear una interfaz

Para ello selecciona el paquete. Luego: New > Java Interface...

PROGRAMACION ORIENTADA A OBJETOS 12

PROGRAMACION ORIENTADA A OBJETOS 13

PROGRAMACION ORIENTADA A OBJETOS 14

Luego presionamos el botón Generate, y veremos la Clase como se muestra a continuación.

PROGRAMACION ORIENTADA A OBJETOS 15

1 throw new UnsupportedOperationException("Not supported yet.");

Formatear el código (Alt + Shift + F)

PROGRAMACION ORIENTADA A OBJETOS 16

Características de los objetos

• color (cadena de caracteres)

• mesa01: "Blanco", 100, 120, 60, "Madera", "Aula1"

PROGRAMACION ORIENTADA A OBJETOS 17

PROGRAMACION ORIENTADA A OBJETOS 18

Llamada al método contructor

NombreDeLaClase nombreDeLaVariable = new NombreDeLaClase();

Compilación de aplicación con varios archivos java

PROGRAMACION ORIENTADA A OBJETOS 19