Nombre: Gustavo Martin del campo Escobar

Matricula: 10001433

Grupo: TI33D

Materia: Programacin

Prof.: Teresa Lpez Segura

Ficha bibliogrfica: http://www.programacion.com, http://pisuerga.inf.ubu.es

Java 2 manual del programador.

Fecha: 11 de agosto del 2011

Introduccin

En este ensayo les mostraremos algunos de los conceptos ms sobresalientes de la programacin orientada a objetos (POO), como lo son la herencia, polimorfismo y encapsulamiento mencionaremos todo lo relacionado a este tema y algunos ejemplos que le ayudaran a comprender ms estos conceptos.

Indice Capitulo 5 Introduccion -------------------------------------------------------------------Descripcin de herencia.---------------------------------------------------La clase base Object.-------------------------------------------------------El mtodo clone.-------------------------------------------------------------El mtodo equals.------------------------------------------------------------El mtodo finalize.-----------------------------------------------------------El mtodo tostring.----------------------------------------------------------El mtodo getclass.---------------------------------------------------------Ventajas de la herencia.---------------------------------------------------Superclases y subclases.-------------------------------------------------Modificadores y herencia.----------------------------------------------- -Clases abstractas.-----------------------------------------------------------Mtodos abstractos.--------------------------------------------------------Interfaces.---------------------------------------------------------------------Definicin de una interfaz.------------------------------------------------2 4 5 5 6 6 7 7 7 8 8 9 9 9 10

Capitulo 6 Encapsulamiento.------------------------------------------------------------Modificadores de clases.---------------------------------------------------Modificadores de variables.-----------------------------------------------Modificadores de mtodos.------------------------------------------------Clases internas.---------------------------------------------------------------Paquetes.-----------------------------------------------------------------------Declaracin de un paquete.------------------------------------------------Paquetes incorporados.-----------------------------------------------------Acceso a los elementos de un paquete.--------------------------------Importacin de paquetes.---------------------------------------------------Polimorfismo.-------------------------------------------------------------------Ligadura.-------------------------------------------------------------------------Ligadura dinmica.------------------------------------------------------------Conclusin-----------------------------------------------------------------------11 11 11 11 12 13 13 13 14 14 15 16 16 17

Herencia Es un mecanismo que permite derivar caractersticas de una clase a otra y as extender sus funcionalidades. En terminologa Java, la clase existente se denomina superclase. La clase derivada de la superclase se denomina la subclase. Tambin se conoce a la superclase como clase padre y una subclase se conoce como clase hija, clase extendida o clase derivada.

En este ejemplo la clase padre seria el instrumento y las clases hijas serian la guitarra, piano, saxofn La definicin de una subclase tiene la sintaxis siguiente: public class Guitarra extends instrumento

La clase base Object La clase Object est situada en la parte ms alta del rbol de la herencia en el entorno de desarrollo de Java. Todas las clases del sistema Java son descendentes (directos o indirectos) de la clase Object. Esta clase define los estados y comportamientos bsicos que todos los objetos deben tener, como la posibilidad de compararse unos con otros, de convertirse a cadenas, de esperar una condicin variable, de notificar a otros objetos que la condicin varible a cambiado y devolver la clase del objeto .

