Está en la página 1de 98

PROGRAMACIN AVANZADA

Empaquetado de las caractersticas(atributos) y el comportamiento


(mtodo) en una definicin(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 mtodos de la misma
Objetos propiamente encapsulado:
- atributos privados
- mtodos pblicos

modificador

clase

private

protected
public
default
Calificador

La clase puede ser


convocada desde
cualquier paquete
La clase puede ser
convocada por otra del
mismo paquete
clase

static

final

La clase no puede tener


subclases.

atributos
Solo mtodos definido
en la clase tiene acceso a
estos atributos. No se
heredan
Tiene acceso las clases
del mismo paquete y las
subcalse
Se puede acceder al
atributo desde fuera de
la clase
Las clase del mismo
paquete pueden acceder
al atributo

mtodos
solo puede ser
convocado desde un
mtodo definido en la
clase. No se heredan
Tiene acceso las clases
del mismo paquete y las
subcalse
Se puede accede al
mtodo desde fuera de la
clase
Las clase del mismo
paquete pueden acceder
al atributo

atributos
El atributo es de clase.
Todas las instancia de la
clase lo comparten

mtodos
El mtodo es de clase.
No se necesita una
instancia para
convocarlo
El mtodo no puede ser
redefinido en la subclase

El atributo es una
constante

<modificador> class NombreDeClase


{
// Cuerpo de La Clase ...
}

Cuenta
saldo : double
nrocuenta : long
titular : Cliente
getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double) : void
extraer(unMonto : double) : void

public class Cuenta


{
// Cuepo de La Clase ...
}

<modificador> class NombreDeClase


{
// Cuerpo de La Clase ...
}
<modificador> class
NombreDeClase
{
// Atributos
// Constructores
//Mtodos
}

sintaxis para declarar un atributo de la clase

[modificador] [cualificador] tipo_de_dato identificador


Cuenta
saldo : double
nrocuenta : long
titular : Cliente
getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double) : void
extraer(unMonto : double) : void

public class Cuenta


{
private double saldo;
private long nroCuenta;
private Cliente titular;
}

Bloque

de cdigo especial que es ejecutado cuando un requerimiento


especifico de creacin de un objeto es invocado
Puede

ser invocado una sola vez por el objeto.

Invocado
Puede
Tiene

varias veces por otros objetos crea diferentes instancias

existir ms de un constructor para un objeto

el mismo nombre que la clase.


No forma parte del comportamiento del objeto
No incluye tipo de retorno

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

Cuenta
saldo : double
nrocuenta : long
titular : Cliente

public class Cuenta


{
//Atributos
private double saldo;
private long nroCuenta;
private Cliente titular;
//Constructores
public Cuenta()
{
}

getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double) : void
extraer(unMonto : double) : void

public Cuenta(long unNro)


{
}
}

Tipos de mtodos
Accesor(getters)
forma estndar de recuperar datos almacenados en atributos de un objeto.

Mutadores(setters)
forma estndar de almacenar datos en atributos de un objeto

Mtodos personalizados(custom)
conjunto de instrucciones para realizar determinada tarea tambin
denominamos mtodos de negocio

Cada argumento de un mtodo debe consistir de por lo menos


el tipo de dato y el identificador.
[modificador] [cualificador] tipo_de_retorno nombreDeMetodo(tipo_de_Dato
identificador,tipo_de_Dato identificador, ...)
{
//instrucciones del mtodo
}

Cuenta

public class Cuenta


{
//Atributos
private double saldo;
private long nroCuenta;
private Cliente titular;

saldo : double
nrocuenta : long
titular : Cliente

//Constructores
public Cuenta()
{
}

getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double) : void
extraer(unMonto : double) : void

public Cuenta(long unNro)


{
}

//Mtodos
public long getNorCuenta()
{
}
public void depositar(double
unMonto)
{
}
}

Cuenta

public class Cuenta


{
//Atributos
private double saldo;
private long nroCuenta;
private Cliente titular;

saldo : double
nrocuenta : long
titular : Cliente

//Constructores
public Cuenta()
{
}

getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double) : void
extraer(unMonto : double) : void

public Cuenta(long unNro)


{
nroCuenta = unNrocuenta;
}

public long getNorCuenta()


{
return nroCuenta
}
public void depositar(double unMonto)
{
saldo += unMonto
}

