PROGRAMACIN ORIENTADA A OBJETOS I INTRODUCCIN JAVA Empaquetado

PROGRAMACIÓN ORIENTADA A OBJETOS I INTRODUCCIÓN JAVA

Empaquetado de las características(atributos) y el comportamiento (método) en una definición(clase). Permite ocultar detalles ATRIBUTOS CLASE = + METODOS

Java utiliza las palabras claves public, protected y private para identificar diferentes niveles de encapsulamiento de un objeto. Definen el nivel de acceso a la clase, datos o métodos de la misma Objetos propiamente encapsulado: - atributos privados - métodos públicos

<modificador> class Nombre. De. Clase { // Cuerpo de La Clase. . . } public class Cuenta { // Cuepo de La Clase. . . }

<modificador> class Nombre. De. Clase { // Cuerpo de La Clase. . . } <modificador> class Nombre. De. Clase { // Atributos // Constructores //Métodos }

sintaxis para declarar un atributo de la clase [modificador] [cualificador] tipo_de_dato identificador public class Cuenta { private double saldo; private long nro. Cuenta; private Cliente titular; }

• Bloque de código especial que es ejecutado cuando un requerimiento especifico de creación de un objeto es invocado • Puede ser invocado una sola vez por el objeto. • Invocado varias veces por otros objetos crea diferentes instancias • Puede existir más de un constructor para un objeto • Tiene el mismo nombre que la clase. No forma parte del comportamiento del objeto No incluye tipo de retorno

$Sintaxis <modificador> nombre. Clase(tipo_de_Dato identificador, . . . ) { //instrucciones del cosntructor }$

Sintaxis <modificador> nombre. Clase(tipo_de_Dato identificador, . . . ) { //instrucciones del cosntructor } public class Cuenta { //Atributos private double saldo; private long nro. Cuenta; private Cliente titular; //Constructores public Cuenta() { } public Cuenta(long un. Nro) { } }

Tipos de métodos Accesor(“getters”) forma estándar de recuperar datos almacenados en atributos de un objeto. Mutadores(“setters”) forma estándar de almacenar datos en atributos de un objeto Métodos personalizados(“custom”) conjunto de instrucciones para realizar determinada tarea también denominamos métodos de negocio

Cada argumento de un método debe consistir de por lo menos el tipo de dato y el identificador. [modificador] [cualificador] tipo_de_retorno nombre. De. Metodo(tipo_de_Dato identificador, . . . ) { //instrucciones del método }

public class Cuenta { //Atributos private double saldo; private long nro. Cuenta; private Cliente titular; //Constructores public Cuenta() { } public Cuenta(long un. Nro) { } //Métodos public long get. Nor. Cuenta() { } public void depositar(double un. Monto) { } }

public class Cuenta { //Atributos private double saldo; private long nro. Cuenta; private Cliente titular; //Constructores public Cuenta() { } public Cuenta(long un. Nro) { nro. Cuenta = un. Nrocuenta; } public long get. Nor. Cuenta() { return nro. Cuenta } public void depositar(double un. Monto) { saldo += un. Monto } }

Herencia Mecanismo por el cual atributos y métodos son adquiridos desde una clase generalizada(suprclase) para ser utilizados en una clase más específica(subclase) relación “es un”

<modificador> class Nombre. De. Clase extends Nombre. Super Clase { // Cuerpo de La Clase. . . } public class Caja. Ahorro extends Cuenta { // Cuepo de La Clase. . . }

USO DE VARIABLES • Para que una variable esté disponible en un método debe: 1. Haber sido declarado como atributo de la clase 2. Ser recibido como argumento del método 3. Haber sido declarado como variable local al método • NOTA: Si ha sido declarado en la superclase, con el modificado de acceso “private”, el atributo no puede ser accedido directamente por ninguno método fuera del cuerpo de la clase donde fue declarado el atributo. En éste caso en las subclase se debe utilizar los métodos get y set declarados en la clase.

CLASE CONTENDORA public class Cajero { int nro; doble disponibilidad; Banco un. Banco; // etcétera }

CUSTODIA DE UN OBJETO • La custodia está relacionada con la propiedad de un objeto y las subsecuentes responsabilidades para destruir el objeto. • Composición: Todos los objetos están implícitamente en la custodia del objeto compuesto. • Asociación: Requiere que los ciclos de vida se solapen. El objeto creado tiene custodia y la custodia puede ser pasada. •

RELACIONES Asociación class Kitchen { Stove my. Stove; Refrigerator my. Refrigerator; public void set. Stove (Stove a. Stove) { my. Stove = a. Stove; } public void set. Refrigerator (Refrigerator a. Refrigerator) { my. Refrigerator = a. Refrigerator; } } Composición class Seat { //lo que la clase hace } class Wheel { // lo que la clase hace } class Frame { // lo que la clase hace } class Car { Seat my. Seat = new Seat(); Wheel my. Wheel = new Wheel(); Frame my. Frame = new Frame(); //etcétera }

CICLO DE VIDA DE UN OBJETO • El ciclo de vida de un objeto es el tiempo que va desde que se crea el objeto hasta que se destruye. • Los objetos compuestos tienen el mismo ciclo de vida • Los objetos asociados tienen ciclos de vida superpuestos

Estructuras de Control Selección If(condición) sentencia por verdadero; else sentencia por falso; If(condición){ sentencias por verdadero; }else{ sentencia por falso; } If(condición){ sentencia por verdadero; }else if(condición){ sentencia por falso; }else{ sentencia/s; } Ejemplo If(a>b) System. out. println( a + “>” + b); else System. out. println( a + “>” + b); If(a>100) System. out. println( a + “>” + 100); elseif(a>50){ b=a; System. out. println( a + “>” + b); }else c = a;

Estructuras de Control Selección Switch valor{ case cosntant sentencias; breack; default case cosntant sentencias; breack; } Ejemplo Switch valor{ case ‘A’ System. out. println(“Alta”); breack; case ‘B’ System. out. println(“Baja”); breack; case ‘Q’ System. out. println(“Salir”); breack; default System. out. println(“Error”); breack; }

Estructuras de Control Repetitivas - While - do while for while(condición) sentencia por verdadero; while(condición){ sentencias por verdadero; } do{ sentencia/s; }while(condición) for(inicial, condición, incremento) sentencia; for(inicial; condición; incremento){ sentencias; } Ejemplo While(a<100){ System. out. println(a); a++; } do{ System. out. println(a); a++; }while(a=101) for(int i = 0; i <=100; i++){ System. out. println(a); }

CLASE Y PAQUETES Un paquete es un conjunto de clases: se pueden importar import java. io. * import java. io. File. Not. Found. Exception class Manager { int employee. Number; String name; int department. Number; int extension. Number; int salary; int number. Of. Workers; // etcétera } se empaquetar package empresa. mi. Aplicacion import java. io. * import java. io. File. Not. Found. Exception class Manager { int employee. Number; String name; int department. Number; int extension. Number; int salary; int number. Of. Workers; // etcétera }

ATRIBUTO DE INSTANCIA Cada instancia hereda todos los atributos definidos en su clase. Cada instancia tiene su propia copia de atributos de instancia. R. A. M. heap nro. Cta = 248 Saldo = 940, 45 nro. Cta = 45 Saldo = 540, 45

MÉTODO DE INSTANCIA Son los servicios que necesitan de una instancias para poder ser convocados. R. A. M. cta 1. extraer(250); stack cta 1 Referencia a una instancia de la clase Cuenta Mensaje de instancia heap nro. Cta = 248 Saldo = 940, 45 cta 2 nro. Cta = 45 Saldo = 540, 45

ATRIBUTOS DE CLASE Son los atributos definidos en la clase cuyo valor es compartido por todas las instancia de la clase. No es necesario tener una instancia para tener static R. A. M. accesos al mismo. Iibb=0, 34 stack cta 1 heap nro. Cta = 248 Saldo = 940, 45 cta 2 nro. Cta = 45 Saldo = 540, 45

MÉTODO DE CLASE Son métodos que no necesitan de una instancia para ser convocados, el receptor del mensaje es la Clase. Los atributos y métodos de clases se definen usando el cualificador static R. A. M. Cuenta. set. IIBB(0, 35); stack cta 1 Clase Mensaje de Clase static Iibb=0, 34 heap nro. Cta = 248 Saldo = 940, 45 cta 2 nro. Cta = 45 Saldo = 540, 45

OBSERVACIONES En los métodos de instancias, se pueden referencias a los atributos de instancias y a los atributos de clases En los métodos de clases solo se pueden referencias a los atributos de clases Desde los métodos de instancias se puede convoca a métodos de instancia o métodos de clases En los métodos de clase solo se puede convocar a métodos de clase

Cualificador final El cualificador final utilizado en la definición de la clase private final class Nombre. De. La. Clase; Determina que esta clase no podrá tener sub clases. El cualificador final utilizado en la definición deun método private final void nombre. Metodo() {}; Determina que esté método no podrá ser sobreescrito en las subclases. El cualificador final y abstract son mutuamente excluyente

Cualificador final El cualificador final utilizado en la definición de un atributo private final atributo; Determina la creación de una constante. Una constante implica que como máximo este atributo puede tener una operación de asignación, la cual puede estar en: • Cuando se define el atributo • o en el constructor de la clase

Conversión de Tipos Primitivos Casting: Conversión entre tipos de datos Implícito: *Los dos tipos son compatibles. *El tipo de la variable destino es de un rango mayor al tipo de la variable que se va a convertir. int a = 4; long b = a; Explícito: *El tipo de la variable destino es de un rango menor al tipo de la variable que se va a convertir. long a = 4; int b = (int)a; NO ES POSIBLE HACER CASTING CON EL TIPO DE DATO boolean

CLASES ABSTRACTA E INTERFACE

CLASE ABSTRACTA Es una clase de la cual no se creará instantancia. Se la define utilizando el cualificador abstract Es una clase cuya descripción es incompleta. Declara métodos pero no lo implementa. Los métodos no implementados se deberán declara como abstracto Una clase con un método abstracto debe declararse como clase abstracta. Pero una clase puede ser abstracta aunque no tenga mátdos abstracto.

CLASE ABSTRACTA Las subclases de una clase abstracta deben: Sobreescribir todos los métodos abstractos de la superclase o bien Ser declaradas como clases abstractas Una clase abstracta puede incluir variables y métodos no abstractos No se pueden definir constructores abstractos o métodos estáticos abstractos

Clase Abstracta public abstract class Cuenta { /** * @attribute */ private String nro. Cta; /** * @attribute */ private double saldo; /** * @attribute */ private static double iibb; public Cuenta(String nro. Cta, doubel saldo) { } public Cuenta() { } public abstract void extraer(double un. Monto) ; }

Clase Abstracta public abstract class Cuenta { /** * @attribute */ private String nro. Cta; /** * @attribute */ private double saldo; /** * @attribute */ private static double iibb; public Cuenta(String nro. Cta, doubel saldo) { } public Cuenta() { } public abstract void extraer(double un. Monto) ; } public class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto) { double aux= 0; if((this. get. Saldo() -10)>= un. Monto) { aux = this. get. Saldo(); aux -= un. Monto; this. set. Saldo(aux); } } } public class Cta. Cte extends Cuenta { /** * @attribute */ private double descubierto; public void extraer(double un. Monto) { double aux= 0; if((this. get. Saldo() + this. descubierto) >= un. Monto) { aux = this. get. Saldo(); aux -= un. Monto; this. set. Saldo(aux); } } }

HERENCIA class Caja. Ahorro { private int nro; private double saldo; // etcétera } Genralización class Cuenta { private int nro; private double saldo; // etcétera } class Cuenta. Corriente { private int nro; private double saldo; private double descubierto; // etcétera }

HERENCIA class Cuenta { private int nro; private double saldo; // etcétera } Especialización class Caja. Ahorro extends Cuenta { // etcétera } Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; // etcétera }

CONSTRUCTORES - HERENCIA • Los constructores no son heredados, cada clase debe tener definido su constructor. • El constructor de una subclase, debe recibir como argumento los valores para sus atributos y lo que esta heredando. • Cada atributo debe ser inicializado con un constructor definido en la clase donde fueron declarados. • Un constructor de la subclase, convocará al constructor nulo de la superclase, si no se ha invocado en forma explícita • Es recomendable que los atributos se inicialicen en un solo constructor.

CONSTRUCTORES - HERENCIA Especialización class Cuenta { private int nro; private double saldo; public Cuenta(){} public Cuenta(int nro, doble saldo){ this. nro = nro; this. saldo= saldo; } } class Caja. Ahorro extends Cuenta { Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public Caja. Ahorro(){ } public Cuenta. Corriente(){} public Caja. Ahorro(int nro, double saldo){ public Cuenta. Corriente(int un. Nro, double un. Saldo, double descu){ super(nro, saldo); super(un. Nro, un. Saldo); this. descubierto = descu; } } } }

SOBREESCRITURA - HERENCIA class Cuenta { private int nro; private double saldo; public void extraer(double un. Monto){ this. saldo -= un. Monto; } } Especialización class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto){ if((saldo - un. Monto) >= 10) this. saldo -=un. Monto; } } Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public void extraer(double un. Monto){ if((this. saldo + this. descubierto) >= un. Monto) this. saldo -= un. Monto } }

SOBREESCRITURA - HERENCIA class Cuenta { private int nro; private double saldo; public void extraer(double un. Monto){ this. saldo -= un. Monto; } } Especialización Genera un error de Compilación class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto){ if((this. saldo - un. Monto) >= 10) this. saldo -=un. Monto; } } Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public void extraer(double un. Monto){ if((this. saldo + this. descubierto) >= un. Monto) this. saldo -= un. Monto } }

SOBREESCRITURA – HERENCIA – ALTERNATIVA 1 Variable Local: debe ser inicializada en forma explicita class Cuenta { private int nro; private double saldo; public void extraer(double un. Monto){ this. saldo -= un. Monto; } } Especialización class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto){ doube aux=0; if((this. get. Saldo() - un. Monto) >= 10) aux = this. get. Saldo(); aux -=un. Monto; this. set. Saldo(aux); } } Variable Local: recibidada como argumento. Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public void extraer(double un. Monto){ double aux=0; if((this. get. Saldo() + this. descubierto) >= un. Monto) aux = this. get. Saldo(); aux -= un. Monto; this. set. Saldo(aux); } }

SOBREESCRITURA – HERENCIA – ALTERNATIVA 2 class Cuenta { private int nro; private double saldo; public void extraer(double un. Monto){ this. saldo -= un. Monto; } } Especialización class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto){ if((this. get. Saldo() - un. Monto) >= 10) super. extraer(un. Monto); } } Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public void extraer(double un. Monto){ if((this. get. Saldo() + this. descubierto) >= un. Monto) super. extraer(un. Monto); } }