Mtodo clone Para implementar la clonacin en una clase, se deben hacer dos cosas: 1. La clase debe implementar la interfaz Cloneable , esta interfaz no tiene mtodos que implementar. El propsito de Cloneable es indicar al mtodo clone de java.lang.Object que el programador ha dado permiso explcito a la clase para permitir que los objetos instanciados a partir de ella sean clonados. 2. El mtodo clone de la clase java.lang.Object debe ser sobreescrito con un acceso de tipo public en vez de protected. Es en este mtodo que se implementar el cdigo que clona del objeto. Un ejemplo de una implementacin sencilla de clone es: public Object clone() { Object clone = null; try {clone = super.clone();} catch(CloneNotSupportedException e){// No deberia suceder } return clone; } La excepcin CloneNotSupportedException es arrojada por el mtodo clone de la clase java.lang.Object para prevenir que la operacin de clonacin se ejecute si no se ha otorgado el permiso para ello (es decir, se implemente la interfaz Cloneable)

Metodo equals equals() se utiliza para comparar si dos objetos son iguales. Este mtodo devuelve true si los objetos son iguales, o false si no lo son. Observe que la igualdad no significa que los objetos sean el mismo objeto. Consideremos este cdigo que compara dos enteros. Integer uno = new Integer(1), otroUno = new Integer(1); if (uno.equals(otroUno)) System.out.println("Los objetos son Iguales"); Este cdigo mostrar Los objetos son Iguales aunque uno y otroUno referencian a dos objetos distintos. Se les considera iguales porque su contenido es el mismo valor entero. Las clases deberan sobreescribir este mtodo proporcionando la comprobacin de igualdad apropiada. Un mtodo equals() debera comparar el contenido de los objetos para ver si son funcionalmente iguales y devolver true si es as.

Mtodo finalize Antes de recolectar la basura de un objeto, el sistema de ejecucin de Java le da la oportunidad de limpiarse a s mismo. Este paso es conocido como finalizacin y se consigue mediante una llamada al mtodo finalize() del objeto. El objeto debe sobreescribir este mtodo para realizar cualquier tarea de limpieza final como la liberacin de recursos del sistema como ficheros o conexiones. Para ms informacinsobre el mtodo finalize() puedes ver: Se puede forzar que ocurra la finalizacin de un objeto llamando al mtodorunFinalization() de la clase System. System.runFinalization(); Este mtodo llama a los mtodos finalize() de todos los objetos que estn esperando para ser recolectados.

El mtodo getClass() de la clase Object se puede utilizar para determinar la clase de un objeto. Es decir, devuelve un objeto de tipo Class, que contiene informacin importante sobre el objeto que crea la clase. Una vez determinada la clase del objeto. Se puede utilizar los mtodos de la clase Class para obtener informacin acerca del objeto.

Metodo to String La clase object define un mtodo llamado to string que regrese ala representacin string de objeto que hace la llamada. Ejemplo System.out.println(Thread.currentThread().toString()); System.out.println(new Integer(44).toString()); El mtodo toString() es muy til para depuracin y tambin puede sobreescribir este mtodo en todas las clases.

Metodo getClass El mtodo getClass() de la clase Object se puede utilizar para determinar la clase de un objeto. Es decir, devuelve un objeto de tipo Class, que contiene informacin importante sobre el objeto que crea la clase. Una vez determinada la clase del objeto. Se puede utilizar los mtodos de la clase Class para obtener informacin acerca del objeto.

Ventajas de la herencia

Ayuda a los programadores a ahorrar cdigo y tiempo, ya que si tiene una clase lista es solo de implementarla y listo todo el cdigo de esta se resume a solo un llamado. Los objetos pueden ser construidos a partir de otros similares. Para ello es necesario que exista una clase base y una jerarqua (relacionamiento) de clases.

La clase derivada puede heredar cdigo y datos de la clase base, aadiendo cdigo o modificando lo heredado. Las clases que heredan propiedades de otra clase pueden servir como clase base de otras.

Superclases y subclases

Una clase extendida hereda todos los miembros de sus superclases, excepto constructores y finalize, y afiade nuevos miembros especficos. Se declara que un clase es una subclase de otra clase dentro de laa declaracin de Clase. Por ejemplo, supongamos que queremos crear una subclase llamada SubClase de otra clase llamada SuperClase. Se escribira esto. class SubClass extends SuperClass { ... } Esto declara que SubClase es una subclase de SuperClase. Y tambin declara implcitamene que SuperClase es la superclase de SubClase. Una subclase tambin hereda variables y miembros de las superclases de su superclase, y as a lo largo del rbol de la herencia. Crear una subclase puede ser tan sencillo como incluir la clausula extends en la declaracin de la clase.

Modificadores y Herencia El lenguaje Java proporciona diversos modificadores que se pueden utilizar para modificar aspectos del proceso de herencia. Los modificadores que controlan el acceso o visibilidad en la clase son: public, prvate y protected . El public permite a acceder al elemento desde cualquier clase, independientemente de que esta pertenezca o no al paquete en que se encuentra el elemento. El prvate por otro lado, es el modificador mas restrictivo y espesifica que los elementos que lo utilizan solo pueden ser accedidos desde la clase en la que se encuentran. En el protected slo se puede acceder dentro de la definicin de la clase en la que aparece, dentro de otras clases del mismo paquete o dentro de la definicin de subclases.

Clase abstracta La clase abstracta no permite crear objetos, se utiliza para que otras clases hereden de ella, "provocando" la reutilizacin de cdigo, o sea que no se puede instanciar, y se usa nicamente para definir subclases. Una clase es abstracta cuando uno de sus mtodos no tiene implementacin y se usa cuando queremos definir una abstraccin que englobe objetos de varios tipos y queremos hacer uso del polimorfismo.

Mtodo abstracto Un mtodo abstracto es un mtodo que se introduce para que sea redefinido en una clase derivada. Por ejemplo abstract class GraphObj { int x, y; // La posicin central GraphObj(int ix, int iy) { x= ix; y= iy; } // constructor void Move(int dx, int dy) { x+= dx; y+= dy; } abstract void Paint(Graphics g); // Paint es abstracto } Esta clase no se puede usar para crear un objeto, por lo que lo siguiente es un error: GraphObj gf= new GraphObj(10,20); // error La idea es que slo se pueden crear objetos de clases derivadas de la clase anterior:

Interfaces

Un interface contiene una coleccin de mtodos que se implementan en otro lugar. Los mtodos de una clase son public, static y final.
Sintaxis m o d i f i c a d o r interface Nombre In t e r f a z t //decldraciones de constantes //declaraciones de los mtodos

Declaracin de una interfaz

La declaracin de una interfaz es similar a una clase, aunque emplea la palabra reservada interface en lugar de class y no incluye ni la declaracin de variables de instancia ni la implementacin del cuerpo de los mtodos (slo las cabeceras). La sintaxis de declaracin de una interfaz es la siguiente: public interface IdentificadorInterfaz { // Cuerpo de la interfaz . . . }

Una interfaz declarada como public debe ser definida en un archivo con el mismo nombre de la interfaz y con extensin .java. Las cabeceras de los mtodos declarados en el cuerpo de la interfaz se separan entre s por caracteres de punto y coma y todos son declarados implcitamente como public y abstract (se pueden omitir). Por su parte, todas las constantes incluidas en una interfaz se declaran implcitamente como public, static y final (tambin se pueden omitir) y es necesario inicializarlas en la misma sentencia de declaracin. Por ejemplo, la interfaz Modificacion declara la cabecera de un nico mtodo:

public interface Modificacion { void incremento(int a); } que se almacena en el archivo fuente Modificacion.java y que, al compilarse: genera un archivo Modificacion.class. Al no corresponder a una clase que implementa un mtodo main, este archivo no puede ejecutarse con el intrprete de Java.

10

Encapsulamiento. Java, como lenguaje orientado a objetos puro que es, implementa la encapsulacin (o encapsulamiento) perfectamente. Este concepto consiste en la ocultacin del estado, o lo que es lo mismo, de los datos miembro de un objeto, de forma que slo es posible modificar los mismos mediante las operaciones (mtodos, en Java) definidos para dicho objeto La encapsulacin es una de las principales ventajas que proporciona la programacin orientada a objetos.

Modificadores de clases.

Se puede declarar clases con uno o varios de los siguientes modificadores para especificar ciertas propiedades .

public la clase es visible desde fuera del fichero. abstract la clase todava no est completa, es decir, no se puede instanciar

objetos antes de que se hayan implementado en una clase derivada los mtodos que faltan. final no se puede extender la clase.

Modificadores de variables. Los modificadores son elementos del lenguaje que se colocan delante de la definicin de variables Public Visible en cualquier parte (la clase tambin debe ser pblica). Protected Visible en el paquete actual y en las subclases de esta c!ase en otros paquetes. Prvate Visible slo en la clase actual.

Modificadores de mtodos. Se puede limitar tambin el acceso de otras clases a mtodos. Esta accin se realiza utilizando una palabra reservada (modificador), antes del tipo de retorno del mtodo public void leerNombre (String nombre) private static int contarObjetos() protected final Object encontrarllave()

11

Clases internas. Son clases definidas dentro de otras. Se usan para dar tener acceso a miembros de la clase anfitriona incluso si son privados. Se usan como mecanismo de encapsulamiento. Tambin se pueden definir al interior de un mtodo.

public void start(double rate) { private class InterestAdder implements ActionListener { public InterestAdder(double aRate) { rate = aRate; } public void actionPerformed(ActionEvent event) { double interest = balance * rate / 100; // update interest balance += interest; NumberFormat formatter = NumberFormat.getCurrencyInstance(); System.out.println("balance=" + formatter.format(balance)); } private double rate; } ActionListener adder = new InterestAdder(rate); Timer t = new Timer(1000, adder); t.start();

Clase annima Cuando necesitamos slo una instancia de la clase, no necesitamos darle un nombre. Decimos que tal clase es interna y annima. public void start(final double rate) { ActionListener adder = new //sigue en otra lnea.. ActionListener() { public void actionPerformed(ActionEvent event) { double interest = balance * rate / 100; balance += interest; NumberFormat formatter = NumberFormat.getCurrencyInstance(); System.out.println("balance=" + formatter.format(balance)); } }; Timer t = new Timer(1000, adder); t.start();

12

Paquetes.

Los paquetes son una forma de organizar grupos de clases. Un paquete contiene un conjunto de clases relacionadas bien por finalidad, por mbito o por herencia. Los paquetes resuelven el problema del conflicto entre los nombres de las clases. Al crecer el nmero de clases crece la probabilidad de designar con el mismo nombre a dos clases diferentes. Las clases tienen ciertos privilegios de acceso a los miembros dato y a las funciones miembro de otras clases dentro de un mismo paquete.

Declaracin de un paquete.

Se ver a continuacin cmo declarar un paquete. Para ello se utiliza la sentencia package seguida del nombre del paquete que estemos creando. package nombrePaquete; Es importante sealar que esta sentencia ha de ir la primera en el archivo fuente. Se recordar seguidamente la estructura que ha de seguir un fichero fuente en Java .

Una nica sentencia de paquete (opcional). Las sentencias de importacin deseadas (opcional). Una nica declaracin de clase pblica. Las clases privadas de paquete deseadas (opcional).

Paquetes incorporados.

El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un sistema de entrada/salida general, herramientas y comunicaciones. En la versin actual del JDK, los paquetes Java que se incluyen son: java.applet Este paquete contiene clases diseadas para usar con applets. Hay una clase Applet y tres interfaces: AppletContext, AppletStub y AudioClip.

13

java.awt El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y componentes GUI (Interfaz Grfico de Usuario). Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField. java.io El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream y FileOutputStream. java.lang Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread, Exception, System, Integer, Float, Math, String, etc. java.net Este paquete da soporte a las conexiones del protocolo TCP/IP y, adems, incluye las clases Socket, URL y URLConnection. java.util Este paquete es una miscelnea de clases tiles para muchas cosas en programacin. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (nmeros aleatorios) y Stack (pila FIFO).
Acceso a los elementos de un paquete. Existen dos medios para acceder a un elemento de un paquete: 1) nombrar totalmente al elemento, incluyendo el paquete, 2) utilizar sentencias import. import java.awt.Pane1; public abstract class Boton extends Panel ( ... Importacin de paquetes.

Con el fin de importar paquetes ya desarrollados se utiliza la sentencia import seguida del nombre de paquete o paquetes a importar.

14

Ser la sentencia que vaya la primera en el fuente a menos que exista una declaracin de paquete. Se pueden importar todos los elementos de un paquete o slo algunos. Para ello vara la forma de la sentencia. Veamos a continuacin cmo importar todas las clases e interfaces de un paquete: import paquetePrueba.*; Tambin existe la posibilidad de que se deseen importar slo algunas de las clases de un cierto paquete o subpaquete: import paquetePrueba.ClasesTipo1.clase0;
Polimorfismo. El concepto de Polimorfismo es uno de los fundamentos para cualquier lenguaje orientado a Objetos, las mismas races de la palabra pueden ser una fuerte pista de su significado: Poli = Multiple, morfismo= Formas , esto implica que un mismo Objeto puede tomar diversas formas. A travs del concepto de Herencias ("Inheritance") es posible ilustrar este comportamiento:

15

Ligadura. El trmino ligadura se refiere al acto de seleccionar cul es el mtodo que se ejecutar en respuesta a una invocacin especfica.

Ligadura dinmica. Consiste en realizar el poseso de ligadura e tiempo de ejecucin siendo la forma dinmica del objeto la que determina la versin del mtodo a ejecutar Se utiliza en todos los mtodos de instancia de java que no son privados ni final

16

Conclusin

La informacin que me proporciono este manual me pareci muy bueno ya que pudo aclarar barias de las dudas que lo tena acerca de estos temas. Todos los ejemplos que presentaba el manual iban acompaados de una clara expolicin de del cdigo que se implemento. Y esto es algo que me ayudo bastante para su comprensin.

17