Manual Java

Este curso tiene por objetivo brindar el conocimiento sobre la programacin orientada a objetos (OOP) en Java, esto incluye, clases, objetos, herencia, polimorfismo, ligadura dinmica, constructores, sobre escritura de mtodos, relacin entre objetos, clases amigas, entre otros, as como el manejo de interfaces graficas.

POO EN JAVA JG TECNOLOGIAS

JG Tecnologas

CONTENIDOJG TECNOLOGIAS

PRESENTACIN DEL CURSO ................................POO EN JAVA ................................

UNIDAD I ................................................................INTRODUCCIN A LA POO Y JAVA

Programacin orientada a objetosEl Lenguaje Java ................................Compilacin, ByteCode y JVMsEntornos de desarrollo Java ................................Java vs otros lenguajes OO ................................

UNIDAD II ................................................................POO EN JAVA ................................

Clases de Objetos ................................Instanciacin de la clase ................................Mtodos o atributos estticosProteccin de miembros de la claseClases amigas................................Proteccin de Clases ................................Inicializacin y finalizacin ................................Sobrecarga de Operaciones................................Creacin de objetos ................................Trabajando con objetos ................................Autoreferencias (this) ................................Aplicaciones orientadas a objetosEntrada y salida ................................

UNIDAD III ................................................................RELACIN ENTRE OBJETOS

Relacin entre objetos ................................La dependencia entre objetosLa asociacin entre objetos ................................

JG Tecnologas MANUAL JAVA jgtecnologias.com

CONTENIDO

................................................................................................

................................................................................................

................................................................................................

INTRODUCCIN A LA POO Y JAVA ................................................................a objetos ................................................................

................................................................................................

Compilacin, ByteCode y JVMs ................................................................................................................................................................

................................................................................................

................................................................................................

................................................................................................

................................................................................................

................................................................................................

Mtodos o atributos estticos ................................................................................................Proteccin de miembros de la clase ................................................................

................................................................................................

................................................................................................

................................................................................................

................................................................................................

................................................................................................

................................................................................................

................................................................................................

Aplicaciones orientadas a objetos ................................................................................................................................................................

................................................................................................

................................................................................................

................................................................................................

dependencia entre objetos ................................................................................................................................................................................................

CONTENIDO PROGRAMATICO

Bsico

1

jgtecnologias.com

........................................ 4

............................................................... 4

.......................................... 5

............................................................ 5

.............................................................. 6

........................................................ 7

................................................................. 9

..................................... 10

..................................... 11

....................................... 13

............................................................. 13

.................................................... 14

.......................................... 15

................................... 17

......................................................... 18

.......................................................... 19

............................................... 22

....................................... 23

..................................... 24

................................................. 27

............................................ 29

............................................... 31

............................................................ 33

....................................................... 35

...................................... 40

.................................... 40

.............................................. 41

.................................. 41

...................................... 42

CONTENIDO PROGRAMATICO

Bsico-Intermedio

2


La agregacin entre objetos ..................................................................................................... 44 La composicin entre objetos ................................................................................................... 44 Clases anidadas e interiores .................................................................................................... 46

UNIDAD IV ...................................................................................................................................... 48 HERENCIA .................................................................................................................................. 48

La herencia .............................................................................................................................. 49

Mtodo Super() ........................................................................................................................ 56 Anular la herencia .................................................................................................................... 58

Adicin, redefinicin y anulacin de la herencia ....................................................................... 58 La redifinicin ........................................................................................................................... 59 La anulacin ............................................................................................................................. 63 Proteccin y herencia ............................................................................................................... 64 Clases abstractas ..................................................................................................................... 65 Herencia mltiple ..................................................................................................................... 70 Polimorfismo ............................................................................................................................ 72

Ligadura dinmica .................................................................................................................... 76 UNIDAD V ....................................................................................................................................... 84

MULTI TAREA ............................................................................................................................. 84 UNIDAD VI ...................................................................................................................................... 87

ESTRUCTURAS DE DATOS EN JAVA ....................................................................................... 87 ArrayList ................................................................................................................................. 101 HashSet ................................................................................................................................. 111 HashMap ................................................................................................................................ 112 TreeSet .................................................................................................................................. 125 Resumen de Colecciones ...................................................................................................... 128

UNIDAD VII ................................................................................................................................... 133 INTERFACES GRFICAS ......................................................................................................... 133

Introduccin ........................................................................................................................... 134 Caractersticas de la programacin en GUIs .......................................................................... 134 Gestin de eventos ................................................................................................................ 137 Arquitectura de una aplicacin con GUI ................................................................................. 139 La capa de presentacin o interfaz......................................................................................... 139 La capa de aplicacin............................................................................................................. 139 La capa de persistencia ......................................................................................................... 139 Programacin de GUIs en Java ............................................................................................. 140 Componentes de swing .......................................................................................................... 144

3


UNIDAD VIII .................................................................................................................................. 148 EJERCICIOS ............................................................................................................................. 148

Orientacin a Objetos............................................................................................................. 149 Herencia................................................................................................................................. 149

Concurrencia. Hilos ................................................................................................................ 149 Ejercicios resueltos ................................................................................................................ 152

4


PRESENTACIN DEL CURSO POO EN JAVA

Objetivo: Este curso tiene como objetivo introducir a los participantes en los conocimientos terico- prcticos de la programacin orientada a objetos tales como: clases, objetos, herencia, polimorfismo, templates, entre otros utilizando como lenguaje de programacin Java

Al concluir este curso el participante deber desarrollar aplicaciones cliente- servidor bajo modo consola y bajo interfaces grficas utilizando para ello la librera Swing.

Dirigido a: Estudiantes, desarrolladores, profesionales con carrera a fin, con slidos conocimientos de programacin estructurada que quieran desarrollar aplicaciones cliente-servidor bajo el paradigma de programacin orientado a objetos.

POO EN JAVA 0

5


UNIDAD I INTRODUCCIN A LA POO Y JAVA

OBJETIVO:

El objetivo de esta unidad es ofrecer un conjunto de saberes relacionados el entorno de desarrollo de Java, esto incluye: la compilacin del cdigo fuente, las maquinas virtuales, caractersticas, y las ventajas de este lenguaje con otros.

PUNTOS A TRATAR:

1. Programacin orientada a objetos 2. El Lenguaje Java 3. Compilacin, ByteCode y JVMs 4. Entornos de desarrollo Java 5. Java vs otros lenguajes OO

INTRODUCCIN A LA POO Y JAVA 1

6


PROGRAMACIN ORIENTADA A OBJETOS

1. Aparece a finales de los 60, pero es a principios de los 80 cuando con el lenguaje Smalltalk comienza un inters claro hacia este paradigma

2. La programacin orientada a objetos es el paradigma de programacin y anlisis y diseo de aplicaciones claramente dominante en la actualidad

3. Hoy prcticamente no se concibe un lenguaje de programacin sin caractersticas de orientacin a objetos: Eiffel, C++, Java, C#, etc.

Las ventajas del paradigma OO son mltiples: 1. Es intuitiva, describe un problema en trminos similares a los que utiliza la mente humana 2. Permite construir soluciones ms seguras y con un mantenimiento ms sencillo 3. Fomenta la reutilizacin y el trabajo en equipo. Escalabilidad de las aplicaciones

Las caractersticas principales del paradigma OO: 1. Incorpora los conceptos de abstraccin, ocultacin de informacin y encapsulacin

heredados de los tipos de datos abstractos 2. Incorpora mecanismos especficos y extremadamente poderosos como son la herencia, el

polimorfismo y la ligadura dinmica 3. Admite de manera muy natural en algunos lenguajes el soporte de genericidad (patrones) y

la definicin de operadores. No soportados por Java

El desarrollo siguiendo el enfoque orientado a objetos es un proceso integral que incluye mtodos especficos de anlisis y diseo, notacin grfica (UML) y lenguajes de programacin orientados a objetos Las soluciones obtenidas durante la fase de anlisis y diseo no son especficos para ningn lenguaje de programacin orientado a objetos

7


EL LENGUAJE JAVA

Java, es un lenguaje de programacin desarrollado por Sun Microsystems (actualmente pertenece a Oracle). Es un lenguaje orientado a objetos, diseado para la ejecucin en mltiples plataformas sin requerir la recompilacin del cdigo fuente para cada plataforma. Aunque Java puede ser compilado como un programa nativo, se le puede atribuir una buena parte de su popularidad a su portabilidad y a otras caractersticas como la recoleccin de basura.

1. Basado en C++ pero simplificado, mucho ms fcil de usar, de ms alto nivel y menos propenso a errores

