Download - 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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
UNIDAD VIII .................................................................................................................................. 148 EJERCICIOS ............................................................................................................................. 148
Orientacin a Objetos............................................................................................................. 149 Herencia................................................................................................................................. 149
Concurrencia. Hilos ................................................................................................................ 149 Ejercicios resueltos ................................................................................................................ 152
-
4
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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.
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
class Cuenta { long numero;
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
class Cuenta { long numero;
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; }}
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
class Cuenta { long numero;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
class Cuenta { long numero;
String titular;
private float saldo;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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;
private float saldo;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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;
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+ public boolean enRojos() { return saldo < public float leerSaldo() { return saldo; }}
JG Tecnologas MANUAL JAVA jgtecnologias.com
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;
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; }
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
public class Cuenta { private long numero;
private String titular;
private float saldo;
private float interesAnual;
//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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
Ejemplo: Inicializacin y Finalizacin
// Importar todas las clases del paquete java.io import java.io.*; public class Cuenta { private long numero;
private String titular;
private float saldo;
private float interesAnual;
//Constructor general Cuenta(long aNumero, String aTitular, float aInteresAnual){ numero = aNumero;
titular = aTitular;
saldo = 0;
interesAnual = aInteresAnual;
} // 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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
Ejemplo: Inicializacin y Finalizacin
// Constructor general public Cuenta(long aNumero,String aTitular,float aInteresAnual){ numero = aNumero;
titular = aTitular;
saldo = 0;
interesAnual = aInteresAnual;
} // 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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
public class Cuenta { private long numero;
private Cliente titular;
private float saldo, interesAnual;
public void ingresoInteresMes() { this.ingreso(interesAnual * saldo / 1200); } // Resto de las operaciones de la clase Cuenta
-
32
JG Tecnologas MANUAL JAVA jgtecnologias.com
En este ejemplo, el uso de this es realmente til. Nos permite implementar la operacin transferirDesde() llamando a una operacin transferirHasta(), previamente implementada
public class Cuenta { private long numero;
private Cliente titular;
private float saldo, interesAnual;
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;
private Cliente titular;
private float saldo, interesAnual;
// Constructor general public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero; titular = aTitular; saldo = 0;
interesAnual = aInteresAnual;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
Nota: Las clases que constituyen una aplicacin Java tambin pueden distribuirse de manera mucho ms compacta en un nico fichero JAR.
-
35
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
public class Cuenta { long numero;
Cliente titular;
private float saldo;
float interesAnual;
LinkedList movimientos;
public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero;
titular = aTitular;
saldo = 0;
interesAnual = aInteresAnual;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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; } }
public class Cuenta { private long numero;
private Cliente titular;
private float saldo;
private float interesAnual;
// Constructor general public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) { numero = aNumero;
titular = aTitular;
saldo = 0;
interesAnual = aInteresAnual;
} Cliente leerTitular() { return titular; } // Resto de operaciones de la clase Cuenta a partir de aqu
Asociacin con la clase Cliente
-
44
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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;
} }
public class Cuenta { private long numero;
private Cliente titular;
private float saldo;
private float interesAnual;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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 Cliente titular;
private float saldo;
private float interesAnual;
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;
interesAnual = aInteresAnual;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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 Cliente titular;
private float saldo, interesAnual;
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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;
actualizarReloj(); activa = true;
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;
actualizarReloj(); activa = true;
cmd = aCmd;
} String leerCmd() { return cmd; } }
-
55
JG Tecnologas MANUAL JAVA jgtecnologias.com
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
JG Tecnologas MANUAL JAVA jgtecnologias.com
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;
actualizarReloj(); activa = true;
msg = aMsg;
} public String leerMsg() { return msg; } }
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;
} public String leerMsg() { return msg; } }
-
57
JG Tecnologas MANUAL JAVA jgtecnologias.com
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) + ":"