CLASE ABSTRACTA Especialización Public asbtract Class Cuenta { private int nro; private double saldo; public Cuenta(){} public Cuenta(int nro, doble saldo){ this. nro = nro; this. saldo= saldo; } public void extraer(double un. Monto){ this. saldo -= un. Monto; } } class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto){ if((this. get. Saldo() - un. Monto) >= 10) super. extraer(un. Monto); } } Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public void extraer(double un. Monto){ if((this. get. Saldo() + this. descubierto) >= un. Monto) super. extraer(un. Monto); } }

MÉTODOS ABSTRACTOS public asbtract class Cuenta { private int nro; private double saldo; public abstract void extraer(double un. Monto); } Especialización class Caja. Ahorro extends Cuenta { public void extraer(double un. Monto){ doube aux=0; if((this. get. Saldo() - un. Monto) >= 10) aux = this. get. Saldo(); aux -=un. Monto; this. set. Saldo(aux); } } Los métodos abstractos no tienen cuerpo Especialización class Cuenta. Corriente extends Cuenta { private double descubierto; public void extraer(double un. Monto){ double aux=0; if((this. get. Saldo() + this. descubierto) >= un. Monto) aux = this. get. Saldo(); aux -= un. Monto; this. set. Saldo(aux); } }

Clase Abstracta public class Cuenta { /**. . . */ private String nro. Cta; public class Caja. Ahorro extends Cuenta { public boolean puedo. Extraer(double un. Monto) { boolean retorno = false; if((this. get. Saldo() - 10)>= un. Monto) retorno = true; /**. . . */ private double saldo; /**. . . */ private static double iibb; public Cuenta(String nro. Cta, double saldo) {. . . public Cuenta() {. . . } public void extraer(double un. Monto) { if(this. puedo. Extraer(un. Monto)) saldo -= un. Monto; } return retorno; } } } public class Cta. Cte extends Cuenta { /** * @attribute */ private double descubierto; public boolean puedo. Extraer(double un. Monto) { boolean retorno = false; if(saldo >= un. Monto) retorno = true; public boolean puedo. Extraer(double un. Monto) { boolean retorno = false; if((this. get. Saldo() + this. descubierto)>= un. Monto) retorno = true; return retorno; }. . . } return retorno; } }