2. Amplsima biblioteca estndar de clases predefinidas 3. Las aplicaciones Java pueden ser ejecutadas indistintamente

en cualquier plataforma sin necesidad de recompilacin 4. Amplio espectro: programacin tradicional, distribuida, GUI, Web, dispositivos mviles, etc. 5. Gestin avanzada de memoria mediante el uso de un recolector de basura 6. Gestin avanzada de errores, tanto en tiempo de compilacin como de ejecucin 7. Soporte sencillo de mltiples hebras de ejecucin 8. Pueden integrarse mdulos escritos en C/C++ 9. Lenguaje abierto. Kits de desarrollo y documentacin gratuitos en la red 10. Las imgenes vectoriales se pueden escalar. Los grficos vectoriales son independientes de

la resolucin, pues no estn definidos por un nmero fijo de pixeles y, por lo tanto, se escalan automticamente para que aparezcan ntidos en cualquier dispositivo de salida y en cualquier resolucin.

Existen distintas ediciones de Java para el desarrollo de aplicaciones en distintos mbitos: 1. Aplicaciones de propsito general (J2SE) 2. Aplicaciones de gestin en entornos empresariales (J2EE) 3. Aplicaciones para telfonos mviles, PDAs y otros dispositivos electrnicos que permitan

aplicaciones empotradas (J2ME) 4. La ms utilizada es sin duda la edicin estndar (J2SE).

8


Existen dos kits diferentes que pueden ser descargados de la pgina oficial de Sun: 1. El Java Development Kit (JDK) permite desarrollar y ejecutar aplicaciones Java 2. El Java Runtime Environment (JRE) permite nicamente la ejecucin

J2SE incluye bibliotecas muy extensas y completas, que permiten la implementacin de casi cualquier tipo de aplicacin:

1. Seguridad 2. EEDDs 3. Componentes (JavaBeans) 4. Internacionalizacin 5. E/S 6. XML 7. Redes y acceso a Internet 8. Programacin distribuida (RMI, CORBA) 9. Matemtica de precisin arbitraria 10. Sonido 11. Interfaz de usuario (AWT, SWING) 12. Grficos 2D 13. Manipulacin, carga y descarga de 14. imgenes 15. Impresin 16. Acceso a bases de datos (JDBC) 17. Gestin de preferencias y 18. Configuraciones

JG Tecnologas

COMPILACIN, BYTECODE

1. Java sigue un esquema no tradicional de compilacin/ejecucin:2. La compilacin genera un ejecutable en bytecode o cdigo intermedio independiente3. Para su ejecucin se requiere un JRE especfico de la

una mquina virtual java (JVM) y las libreras de clases.4. La JVM interpreta el bytecode o realiza su compilacin justintime

ms eficiente

En resumen, EL bytecode JavaJava compila el cdigo Java a una representacin intermedia denominada "bytecode Java" el cual se ejecuta en un JRE (Java Runtime Environment, Entorno de Ejecucin Java) y no directamente en el Sistema Operativo.


OMPILACIN, BYTECODE Y JVMS

Java sigue un esquema no tradicional de compilacin/ejecucin: La compilacin genera un ejecutable en bytecode o cdigo intermedio independientePara su ejecucin se requiere un JRE especfico de la plataforma. El JRE estuna mquina virtual java (JVM) y las libreras de clases. La JVM interpreta el bytecode o realiza su compilacin justintime para que su

bytecode Java, hace posible la independencia de plataforma, el compilador de Java compila el cdigo Java a una representacin intermedia denominada "bytecode Java" el cual se ejecuta en un JRE (Java Runtime Environment, Entorno de Ejecucin Java) y no directamente en

9

jgtecnologias.com

La compilacin genera un ejecutable en bytecode o cdigo intermedio independiente plataforma. El JRE est formado por

para que su ejecucin sea

endencia de plataforma, el compilador de Java compila el cdigo Java a una representacin intermedia denominada "bytecode Java" el cual se ejecuta en un JRE (Java Runtime Environment, Entorno de Ejecucin Java) y no directamente en

10


Ventajas de este sistema: 1. Se compila la aplicacin una nica vez y los ejecutables en bytecode obtenidos son vlidos

para cualquier plataforma. 2. El cdigo fuente queda a salvo 3. Es muy robusto. La mquina virtual Java es capaz de detectar y notificar gran cantidad de

errores durante la ejecucin de la aplicacin (como accesos a elementos fuera de un vector) 4. El recolector de basura no ocupa espacio en el ejecutable, ya que viene integrado en la JVM 5. Los ejecutables son pequeos porque las libreras de clases vienen proporcionadas junto a

la JVM en el JRE de la plataforma concreta

Inconvenientes:

1. Velocidad. Evidentemente la interpretacin o incluso compilacin justintime del bytecode produce aplicaciones ms lentas que en el caso de la ejecucin directa de un binario. El recolector de basura puede suponer una sobrecarga adicional al procesador

2. La generalidad tiene como inconveniente que no se aprovecha totalmente la potencia de la mquina y del sistema operativo. Por ejemplo, el aspecto de una aplicacin Java puede resultar simple y poco atractivo en comparacin con las aplicaciones nativas

ENTORNOS DE DESARROLLO JAVA

JDK. El kit de desarrollo bsico proporcionado por Sun. Es lo mnimo que se necesita para desarrollar. til si se necesita compilar aplicaciones Java de manera espordica o en general para programadores con espiritu espartano. Puede bajarse gratuitamente para cualquier plataforma de java.sun.com

netBeans. El IDE Java ms popular, realizado ntegramente en Java (y por tanto multiplataforma). Consume bastantes recursos. Tiene una arquitectura extensible con mdulos especficos para desarrollo web, aplicaciones mviles, diseo UML, etc. Puede obtenerse gratuitamente de www.netbeans.org

Eclipse. Junto a netBeans, el entorno de desarrollo Java gratuito ms utilizado. Tambin permite el desarrollo en C++ y otros lenguajes de programacin. Puede descargarse en www.eclipse.org

Borland JBuilder. Excelente entorno integrado de desarrollo Java de Borland. Existen versiones limitadas que pueden bajarse de www.borland.com

Microsoft Visual J++. Uno de los ms populares, aunque las aplicaciones obtenidas pueden presentar problemas de compatibilidad con el SDK oficial de Java, por el uso de libreras especificas

11


de Microsoft. Permite construir aplicaciones Java dentro de la plataforma .NET. La versin express puede obtenerse gratuitamente.

JAVA VS OTROS LENGUAJES OO

Java C# C++ Eiffel Smaltalk Aparicin 1995 2000 1985 1985 1970 Sintaxis ins. C++ ins. Java ins. C ins. Pascal original Difusin Amplia Amplia Amplia Limitada Limitada Librera de clases Muy Amplia Muy Amplia Escasa Amplia Amplia Recolector basura Si Si No Si Si Manejo objetos Dinmico Dinmico Est./Din. Est./Din Dinmico Tipo ejecutable Bytecode IL code binario binario Byte codes Ejecucin mediante JVM mediante CLR directa directa Mediante SVM Velocidad Ejecutable media media muy alta alta baja Soporte excepciones Si Si Si Si Si Herencia mltiple No No Si Si No Soporte operadores Muy Limitado Limitado Si Si No Soporte plantillas No No Si Si No

12


Ejemplos bsicos

Ejemplo: convertidor de unidades

