Lección 2 Encapsulamiento Mari Carmen Otero Escuela Universitaria de Ingeniería de Vitoria-Gasteiz

Definición de encapsulamiento El encapsulamiento es la característica de autonomía de la OO. Esta característica permite generar componentes autónomos de software tomando una parte de funcionalidad y ocultando los detalles de la implementación al mundo exterior. Los términos módulo, componente o bean se suelen utilizan en lugar de “componente encapsulado de software”. Una vez encapsulada, una entidad de software se puede visualizar como una caja negra. Interfaz Mensaje Interfaz Interfaz Mensaje Interfaz

Interfaz e implementación Una interfaz lista los servicios proporcionados por un componente. La interfaz actúa como un contrato con el mundo exterior que define exactamente lo que una entidad externa puede hacer con el objeto. Una interfaz es equivalente a la API (Interfaz de Programación de Aplicaciones) para un objeto. La implementación define la manera en que un objeto proporciona realmente un servicio. La implementación define los detalles internos del componente.

Interfaz e implementación: Ejemplo public class Log { public void debug( String mensaje ) { print( "DEBUG", mensaje ); } public void info( String mensaje ) { print( "INFO", mensaje ); public void warning( String mensaje ) { print( "WARNING", mensaje ); public void error( String mensaje ) { print( "ERROR", mensaje ); public void fatal( String mensaje ) { print( "FATAL", mensaje ); System.exit( 0 ); private void print( String mensaje, String severidad ) { System.out.println( severidad + ": " + mensaje );

Interfaz e implementación: Ejemplo La clase Log da a sus objetos una forma para enviar mensajes de depuración, informativos, de advertencia y de error durante la ejecución. La interfaz pública de Log contiene estos métodos: public void debug ( String mensaje ) public void info ( String mensaje ) public void warning ( Sting mensaje ) public void error ( String mensaje ) public void fatal ( String mensaje ) Todo lo demás en la definición de la clase Log, aparte de estos cinco métodos, es implementación. La implementación define el cómo se realiza algo. Pero, la interfaz oculta completamente el cómo, en vez de ello, define un contrato con el mundo exterior.

Interfaz e implementación: Ejemplo Lo importante es lo que la interfaz no dice. Estos métodos public void degub ( String mensaje ) public void info ( String mensaje ) public void warning ( Sting mensaje ) public void error ( String mensaje ) public void fatal ( String mensaje ) no indican que se va a imprimir un mensaje en la pantalla. La implementación se encarga de decidir qué hacer con el mensaje. La implementación podría enviar el mensaje a la pantalla, descargarlo a un archivo, escribirlo en una base de datos o enviarlo a un cliente de monitoreo de red.

Interfaz e implementación: Ejemplo La interfaz pública no contiene private void print ( String mensaje, String severidad ) pues el objeto Log restringe el acceso a print () para sí mismo. Tres niveles de acceso: Public: Permite acceso a todos los objetos. Protected: Permite acceso a la instancia y a cualquiera de las subclases. Private: Sólo permite acceso a la instancia. Un comportamiento que se quiera poner a disposición del mundo exterior debe tener acceso público. Por el contrario, lo que se desee ocultar del mundo exterior debe tener acceso protegido o privado.

Características de un encapsulamiento eficaz Un encapsulamiento eficaz permite escribir componentes autónomos de software. Las tres características de un encapsulamiento eficaz son: Abstracción. Ocultamiento de la implementación. División de la responsabilidad.

Abstracción La abstracción es el proceso de simplificar un problema complejo. La abstracción permite resolver un problema una vez y utilizar la solución posteriormente en todo el dominio del problema. Ejemplo 1 Imaginemos una cola de personas ante un cajero en un banco. Tan pronto como el cajero está listo, la primera persona de la cola avanza a la ventanilla. La gente mantiene este orden: primero en entrar, primero en salir. Ejemplo 2 Consideremos un establecimiento de venta rápida de hamburguesas. Conforme una hamburguesa llega al final de la banda transportadora, es colocada tras la última hamburguesa por preparar. Así, la primera hamburguesa que se toma es también la primera que se preparó. Ambos dominios son un ejemplo de una cola primero en entrar, primero en salir (orden de elementos tipo FIFO). Entrada Salida

Ocultamiento de la implementación El ocultamiento de la implementación presenta dos beneficios: Proteger al objeto de los usuarios. Mediante los Tipos Abstractos de Datos. Proteger a sus usuarios del objeto. Mediante la utilización de código moderadamente ligado.

Tipos Abstractos de Datos Un Tipo Abstracto de Dato (TDA) es un conjunto de datos y un conjunto de operaciones que se realizan con esos datos. Los TDA permiten definir nuevos tipos del lenguaje mediante el ocultamiento de los datos internos y el estado en una interfaz bien definida. Esta interfaz presenta al TDA como una sola unidad indivisible. La creación de la clase Articulo de la Lección 1 añade un nuevo tipo de dato. A continuación, vamos a ver un ejemplo de esta misma clase pero sin encapsular.

ArticuloSinEncapsular.java public class ArticuloSinEncapsular { public double precio_unitario; public double descuento; // porcentaje de descuento que se aplicará al precio public int cantidad; public String descripcion; public String id; public ArticuloSinEncapsular( String id, String descripcion, int cantidad, double precio ) { this.id = id; this.descripcion = descripcion; if ( cantidad >= 0 ) this.cantidad = cantidad; else this.cantidad = 0; this.precio_unitario = precio; } ….

ArticuloSinEncapsular.java Todas los atributos son públicos. ¿Qué pasaría si alguien escribiera el siguiente programa: EjemploArticuloSinEncapsular.java, donde se crean objetos de la nueva clase Articulo?

EjemploArticuloSinEncapsular.java public class EjemploArticuloSinEncapsular extends Object { public static void main( String [] args ) { ArticuloSinEncapsular monitor = new ArticuloSinEncapsular( "electrónicos-012", "Monitor SVGA de 17\"", 1, 2500.00 ); monitor.descuento = 1.25; // inválido, ¡el descuento debe ser menor a 100%! double precio = monitor.getTotalAjustado(); System.out.println( "Total incorrecto: " + precio + “ € "); monitor.setDescuento( 1.25 ); // inválido // no obstante, el monitor atrapará el error precio = monitor.getTotalAjustado(); System.out.println( "Total correcto: " + precio + “ € "); }

EjemploArticuloSinEncapsular.java El resultado de la ejecución es el siguiente: Total incorrecto: -625.0 € Total correcto: 2500.0 € Process exited with exit code 0. Se crea un objeto de la clase ArticuloSinEncapsular y se aplica un descuento inválido. Por tanto, el resultado es un precio ajustado erróneo.

¿Cómo proteger a los usuarios mediante el ocultamiento de la implementación? El ocultamiento de la implementación conduce a un diseño más flexible porque evita que los usuarios del objeto dependan estrechamente de la implementación del objeto. Así, el ocultamiento de la implementación no sólo protege al objeto, sino también a aquellos que lo utilizan pues fomenta la creación de código moderadamente ligado al objeto. El código moderadamente ligado es independiente de la implementación de otros componentes. El código estrechamente ligado depende intensamente de la implementación de otros componentes.

¿Cómo proteger a los usuarios mediante el ocultamiento de la implementación? El encapsulamiento y el ocultamiento de la implementación no son mágicos. Si se realizan cambios en una interfaz, será necesario actualizar el código dependiente de esa interfaz. Mediante el ocultamiento de los detalles y la escritura de software para una interfaz, se crea código moderadamente ligado. El código estrechamente ligado choca con el propósito del encapsulamiento: crear objetos independientes y reutilizables.

Ejemplo de ocultamiento de la implementación public class Cliente { // ... diversos métodos para el cliente ... public Articulo [] articulos; // este arreglo contiene cualquier artículo seleccionado } ------------------------------------------------------------------------------------------------------------------------ ... public static void main ( String [] args ) { Cliente cliente = new Cliente(); // … elige algunos artículos … // asigna precio a los artículos double total = 0.0; for (int i = 0; i < cliente.articulos.length; i++) { Articulo articulo = cliente.articulos[i]: total = total + articulo.getTotalAjustado(); …

Ejemplo de ocultamiento de la implementación El método main() toma un cliente, agrega algunos artículos y da el total del pedido. Aquí, el arreglo Articulo forma parte de la interfaz externa de Cliente. Todo funciona, pero ¿qué pasa si deseamos cambiar la forma en que el cliente selecciona los artículos? Supongamos que queremos agregar la clase Canasta. Si esto modifica la implementación, tendremos que actualizar todo el código que accede directamente al arreglo Articulo. En el ejemplo anterior en la clase Cliente se debe hacer privado el arreglo Articulo, y dar acceso a los artículos a través de accesores.

División de la responsabilidad Para generar código moderadamente desligado, hay que contar con una división apropiada de la responsabilidad. El ocultamiento de la implementación y la responsabilidad van de la mano. Un objeto tiene la responsabilidad de saber cómo llevar a cabo su trabajo. Si la implementación se deja abierta a todo el mundo exterior, un usuario podría empezar a actuar sobre ella, duplicando en consecuencia la responsabilidad.

ArticuloDefectuoso.java public class ArticuloDefectuoso { private double precio_unitario; private double precio_ajustado; private double descuento; // porcentaje de descuento que se aplicará al precio private int cantidad; private String descripcion; private String id; public ArticuloDefectuoso( String id, String descripcion, int cantidad, double precio ) { this.id = id; this.descripcion = descripcion; if ( cantidad >= 0 ) this.cantidad = cantidad; else this.cantidad = 0; this. precio_unitario = precio; }

ArticuloDefectuoso.java public double getPrecioUnitario () { return precio_unitario; } // aplica un porcentaje de descuento al precio public void setDescuento( double descuento ) { if( descuento <= 1.00 ) { this.descuento = descuento; public double getDescuento() { return descuento; public int getCantidad() { return cantidad; public void setCantidad ( int cantidad ) { this.cantidad = cantidad;

ArticuloDefectuoso.java public String getIDProducto() { return id; } public String getDescripcion() { return descripcion; public double getPrecioAjustado() { return precio_ajustado; public void setPrecioAjustado ( double precio) { precio_ajustado = precio;

ArticuloDefectuoso.java ArticuloDefectuoso.java ya no contiene la responsabilidad de calcular el precio ajustado. ¿Entonces cómo generará un precio ajustado? Consideremos el siguiente programa: EjemploArticuloDefectuoso.java.

EjemploArticuloDefectuoso.java public class EjemploArticuloDefectuoso extends Object { public static void main( String [] args ) { // crea los artículos ArticuloDefectuoso leche = new ArticuloDefectuoso( "lácteos-011", "1 Litro de leche", 2, 2.50 ); // aplica cupones leche.setDescuento( 0.15 ); // obtiene precios ajustados double precio_leche = leche.getCantidad() * leche.getPrecioUnitario(); double descuento_leche = leche.getDescuento() * precio_leche; leche.setPrecioAjustado( precio_leche - descuento_leche ); System.out.println( "Su leche cuesta: " + leche.getPrecioAjustado() + " € " ); }

EjemploArticuloDefectuoso.java Cuando trabajamos con objetos que no dividen apropiadamente la responsabilidad, al final lo que tenemos es código procedural orientado a datos. El método main() para calcular el precio ajustado es propio de la programación procedural. Hay que indicar paso a paso al objeto leche lo que debe hacer.

Mejor definición de encapsulamiento El encapsulamiento eficaz se compone de: Abstracción más Ocultamiento de la implementación más Responsabilidad. Si eliminamos La abstracción, el rdo será código no reutilizable. El ocultamiento de la implementación, el rdo será código frágil y estrechamente ligado. La responsabilidad, el rdo será código orientado a datos y con una lista de procedimientos (procedural).