PROGRAMACIÓN ORIENTADA A OBJETOS I

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

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

class NombreDeClase { // Cuerpo de La Clase... } public class Cuenta { // Cuepo de La Clase... }

class NombreDeClase { // Atributos // Constructores //Métodos } class NombreDeClase { // Cuerpo de La Clase... }

sintaxis para declarar un atributo de la clase [modificador] [cualificador] tipo_de_dato identificador public class Cuenta { private double saldo; private long nroCuenta; 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

public class Cuenta { //Atributos private double saldo; private long nroCuenta; private Cliente titular; //Constructores public Cuenta() { } public Cuenta(long unNro) { } Sintaxis nombreClase(tipo_de_Dato identificador, tipo_de_Dato identificador,...) { //instrucciones del cosntructor }

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 nombreDeMetodo(tipo_de_Dato identificador,tipo_de_Dato identificador,...) { //instrucciones del método }

public class Cuenta { //Atributos private double saldo; private long nroCuenta; private Cliente titular; //Constructores public Cuenta() { } public Cuenta(long unNro) { } //Métodos public long getNorCuenta() { } public void depositar(double unMonto) { }

public class Cuenta { //Atributos private double saldo; private long nroCuenta; private Cliente titular; //Constructores public Cuenta() { } 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 métodos son adquiridos desde una clase generalizada(suprclase) para ser utilizados en una clase más específica(subclase) relación “es un” “es un”

class NombreDeClase extends NombreSuper Clase { // Cuerpo de La Clase... } public class CajaAhorro extends Cuenta { // Cuepo de La Clase... }

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.

public class Cajero { int nro; doble disponibilidad; Banco unBanco; // etcétera }

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.

Asociación Composición class Kitchen { Stove myStove; Refrigerator myRefrigerator; public void setStove (Stove aStove) { myStove = aStove; } public void setRefrigerator (Refrigerator aRefrigerator) { myRefrigerator = aRefrigerator; } 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(); //etcétera }

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; } 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; Ejemplo

Estructuras de Control Selección Switch valor{ case cosntant sentencias; breack; case cosntant sentencias; breack; case cosntant sentencias; breack; default case cosntant sentencias; breack; } 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; } Ejemplo

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; } 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); } Ejemplo

Un paquete es un conjunto de clases: se pueden importar se empaquetar import java.io.* import java.io.FileNotFoundException class Manager { int employeeNumber; String name; int departmentNumber; int extensionNumber; int salary; int numberOfWorkers; // etcétera } package empresa.miAplicacion import java.io.* import java.io.FileNotFoundException class Manager { int employeeNumber; String name; int departmentNumber; int extensionNumber; int salary; int numberOfWorkers; // etcétera }

 Cada instancia hereda todos los atributos definidos en su clase.  Cada instancia tiene su propia copia de atributos de instancia. nroCta = 45 Saldo = 540,45 nroCta = 248 Saldo = 940,45 heap R.A.M.

 Son los servicios que necesitan de una instancias para poder ser convocados. nroCta = 45 Saldo = 540,45 nroCta = 248 Saldo = 940,45 heap R.A.M. stack cta1 cta2 cta1.extraer(250); Referencia a una instancia de la clase Cuenta Mensaje de instancia

 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. nroCta = 45 Saldo = 540,45 heap R.A.M. stack cta1 cta2 static Iibb=0,34 nroCta = 248 Saldo = 940,45

static  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 nroCta = 45 Saldo = 540,45 heap R.A.M. stack cta1 cta2 nroCta = 248 Saldo = 940,45 Cuenta.setIIBB(0,35); Clase Mensaje de Clase static Iibb=0,34

 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 NombreDeLaClase; Determina que esta clase no podrá tener sub clases. El cualificador final utilizado en la definición deun método private final void nombreMetodo() {}; 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

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

 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.

 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 abstract public abstract class Cuenta { /** */ private String nroCta; /** */ private double saldo; /** */ private static double iibb; public Cuenta(String nroCta, doubel saldo) { } public Cuenta() { } public abstract void extraer(double unMonto) ; }

Clase Abstracta abstract public abstract class Cuenta { /** */ private String nroCta; /** */ private double saldo; /** */ private static double iibb; public Cuenta(String nroCta, doubel saldo) { } public Cuenta() { } public abstract void extraer(double unMonto) ; } public class CajaAhorro extends Cuenta 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 public class CtaCte extends Cuenta { /** */ 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; // etcétera } class CuentaCorriente { private int nro; private double saldo; private double descubierto; // etcétera } Genralización class Cuenta { private int nro; private double saldo; // etcétera }

Especialización class CajaAhorro extends Cuenta { // etcétera } Especialización class CuentaCorriente extends Cuenta { private double descubierto; // etcétera } class Cuenta { private int nro; private double saldo; // etcétera }

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.

Especialización class CajaAhorro extends Cuenta { public CajaAhorro(){ } public CajaAhorro(int nro,double saldo){ super(nro,saldo); } Especialización class CuentaCorriente extends Cuenta { private double descubierto; public CuentaCorriente(){} public CuentaCorriente(int unNro,double unSaldo,double descu){ super(unNro,unSaldo); this.descubierto = descu; } class Cuenta { private int nro; private double saldo; public Cuenta(){} public Cuenta(int nro,doble saldo){ this.nro = nro; this.saldo= saldo; }

Especialización class CajaAhorro extends Cuenta { public void extraer(double unMonto){ if((saldo - unMonto) >= 10) this.saldo -=unMonto; } Especialización 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; }

Especialización class CajaAhorro extends Cuenta { public void extraer(double unMonto){ if((this.saldo - unMonto) >= 10) this.saldo -=unMonto; } Especialización 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; } Genera un error de Compilación

Especialización class CajaAhorro extends Cuenta { public void extraer(double unMonto){ doube aux=0; if((this.getSaldo() - unMonto) >= 10) aux = this.getSaldo(); aux -=unMonto; this.setSaldo(aux); } Especialización class CuentaCorriente extends Cuenta { 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 Cuenta { private int nro; private double saldo; public void extraer(double unMonto){ this.saldo -= unMonto; } Variable Local: debe ser inicializada en forma explicita Variable Local: recibidada como argumento.

Especialización class CajaAhorro extends Cuenta { public void extraer(double unMonto){ if((this.getSaldo() - unMonto) >= 10) super.extraer(unMonto); } Especialización class CuentaCorriente extends Cuenta { private double descubierto; public void extraer(double unMonto){ if((this.getSaldo() + this.descubierto) >= unMonto) super.extraer(unMonto); } class Cuenta { private int nro; private double saldo; public void extraer(double unMonto){ this.saldo -= unMonto; }

Especialización class CajaAhorro extends Cuenta { public void extraer(double unMonto){ if((this.getSaldo() - unMonto) >= 10) super.extraer(unMonto); } Especialización 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 Cuenta(){} public Cuenta(int nro,doble saldo){ this.nro = nro; this.saldo= saldo; } public void extraer(double unMonto){ this.saldo -= unMonto; }

Especialización class CajaAhorro extends Cuenta { public void extraer(double unMonto){ doube aux=0; if((this.getSaldo() - unMonto) >= 10) aux = this.getSaldo(); aux -=unMonto; this.setSaldo(aux); } Especialización class CuentaCorriente extends Cuenta { 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); } public asbtract class Cuenta { private int nro; private double saldo; public abstract void extraer(double unMonto); } Los métodos abstractos no tienen cuerpo

Clase Abstracta public class Cuenta { /**... */ private String nroCta; /**...*/ 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; } public boolean puedoExtraer(double unMonto) { boolean retorno = false; if(saldo >= unMonto) retorno = true; return retorno; }... } public class CajaAhorro extends Cuenta { public boolean puedoExtraer(double unMonto) { boolean retorno = false; if((this.getSaldo() - 10)>= unMonto) retorno = true; return retorno; } public class CtaCte extends Cuenta { /** */ private double descubierto; public boolean puedoExtraer(double unMonto) { boolean retorno = false; if((this.getSaldo() + this.descubierto)>= unMonto) retorno = true; return retorno; }

Herencia y Binding Dinámico

nroCta = 45 Saldo = 540,45 heapstack cta1 cta2 nroCta = 248 Saldo = 940,45 static Iibb=0,34 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:una clase abstracta en Java - 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.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

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

Ejemplo - Solución

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

LinkedList LinkedTreeSet TreeSetHashSetVector ArrayList SortedSet AbstractSet AbstractSequentialList AbstractList ListSet Collection AbstractCollection

HashMap TreeMap LinkedHashMap Map SortedMap AbstractMap

 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

 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

// 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; // Optional removeAll(Collection):boolean; // Optional retainAll(Collecton):boolean; // Optional clear():void; // Optional // Array Operations toArray():Object[]; toArray(Object[]):Object[]; Collection

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

// 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; Map

 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(). hasNext():boolean; next():Object; remove():void; Iterator

 La interface ListIterator extends Iterator  Es posible moverse en ambas direcciones en la serie  ListIterator esta disponible para Lists, particularmente en la implementación LinkedList hasNext():boolean; next():Object; hasPrevious():boolean; previous(): Object; nextIndex(): int; previousIndex(): int; remove():void; set(Object o): void; add(Object o): void; ListIterator

InterfaceImplementationHistorical SetHashSetTreeSet ListArrayListLinkedListVector Stack MapHashMapTreeMapHashTable Properties

OperaciónCollectionMap DeclararCollection miColeccion; List miList; Set miSet; LinkedList miColeccion Map miColeccion; HashMap miColeccion; CrearmiColeccion = new LinkedList(); miColección = HashSet(); miSet = new TreeSet(); miColeccion = new HashMap(); Agregar un ElementoCollection 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)

OperaciónCollectionMap Agregar varios elementos Collection addAll(Collection unaColeccion) miColeccion.addAll(unaColeccion); List addAll(int i,Collection cols) miList.addAll(i,unaColeccion) putAll(Map unMap) miColeccion.putAll(unMap); Eliminar un ElementoCollection remove(Object aObject) miColeccion.remove(unObjeto) List remove(int i) miList.remove(i); remove(object clave) miColeccion.remove(clave) Eliminar Varios Elementos removeAll(Collection aCollection) miCollection.removeAll(unaCols)

OperaciónCollectionMap Recuperar un Elemento Collection Utilizando el Iterator List get(int index) Object unObj = miCollection.get(i) get(Object clave) unObj = micoleccion.get(clave); Informacióncontains(Object unObjeto):boolean size():int isEmpty():boolean containAll(Collection unaColeccion) containsKey(Object clave) : boolean containsValue(Object value):boolean isEmpty():boolean size():int

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

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

HashSet

Es Necesario que la clase de las instancia que va a ser agregada a la colección 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 2.- Crear la clase que genere la Exception 3.- Usar el método que puede generar la Exception public class CuentaException extends Exception { public CuentaException(String mensaje) { super(mensaje); } public class Cuenta { public void extraer(double unMonto) throws CuentaException public void extraer(double unMonto) throws CuentaException { if(this.puedoExtraer(unMonto)) saldo -= unMonto; else throw new CuentaException("Saldo Insuficiente"); } 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()); } }