import java.io.*; import java.util.Scanner; public class Medidas{ public static void main( String args[] ){ Scanner leer = new Scanner(System.in); int KM,CM,Y, op;

double RES;

System.out.println( "Ingrese la operacion" ); System.out.println( "1.- Centimetos a pulgadas" ); System.out.println( "2.- Yardas a metros" ); System.out.println( "3.- Kilometros a millas" ); System.out.println( "\n" ); op = leer.nextInt(); switch(op){ case 1:

System.out.println(Centimetros a pulgadas" ); System.out.println("Ingrese los centimetros" ); CM = leer.nextInt(); RES = CM * 2.3; System.out.println("El resultado es: "+RES+" pulgadas" ); break;

case 2:

System.out.println( "Yardas a Metros" ); System.out.println( "Ingrese el numero de Yardas" ); Y = leer.nextInt(); RES = Y * 0.914401829; System.out.println( "El resultado es: "+RES+" metros" ); break;

case 3:

System.out.println( "Kilometros a Millas" ); System.out.println( "Ingrese el numero de Kilometros" ); KM = leer.nextInt(); RES = KM * 0.621; System.out.println( "El resultado es: "+RES+" millas" ); break;

} } }

13


UNIDAD II POO EN JAVA

OBJETIVO:

El objetivo de esta unidad es introducir al participante en los conceptos tericos y prcticos de la programacin orientada a objetos, esto incluye: la implementacin de clases, objetos, proteccin de clases, su inicializacin y finalizacin, como se sobrecargan las operaciones, los constructores, y como realizar escrituras y lecturas a disco utilizando para ello las clases propias de Java.

Al concluir, esta unidad el participante deber estar en la capacidad de definir propiedades y mtodos con sus diferente tipos de proteccin, instanciar clase, trabajar con objetos, persistir a disco los objetos con serializacin, sobrecargar operaciones y leer entradas de datos utilizando diferentes clases de Java.

PUNTOS A TRATAR:

1. Clases de Objetos 2. Instanciacin de la clase 3. Mtodos o atributos estticos 4. Proteccin de miembros de la clase 5. Clases amigas 6. Proteccin de Clases 7. Inicializacin y finalizacin 8. Sobrecarga de Operaciones 9. Creacin de objetos 10. Trabajando con objetos 11. Autoreferencias (this) 12. Aplicaciones orientadas a objetos 13. Entrada y salida

POO EN JAVA 1

14


CLASES DE OBJETOS

Las clases de objetos representan conceptos o entidades significativos en un problema determinado. Una clase describe las caractersticas comunes de un conjunto de objetos, mediante dos elementos:

1. Atributos (o variables miembro, variables de clase). Describen el estado interno de cada objeto

2. Operaciones (o mtodos, funciones miembro). Describen lo que se puede hacer con el objeto, los servicios que proporciona

Cuenta Nombre de la clase

nmero: String

titular: String

Atributos saldo: Float

interesAnual: Float

ingreso(cantidad: Float)

reintegro(cantidad: Float)

Operaciones ingresoInteresMes()

enRojos(): Boolean

leerSaldo(): Real

15


INSTANCIACIN DE LA CLASE

Durante la ejecucin de la aplicacin se producir la instanciacin de la clase, es decir, la creacin de los objetos que representan cada uno de los individuos con sus caractersticas propias, es decir, valores especficos para sus atributos

c : Cuenta numero=123890023 titular=Miguel Prez saldo=1800.4 intersAnual=0.25

Cuenta nmero: String titular: String saldo: Float interesAnual: Float ingreso(cantidad: Float) reintegro(cantidad: Float) ingresoInteresMes() enRojos(): Boolean leerSaldo(): Real

e : Cuenta numero=151590020 titular=Javier Snchez saldo=1200.2 intersAnual=1.25

Clase de Objetos d : Cuenta numero=23900839 titular=Antonio Gmez saldo=200 intersAnual=0.25

Objetos

La implementacin de esta clase en Java se realizara en un fichero con nombre cuenta.java, y su contenido sera el siguiente:

Atributos

Operaciones

class Cuenta { long numero;

String titular;

float saldo;

float interesAnual;

void ingreso(float cantidad){} void reintegro(float cantidad){} void ingresoInteresMes(){} boolean enRojos(){} float leerSaldo(){} }

16


Los atributos pueden ser de cualquiera de los tipos bsicos 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

Al contrario que C++, Java realiza la definicin e implementacin de la clase en el mismo lugar, en un nico fichero .java

Ejemplo: implementacin del archivo Cuenta.java


String titular;

float saldo;

float interesAnual;

void ingreso(float cantidad) {saldo += cantidad;} void reintegro(float cantidad) {saldo =cantidad;} void ingresoInteresMes(){saldo+=interesAnual * saldo / 1200;} boolean enRojos() { return saldo < 0; } float leerSaldo() { return saldo; } }

JG Tecnologas

MTODOS O ATRIBUTOS

El acceso a los atributos de la clase desde la implementacioperaciones se realiza de forma directa

Los atributos u operaciones estticas (el proceso de instanciacin de objetos a partir de la clase

De un que se crea. Exitodos los objetos de la clase

Una estticos

En el siguiente ejemplo, se desea llevar el control del nmero de transacciones que realiza el banco, es importante destacar que cada cuenta puede generar n movimientos.

El atributo nOp mantiene una cuenta global del nmero de operaciones realizadas en las cuentas del banco, para la realizacin de estadsticas.

La operacin leerNOperaciones() permite leer est La operacin eurosAPesetas() es una operacin auxiliar de la clase Cuenta para ser usada

cuando sea necesaria una conversin de moneda

Ejemplo: Metodos y Atributos Static


String titular;

float saldo;

float interesAnual;

//Contador de operaciones static int nOp = 0;

static int leerNOperaciones() { return nOp; } //Operacin esttica auxiliar de conversin static long eurosAPesetas(float euros){return euros * 166.386f;} void ingreso(float cantidad void reintegro(float cantidad) { saldo =cantidad; ++nOp; }}


MTODOS O ATRIBUTOS ESTTICOS

El acceso a los atributos de la clase desde la implementacioperaciones se realiza de forma directa Los atributos u operaciones estticas (static) no son afectados por el proceso de instanciacin de objetos a partir de la claseDe un atributo esttico no se genera una copia por cada objeto que se crea. Existe una nica copia compartida y accesible desde todos los objetos de la clase Una operacin esttica nicamente puede acceder a miembros estticos

En el siguiente ejemplo, se desea llevar el control del nmero de transacciones que realiza el mportante destacar que cada cuenta puede generar n movimientos.

mantiene una cuenta global del nmero de operaciones realizadas en las cuentas del banco, para la realizacin de estadsticas. La operacin leerNOperaciones() permite leer este contador La operacin eurosAPesetas() es una operacin auxiliar de la clase Cuenta para ser usada cuando sea necesaria una conversin de moneda

: Metodos y Atributos Static


String titular;

float saldo;

t interesAnual;

//Contador de operaciones int nOp = 0;

int leerNOperaciones() { return nOp; } //Operacin esttica auxiliar de conversin

long eurosAPesetas(float euros){return euros * 166.386f;}void ingreso(float cantidad) { saldo += cantidad; ++nOp; }void reintegro(float cantidad) { saldo =cantidad; ++nOp; }

17

jgtecnologias.com

El acceso a los atributos de la clase desde la implementacin de las

) no son afectados por el proceso de instanciacin de objetos a partir de la clase

no se genera una copia por cada objeto ste una nica copia compartida y accesible desde

nicamente puede acceder a miembros

En el siguiente ejemplo, se desea llevar el control del nmero de transacciones que realiza el mportante destacar que cada cuenta puede generar n movimientos.

mantiene una cuenta global del nmero de operaciones realizadas en las

La operacin eurosAPesetas() es una operacin auxiliar de la clase Cuenta para ser usada

long eurosAPesetas(float euros){return euros * 166.386f;} ) { saldo += cantidad; ++nOp; }

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

JG Tecnologas

PROTECCIN DE MIEMBR

El principio de ocultacin de informacin se plasmamecanismos de proteccin de los miembniveles de proteccin diferentes a cada miembro de la clase:

Miembros pblicos (+) Sin ningn tipo de proteccin especialMiembros privados (-) Inaccesibles desde el exterior de la claseMiembros protegidos (#)acceso desde las clases descendientes

En Java un miembro se etiqueta como pblico colocando el identificador public delante de su declaracin

Para los miembros privados utilizaremos el identificador

Cuenta numero: Long titular: String saldo: Float intersAnual: Real +ingreso(cantidad: Integer) +reintegro(cantidad: Integer) +ingresoInteresMes() +enRojos(): Boolean +leerSaldo(): Integer


PROTECCIN DE MIEMBROS DE LA CLASE

El principio de ocultacin de informacin se plasma en los lenguajes OO en diversos proteccin de los miembros de la clase. UML permite asociar tres

diferentes a cada miembro de la clase: Sin ningn tipo de proteccin especial Inaccesibles desde el exterior de la clase

Miembros protegidos (#) Similares a los privados aunque se permite su desde las clases descendientes (sub clases derivadas de una clase padre)

Clase +atributoPublico: Tipo -atributoPrivado: Tipo #atributoProtegido: Tipo operacionPrivada() +operacionPublica() #operacionProtegida()

En Java un miembro se etiqueta como pblico colocando el identificador delante de su declaracin

Para los miembros privados utilizaremos el identificador

18

jgtecnologias.com

en los lenguajes OO en diversos UML permite asociar tres

ilares a los privados aunque se permite su (sub clases derivadas de una clase padre)

En Java un miembro se etiqueta como pblico colocando el identificador

Para los miembros privados utilizaremos el identificador private

19


Ejemplo: Proteccin de miembros de la clase Cuenta

class Cuenta { private long numero;

private String titular;

private float saldo;

private float interesAnual;

public void ingreso(float cantidad) {saldo += cantidad;} public void reintegro(float cantidad) {saldo =cantidad;} public void ingresoInteresMes(){saldo+=interesAnual*saldo/ 1200;} public boolean enRojos() { return saldo < 0; } public float leerSaldo() { return saldo; } }

CLASES AMIGAS

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 archivos fuente pueden agruparse en un nico paquete

indicando el nombre de paquete al principio de cada archivo mediante el indicador package 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 explcitamente

archivo A.java archivo C.java archivo D.java package prueba; class A { ...

} class B { ...

}

package prueba; class C { ...

}

class D { ....

}

class E { ....

}

Las clases A, B y C son amigas al pertenecer al mismo paquete prueba

Las clases D y E son amigas al pertenecer al mismo fichero fuente

JG Tecnologas

En el siguiente ejemplo, las clases 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 operacin que permite obtener su valor:

Ejemplo: clases amigas. Implementacin del archivo Cuenta.java


String titular;


float interesAnual;

public void ingreso(float cantidad) {saldo += cantidad;} public void reintegro(float cantidad) {saldo =ca public void ingresoInteresMes( public boolean enRojos() { return saldo < 0; } public float leerSaldo() { return saldo; }}

class Banco { Cuenta[] c; // vector de cuentas...

}

Atencin: todas las claspaquete de forma explcita, 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:

1. Utilizar su nombre completo: 2. Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del

cdigo fuente mediante 3. Importar directamente t

import prueba.* Un paquete puede estar situado dentro de otro paquete

jerrquicas. Ejemplo: miapp.prueba.A


En el siguiente ejemplo, las clases Cuenta y Banco son amigas al pertenecer al mismo archivo . 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 operacin que permite obtener su valor:

lases amigas. Implementacin del archivo Cuenta.java

{ long numero;

String titular;


float interesAnual;

public void ingreso(float cantidad) {saldo += cantidad;}public void reintegro(float cantidad) {saldo =capublic void ingresoInteresMes( {saldo+=interesAnual*saldo/public boolean enRojos() { return saldo < 0; } public float leerSaldo() { return saldo; }

Cuenta[] c; // vector de cuentas

: todas las clases que no se declaren como pertenecientes a ningn paquete de forma explcita, pertenecen a un paquete por defecto y por tanto son

Un paquete crea un espacio de nombres propios. Esto significa que la clase pasa a tener ombre 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 cdigo fuente mediante import prueba.A Importar directamente todas las clases del paquete, que se usaran sin prefijo:

Un paquete puede estar situado dentro de otro paquete miapp.prueba.A 20

jgtecnologias.com

Cuenta y Banco son amigas al pertenecer al mismo archivo . 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

lases amigas. Implementacin del archivo Cuenta.java

public void ingreso(float cantidad) {saldo += cantidad;} public void reintegro(float cantidad) {saldo =cantidad;}

saldo+=interesAnual*saldo/1200;}

es que no se declaren como pertenecientes a ningn paquete de forma explcita, pertenecen a un paquete por defecto y por tanto son

Un paquete crea un espacio de nombres propios. Esto significa que la clase pasa a tener ombre del paquete. A la hora de utilizarla tenemos tres opciones:

Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del

odas las clases del paquete, que se usaran sin prefijo:

formando estructuras

21


Java obliga a que exista una correspondencia entre la estructura de paquetes de una clase y la estructura de directorios donde est situada

La raiz de la estructura de directorios debe estar incluida en el classpath de Java (parmetro cp )

Las clases: miapp.prueba.A, miapp.prueba.B y miapp.C Deben estar en la siguiente estructura de directorios:

Paquete prueba est dentro del paquete miapp

miapp.prueba.A

Archivo A.java

Archivo B.java

Archivo C.java

JG Tecnologas

PROTECCIN DE CLASES

Por proteccin de clases entendemos un a nivel de clases. Es decir, se trata de especificar que clases pueden ser utilizadas y cules no, y por quin

Dentro de un paquete, las clases son amigasa la utilizacin de una clase por las otras

Sin embargo, desde el punto de vista del exterior, nicamente podrn ser utilizadas las clases pblicas del paquetede su declaracin

Atencin: Java slo permite una clase pblica por fichero fuente, y el nombre de la clase y el fichero deben coincidir obligatoriamenteque la clase Cuenta pueda ser utilizada desde eldeberemos declararla como pblica

Ejemplo: Proteccin de clases

public class Cuenta { private long numero;




public void ingreso(float cantidad) {saldo += cantidad;} public void reintegro(float cantidad) {saldo =cantidad;} public void ingresoInteresMes(){saldo+ public boolean enRojos() { return saldo < public float leerSaldo() { return saldo; }}


PROTECCIN DE CLASES

Por proteccin de clases entendemos un nivel superior de la ocultacin de informacin, . Es decir, se trata de especificar que clases pueden ser utilizadas y cules

Dentro de un paquete, las clases son amigas y por tanto no existen restricciones respecto a la utilizacin de una clase por las otras

desde el punto de vista del exterior, nicamente podrn ser utilizadas las aquete, es decir, aquellas con el identificador public situado delante

: Java slo permite una clase pblica por fichero fuente, y el nombre de la clase y el fichero deben coincidir obligatoriamente. En nuestro ejemplo, si queque la clase Cuenta pueda ser utilizada desde el exterior del fichero Cuenta.java deberemos declararla como pblica.

: Proteccin de clases

Cuenta { private long numero;




public void ingreso(float cantidad) {saldo += cantidad;}public void reintegro(float cantidad) {saldo =cantidad;}public void ingresoInteresMes(){saldo+=interesAnual*saldo/1200;}public boolean enRojos() { return saldo < 0; } public float leerSaldo() { return saldo; }

22

jgtecnologias.com

nivel superior de la ocultacin de informacin, . Es decir, se trata de especificar que clases pueden ser utilizadas y cules

y por tanto no existen restricciones respecto

desde el punto de vista del exterior, nicamente podrn ser utilizadas las , es decir, aquellas con el identificador public situado delante

: Java slo permite una clase pblica por fichero fuente, y el nombre de la En nuestro ejemplo, si queremos exterior del fichero Cuenta.java

public void ingreso(float cantidad) {saldo += cantidad;} public void reintegro(float cantidad) {saldo =cantidad;}

interesAnual*saldo/1200;}

23


INICIALIZACIN Y FINALIZACIN

La iniciacin de los atributos de la clase se realiza en Java, al igual que en C++, mediante el uso de constructores cuyo nombre coincide con el de la clase, en el siguiente ejemplo podemos notar que hay un mtodo llamado igual al nombre de la clase, en este caso cuenta,

Ejemplo: Inicializacin y Finalizacin





//Constructor de la clase Cuenta(long aNumero, String aTitular, float aInteresAnual){ numero = aNumero;

titular = aTitular;

saldo = 0;

interesAnual = aInteresAnual;

} public void ingreso(float cantidad){saldo += cantidad;} // Resto de operaciones de la clase Cuenta a partir de aqu

24


SOBRECARGA DE OPERACIONES

Java permite la sobrecarga de operaciones, por tanto se pueden definir varios constructores posible para una clase siempre que se diferencien en la lista de argumentos


// Importar todas las clases del paquete java.io import java.io.*; public class Cuenta { private long numero;




//Constructor general Cuenta(long aNumero, String aTitular, float aInteresAnual){ numero = aNumero;

titular = aTitular;

saldo = 0;


} // Constructor para obtener los datos de la cuenta de un archivo Cuenta(long aNumero) throws FileNotFoundException, IOException, ClassNotFoundException { FileInputStream fis = new FileInputStream(aNumero + .cnt); ObjectInputStream ois = new ObjectInputStream(fis); numero = aNumero;

titular = (String) ois.readObject(); saldo = ois.readFloat(); interesAnual = ois.readFloat(); ois.close(); } public void ingreso(float cantidad) {saldo += cantidad;} public void reintegro(float cantidad) {saldo =cantidad;} public void ingresoInteresMes(){saldo+=interesAnual*saldo/1200;} public boolean enRojos() { return saldo < 0; } public float leerSaldo() { return saldo; } }

25


Si no se proporciona ningn constructor, Java proporciona automticamente un constructor por defecto, que no recibe argumentos y realiza una inicializacin por defecto de los atributos

Una vez implementado un constructor propio por parte del programador, Java elimina dicho constructor, aunque puede ser definido nuevamente de manera explcita

class Cuenta { numero = 00000000;

titular = ninguno;

saldo = 0;

interesAnual = 0;

}

Naturalmente los constructores pueden ser marcados como pblicos, privados, protegidos o con acceso a nivel de paquete, lo que especificar quien puede crear objetos de esta clase y de qu manera


// Constructor general public Cuenta(long aNumero,String aTitular,float aInteresAnual){ numero = aNumero;

titular = aTitular;

saldo = 0;


} // Constructor para obtener los datos de la cuenta de un fichero public Cuenta(long aNumero) throws FileNotFoundException, IOException, ClassNotFoundException { FileInputStream fis = new FileInputStream(aNumero + .cnt); ObjectInputStream ois = new ObjectInputStream(fis); numero = aNumero;

titular = (String)ois.readObject(); saldo = ois.readFloat(); interesAnual = ois.readFloat(); ois.close(); }

26


Cuando finaliza el uso de un objeto, es frecuente la realizacin de ciertas tareas antes de su destruccin, principalmente la liberacin de la memoria solicitada durante su ejecucin. Esto se realiza en C++ y otros lenguajes OO en los denominados destructores.

Estos destructores son operaciones invocadas automticamente justo antes de la destruccin del objeto.

Sin embargo, en Java la liberacin de memoria se realiza de manera automtica por parte del recolector de basura, por tanto la necesidad de este tipo de operaciones no existe en la mayor parte de los casos.

Sin embargo s puede ser necesario realizar alguna tarea no relacionada con la liberacin de memoria antes de la destruccin del objeto, como por ejemplo salvar el estado de la clase en un fichero o base de datos

Java permite introducir cdigo para este fin implementando una operacin pblica especial denominada finalize. Esta operacin es invocada automticamente antes de la destruccin

del objeto por parte del recolector de basura

Siguiendo nuestro ejemplo, vamos asegurarnos de que el estado de una cuenta queda salvado en disco antes de su destruccin, para poder ser recuperada posteriormente. Para ello introducimos el cdigo de escritura en fichero en la operacin finalize de la clase Cuenta

Ejemplo: uso de finalize

public void finalize() : throws FileNotFoundException, IOException { FileOutputStream fos = new FileOutputStream(numero + .cnt); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(titular); oos.writeFloat(saldo); oos.writeFloat(interesAnual); oos.close(); }

Problema: no es posible saber con seguridad en qu momento ser invocada finalize, puesto que el recolector de basura puede decidir su eliminacin en un momento indeterminado, e incluso no ser eliminado hasta el final de la ejecucin de la aplicacin.

27


Una posible solucin es ordenar al recolector de basura que realice una limpieza de memoria inmediata, para asegurar la finalizacin de los objetos. Esto se realiza mediante Runtime.getRuntime().gc()

Por motivos de eficiencia, lo anterior es poco recomendable, sobre todo si se hace con frecuencia

Una mejor opcin es definir una operacin ordinaria con este mismo propsito, a llamar de manera explcita cuando haya finalizado el uso del objeto Introduciremos en la clase Cuenta una operacin pblica salvar en lugar de finalize, con la misma implementacin. Tras finalizar las operaciones sobre la cuenta, invocaremos a salvar para guardar los cambios realizados.

CREACIN DE OBJETOS

1. En Java los objetos se crean nicamente de forma dinmica. Para ello se utiliza el operador new, de manera similar a C++

2. Los objetos en Java se utilizan siempre a travs de referencias. Las referencias son similares a los punteros de C/C++, aunque su uso es mucho ms sencillo

3. Por tanto los pasos a seguir en la creacin de un objeto son: a. Declarar una referencia a la clase b. Crear un objeto mediante el operador new invocando al constructor adecuado c. Conectar el objeto con la referencia

La creacin de un objeto de la clase Cuenta se realizara de la siguiente forma: Cuenta c; // Una referencia a un objeto de la clase Cuenta c = new Cuenta(18400200, Pedro Jimnez, 0.1f);

En cambio, los tipos bsicos (int, long, float, etc.) s pueden ser creados directamente en la pila. Esto es posible porque Java no los implementa realmente como clases de objetos, por motivos de eficiencia y comodidad, ya que su uso es muy frecuente

Cuenta c;

float in;

long num;

in = 0.1f;

num = 18400200;

c = new Cuenta(num, Pedro Garcia, in);

Las cadenas de caracteres se implementan con una clase (String). Sin embargo no suele ser necesaria su creacin de manera explcita, ya que Java lo hace de manera automtica al asignar una cadena constante*

28


String s; // Una referencia a un objeto de la clase String // Conexin de la referencia s con un objeto String // creado dinmicamente e inicializado con la constante Pedro s = Pedro;

// Sera equivalente a: // char[] cc = {'P', 'e', 'd', 'r', 'o'} // s = new String(cc);

Los arrays tambin deben ser creados dinmicamente con new como si fueran objetos

int[] v; // Una referencia a un vector de enteros v = new int[10] // Creacin de un vector de 10 enteros

Si el array es de referencias a objetos, habr que crear adems cada uno de los objetos referenciados por separado

La destruccin de los objetos se realiza de manera automtica cuando el recolector de basura detecta que el objeto no est siendo usado, es decir, no est conectado a ninguna referencia

Cuenta[] v; // Un vector de referencias a objetos de la clase Cuenta int c;

v = new Cuenta[10] // Crear espacio para 10 referencias a cuentas for (c = 0; c < 10; c++) v[c] = new Cuenta(18400200 + c, Cliente n. + c, 0.1f);

Cuenta c1 = new Cuenta(18400200, Cliente 1, 0.1f); Cuenta c2 = new Cuenta(18400201, Cliente 2, 0.1f); c1 = c2

// El objeto asociado a la cuenta 18400200 ha quedado desconectado y ser // eliminado por el recolector de basura

29


TRABAJANDO CON OBJETOS

Trabajar con un objeto Java es similar a C++, aunque las referencias permiten un uso mucho ms sencillo.

Cuenta c1 = new Cuenta(18400200, Pedro Jimnez, 0.1f); Cuenta c2 = new Cuenta(18400201); c2.reintegro(1000); c1.ingreso(500); if (c2.enRojos()) System.out.println(Atencin: cuenta 18400201 en nmeros rojos); System.out.println(Saldo actual de la cuenta 18400201: + c1.leerSaldo()); c1 = new Cuenta(18400202); // El objeto asociado a la Cuenta 18400200 queda desconectado c1.ingreso(500); System.out.println(Saldo actual de la cuenta 18400202: + c1.leerSaldo());

30


Ejemplo: se pide un nmero de cuenta al usuario y una cantidad a retirar. A continuacin se carga la cuenta solicitada y se realiza el reintegro.

BufferedReader br = new

BufferedReader(InputStreamReader(System.in)); long nc;

float mi;

try{ System.out.println(Introduzca nm. de de cuenta: ); nc = Long.parseLong(br.readLine()); System.out.println(Introduzca importe a retirar: ); mi = Float.parseFloat(br.readLine()); } catch(Exception e) { System.out.println(Error al leer datos); return;

} Cuenta c;

try { c = new Cuenta(nc); } catch(Exception e) { System.out.println(Imposible recuperar cuenta); return;

} if (c.leerSaldo() < mi) System.out.println(Saldo insuficiente); else

c.reintegro(mi); c.salvar();

31


Naturalmente el compilador producir un error ante cualquier acceso ilegal a un miembro de la clase Cuenta c = new Cuenta(18400200, Pedro Jimnez, 0.1f); c.saldo = 1000;

Cuenta.java:XX: saldo has private access c.saldo = 1000;

^

1 error

El acceso a un miembro esttico se realiza utilizando el nombre de la clase en lugar de un objeto

Cuenta c = new Cuenta(18400200, Cliente 1, 0.1f); c.ingreso(1000); int pts = Cuenta.eurosAPesetas(c.leerSaldo()); System.out.println(Saldo: + c.leerSaldo() + ( + pts + pesetas);

AUTOREFERENCIAS (THIS)

En ocasiones es necesario obtener una referencia en la implementacin de una operacin al propio objeto sobre el que ha sido invocada la operacin.

Esta referencia se obtiene en C++ y Java mediante el operador this Cuando encontremos this en una expresin, podremos sustituirlo mentalmente por este

objeto Aunque no es necesario, podemos utilizar this para llamar desde la implementacin de una

operacin a otra operacin del mismo objeto

La llamada a la operacin ingreso desde ingresoInteresMes() puede realizarse utilizando this como referencia del objeto sobre el que se invoca la operacin


private Cliente titular;

private float saldo, interesAnual;

public void ingresoInteresMes() { this.ingreso(interesAnual * saldo / 1200); } // Resto de las operaciones de la clase Cuenta

32


En este ejemplo, el uso de this es realmente til. Nos permite implementar la operacin transferirDesde() llamando a una operacin transferirHasta(), previamente implementada




public void transferirHasta(Cuenta c, float cant) { reintegro(cant); c.ingreso(cant); } public void transferirDesde(Cuenta c, float cant) { c.transferirHasta(this, cant); } // Resto de las operaciones de la clase Cuenta

Otra utilidad de this en Java es realizar una llamada a un constructor desde otro constructor public class Cuenta { private long numero;



// Constructor general public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero; titular = aTitular; saldo = 0;


movimientos = new LinkedList(); } // Constructor especfico para cuentas de ahorro (interesAnual = 0.1%) public Cuenta(long aNumero, Cliente aTitular) { this(aNumero, aTitular, 0.1); } // Resto de la clase Cuenta

Pero atencin: un constructor no es una operacin ordinaria. nicamente puede llamarse a un constructor desde otro constructor y debe ser la primera instruccin dentro de la implementacin.

33


APLICACIONES ORIENTADAS A OBJETOS

En una aplicacin orientada a objetos debe existir una clase que represente la propia aplicacin. Este sera el punto donde comenzara la ejecucin de la misma.

En lenguajes no totalmente orientados como C++ en la funcin main se crea una instancia de esta clase y se llama a alguna operacin como ejecutar para arrancar la aplicacin. Sin embargo esto no es obligatorio, y un mal programador puede realizar una aplicacin hbrida, con cdigo no orientado a objetos.

En un lenguaje orientado a objetos puro como Java esta clase de aplicacin es obligatoria.

La mquina virtual Java se encarga de instanciar esta clase y llamar a una operacin especial con nombre main. La existencia de esta operacin especial es lo que caracteriza a la clase de aplicacin

1. La clase de aplicacin debe ser pblica y no tener ningn constructor o un constructor por defecto

2. Al menos debe implementar la operacin main, con la siguiente declaracin: public static main(String[] args)

public class BancoApp { public static void main(String[] args) { Cuenta c1 = new Cuenta(18400200, Pedro Jimnez, 0.1f); c1.ingreso(1000); System.out.println(Ingreso realizado); } }

A la hora de ejecutar la aplicacin, deber indicarse esta clase a la mquina virtual Java 1. Tras compilar los archivos de la ltima versin de nuestro ejemplo:

Cliente.java, Cuenta.java y BancoApp.java Obtendremos los ficheros en byte code: Cliente.class, Cuenta.class, Movimiento.class y BancoApp.class

2. Finalmente, pasando la clase BancoApp.class a la mquina virtual java pondremos en funcionamiento la aplicacin

34


Nota: Las clases que constituyen una aplicacin Java tambin pueden distribuirse de manera mucho ms compacta en un nico fichero JAR.

35


ENTRADA Y SALIDA

Entrada/ Salida. La librera de clases de Java dispone de gran cantidad de clases para la gestin transparente de E/S. Estas clases pueden combinarse para crear flujos de datos especializados

E/S Binaria (streams): a) Las clases FileInputStream y FileOutputStream permite abrir streams de E/S secuencial a

ficheros en disco. La clase RandomAccessFile permite leer y escribir informacin a un fichero de forma aleatoria

b) Las clases BufferedInputStream y BufferedOutputStream permite leer y escribir informacin de un input/output stream, utilizando un buffer intermedio para acelerar las operaciones

c) Las clases DataInputStream y DataOutputStream permite leer y escribir tipos simples en un input/output stream