Herencia y Binding Dinámico

Herencia y Binding Dinámico static stack cta 1 Iibb=0, 34 heap nro. Cta = 248 Saldo = 940, 45 cta 2 nro. Cta = 45 Saldo = 540, 45 public static void main(String[] args) { Caja. Ahorro ct 1 = new Caja. Ahorro(940. 45, "248"); Cta. Cte ct 2 = new Cta. Cte(540. 45, "45", 500); ct 1. extraer(500); ct 2. extraer(250); } public static void main(String[] args) { Cuenta ct 1 = new Caja. Ahorro(940. 45, "248"); Cuenta ct 2 = new Cta. Cte(540. 45, "45", 500); ct 1. extraer(500); ct 2. extraer(250); }

Interface Un interface es parecido a una clase abstracta en Java, pero con las siguientes diferencias: - Todo método es abstracto y público sin necesidad de declararlo. Por lo tanto un interface en Java no implementa ninguno de los métodos que declara. - Los atributos del interface serán las atributo de clase. - Un interface se implementa (implements) no se extiende (extends) por sus subclases. - Una clase puede implementar más de un interfaz en Java, pero sólo puede extender una clase. Es lo más parecido que tiene Java a la herencia múltiple, que de clases normales está prohibida. - Podemos declarar variables del tipo de clase del interfaz, pero para inicializarlas tendremos que hacerlo de una clase que lo implemente.