Herencia
Mecanismo por el cual atributos y mtodos son adquiridos desde una
clase generalizada(suprclase) para ser utilizados en una clase ms
especfica(subclase)
relacin es un
Cuenta
saldo : double
nroCuenta : long
titular : Cliente
Cuenta()
Cuenta(unNro : long)
getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double)

es un
CajaAhorro
maximaExtraciones : int
extraccionesRealizadas : int
CajaAhorro()
CajaAhorro(unNrocta : long, nroMax : int)
extraer(unMonto : double)

CuentaEspecial
depositar(unMonto : double)

<modificador> class NombreDeClase extends


NombreSuper Clase
{
// Cuerpo de La Clase ...
}
Cuenta
saldo : double
nroCuenta : long
titular : Cliente

Cuenta()
Cuenta(unNro : long)
getNroCuenta() : long
getSaldo() : double
depositar(unMonto : double)

CajaAhorro
maximaExtraciones : int
extraccionesRealizadas : int
CajaAhorro()
CajaAhorro(unNrocta : long, nroMax : int)
extraer(unMonto : double)

public class CajaAhorro extends Cuenta


{
// Cuepo de La Clase ...
}
CuentaEspecial

depositar(unMonto : double)

Para que una variable est disponible en un mtodo debe:


1. Haber sido declarado como atributo de la clase
2. Ser recibido como argumento del mtodo
3. Haber sido declarado como variable local al mtodo

NOTA: Si ha sido declarado en la superclase, con el modificado de


acceso private, el atributo no puede ser accedido directamente por
ninguno mtodo fuera del cuerpo de la clase donde fue declarado el
atributo. En ste caso en las subclase se debe utilizar los mtodos
get y set declarados en la clase.

public class Cajero


{
int nro;
doble disponibilidad;
Banco unBanco;
// etctera
}

La

custodia est relacionada con la propiedad de un objeto y las


subsecuentes responsabilidades para destruir el objeto.
Composicin:

Todos los objetos estn implcitamente en la


custodia del objeto compuesto.
Asociacin:

Requiere que los ciclos de vida se solapen. El objeto


creado tiene custodia y la custodia puede ser pasada.

Asociacin
class Kitchen
{
Stove myStove;
Refrigerator myRefrigerator;
public void setStove (Stove aStove)
{
myStove = aStove;
}
public void setRefrigerator (Refrigerator
aRefrigerator)
{
myRefrigerator = aRefrigerator;
}
}