Ejemplo: Lectura y escritura bsicas en un fichero:

import java.io.*; public class ESBinaria { public static void main(String[] args) { DataOutputStream ds =

new DataOutputStream( new BufferedOutputStream( new FileOutputStream(datos))); ds.writeInt(2); ds.writeFloat(4.5); ds.writeChars(Hola); ds.close(); ds = new DataInputStream( new BufferedInputStream( new FileInputStream(datos))); int k = ds.readInt(); System.out.println(k); ds.close(); } }

36


E/S de caracteres (readers) a) Las clases FileReader y FileWriter permite abrir readers/writers de acceso secuencial a

ficheros en disco b) Las clases BufferedReader y BufferedWriter permite leer y escribir informacin utilizando

un buffer intermedio para acelerar las operaciones. Posibilitan el leer/escribir lneas completas

c) Las clases InputStreamReader y OutputStreamWriter permiten convertir un stream en un reader/writer

d) La clase especializada PrintWriter permite escribir directamente cualquier tipo de dato en un writer. Su uso es ms cmodo que el de un BufferedWriter

e) La clase especializada Scanner permite leer de manera sencilla cualquier tipo simple de un fichero de texto. Su uso es ms cmodo que mediante BufferedReader

Ejemplo: Escritura de un fichero mediante BufferedWriter y PrintWriter:

import java.io.*; public class ESTexto { public static void main(String[] args) { try { BufferedWriter bw =

new BufferedWriter(New FileWriter(datos.txt)); bw.write(Hola); bw.writeLine(); bw.write(new Integer(3).toString()); bw.writeLine(); bw.write(new Float(10.3).toString()); bw.close(); PrintWriter pw = new PrintWriter(datos.txt); pw.println(Hola); pw.println(3); pw.println(10.3); pw.close(); } catch(IOException e) { System.out.println(Error de E/S); } } }

37


Hay dos mtodos de lectura:

a) El primero usa la operacin parse() de las clases wrapper de los tipos bsicos b) El segundo, ms flexible y sencillo, utiliza la clase Scanner

Ejemplo: Leyendo con la clase BufferedReader y la clase scanner

import java.io.*; import java.util.Scanner; public class ESTexto { public static void main(String[] args) { try { BufferedReader br = new BufferedReader( new FileReader(datos.txt)); String s = br.readLine(); int k = Integer.parseInt(br.readLine()); float p = Float.parseFloat(br.readLine()); br.close(); Scanner sc = new Scanner(new File(datos.txt)); s = sc.nextLine(); k = sc.nextInt(); p = sc.nextFloat(); sc.close(); } catch(IOException e) { System.out.println(Error de E/S); } } }

38


Serializacin. Una de las caractersticas ms potentes de Java es la posibilidad de serializar un objeto, es decir, convertirlo en una secuencia de bytes y enviarlo a un fichero en disco, por un socket a otro ordenador a travs de la red, etc. El proceso sera el siguiente:

a) Declarar la implementacin de la interfaz Serializable en la clase que deseemos serializar. Se trata de una interfaz vaca, por lo que no hay operaciones que implementar

b) Para serializar el objeto crearamos un stream ObjectOutputStream y escribiramos el objeto mediante la operacin writeObject()

c) Para deserializar el objeto crearamos un stream ObjectInputStream, leeramos el objeto mediante readObject() y realizaramos un casting a la clase del objeto

Vamos a modificar ahora el constructor de la clase Cuenta y la operacin salvar() para que sean capaces de cargar y salvar el histrico de movimientos. La capacidad de serializacin de Java permite salvar la lista enlazada de un solo golpe.

import java.io.*; import java.util.*; // Es necesario que tanto las clases Cliente como Movimiento implementen la interfaz

// Serializable para que los objetos puedan ser escritos en disco class Movimiento implements Serializable { Date fecha;

char tipo;

float importe;

float saldo;

public Movimiento

(Date aFecha, char aTipo, float aImporte, float aSaldo) { fecha = aFecha;

tipo = aTipo;

importe = aImporte;

saldo = aSaldo;

} } //continua abajo

39


public class Cuenta { long numero;

Cliente titular;


float interesAnual;

LinkedList movimientos;

public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero;

titular = aTitular;

saldo = 0;


movimientos = new LinkedList(); }

Cuenta(long aNumero) throws FileNotFoundException, IOException, ClassNotFoundException { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(aNumero + ".cnt")); numero = ois.readLong(); titular = (Cliente) ois.readObject(); saldo = ois.readFloat(); interesAnual = ois.readFloat(); movimientos = (LinkedList) ois.readObject(); ois.close(); } void salvar() throws FileNotFoundException, IOException { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(numero + ".cnt")); oos.writeLong(numero); oos.writeObject(titular); oos.writeFloat(saldo); oos.writeFloat(interesAnual); oos.writeObject(movimientos); oos.close(); } // Resto de operaciones de la clase Cuenta a partir de aqu

40


UNIDAD III RELACIN ENTRE OBJETOS

OBJETIVO:

El objetivo de esta unidad es ofrecer un conjunto de saberes relacionados con los distintos tipos de relaciones que pueden surgir entre varios objetos, tales como dependencia, asociacin, agregacin, composicin y de las clases anidadas e interiores.