Interface La principal diferencia entre interface y abstract es que un interfaz proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia public interface nombre_interface { tipo_retorno nombre_metodo ( lista_argumentos ) ; . . . }

Conversión de Tipos de Referencia Para poder hacer casting entre tipo de datos de referencia se debe cumplir que: Entre los tipos de datos exista una relación de jerarquía de clase O que uno se una interface y que la clase lo implemente. Para poder ejemplificar los conceptos de interface y Casting, vamos a presentar un ejemplo. Se implementará un modelo que permita modelar el funcionamiento de un arreglo ( estructura estática)

Ejemplo Características de los arreglos: • Tipos de Datos homogéneos • Tamaño estático. Operaciones: • Agregar un elemento • Eliminar un elemento • Buscar un elemento • Ordenar

Ejemplo - Solución Se define una clase que encapsula todo el funcionamientos y datos que debe mantener un arreglo, y una interface que será los elementos a ser agregados en el arreglo.

Ejemplo - Solución

Ejemplo - Solución El tipo de Dato determina si la operación es validad. La instancia busca en su clase la implementación

Ejemplo - Solución

COLLECTION

Collections Una colección ( a veces llamada contenedor) son objetos que agrupan multiples objetos en una unidad. Las coleccines son estructuras de datos dinámicas. El framework de Colecciones se encuenta en el paquete: java. util.