Composicin
class Seat
{
//lo que la clase hace
}
class Wheel
{
// lo que la clase hace
}
class Frame
{
// lo que la clase hace
}
class Car
{
Seat mySeat = new Seat();
Wheel myWheel = new Wheel();
Frame myFrame = new Frame();
//etctera
}

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
Seleccin
If(condicin)
sentencia por verdadero;
else
sentencia por falso;
If(condicin){
sentencias por verdadero;
}else{
sentencia por falso;
}
If(condicin){
sentencia por verdadero;
}else if(condicin){
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
Seleccin
Switch valor{
case cosntant
sentencias;
breack;
case cosntant
sentencias;
breack;
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(condicin)
sentencia por verdadero;
while(condicin){
sentencias por verdadero;
}
do{
sentencia/s;
}while(condicin)
for(inicial,condicin,incremento)
sentencia;
for(inicial;condicin;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);
}

Un paquete es un conjunto de clases:

se pueden importar
import java.io.*
import java.io.FileNotFoundException
class Manager
{
int employeeNumber;
String name;
int departmentNumber;
int extensionNumber;
int salary;
int numberOfWorkers;
// etctera
}

se empaquetar
package empresa.miAplicacion
import java.io.*
import java.io.FileNotFoundException
class Manager
{
int employeeNumber;
String name;
int departmentNumber;
int extensionNumber;
int salary;
int numberOfWorkers;
// etctera
}

Cada instancia hereda todos los atributos


definidos en su clase.
Cada instancia tiene su propia copia de
atributos de instancia.
R.A.M.

heap
nroCta = 248
Saldo = 940,45

nroCta = 45
Saldo = 540,45

Son los servicios que necesitan de una


instancias para poder ser convocados.
R.A.M.

cta1.extraer(250);

stack
cta1

Referencia a
una instancia
de la clase
Cuenta

Mensaje de
instancia

heap
nroCta = 248
Saldo = 940,45

cta2
nroCta = 45
Saldo = 540,45

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 accesos al mismo.
static
R.A.M.

Iibb=0,34

stack
cta1

heap
nroCta = 248
Saldo = 940,45

cta2
nroCta = 45
Saldo = 540,45

Son mtodos que no necesitan de una


instancia para ser convocados, el receptor
del mensaje es la Clase. Los atributos y
mtodos de clases se definen usando el
cualificador static
static
R.A.M.
Iibb=0,34

Cuenta.setIIBB(0,35);

stack
cta1

Clase

Mensaje de
Clase

heap
nroCta = 248
Saldo = 940,45

cta2
nroCta = 45
Saldo = 540,45

En los mtodos de instancias, se pueden


referencias a los atributos de instancias y
a los atributos de clases
En los mtodos de clases solo se pueden
referencias a los atributos de clases
Desde los mtodos de instancias se puede
convoca a mtodos de instancia o
mtodos de clases
En los mtodos de clase solo se puede
convocar a mtodos de clase

Cualificador final
El cualificador final utilizado en la definicin de la clase
private final class NombreDeLaClase;
Determina que esta clase no podr tener sub clases.
El cualificador final utilizado en la definicin deun mtodo
private final void nombreMetodo() {};
Determina que est mtodo no podr ser sobreescrito en las
subclases.
El cualificador final y abstract son mutuamente excluyente

Cualificador final
El cualificador final utilizado en la definicin de un atributo
private final atributo;
Determina la creacin de una constante.
Una constante implica que como mximo este atributo puede tener
una operacin de asignacin, la cual puede estar en:
Cuando

se define el atributo
o en el constructor de la clase

Cualificador final
El cualificador final utilizado en la definicin de un atributo
private final atributo;
Determina la creacin de una constante.
Una constante implica que como mximo este atributo puede tener
una operacin de asignacin, la cual puede estar en:
Cuando

se define el atributo
o en el constructor de la clase

Conversin de Tipos Primitivos


Casting: Conversin entre tipos de datos
Implcito:
*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;

Explcito:
*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

Es una clase de la cual no se crear


instantancia. Se la define utilizando el
cualificador abstract
Es una clase cuya descripcin es
incompleta. Declara mtodos pero no lo
implementa.

Los mtodos no implementados se debern


declara como abstracto
Una clase con un mtodo abstracto debe
declararse como clase abstracta. Pero una
clase puede ser abstracta aunque no tenga
mtdos abstracto.

Las subclases de una clase abstracta


deben:

Sobreescribir todos los mtodos abstractos de la


superclase o bien
Ser declaradas como clases abstractas

Una clase abstracta puede incluir


variables y mtodos no abstractos
No se pueden definir constructores
abstractos o mtodos estticos
abstractos

Clase Abstracta
public abstract class Cuenta {
/**
* @attribute
*/
private String nroCta;
/**
* @attribute
*/
private double saldo;
/**
* @attribute
*/
private static double iibb;
public Cuenta(String nroCta, doubel saldo) {
}
public Cuenta() {
}
public abstract void extraer(double unMonto) ;
}

Clase Abstracta
public abstract class Cuenta {
/**
* @attribute
*/
private String nroCta;
/**
* @attribute
*/
private double saldo;
/**
* @attribute
*/
private static double iibb;
public Cuenta(String nroCta, doubel saldo) {
}
public Cuenta() {
}
public abstract void extraer(double unMonto) ;
}

public class CajaAhorro extends Cuenta {


public void extraer(double unMonto) {
double aux= 0;
if((this.getSaldo() -10)>= unMonto) {
aux = this.getSaldo();
aux -= unMonto;
this.setSaldo(aux);
}
}
}
public class CtaCte extends Cuenta {
/**
* @attribute
*/
private double descubierto;
public void extraer(double unMonto) {
double aux= 0;
if((this.getSaldo() + this.descubierto) >=
unMonto) {
aux = this.getSaldo();
aux -= unMonto;
this.setSaldo(aux);
}
}
}

class CajaAhorro
{
private int nro;
private double saldo;
// etctera
}

Genralizacin

class Cuenta
{
private int nro;
private double saldo;
// etctera
}

class CuentaCorriente
{
private int nro;
private double saldo;
private double descubierto;
// etctera
}

class Cuenta
{
private int nro;
private double saldo;
// etctera
}

Especializacin

class CajaAhorro extends Cuenta


{
// etctera
}

Especializacin

class CuentaCorriente extends Cuenta


{
private double descubierto;
// etctera
}

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 explcita
Es

recomendable que los atributos se inicialicen en un solo


constructor.

class Cuenta
{
private int nro;
private double saldo;
public Cuenta(){}
public Cuenta(int nro,doble saldo)
{
this.nro = nro;
this.saldo= saldo;

Especializacin

}
}

class CajaAhorro extends Cuenta


{

Especializacin

class CuentaCorriente extends Cuenta


{
private double descubierto;

public CajaAhorro(){
}
public CuentaCorriente(){}
public CajaAhorro(int nro,double saldo){ public CuentaCorriente(int unNro,double unSaldo,double descu)
super(nro,saldo);
{
super(unNro,unSaldo);
}
this.descubierto = descu;
}
}

class Cuenta
{
private int nro;
private double saldo;
public void extraer(double unMonto)
{
this.saldo -= unMonto;
}
}

Especializacin

class CajaAhorro extends Cuenta


{
public void extraer(double unMonto){
if((saldo - unMonto) >= 10)
this.saldo -=unMonto;
}
}

Especializacin

class CuentaCorriente extends Cuenta


{
private double descubierto;
public void extraer(double unMonto){
if((this.saldo + this.descubierto) >= unMonto)
this.saldo -= unMonto
}
}

class Cuenta
{
private int nro;
private double saldo;
public void extraer(double unMonto)
{
this.saldo -= unMonto;
}
}

Especializacin

Genera un error
de Compilacin

class CajaAhorro extends Cuenta


{
public void extraer(double unMonto){
if((this.saldo - unMonto) >= 10)
this.saldo -=unMonto;
}
}

Especializacin

class CuentaCorriente extends Cuenta


{
private double descubierto;
public void extraer(double unMonto){
if((this.saldo + this.descubierto) >= unMonto)
this.saldo -= unMonto
}
}

class Cuenta
{
private int nro;
private double saldo;
public void extraer(double unMonto)
Variable Local: debe
ser inicializada en
forma explicita

Especializacin

{
this.saldo -= unMonto;
}
}

Variable Local:
recibidada como
argumento.

Especializacin

class CuentaCorriente extends Cuenta


class CajaAhorro extends Cuenta
{
{
private double descubierto;
public void extraer(double unMonto){
public void extraer(double unMonto){
doube aux=0;
double aux=0;
if((this.getSaldo() - unMonto) >= 10)
if((this.getSaldo() + this.descubierto) >= unMonto)
aux = this.getSaldo();
aux = this.getSaldo();
aux -=unMonto;
aux -= unMonto;
this.setSaldo(aux);
this.setSaldo(aux);
}
}
}
}

class Cuenta
{
private int nro;
private double saldo;
public void extraer(double unMonto)
{
this.saldo -= unMonto;
}
}

Especializacin

Especializacin

class CuentaCorriente extends Cuenta


class CajaAhorro extends Cuenta
{
{
private double descubierto;
public void extraer(double unMonto){
public void extraer(double unMonto){
if((this.getSaldo() - unMonto) >= 10)
if((this.getSaldo() + this.descubierto) >= unMonto)
super.extraer(unMonto);
super.extraer(unMonto);
}
}
}
}

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 unMonto)
{
this.saldo -= unMonto;

Especializacin

}
}