Al concluir, esta unidad el participante deber estar en la capacidad de realizar implementaciones entre clases a travs de sus relaciones, como por ejemplo, relacionar una clase cuenta bancaria con sus clientes y movimientos.

PUNTOS A TRATAR:

1. Relacin entre objetos 2. La dependencia entre objetos 3. La asociacin entre objetos 4. La agregacin entre objetos 5. La composicin entre objetos 6. Clases anidadas e interiores

RELACIN ENTRE OBJETOS JAVA 3

41


RELACIN ENTRE OBJETOS

Un conjunto de objetos aislados tiene escasa capacidad para resolver un problema. En una aplicacin real los objetos colaboran e intercambian informacin, existiendo distintos tipos de relaciones entre ellos

A nivel de diseo, podemos distinguir entre 5 tipos de relaciones bsicas entre clases de objetos:

dependencia, asociacin, agregacin, composicin y herencia

LA DEPENDENCIA ENTRE OBJETOS

La dependencia es la relacin menos importante. Simplemente refleja que la implementacin de una clase depende de otra

Una dependencia puede indicar la utilizacin de un objeto de una clase como argumento de una operacin de otra o en su implementacin.

La Dependencia corresponde a relacin "usa-un": Esta relacin generalmente se refleja en el uso de instancias de otras clases para cumplir los servicios o responsabilidades de una clase. Eje.: Un amplificador usa un parlante para emitir el sonido. Un Computador usa la red para enviar sus datos. Es decir si en nuestro diseo el Computador es el responsable de enviar los datos, entonces ste deber acceder a una instancia de Red para enviar los datos.

Como vimos anteriormente, la clase Cuenta requiere las clases FileOutputStream y ObjectOutputStream de la librera de clases de Java para la implementacin de la operacin salvar

Cuenta numero: Long titular: String saldo: Float intersAnual: Real +ingreso(cantidad: Integer) +reintegro(cantidad: Integer) +ingresoInteresMes() +enRojos(): Boolean +leerSaldo(): Integer

java.io.FileOutputStream

java.io.ObjectOutputStrea

42


LA ASOCIACIN ENTRE OBJETOS

En cambio, la asociacin es la relacin ms importante y comn. Refleja una relacin 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 relacin, el sentido de dicha relacin y las cardinalidades en los dos extremos

Vamos a sustituir el atributo titular por una asociacin con una nueva clase Cliente completa

Cuenta - numero: Long - titular: String - saldo: Float - intersAnual: Real +ingreso(cantidad: Integer) +reintegro(cantidad: Integer) +ingresoInteresMes() +enRojos(): Boolean +leerSaldo(): Integer

Cliente - nombres: String - apellidos: String - direccion: String - localidad: String - fnacimiento: Date +nombreCompleto(): String +direccionCompleta(): String

Una asociacin se implementa en Java introduciendo referencias a objetos una clase como atributos en la otra

Si la relacin tiene una cardinalidad superior a uno entonces ser necesario utilizar un array de referencias. Tambin es posible utilizar una estructura de datos dinmica del paquete java.util como Vector o LinkedList para almacenar las referencias

Normalmente la conexin entre los objetos se realiza recibiendo la referencia de uno de ellos en el constructor o una operacin ordinaria del otro

* 1

titular

43


public class Cliente { private String nombre, apellidos;

private String direccion, localidad;

private Date fNacimiento;

Cliente(String aNombre, String aApellidos, String aDireccion, String aLocalidad, Date aFNacimiento) { nombre = aNombre;

apellidos = aApellidos;

direccion = aDireccion;

localidad = aLocalidad;

fNacimiento = aFNacimiento;

} String nombreCompleto() { return nombre + + apellidos; } String direccionCompleta() { return direccion + , + localidad; } }





// Constructor general public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero;

titular = aTitular;

saldo = 0;


} Cliente leerTitular() { return titular; } // Resto de operaciones de la clase Cuenta a partir de aqu

Asociacin con la clase Cliente

44


LA AGREGACIN ENTRE OBJETOS

La agregacin es un tipo especial de asociacin donde se aade el matiz semntico de que la clase de donde parte la relacin representa el todo y las clases relacionadas las partes

Realmente Java y la mayora de lenguajes orientados a objetos no disponen de una implementacin especial para este tipo de relaciones. Bsicamente se tratan como las asociaciones ordinarias

Polgono

Segmento

Departamento

Despacho

LA COMPOSICIN ENTRE OBJETOS

La composicin es un tipo de agregacin que aade 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 destruccin

Supongamos que aadimos un registro de movimientos a la clase Cuenta, de forma que quede constancia tras cada ingreso o reintegro

Cuenta - numero: Long - titular: String - saldo: Float - intersAnual: Real +ingreso(cantidad: Integer) +reintegro(cantidad: Integer) +ingresoInteresMes() +enRojos(): Boolean +leerSaldo(): Integer

Cliente - nombres: String - apellidos: String - direccion: String - localidad: String - fnacimiento: Date +nombreCompleto(): String +direccionCompleta(): String

Movimiento fecha: Date tipo: Char importe: Real saldo: Real - fnacimiento: Date

2 *

1 *

formado por

dispone de

* 1

titular

registra

*

45


Las composiciones tienen una implementacin similar a las asociaciones, con la diferencia de que el objeto principal realizar en algn momento la construccin de los objetos compuestos

import java.util.Date class Movimiento { Date fecha;

char tipo;

float importe;

float saldo;

public Movimiento(Date aFecha,char aTipo,float aImporte,float aSaldo){ fecha = aFecha;

tipo = aTipo;

importe = aImporte;

saldo = aSaldo;

} }





private LinkedList movimientos; // Lista de movimientos // Constructor general public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero; titular = aTitular; saldo = 0;

interesAnual = aInteresAnual; movimientos = new LinkedList(); } // Nueva implementacin de ingreso y reintegro public void ingreso(float cantidad) { movimientos.add(new Movimiento(new Date(), 'I', cantidad, saldo += cantidad)); } public void reintegro(float cantidad) { movimientos.add(new Movimiento(new Date(), 'R', cantidad, saldo = cantidad)); } public void ingresoInteresMes() { ingreso(interesAnual * saldo / 1200); } // Resto de operaciones de la clase Cuenta a partir de aqu

Nota: tambin sera necesario modificar el otro constructor y la operacin salvar para tener en cuenta la lista de movimientos a la hora de leer/escribir la informacin de la Cuenta en disco

46


CLASES ANIDADAS E INTERIORES

Java y algunos otros lenguajes OOP permiten la definicin de una clase de objetos dentro de otra, con una doble utilidad:

1. Organizar mejor el cdigo. 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 esttica o no esttica y utilizar los niveles de proteccin public, private y protected

El tipo de clase anidamiento ms sencillo es aquel en que la clase contenida se declara como esttica

Desde el punto de vista de la organizacin del cdigo, tendra mucho ms sentido introducir la clase Movimiento en el interior de Cuenta. Al ser declarada como privada, se impedira su utilizacin desde el exterior

import java.util.Date public class Cuenta { private long numero;




private LinkedList movimientos; // Lista de movimientos

static private class Movimiento { Date fecha;

char tipo;

float importe;

float saldo;

public Movimiento(Date aFecha, char aTipo, float aImporte, float aSaldo){ fecha = aFecha; tipo = aTipo; importe = aImporte; saldo = aSaldo;

} } // Constructor general public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero; titular = aTitular; saldo = 0;


movimientos = new LinkedList(); } // Resto de operaciones de la clase Cuenta a partir de aqu

introduciendio la clase movimiento en el interior de la clase cuenta

47


Cuando la clase anidada no es esttica, se denomina clase interior y tiene caractersticas especiales:

1. Pueden ser creadas nicamente dentro de la clase continente 2. Tiene acceso completo y directo a todos los atributos y operaciones del objeto que realiza su

creacin

Los objetos de la clase interior quedan ligados permanentemente al objeto concreto de la clase continente que realiz su creacin.

No debe confundirse este elemento con la relacin de composicin, aunque en muchos casos es posible utilizar clases interiores para la implementacin 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.