EL FRAMEWORK JAVA COLLECTIONS El framwork Java esta compuesto por un conjunto de Interface y clases para trabajar grupos de objetos El Framework provee: Interfaces: Representación de tipos de datos abstractos. Implementations: implementación concreta de las interfaces. Algorithms: métodos. Ordenar, buscar elementos, etc. .

LAS INTERFACES

COLLECTION INTERFACES Y CLASSES Collection List Set Sorted. Set Abstract. Collection Abstract. List Abstract. Sequential. List Linked. List Array. List Vector Hash. Set Tree. Set Linked. Tree. Set

MAP INTERFACES Y CLASSES Map Sorted. Map Abstract. Map Hash. Map Linked. Hash. Map Tree. Map

SETS Un colección de items único, no permite items repetidos Lists • Los elementos de la lista estan ordenados – Por el orden de inserción, – Por críterio. • Una lista contiene elementos repetidos

MAPS Es un set de pares Cada par representa un mapeo direccional desde objeto (la clave) a otro objetos (el valor) EL uso tipico de un Map es proveer un acceso al valor por medio de la clave

COLLECTION FRAMEWORK La interface Collection es grupo de objetos, que permite duplicados Set extends Collection pero no permite duplicados List extends Collection y permite duplicado y es indexado Map No extiende de Collection

THE COLLECTION INTERFACE Collection // Basic Operations size(): int; is. Empty(): boolean; contains(Object): boolean; add(Object): boolean; // Optional remove(Object): boolean; // Optional iterator(): Iterator; // Bulk Operations contains. All(Collection): boolean; add. All(Collection): boolean; // remove. All(Collection): boolean; // retain. All(Collecton): boolean; // clear(): void; // // Array Operations to. Array(): Object[]; to. Array(Object[]): Object[]; Optional

LIST INTERFACE List // Positional Access get(int): Object; set(int, Object): Object; add(int, Object): void; remove(int index): Object; add. All(int, Collection): boolean; // Search int index. Of(Object); int last. Index. Of(Object); // Iteration list. Iterator(): List. Iterator; list. Iterator(int): List. Iterator; // Range-view List sub. List(int, int): List; // // Optional

MAP INTERFACE Map // Basic Operations put(Object, Object): Object; get(Object): Object; remove(Object): Object; contains. Key(Object): boolean; contains. Value(Object): boolean; size(): int; is. Empty(): boolean; // Bulk Operations void put. All(Map t): void; void clear(): void; // Collection Views key. Set(): Set; values(): Collection; entry. Set(): Set;