class CajaAhorro extends Cuenta


{
public void extraer(double unMonto){
if((this.getSaldo() - unMonto) >= 10)
super.extraer(unMonto);
}
}

Especializacin
class CuentaCorriente extends Cuenta
{
private double descubierto;
public void extraer(double unMonto){
if((this.getSaldo() + this.descubierto) >= unMonto)
super.extraer(unMonto);
}
}

public asbtract class Cuenta


{
private int nro;
private double saldo;
public abstract void extraer(double unMonto);

Los mtodos
abstractos no
tienen cuerpo

Especializacin

Especializacin

class CuentaCorriente extends Cuenta


class CajaAhorro extends Cuenta
{
{
private double descubierto;
public void extraer(double unMonto){
public void extraer(double unMonto){
doube aux=0;
double aux=0;
if((this.getSaldo() - unMonto) >= 10)
if((this.getSaldo() + this.descubierto) >= unMonto)
aux = this.getSaldo();
aux = this.getSaldo();
aux -=unMonto;
aux -= unMonto;
this.setSaldo(aux);
this.setSaldo(aux);
}
}
}
}

Clase Abstracta
public class Cuenta {
/** ... */
private String nroCta;

public class CajaAhorro extends Cuenta {


public boolean puedoExtraer(double unMonto) {
boolean retorno = false;
if((this.getSaldo() - 10)>= unMonto)
retorno = true;

/**...*/
private double saldo;
/**...*/
private static double iibb;
public Cuenta(String nroCta, double saldo) {...
public Cuenta() {...

public void extraer(double unMonto) {


if(this.puedoExtraer(unMonto))
saldo -= unMonto;
}

return retorno;
}

}
}
public class CtaCte extends Cuenta {
/**
* @attribute
*/
private double descubierto;

public boolean puedoExtraer(double unMonto) {


boolean retorno = false;
if(saldo >= unMonto)
retorno = true;

public boolean puedoExtraer(double unMonto) {


boolean retorno = false;
if((this.getSaldo() + this.descubierto)>= unMonto)
retorno = true;

return retorno;
}
...
}

return retorno;
}
}

Herencia y Binding Dinmico

Herencia y Binding Dinmico


static
stack
cta1

Iibb=0,34

heap
nroCta = 248
Saldo = 940,45

cta2
nroCta = 45
Saldo = 540,45

public static void main(String[] args) {


CajaAhorro ct1 = new CajaAhorro(940.45,"248");
CtaCte ct2 = new CtaCte(540.45,"45",500);
ct1.extraer(500);
ct2.extraer(250);
}

public static void main(String[] args) {


Cuenta ct1 = new CajaAhorro(940.45,"248");
Cuenta ct2 = new CtaCte(540.45,"45",500);
ct1.extraer(500);
ct2.extraer(250);
}

Interface
Un interface es parecido a una clase abstracta en Java, pero con las
siguientes diferencias:
- Todo mtodo es abstracto y pblico sin necesidad de declararlo. Por
lo tanto un interface en Java no implementa ninguno de los
mtodos que declara.
- Los atributos del interface sern las atributo de clase.
- Un interface se implementa (implements) no se extiende (extends) por
sus subclases.
- Una clase puede implementar ms de un interfaz en Java, pero slo
puede extender una clase. Es lo ms parecido que tiene Java a la
herencia mltiple, 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 encapsulacin de los protocolos de los mtodos sin forzar al
usuario a utilizar la herencia

public interface nombre_interface {


tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}

Conversin 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 relacin de jerarqua 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 esttica)

Ejemplo
Caractersticas de los arreglos:
Tipos de Datos homogneos
Tamao esttico.
Operaciones:
Agregar un elemento
Eliminar un elemento
Buscar un elemento
Ordenar

Ejemplo - Solucin
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 - Solucin

Ejemplo - Solucin

Ejemplo - Solucin

Ejemplo - Solucin

Ejemplo - Solucin

Ejemplo - Solucin

Ejemplo - Solucin

Ejemplo - Solucin
El tipo de Dato determina si la operacin
es validad.
La instancia busca en su clase la
implementacin

Ejemplo - Solucin

Ejemplo - Solucin

Ejemplo - Solucin

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

El framwork Java esta compuesto por


un conjunto de Interface y clases para
trabajar grupos de objetos
El Framework provee:

Interfaces: Representacin de tipos de


datos abstractos. Implementations:
implementacin concreta de las interfaces.
Algorithms: mtodos . Ordenar, buscar
elementos, etc..

Collection
List

Set
SortedSet
AbstractCollection

AbstractList

AbstractSet

AbstractSequentialList

LinkedList

ArrayList Vector

HashSet

TreeSet
LinkedTreeSet

Map

SortedMap
AbstractMap

HashMap
LinkedHashMap

TreeMap

Un coleccin de items nico, no


permite items repetidos

Lists

Los elementos de la lista estan ordenados

Por el orden de insercin,


Por crterio.

Una lista contiene elementos repetidos

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

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

Collection
// Basic Operations
size():int;
isEmpty():boolean;
contains(Object):boolean;
add(Object):boolean;
// Optional
remove(Object):boolean;
// Optional
iterator():Iterator;
// Bulk Operations
containsAll(Collection):boolean;
addAll(Collection):boolean;
//
removeAll(Collection):boolean; //
retainAll(Collecton):boolean;
//
clear():void;
//
// Array Operations
toArray():Object[];
toArray(Object[]):Object[];

Optional
Optional
Optional
Optional

List
// Positional Access
get(int):Object;
set(int,Object):Object;
add(int, Object):void;
remove(int index):Object;
addAll(int, Collection):boolean;
// Search
int indexOf(Object);
int lastIndexOf(Object);
// Iteration
listIterator():ListIterator;
listIterator(int):ListIterator;
// Range-view List
subList(int, int):List;

//
//
//
//

Optional
Optional
Optional
Optional

Map
// Basic Operations
put(Object, Object):Object;
get(Object):Object;
remove(Object):Object;
containsKey(Object):boolean;
containsValue(Object):boolean;
size():int;
isEmpty():boolean;
// Bulk Operations
void putAll(Map t):void;
void clear():void;
// Collection Views
keySet():Set;
values():Collection;
entrySet():Set;

Un objeto que
implementa la
interfaceIterator
genera a serie de
elementos uno a la
vez

El mtodo next()
retorna el siguiente
elemento de la serie.

El mtodo remove()
elimina de la coleccin
el ltimo elemento
retornado por next().

Iterator
hasNext():boolean;
next():Object;
remove():void;

La interface
ListIterator
extends Iterator

Es posible moverse
en ambas direcciones
en la serie

ListIterator esta
disponible para
Lists,
particularmente en
la implementacin
LinkedList

ListIterator
hasNext():boolean;
next():Object;
hasPrevious():boolean;
previous(): Object;
nextIndex(): int;
previousIndex(): int;
remove():void;
set(Object o): void;
add(Object o): void;

Interface
Set

Implementation
HashSet

List
Map

TreeSet
ArrayList

HashMap

Historical

LinkedList
TreeMap

Vector
Stack
HashTable
Properties

Operacin

Collection

Map

Declarar

Collection miColeccion;
List miList;
Set miSet;
LinkedList miColeccion

Map miColeccion;
HashMap miColeccion;

Crear

miColeccion = new LinkedList();


miColeccin = HashSet();
miSet = new TreeSet();

miColeccion = new HashMap();

Agregar un Elemento

Collection
add(Object ob)
miColeccion.add(unObjeto);
Lista
add(int index,Object aObject)
miColeccion.add(i,unObjeto)

put(Object clave,Object valor)


miColeccion.put(unaClave,unObjeto)

Operacin
Agregar varios
elementos

Eliminar un Elemento

Eliminar Varios
Elementos

Collection

Map

Collection
addAll(Collection unaColeccion)
miColeccion.addAll(unaColeccion);
List
addAll(int i,Collection cols)
miList.addAll(i,unaColeccion)

putAll(Map unMap)

Collection
remove(Object aObject)
miColeccion.remove(unObjeto)
List
remove(int i)
miList.remove(i);

remove(object clave)

removeAll(Collection aCollection)
miCollection.removeAll(unaCols)

miColeccion.putAll(unMap);

miColeccion.remove(clave)

Operacin
Recuperar un
Elemento

Informacin

Collection

Map

Collection
Utilizando el Iterator
List
get(int index)
Object unObj = miCollection.get(i)

get(Object clave)

contains(Object unObjeto):boolean
size():int
isEmpty():boolean
containAll(Collection unaColeccion)

containsKey(Object clave) : boolean


containsValue(Object value):boolean
isEmpty():boolean
size():int

unObj = micoleccion.get(clave);

La coleccin de tipo set no permite elementos repetidos, por lo que hay que
Sobre escribir el mtodo equals.

La coleccin de tipo set no permite elementos repetidos, por lo que hay que
Sobre escribir el mtodo equals.

HashSet

Es Necesario que la clase de las instancia que va a ser agregada a la coleccin


Implemente la interface Comparable

TreeSet

Exception
Object

Throwable

Error

Exception

Runtime
Exception

Throws
Throw
Try{}
catch{}

Try{
Bloque de codigo que
puede generar una
exception
} catch{Exception1 id1}
{bloque de codigo}
catch{Exception2 id1}
{bloque de codigo}
finally()
{
}

Exception
Definir Exception propias
1. - Crear un clase que
extienda de Exeption
public class CuentaException extends
Exception
{
public CuentaException(String mensaje)
{
super(mensaje);
2.- Crear la clase que
}
genere la Exception
}

3.- Usar el mtodo que


puede generar la
Exception
public static void main(String[] args) {
Cuenta ct1 = new CajaAhorro(940.45,"248");
Cuenta ct2 = new CtaCte(540.45,"45",500);
try{
ct1.extraer(500);
}catch (CuentaException exp) {
System.out.println(exp.getMessage());
}
}

public class Cuenta {


public void extraer(double unMonto) throws
CuentaException {
if(this.puedoExtraer(unMonto))
saldo -= unMonto;
else
throw new CuentaException("Saldo Insuficiente");
}