import java.util.Date public class Cuenta { private long numero;



private LinkedList movimientos; // Lista de movimientos

private class Movimiento { Date fecha; char tipo; float importe, saldoMov;

public Movimiento(Date aFecha, char aTipo, float aImporte) { fecha = aFecha; tipo = aTipo; importe = aImporte;

saldoMov = saldo; // Copamos el saldo actual } } // Sigue la implementacin de la clase Cuenta

48


UNIDAD IV HERENCIA

Objetivo: El objetivo de esta unidad es ofrecer un conjunto de saberes relacionados con el mecanismo de herencia entre clases.

Al concluir esta unidad el participante deber estar en la capacidad de implementar herencia simple y mltiple entre clases, como por ejemplo: una clase cuenta corriente, una cuenta plazo fijo que heredan de una superclase genrica denominada cuenta, aparte de poder redefinir, anular, y adicionar la herencia, aparte de trabajar con clases abstractas, polimorfismo y ligadura dinmica.

Puntos a tratar:

1. La herencia 2. Mtodo Super() 3. Adicionar la herencia 4. Redefinir la herencia 5. Anular la herencia 6. Proteccin y herencia 7. Clases abstractas 8. Herencia mltiple 9. Polimorfismo 10. Ligadura dinmica

HERENCIA 4

49


LA HERENCIA

La herencia es un mecanismo de la OOP que permite construir una clase incorporando de manera implcita todas las caractersticas de una clase previamente existente. Las razones que justifican su necesidad son variadas:

1. Modelado de la realidad. Son frecuentes las relaciones de especializacin/generalizacin entre las entidades del mundo real, por tanto es lgico 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 repeticin de cdigo entre clases semejantes.

3. Facilitar la reutilizacin. Una clase no tiene por qu limitarse a recibir una serie de caractersticas de otra clase por herencia de forma pasiva. Tambin disponen de cierto margen de adaptacin de estas caractersticas

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

adems 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 adems

que B es una clase hija de A A

B

C

D

En Java, Eiffel, Smalltalk y otros lenguajes orientados a objetos puros, todas las clases heredan automticamente de una superclase universal. En Java esta superclase se denomina Object

50


Existen diferentes situaciones en las que puede aplicarse herencia: 1. Especializacin. Dado un concepto B y otro concepto A que representa una especializacin

de A, entonces puede establecerse una relacin 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

vehiculo

empleado

figura

coche

contable

cuadrado

2. Extensin. Una clase puede servir para extender la funcionalidad de una superclase sin que represente necesariamente un concepto ms especfico

lista

cuenta

lista salvable

recuperar() salvar()

CuentaConhistorico

movimiento fecha: date tipo: Char

importe: Real saldo: Real

3. Especificacin. Una superclase puede servir para especificar la funcionalidad mnima comn de un conjunto de descendientes. Existen mecanismos para obligar a la implementacin de una serie de operaciones en estos descendientes

ObjetoGrafico seleccionar()

mover() escalar()

cambiarColor()

texto

linea

cuadrado

registra *

51


Construccin. 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 conexin alguna

lista

pila

Ejemplos de herencia: Distintos tipos de cuentas bancarias:

cuenta

numero: Long titular: String saldo: Float interes: Float ingreso() ingresoInteresMes() leerSaldo() transferirHasta()

CuentaCorriente

reintegro()

CuentaAhorroPFijo vencimiento: Date

ingresoMes()

PlanPensiones vencimiento:Date cotizacion: Float

numCuentaOrigen: String

52


Vamos a estudiar la implementacin 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 peridicamente) y TPEjecucion (ejecucin de un comando cada cierto tiempo)

tareaPeriodica periodoSegs: Integer ultimaej: Date activa: Boolean periodoSegs: Integer +necesitaEjecucion(): Boolean +actualizarReloj() +ejecutarTarea() +activar() +desactivar()

TPReloj

+leerHora(): String

TPAviso msg: String

+leerMsg(): String

TPEjecucion cmd: String

+leerCmd(): String

53


La clase TareaPeriodica tiene las caractersticas comunes a los tres tipos de tarea:

1. Periodo de ejecucin en segundos, 2. Hora de la ltima ejecucin y 3. Bandera de estado activo/inactivo

import java.util.*; public class TareaPeriodica { int periodoSegs; // Periodo de ejecucin Date ultimaEj; // Hora de ltima ejecucin boolean activa;

public TareaPeriodica(int aPeriodoSegs) { periodoSegs = aPeriodoSegs;

actualizarReloj(); activa = true;

}

// Constructor para ejecuciones cada segundo public TareaPeriodica() { this(1); }

// Establecer la ltima ejecucin a la hora actual public void actualizarReloj() { ultimaEj = new Date(); // Hora actual }

public boolean necesitaEjecucion() { if (!activa) return false;

// Calcular la hora de la prxima ejecucin Calendar calProximaEj = new GregorianCalendar(); calProximaEj.setTime(ultimaEj); calProximaEj.add(Calendar.SECOND, periodoSegs); Calendar calAhora = new GregorianCalendar(); // Comprobar si ha pasado a la hora actual return (calProximaEj.before(calAhora)); } public void ejecutarTarea() {System.out.println("Ejecucion de tarea");} public void activar() { activa = true; } public void desactivar() { activa = false; } }

Nota: La operacin ejecutarTarea realmente no tiene una implementacin concreta a este nivel

54


Para que una clase herede de otra, utilizaremos el indicador extends en la declaracin de la clase

import java.util.Calendar; import java.util.GregorianCalendar; public class TPReloj extends TareaPeriodica { public TPReloj() { periodoSegs = 60; // Comprobar cada minuto actualizarReloj(); activa = true;

}

public String leerHora() { Calendar cal = new GregorianCalendar(); return cal.get(Calendar.HOUR_OF_DAY) + ":" + cal.get(Calendar.MINUTE); } }

Atencin: Aunque el cdigo de estas clases compila perfectamente, la implementacin de los constructores es formalmente incorrecta. Ms adelante veremos por qu.

public class TPAviso extends TareaPeriodica { String msg;

public TPAviso(String aMsg, int aPeriodoSegs) { periodoSegs = aPeriodoSegs;


msg = aMsg;

} public String leerMsg() { return msg; } }

import java.lang.Runtime; import java.io.IOException; public class TPEjecucion extends TareaPeriodica { String cmd;

public TPEjecucion(String aCmd, int aPeriodoSegs) { periodoSegs = aPeriodoSegs;


cmd = aCmd;

} String leerCmd() { return cmd; } }

55


Todas las clases en Java heredan en ltima instancia de Object. Incluso si creamos una clase independiente, Java la hace heredar implcitamente de Object

Esto hace que las clases formen una jerarqua con Object como raz

En la implementacin de una operacin de la subclase no existe diferencia aparente entre un atributo u operacin propia de la clase y un atributo u operacin 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 operacin heredada o propia de la clase:

public class AppGestorTareas { public static void main(String[] args) { TareaPeriodica tp = new TareaPeriodica(5); TPAviso tpa = new TPAviso(Estudiar Programacin Avanzada !, 60); while (!tp.necesitaEjecucion()) System.println(Esperando ejecucin de tarea peridica...); tp.ejecutarTarea(); while (!tpa.necesitaEjecucion()){ System.println(Esperando ejecucin de aviso...); System.println(Aviso: + tpa.leerMsg()); } }

Object #clone(): Object +equals(Object obj): Boolean #finalize() +getClass(): Class +hasCode(): int +notify() +notifyAll() +toString(): String +wait() +wait(timeout: Long) +wait(timeout: Long, nanos: Integer)

56


MTODO SUPER()

La inicializacin de los atributos de una superclase en el constructor de una subclase presenta varios inconvenientes serios:

Resulta redundante. La superclase tiene ya un constructor que hace ese trabajo. Por qu repetir cdigo entonces? Si la clase tiene una larga lista de ascendientes, entonces el constructor sera muy largo La superclase puede tener una inicializacin compleja, y la inclusin del cdigo de

inicializacin en la subclase puede requerir un conocimiento excesivo de la superclase por parte del implementador

public class TPAviso extends TareaPeriodica { String msg;

public TPAviso(String aMsg, int aPeriodoSegs) { periodoSegs = aPeriodoSegs;


msg = aMsg;


El procedimiento correcto consiste en realizar una llamada al constructor de la superclase para que realice la inicializacin de los atributos heredados

En Java esta llamada al constructor de la superclase se realiza con la operacion super() seguida de los parmetros de inicializacin de alguno de los constructores del padre de la clase

La implementacin correcta del constructor de la clase TPAviso sera por tanto la siguiente: public class TPAviso extends TareaPeriodica { String msg;

public TPAviso(String aMsg, int aPeriodoSegs) { super(aPeriodoSegs); msg = aMsg;


57


Y de las otras dos subclases:

import java.util.Calendar; import java.util.GregorianCalendar; public class TPReloj extends TareaPeriodica { public TPReloj() { super(60); } public String leerHora() { Calendar cal = new GregorianCalendar(); return cal.get(Calendar.HOUR_OF_DAY) + ":"

Manual Java

Documents

Transcript of Manual Java