ITERATOR Un objeto que implementa la interface. Iterator genera a serie de elementos uno a la vez El método next() retorna el siguiente elemento de la serie. El método remove() elimina de la colección el último elemento retornado por next(). Iterator has. Next(): boolean; next(): Object; remove(): void;

LISTITERATOR La interface List. Iterator extends Iterator Es posible moverse en ambas direcciones en la serie List. Iterator esta disponible para Lists, particularmente en la implementación Linked. List. Iterator has. Next(): boolean; next(): Object; has. Previous(): boolean; previous(): Object; next. Index(): int; previous. Index(): int; remove(): void; set(Object o): void; add(Object o): void;

IMPLEMENTATION CLASSES Interface Set Implementation Hash. Set List Map Tree. Set Array. List Hash. Map Historical Linked. List Tree. Map Vector Stack Hash. Table Properties

OPERACINES Operación Collection Map Declarar Collection mi. Coleccion; List mi. List; Set mi. Set; Linked. List mi. Coleccion Map mi. Coleccion; Hash. Map mi. Coleccion; Crear mi. Coleccion = new Linked. List(); mi. Colección = Hash. Set(); mi. Set = new Tree. Set(); mi. Coleccion = new Hash. Map(); Agregar un Elemento Collection add(Object ob) mi. Coleccion. add(un. Objeto); Lista add(int index, Object a. Object) mi. Coleccion. add(i, un. Objeto) put(Object clave, Object valor) mi. Coleccion. put(una. Clave, un. Objeto)

OPERACINES Operación Agregar varios elementos Eliminar un Elemento Eliminar Varios Elementos Collection Map Collection add. All(Collection una. Coleccion) mi. Coleccion. add. All(una. Coleccion); List add. All(int i, Collection cols) mi. List. add. All(i, una. Coleccion) put. All(Map un. Map) Collection remove(Object a. Object) mi. Coleccion. remove(un. Objeto) List remove(int i) mi. List. remove(i); remove(object clave) remove. All(Collection a. Collection) mi. Collection. remove. All(una. Cols) mi. Coleccion. put. All(un. Map); mi. Coleccion. remove(clave)

OPERACINES Operación Recuperar un Elemento Información Collection Map Collection Utilizando el Iterator List get(int index) Object un. Obj = mi. Collection. get(i) get(Object clave) contains(Object un. Objeto): boolean size(): int is. Empty(): boolean contain. All(Collection una. Coleccion) contains. Key(Object clave) : boolean contains. Value(Object value): boolean is. Empty(): boolean size(): int un. Obj = micoleccion. get(clave);

EJEMPLO

EMPRESA - COLLECTION

EJEMPLO – EMPRESA - MAP

EJEMPLO – EMPRESA - SET La colección de tipo set no permite elementos repetidos, por lo que hay que Sobre escribir el método equals.

EMPRESA - SET Hash. Set

EMPRESA - SET ORDENADOS Es Necesario que la clase de las instancia que va a ser agregada a la colección Implemente la interface Comparable

EMPRESA - SET Tree. Set

EXCEPTION “UN ERROR EN TIEMPO DE EJECUCIÓN QUE CORTA EL FLUJO NORMAL DE EJECUCIÓN. ”

Exception Object Throwable Error Exception Runtime Exception

EXCEPTION Throws Throw Try{} catch{} Try{ Bloque de codigo que puede generar una exception } catch{Exception 1 id 1} {bloque de codigo} catch{Exception 2 id 1} {bloque de codigo} finally() { }

Exception Definir Exception propias 1. - Crear un clase que extienda de Exeption public class Cuenta. Exception extends Exception { public Cuenta. Exception(String mensaje) { super(mensaje); 2. - Crear la clase que } genere la Exception } 3. - Usar el método que puede generar la Exception public static void main(String[] args) { Cuenta ct 1 = new Caja. Ahorro(940. 45, "248"); Cuenta ct 2 = new Cta. Cte(540. 45, "45", 500); try{ ct 1. extraer(500); }catch (Cuenta. Exception exp) { System. out. println(exp. get. Message()); } } public class Cuenta { public void extraer(double un. Monto) throws Cuenta. Exception { Cuenta. Exception if(this. puedo. Extraer(un. Monto)) saldo -= un. Monto; else throw new Cuenta. Exception("Saldo Insuficiente"); }