Está en la página 1de 66

Facultad de Ingeniera

Java
Autor: Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

NDICE

NDICE ........................................................................................................................................................... 2 CAPTULO 1: INTRODUCCIN A JAVA ...................................................................................... 4

1.1 ORGENES ................................................................................................................................................. 4 1.2 QU ES JAVA? ......................................................................................................................................... 5 1.3 CARACTERSTICAS .................................................................................................................................... 7 1.4 QU SE PUEDE HACER CON JAVA? ......................................................................................................... 11 CAPTULO 2: PROGRAMACIN ORIENTADA A OBJETOS Y JAVA ............................... 12 2.1 CLASES ................................................................................................................................................... 12 2.2 OBJETOS ................................................................................................................................................. 13 2.3 ATRIBUTOS Y MTODOS .......................................................................................................................... 13 2.4 HERENCIA............................................................................................................................................... 15 2.5 INTERFACES Y PAQUETES ....................................................................................................................... 18 CAPTULO 3: FUNDAMENTOS Y SINTAXIS .............................................................................. 21 3.1 COMENTARIOS ........................................................................................................................................ 21 3.2 TIPOS DE DATOS PRIMITIVOS................................................................................................................... 21 3.3 VARIABLES ............................................................................................................................................. 21 3.4 CONSTANTES .......................................................................................................................................... 23 3.5 LITERALES .............................................................................................................................................. 23 3.6 PALABRAS RESERVADAS ......................................................................................................................... 24 3.7 OPERADORES .......................................................................................................................................... 24 3.8 ARREGLOS .............................................................................................................................................. 27 CAPTULO 4. CONTROL DE FLUJO ................................................................................................ 30 4.1 SENTENCIA IF-ELSE ................................................................................................................................. 30 4.3 BUCLE FOR ............................................................................................................................................. 30 4.4 BUCLE WHILE ......................................................................................................................................... 31 4.5 BUCLE DO-WHILE ................................................................................................................................... 31 4.6 CONTROL GENERAL DE FLUJO ................................................................................................................. 32 CAPTULO 5: CLASES ........................................................................................................................... 34 5.1 DEFINICIN DE CLASES ........................................................................................................................... 34 5.2 TIPOS DE CLASE ...................................................................................................................................... 36 5.3 MODIFICADORES DE ACCESO .................................................................................................................. 37 CAPTULO 6: OBJETOS........................................................................................................................ 39 6.1 CICLO DE VIDA DE LOS OBJETOS ............................................................................................................. 39 6.2 COMPARACIN DE OBJETOS .................................................................................................................... 40 CAPTULO 7: MTODOS ...................................................................................................................... 42 7.1 IMPLEMENTACIN DE MTODOS ............................................................................................................. 42 7.2 TIPOS DE MTODOS ................................................................................................................................. 43 7.3 RETORNO POR VALOR Y POR REFERENCIA............................................................................................... 44 7.4 SOBREESCRIBIR Y SOBRECARGAR MTODOS ........................................................................................... 44 7.5 CONSTRUCTORES .................................................................................................................................... 46 7.6 THIS Y SUPER .......................................................................................................................................... 47 7.7 INTERFACES ............................................................................................................................................ 47 CAPTULO 8: EXCEPCIONES ............................................................................................................ 49

Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

8.1 CAPTURAR Y MANEJAR EXCEPCIONES..................................................................................................... 50 8.2 LAS SENTENCIAS THROW ........................................................................................................................ 52 8.3 LA CLASE THROWABLE Y SUS SUBCLASES .............................................................................................. 52 8.4 EXCEPCIONES EN TIEMPO DE EJECUCIN................................................................................................ 53 CAPTULO 9: EJEMPLOS ..................................................................................................................... 55

Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

CAPTULO 1:

INTRODUCCIN A JAVA

1.1 Orgenes Hace algunos aos Sun Microsystems decidi intentar introducirse en el mercado de la electrnica de consumo y desarrollar programas para pequeos dispositivos electrnicos. Tras unos comienzos dudosos, Sun decidi crear una filial, denominada FirstPerson Inc., para dar margen de maniobra al equipo responsable del proyecto. El mercado inicialmente previsto para los programas de FirstPerson eran los equipos domsticos: microondas, tostadoras y, fundamentalmente, televisin interactiva. Este mercado, dada la falta de sofisticacin de los usuarios, requera unas interfaces mucho ms cmodas e intuitivas que los sistemas de ventanas que proliferaban en el momento. Otros requisitos importantes eran la fiabilidad del cdigo y la facilidad de desarrollo. James Gosling, el miembro del equipo con ms experiencia en lenguajes de programacin, decidi que las ventajas de eficiencia de C++ no compensaban el gran coste de pruebas y depuracin. Gosling haba estado trabajando en su tiempo libre en un lenguaje de programacin que l haba llamado Oak, el cual, aun partiendo de la sintaxis de C++, intentaba remediar las deficiencias que haba observado. Los lenguajes al uso, como C o C++, deben ser compilados para un chip, y si se cambia el chip, todo el software debe compilarse de nuevo. Esto encarece mucho los desarrollos y el problema es especialmente acusado en el campo de la electrnica de consumo. La aparicin de un chip ms barato y, generalmente, ms eficiente, conduce inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de produccin, por pequea que sea la diferencia en precio, ya que, multiplicada por la tirada masiva de los aparatos, supone un ahorro considerable. Por tanto, Gosling decidi mejorar las caractersticas de Oak y utilizarlo. El primer proyecto en que se aplic este lenguaje recibi el nombre de proyecto Green y consista en un sistema de control completo de los aparatos electrnicos y el

Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

entorno de un hogar. Para ello se construyo un computador experimental denominado *7(start seven). El sistema presentaba una interfaz basada en la representacin de la casa de forma animada y el control se llevaba a cabo mediante un apantalla sensible al tacto. En le sistema apareca Duke. La actual mascota de Java. Posteriormente se aplic a otro proyecto denominado VOD(Video On Demand) en el que se empleaba como interfaz para la televisin interactiva. Ninguno de estos proyectos se convirti nunca en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo y fueron como su bautismo de fuego. Una vez que en Sun se dieron cuenta de que a corto plazo la televisin interactiva no iba a ser un gran xito, urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios. No lo consiguieron y FirstPerson cerr en la primavera de 1994. Pese a lo que pareca un olvido definitivo, Bill Joy, cofundador de Sun y uno de los desarrolladores principales de Unix de Berkeley, juzg que internet podra llegar a ser el campo de juego adecuado para disputar a Microsoft su primaca casi absoluta en el terreno del software, y vio en Oak el instrumento idneo para llevar a cabo estos planes. Tras un cambio de nombre y algunos de diseo, el lenguaje Java fue presentado en agosto de 1995. 1.2 Qu es Java? La tecnologa Java consta de un lenguaje de programacin y una plataforma. Lenguaje de Programacin Java es un lenguaje de programacin de alto nivel, adems de que es orientado a objetos tiene las siguientes caractersticas: Simple Orientado a Objetos Distribuido Robusto Seguro Porttil interpretado

Ing. Israel Durn Martnez

Facultad de Ingeniera Independiente de la plataforma Multihilos Dinmico

Java

Java tiene la caracterstica de que el compilador es el encargado de convertir el cdigo fuente de un programa en un cdigo intermedio llamado bytecode que es independiente de la plataforma en que se trabaje y que es ejecutado por el intrprete de Java que forma parte de la Mquina Virtual de Java.

Ing. Israel Durn Martnez

Facultad de Ingeniera La plataforma Java

Java

Una plataforma es el ambiente de hardware o software en el cual se ejecutan los programas. En general, la mayora de las plataformas pueden ser descritas como una combinacin de hardware y sistema operativo. Algunas de las plataformas ms populares son Windows, Solaris, Linux y MacOS. La plataforma Java difiere de las anteriores en que sta es una plataforma basada nicamente en software que corre por encima de las plataformas basadas en hardware. La plataforma Java consta de dos componentes: La Mquina Virtual de Java (JVM): es la que interacta con el hardware y el sistema operativo para interpretar el programa. La Interfaz de Programacin de Aplicaciones de Java (API Java): que son todas aquellas clases ya definidas. A continuacin se muestra una representacin de los elementos que forman parte de la plataforma Java.

1.3 Caractersticas Al igual que otros lenguajes de programacin, Java tiene un compilador que se encarga de realizar un anlisis sintctico y lxico del texto de nuestro programa, entre otras etapas de la traduccin. Una caracterstica especial de Java es que cuando se compila un programa de Java, no se produce un programa ejecutable (en lenguaje de maquina) que se pueda correr de inmediato, Java trabajo algo diferente.

Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

La mayora de los lenguajes de programacin se caracterizan por ser interpretados o compilados, lo que determina la manera en como sern ejecutados en una computadora. Principales Caractersticas: Simple Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las caractersticas menos usadas y ms confusas de stos. C++ no es un lenguaje conveniente por razones de seguridad, pero C y C++ son los lenguajes ms difundidos, por ello Java se diseo para ser parecido a C++ y as facilitar un rpido y fcil aprendizaje. Java elimina muchas de las caractersticas de otros lenguajes de programacin como C++, para mantener reducidas las especificaciones del lenguaje y aadir caractersticas muy tiles como el garbage collector (reciclador de memoria dinmica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es de baja prioridad, cuando entra en accin, permite liberar bloques de memoria muy grandes, lo que limita mucho la fragmentacin de la memoria. Java reduce en un 50% los errores ms comunes de programacin con lenguajes como C y C++ al eliminar muchas de las caractersticas de stos, entre las que destacan: Aritmtica de punteros. Registros (struct) Definicin de tipos (typedef) Macros (#define) Necesidad de liberar memoria (free)

Orientado a objetos para algunas personas, la tcnica de programacin orientada a objetos (OOP) es meramente una manera de organizar programas, y que puede ser completada con un lenguaje. El trabajar en un ambiente y lenguaje orientado a objetos, nos da todas las ventajas de aprovechar todas las capacidades para crear programas flexibles, modulares, adems de poder reutilizar cdigo. Distribuido java se ha construido con extensas capacidades de interconexin TCP/IP. Existen libreras de rutinas para acceder e interactuar con protocolos

Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

como http y ftp. Esto permite a los programadores acceder a la informacin a travs de la red con tanta facilidad como a los archivos locales. Robusto Java realiza verificaciones tanto en tiempo de compilacin como en tiempo de ejecucin. La comprobacin de tipos en Java ayuda a detectar errores, lo antes posible, en el ciclo de desarrollo. Java obliga a la declaracin explcita de mtodos, reduciendo as las posibilidades de error. Maneja la memoria para eliminar las preocupaciones por parte del programador de la liberacin o corrupcin de memoria. Adems, para asegurar el funcionamiento de la aplicacin, realiza una verificacin de los ByteCodes, que son el resultado de la compilacin de un programa Java. Seguro el cdigo Java pasa muchas comprobaciones antes de ejecutarse en una mquina. El cdigo se pasa a travs de un verificador de ByteCode que comprueba el formato de los fragmentos de cdigo y aplica un probador de teoremas para detectar fragmentos de cdigo ilegal (cdigo que falsea punteros, viola derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un objeto). Java imposibilita, tambin, abrir archivos de la mquina local (siempre que se realizan operaciones con archivos, stas trabajan sobre el disco duro de la mquina de donde parti el applet), no permite ejecutar ninguna aplicacin nativa de una plataforma e impide que se utilicen otros computadores como puente, es decir, nadie puede utilizar una mquina para hacer peticiones o realizar operaciones con otra. Adems, los intrpretes que incorporan los navegadores Web son an ms restrictivos y por lo tanto los applets estn libres de virus. Respecto a la seguridad del cdigo fuente, no ya del lenguaje, el propio JDK proporciona un desemsamblador de ByteCode, que hace que cualquier programa pueda ser convertido a cdigo fuente, lo que para el programador significa una vulnerabilidad total a su cdigo. La proteccin de los programadores ante esto es utilizar llamadas a programas nativos, externos (incluso C y C++) de forma que no sea descompilable todo el cdigo; aunque as se pierda portabilidad.

Ing. Israel Durn Martnez

Facultad de Ingeniera

Java

Porttil ms all de la portabilidad bsica por ser de arquitectura independiente, Java implementa otros estndares de portabilidad para facilitar el desarrollo. Los enteros son siempre enteros y, adems, enteros de 32 bits en complemento a 2. Adems, Java construye sus interfaces de usuario a travs de un sistema abstracto de ventanas de forma que stas puedan ser implementadas en entornos Uns, Pc o Mac. Interpretado el intrprete Java (sistema run-time) puede ejecutar

directamente el cdigo objeto. Enlazar ( linkar) un programa normalmente consume menos recursos que compilarlo, por lo que los desarrolladores con Java pasarn ms tiempo desarrollando y menos esperando por el computador. No obstante, el compilador actual del JDK es bastante lento. Por ahora, en que todava no hay compiladores especficos de Java para las diversas plataformas, Java es ms lento que otros lenguajes de programacin, como C++, ya que debe ser interpretado y no ejecutado como sucede en cualquier programa tradicional. No obstante, este panorama est cambiando a pasos agigantados, y aunque Java sigue siendo bsicamente un lenguaje interpretado, la situacin se acerca mucho a la de los programas compilados, sobre todo en lo que se refiere a la rapidez en la ejecucin del cdigo se refiere. Independiente de la plataforma nos dice que debido a la forma que java compila e interpreta los programas, los programas creados en java tienen la capacidad de poder ser ejecutados en cualquier sistema operativo, sin tener que volver a compilarlo en un sistema operativo especfico.

Multi-hilos con java no tenemos la limitacin de escribir programas que solo


hagan una cosa a la vez. El soporte para hilos mltiples y sincronizados est construido directamente en el lenguaje java y el ambiente de ejecucin. Los hilos sincronizados son extremadamente tiles al crear aplicaciones distribuidas y con soporte para red. Tal es el caso de una aplicacin que establece comunicacin con un servidor remoto en un hilo mientras que interacta con el usuario en otro hilo.

Dinmico - Java se beneficia todo lo posible de la tecnologa orientada a


objetos y no intenta conectar todos los mdulos que comprenden una aplicacin hasta el mismo tiempo de ejecucin. Las libreras nuevas o actualizadas no

Ing. Israel Durn Martnez

10

Facultad de Ingeniera

Java

paralizarn la ejecucin de las aplicaciones actuales siempre que mantengan el API anterior.

1.4 Qu se puede hacer con Java? Con Java se pueden crear applets, servlets, jsp y aplicaciones. Applet un applet es un pequeo programa creado en java capaz de ejecutarse en la mquina cliente por medio del explorador de internet, ya sea Netscape o Internet Explorer o cualquier browser que tenga la habilidad de manejar java. Los applets son insertados mediante cdigo HTML en la pgina de internet, con el fin de que el usuario que consulte esa pgina pueda ver en ejecucin el applet. Aplicaciones una aplicacin en Java es mucho ms que un simple programa en

Java, es todo un conjunto de programas que pueden comunicarse entre s, de manera que proporcionen toda una interfaz entre el usuario y la computadora. Servlet esta tecnologa proporciona un mecanismo simple a los desarrolladores web para extender la funcionalidad de un servidor web y para acceder a sistemas de negocios existentes. Un servlet puede ser imaginado como un applet que corre del lado del servidor. Los servlets de java han hecho posible muchas aplicaciones web. JSP - JavaServer Pages (JSP) es una tecnologa basada en el lenguaje java que da la posibilidad de desarrollar sitios web dinmicos. Esta tecnologa fue desarrollada para permitir el desarrollo del lado del servidor. Los archivos JSP son archivos HTML con etiquetas especiales que contienen cdigo fuente en java para proporcional el contenido dinmico. 1.5 Entornos de desarrollo Entornos de desarrollo integrados para Java hay muchos: Sun ONE y netbeans de Sun. Visual Caf de Symantec. JBuilder de Borland. Kawa de TekTools. Visual Age Windows de IBM

Ing. Israel Durn Martnez

11

Facultad de Ingeniera

Java

CAPTULO 2: PROGRAMACIN ORIENTADA A OBJETOS Y JAVA

La programacin orientada a objetos es una de las ms grandes ideas en el campo de la programacin durante los aos recientes, y en cierta forma es ms fcil de manejar que la forma antigua de programacin. Todo se reduce a organizar sus programas en formas que reproducen la manera en que las cosas se unen en el mundo real. La programacin orientada a objetos (OOP) est modelada sobre cmo, en el mundo real, los objetos estn compuestos de muchos otros tipos pequeos objetos. Esta capacidad de combinar objetos, sin embargo, solo es un aspecto muy general de la programacin orientada a objetos. La OOP proporciona muchos otros conceptos y caractersticas para crear y usar objetos de manera fcil y flexible, y la ms importante de estas caractersticas es el concepto de clase. 2.1 Clases Definicin Una clase es una plantilla para mltiples objetos con caractersticas similares. Las clases engloban todas las caractersticas de una serie particular de objetos. Cuando se escribe un programa en un lenguaje orientado a objetos, no definimos objetos en realidad, lo que definimos son clases de objetos. Por ejemplo, uno podra tener la clase rbol que describe las caractersticas de todos los rboles (que tienen hojas y races, que crece, que produce clorofila, etc.). La clase rbol sirve como un modelo abstracto para el concepto de un rbol. Pero para poder interactuar con un rbol, es decir, para poder tocarlo, cortarlo, etc. debemos de tener una instancia concreta de ese rbol. Una vez que tenemos la clase rbol, podemos crear tantas instancias de un rbol como deseemos, pudiendo cada instancia de la clase rbol tener caractersticas diferentes (por ejemplo, altura, tipo, etc.) pero lo importante de esto es que tiene las caractersticas y comportamientos de un rbol.

Ing. Israel Durn Martnez

12

Facultad de Ingeniera 2.2 Objetos

Java

Una instancia de una clase es otra palabra para referirse a los objetos. Si una clase es la representacin genrica de un objeto, una instancia es su representacin concreta. Entonces, Cul es la diferencia entre una instancia y un objeto? En realidad ninguna. Objeto es un trmino ms general, pero tanto las instancias como los objetos son la representacin concreta de una clase. De hecho, los trminos instancia y objeto son usados intercambiablemente en un lenguaje de programacin orientado a objetos. Cuando se escribe un programa en Java, se disea y construye un conjunto de clases. Luego, cuando el programa se ejecuta, instancias de esas clases son creadas y manipulados como sea necesario. La tarea de un programador en java, es crear el conjunto correcto de clases para realizar lo que nuestro programa tenga que realizar. Afortunadamente, no tenemos que empezar desde cero: el ambiente de java viene con una librera de clases que implementan mucho del comportamiento bsico que necesita, no solo para las tareas de programacin bsicas (clases que ofrecen funciones matemticas elementales, arreglos, cadenas, entre otros), sino tambin para complejas tareas de cmputo, por ejemplo grficos, trabajo en red, etc. En muchos casos las bibliotecas de clases Java sern suficientes para que slo se requiera crear una clase en el programa Java que utiliza las bibliotecas de clase estndares. Para otros programas Java ms complejos, quiz se tenga que crear un conjunto completo de clases, con interacciones definidas entre ellas. 2.3 Atributos y mtodos Cada clase que se escribe en java esta generalmente compuesta de dos componentes: atributos y mtodos. Para poder comprender lo anterior, se explicar a la par con un ejemplo, se trata de una clase llamada Motocicleta. Atributos Los atributos son las caractersticas individuales que diferencian a un objeto de otro, y determina la apariencia, el estado u otras cualidades de ese objeto. Los atributos de una motocicleta podran incluir los siguientes:

Ing. Israel Durn Martnez

13

Facultad de Ingeniera

Java

Color: rojo, verde, plata, caf Estilo: estndar, moto deportiva Fabricante: Honda, BMW, Bultaco. Los atributos de un objeto pueden tambin incluir informacin acerca de su

estado; por ejemplo, puede contar con caractersticas como condicin del motor (apagado o encendido) o velocidad actual seleccionada. Los atributos son definidos por variables; de hecho, puede considerarceles anlogos a las variables globales del objeto completo. Puesto que cada instancia de una clase puede tener diferentes valores para sus variables, a cada variable se le llama una variable de instancia. Definicin Las variables de instancia definen los atributos de un objeto. La clase define el tipo de atributo, y cada instancia almacena su propio valor para ese atributo. Cada atributo cuenta con una correspondiente variable de instancia; as que, al cambiar el valor de una variable se cambia el atributo de ese objeto. Las variables de instancia pueden fijarse cuando se crea un objeto y permanecen constantes durante la vida del objeto, o bien se pueden habilitar para cambiar como se desee al ejecutarse el programa. Mtodos (Comportamiento) El comportamiento de una clase determina que instancias de esa clase requieran cambiar su estado interno o cuando esa instancia es llamada para realizar algo por otra clase u objeto. El comportamiento es la nica manera en que los objetos pueden hacerse algo a s mismos o tener que hacerles algo. Por ejemplo, regresando al ejemplo de la clase Motocicleta, aqu estn algunos comportamientos: Encender el motor Apagar el motor Acelerar Frenar Cambiar velocidades Para definir el comportamiento de un objeto, se crean mtodos, los cuales se parecen y comportan como funciones en otros lenguajes de programacin, pero son

Ing. Israel Durn Martnez

14

Facultad de Ingeniera

Java

definidos dentro de una clase. Java no tiene funciones definidas fuera de las clases (como C++ lo hace). Definicin Los mtodos son funciones definidas dentro de las clases que operan en las instancias de esas clases. Los mtodos no siempre afectan a un solo objeto; los objetos tambin se comunican entre s mediante el uso de mtodos. Una clase u objeto puede llamar a mtodos en otra clase u objeto para avisar sobre los cambios en el ambiente o para solicitarle a ese objeto que cambie su estado. 2.4 Herencia La herencia es uno de los conceptos ms importantes de la programacin orientada a objetos y tiene un efecto demasiado directo en la forma en que usted disea y escribe sus clases Java. La herencia es un poderoso mecanismo, lo que significa que cuando se escribe una clase, slo tiene que especificar como esa clase es diferente de otra case; por tanto, la herencia le dar acceso automtico a la informacin contenida en esa otra clase. Con la herencia, todas las clases, estn en una jerarqua estricta. Cada clase tiene una superclase (la clase superior en la jerarqua), y cada clase puede tener una o ms subclases (clases abajo en la jerarqua). Se dice que las clase inferiores en la jerarqua, heredan de las clases ms altas.

Ing. Israel Durn Martnez

15

Facultad de Ingeniera Jerarqua de Clases

Java

Clase A es la superclase de B Clase B es la subclase de A Clase B es la superclase de C, D, y E Las clases C,D, y E son subclases de B

Las subclases heredan todos los mtodos y variables de las superclases; es decir, en cualquier clase particular, si la superclase define un comportamiento que la clase necesita, no se tiene que volver a definir o copiar ese cdigo de alguna otra clase. La clase, en forma automtica, obtiene ese comportamiento de la superclase, y as sucesivamente, hacia arriba de la jerarqua. La clase se convierte entonces en una combinacin de todas las caractersticas de las clases arriba de ella, en la jerarqua. En la cima de la jerarqua de clases en Java esta la clase Object; todas las clases heredan de esta superclase. Object es la clase ms general en la jerarqua de clases, ya que define el comportamiento heredado por todas las clases en la jerarqua de clase Java. Cada clase hacia abajo aade ms informacin y se vuelve cada vez mas de propsito especfico. De esta manera se puede pensar en una jerarqua de clases como la definicin de conceptos demasiados abstractos en lo alto de la jerarqua, y esas ideas se convierten en algo ms concreto conforme desciende por la cadena de la superclase. La forma en que hereda Java se llama herencia sencilla, lo cual quiere decir que cada clase Java puede tener slo una superclase aunque cualquier superclase puede tener mltiples subclases.

Ing. Israel Durn Martnez

16

Facultad de Ingeniera

Java

Si se va a crear un conjunto ms grande de clases, tiene sentido que las clases no slo hereden de la jerarqua de clases existentes, sino que tambin hagan por s mismas una jerarqua. Esto podra implicar una planeacin previa al organizar el cdigo Java. Ejemplo: Object

Vehculo

Vehculo movidos por el hombre

Vehculos movidos por motor

De dos ruedas

De cuatro ruedas

Motoneta

Motocicleta

Como funciona la herencia En las variables de instancia, cuando crea una nueva instancia de una clase, obtiene una ranura para cada variable definida en la clase actual, y para cada variable definida en todas sus superclases. De esta manera, todas las clases se combinan para formar una plantilla para el objeto actual, y despus cada objeto llena el hueco de la informacin adecuada para su situacin. Los mtodos operan en forma similar: los objetos nuevos tienen acceso a todos los nombres de mtodos de su clase y sus superclases, pero las definiciones de mtodos se eligen en forma dinmica cuando se llama a un mtodo. Es decir, si se llama a un mtodo de un objeto en particular, Java primero revisa en la clase del objeto al buscar la definicin de ese mtodo. Si no esta definida la clase del objeto,
Ing. Israel Durn Martnez

17

Facultad de Ingeniera

Java

busca en la superclase de la clase, y as en lo sucesivo hacia arriba de la cadena, hasta que encuentra la definicin del mtodo. Definicin del mtodo Clase

Clase

Clase

Clase

Clase

El mensaje se enva al objeto y se transmite a las clases superiores de la jerarqua hasta encontrar una definicin 2.5 Interfaces y Paquetes Interfaces Las clases en Java tienen slo una superclase, y heredan variables y mtodos de esa superclase y de todas sus superclases. Aunque la herencia sencilla hace la relacin entre clases, y la funcionalidad que esas clases implantan es fcil de entender y de disear, tambin puede ser de alguna manera restrictiva; en particular, cuando tiene un comportamiento similar que necesita duplicarse mediante diferentes ramas de la jerarqua de clase. Java soluciona este problema al utilizar el concepto de interfaz. Definicin Una interfaz es una coleccin de nombres de mtodos, sin definicin en realidad, que indican que una clase tiene un conjunto de comportamientos en adicin a los comportamientos que hereda de su superclase.
Ing. Israel Durn Martnez

Objeto

18

Facultad de Ingeniera

Java

Aunque una clase Java puede tener slo una superclase (a causa de la herencia sencilla), esa clase tambin puede implantar cualquier nmero de interfaces. Al implantar una interfaz, una clase proporciona implantaciones de mtodos para los nombres de mtodos definidos por la interfaz. Si dos clases muy diferentes implantan la misma interfaz, ambas pueden responder a la misma llamada del mtodo, aunque lo que cada clase hace en respuesta a esas llamadas del mtodo puede ser distinto. Paquetes El elemento fundamental de este lenguaje son las clases. Existe, sin embargo, un elemento de mayor rango llamado paquete, que no es ms que un contenedor de clases. Actan a modo de libreras y existen ms que nada por comodidad. Para agrupar varios ficheros fuente de Java en un slo paquete incluiremos una lnea al comienzo de los mismos: package mipaquete; Y el cdigo resultante (los ficheros con extensin class) se situaran en el directorio mipaquete. Perteneceran al paquete mipaquete. Para poder utilizarlos desde otro programa deberamos utilizar la sentencia import, que tambin se coloca al principio del programa (aunque despus de package): import mipaquete.*; Hay que indicar que import es una palabra clave que indica las clases que deseamos cargar, no los paquetes. Sin embargo, al admitir el uso del comodn *, se puede utilizar para cargar paquetes enteros. Por ejemplo, si deseamos utilizar la clase Date, situada en el paquete java.util, podemos cargarla de dos maneras: import java.util.Date; import java.util.*; Algunos paquetes de Java

Ing. Israel Durn Martnez

19

Facultad de Ingeniera

Java

Existen muchos paquetes en la librera estndar de Java, paquetes que, adems, han ido variando segn se sucedan las versiones del mismo. As, pues, vamos a destacar algunos paquetes presentes en todos los JDK: java.lang Este paquete incluye las clases imprescindibles para que el lenguaje Java funcione como tal, es decir, clases como Object, Thread, Exception, System, Integer, Float, Math, Package, String, etc., que implementan la base del lenguaje. No es necesario importar nada desde ese paquete porque se carga por defecto. java.util Este paquete es el segundo en importancia, ya que incluye muchas clases tiles como pueda ser Date (fecha) y, sobre todo, diversas clases que permiten el almacenamiento dinmico de informacin, como Vector, LinkedList, HashMap, etc.. java.applet Contiene la archifamosa clase Applet, que nos permite crear applets para verlos en nuestro navegador. java.awt Este paquete, cuyo nombre corresponde a las siglas de Abstract Windowing Toolkit, contiene las clases necesarias para crear interfaces de usuario, por medio de mens, botones, reas de texto, cajas de confirmacin, etc.. java.io Este paquete contiene las clases necesarias para realizar las operaciones de entrada/salida, ya sea a pantalla o a ficheros, clases heredadas de FileInputStream y FileOutputStream. java.net Paquete que permite la programacin de aplicaciones que accedan a bajo nivel a redes TCP/IP.

Ing. Israel Durn Martnez

20

Facultad de Ingeniera

Java

CAPTULO 3: FUNDAMENTOS Y SINTAXIS

3.1 Comentarios /* Este es un comentario de varias lneas */ // Este es un comentario de una sola lnea /** Comentario de documentacin que interpreta Javadoc */ 3.2 Tipos de datos primitivos

O tr o

Tipo byte short int long float double char boolean

Descripcin Entero de 1 Byte Entero corto Entero Entero largo Punto flotante precisin sencilla Punto flotante doble precisin Caracter valor booleano (true o false)

Formato 8 bits en complemento a dos 16 bits en complemento a dos 32 bits en complemento a dos 64 bits en complemento a dos 32 bits segn IEEE 754 64 bits segn IEEE 754 Cdigo Unicode de 16 bits

En R s ea le s

primitivos de datos depender de la plataforma en la cual se corra el programa. En contraste, Java especifica el tamao y el formato de estos tipos primitivos de datos. Por lo tanto, no importa en la plataforma en que s este trabajando ya que los tipos primitivos de datos siempre conservaran el mismo valor. 3.3 Variables Declaracin Tipo_dato nombre_variable = valor_inicio; Tipos de Variables

Ing. Israel Durn Martnez

te ro s

En otros lenguajes de programacin, el formato y el tamao de los tipos

21

Facultad de Ingeniera

Java

Las variables son localidades de memoria en las que pueden almacenarse datos. Cada una tiene un nombre, un tipo y valor. Java tiene tres tipos de variables: de instancia, de clase y locales. Variables de instancia. Se utilizan para definir los atributos de un objeto. Variables de clase. Son similares a las variables de instancia, con la excepcin de que sus valores son los mismos para todas las instancias de la clase. Variable locales. Se declaran y se utilizan dentro de las definiciones de los mtodos. Nombre de las variables El nombre de las variables no debe de pertenecer al conjunto de las palabras reservadas. El nombre de las variables empiezan con una letra minscula y los nombres de las clases empiezan con una letra mayscula. Si el nombre de la variable consiste en ms de una palabra, las palabras van unidas y la primera letra despus de la primera palabra se empieza con una letra mayscula; al igual que en el nombre de las clases. Ejemplo: int varEntera; int varEntera = 2; String varCadena = variable de cadena; boolean varBooleana = true; char varChar = a; En caso de que no se inicialicen las variables de instancia y de clase con algn valor, el compilador de java les asignar los siguientes valores por default: Cadenas: null; Nmeros: 0; Booleanos: false; Carcter: \0; Las variables locales siempre se inicializan.

Ing. Israel Durn Martnez

22

Facultad de Ingeniera Alcance de las Variables

Java

3.4 Constantes Las constantes son tiles para definir valores comunes para todos los mtodos de un objeto (para dar nombres significativos a valores de objetos generales que nunca cambiarn). En Java, puede crear constantes slo para variables de instancia o de clase, no para variables locales. Para declarar una constante se utiliza la palabra clave final antes de la declaracin de la variable. Ejemplos: final flota PI = 3.141592; final bolean DERECHA = true, final int MAXIMO_VALOR = 100; 3.5 Literales nmero nmero[l|L] 0[X|x]hex 0octal [nmero].nmero nmero[D|d] nmero[F|f] [+|-] nmero Tipo int Tipo long Entero hexadecimal Entero octal Tipo double Tipo double Tipo float Con signo

Ing. Israel Durn Martnez

23

Facultad de Ingeniera nmeroenmero nmeroEnmero caracter caracteres \b \t \n \r \ \ \\ \uNNNN true false 3.6 Palabras reservadas abstract boolean break byte case catch char class const* continue default do 3.7 Operadores Operadores Aritmticos double else extends final finally float for goto* if implements import instanceof int interface long native new package private protected public return short static strictfp** super switch synchronized this throw throws transient try void volatile while Exponencial Exponencial Tipo char Cadena (String) Caracter retroceso Tabulador Salto de lnea (Enter) Regreso de carro Comillas Comilla sencilla Diagonal inversa Caracter en Unicode (NNNN es hexadecimal) Booleano Booleano

Java

Operador + * / %

Sintaxis op1 + op2 +op op1 - op2 -op op1 * op2 op1 / op2 op1 % op2

Descripcin Suma de op1 y op2 Convierte op a int, si este es byte, short o char Resta op2 de op1 Regresa el valor negativo de op Multiplicacin de op1 por op2 Divisin de op1 entre op2 Residuo de dividir op1 por op2

Ing. Israel Durn Martnez

24

Facultad de Ingeniera Operadores Incremento y Decremento

Java

Operador ++ ++ ---

Sintaxis op++ ++op op---op

Descripcin Incremento de op en 1. Se toma el valor de op antes de incrementarse Incremento de op en 1. Se toma el valor de op despus de incrementarse Decremento de op en 1. Se toma el valor de op antes de Decrementarse Decremento de op en 1. Se toma el valor de op despus de Decrementarse

Operadores Relacionales
Operador > >= < <= == != Sintaxis op1 > op2 op1 >= op2 op1 < op2 op1 <= op2 op1 == op2 op1 != op2 Regresa true si: op1 es mayor que op2 op1 es mayor o igual a op2 op1 es menor que op2 op1 es menor o igual a op2 op1 y op2 son iguales op1 y op2 son diferentes

Operadores Condicionales
Operador && || ! & | ^ Sintaxis op1 && op2 op1 || op2 !op op1 & op2 op1 | op2 op1 ^ op2 Regresa true si: op1 y op2 son ambos true. Condicionalmente evalua op2. op1 op2 es true. Condicionalmente evalua op2. op es false op1 y op2 son ambos true.Siempre evalua op1 y op2. op1 op2 es true.Siempre evalua op1 y op2. op1 y op2 son diferentes

Estas expresiones regresan true o false.

Ing. Israel Durn Martnez

25

Facultad de Ingeniera

Java

Operadores a nivel de bits


Operador & | ^ ~ >> << >>> Sintaxis op1 & op2 op1 | op2 op1 ^ op2 ~op2 op1 >> op2 op1 << op2 op1 >>> op2 and a nivel de bits or a nivel de bits xor a nivel de bits complemento a uno Corrimiento de bits a la derecha de op1 en op2 posiciones Corrimiento de bits a la izquierda de op1 en op2 posiciones Corrimiento de bits a la derecha de op1 en op2 posiciones (unsigned) Operacin

Otros Operadores
Operador ?: [] . ( params ) ( tipo ) new instanceof Descripcin Operador condicional. Simulacin de if-else. Para declarar, crear y accesar arreglos. Acceso a miembros de instancia y de clase Lista de parmetros separados por coma. Conversin de tipo al tipo especficado (cast) Crea un nuevo objeto o arreglo Determina si un operando es una instancia de otro.

Ing. Israel Durn Martnez

26

Facultad de Ingeniera Precedencia de operadores


Operadores posfijos
Menor precedencia <---------------->Mayor Precedencia

Java

[] . (params ) expr ++ expr -++expr --expr +expr -expr ~ ! new (type )expr * / % + << >> >>> < > <= >= instanceof == != & ^ | && || ? : = += -= *= /= %= &= ^= |= <<= >>= >>>=

Operadores unarios Creacin o cast Multiplicativos Aditivos Corrimiento Relacionales Igualdad AND a nivel de bits XOR a nivel de bits OR a nivel de bits AND lgico OR lgico Op. Condicional Asignacin

3.8 Arreglos Los arreglos en java son diferentes con respecto a los de otros lenguajes de programacin; en Java son verdaderos objetos que pueden pasarse y tratarse de la misma manera que otros objetos. Los arreglos son una forma de almacenar una lista de elementos. Cada espacio del arreglo guarda un elemento individual en el cual se pueden colocar los elementos o cambiar el contenido de esos espacios segn se necesite. Los arreglos pueden tener cualquier tipo de valor de elemento (tipo primitivo u objetos), pero no podr almacenar diferentes tipos en un solo arreglo. Es factible tener un arreglo de enteros o un arreglo de cadenas, o un arreglo de arreglos, pero no tendr un arreglo que contenga, por ejemplo, cadenas y enteros. El tamao de un arreglo es establecido cuando el arreglo es creado.

Ing. Israel Durn Martnez

27

Facultad de Ingeniera Cmo declarar variables de arreglo

Java

El primer paso para crear un arreglo es crear una variable que guarde el arreglo, justo como lo hara con cualquier otra variable. As como cuando se declaran variables de otro tipo, la declaracin de un arreglo consta de dos componentes: el tipo de arreglo y el nombre del arreglo. Un tipo de arreglo es escrito as: tipo[], donde tipo es el tipo de dato de los elementos del arreglo, y los corchetes ([]) indican que es un arreglo. Recuerde que los elementos de un arreglo son de un mismo tipo. Los siguientes son enunciados de variables de arreglo comunes: Tipo_arreglo nombre_arreglo[]; String palabras[]; int numeros[]; Un mtodo alterno para definir una variable de arreglo es colocar los corchetes despus del tipo, en lugar de en seguida de la variable. Estos dos mtodos son equivalentes, pero con frecuencia el segundo es ms legible. Tipo_arreglo[] nombre_arreglo; String[] palabras; int[] numeros;

Cmo crear objetos de arreglo Existen dos formas de crear un objeto de arreglo y asignarlo a una variable. Las dos formas son las siguientes: Usar new. Inicializar de manera directa el contenido de ese arreglo. La primera forma de hacerlo implica el uso del operador new para crear una nueva instancia de un arreglo: tipo_arreglo[] nombre_arreglo = new tipo_arreglo[tamao_arreglo]; o tambin: tipo_arreglo[] nombre_arreglo; nombre_arreglo = new tipo_arreglo[tamao_arreglo];

String colores[]; Declaracin colores = new String[5]; Creacin del arreglo

Ing. Israel Durn Martnez

28

Facultad de Ingeniera

Java

String[] colores = new String[5]; La lnea crea un nuevo arreglo de Strings con cinco slots (casillas) conteniendo los elementos. Cuando crea un nuevo objeto de arreglo con new deber indicar cuantas casillas tendr ese arreglo. Los objetos de arreglo pueden contener tipos primitivos o bolanos, de la misma forma que contienen objetos. Cuando se crean objetos de arreglo mediante el uso de new, todas sus casillas se inicializan por default(0 para arreglos numricos, false para booleanos, \0 para arreglos de caracteres y null para objetos). Tambin puede crear e inicializar un arreglo al mismo tiempo; en lugar de utilizar new para crear un objeto de arreglo distinto, encierre los elementos del arreglo dentro de llaves, separados por comas: String[] colores = {azul, rojo, amarillo, negro, blanco}; Cada uno de los elementos dentro de las llaves debe ser del mismo tipo y debe coincidir con el tipo de la variable que contiene ese arreglo. Acceso a los elementos del arreglo Una vez que se tenga un arreglo con valores iniciales, puede probar y cambiar los valores de cada casilla de ese arreglo. Para lograr lo anterior se hace lo siguiente: nombreArreglo[indice]=dato_a_ingresar; Recurdese que los ndices comienzan desde cero y que el dato a ingresar debe ser del tipo de dato del arreglo. Obtener el tamao de un arreglo Para obtener el tamao de un arreglo se hace lo siguiente: nombreArreglo.length Se debe de tomar en cuenta que length no es un mtodo sino que es una propiedad que proviene de la plataforma de java para todos los arreglos.

Ing. Israel Durn Martnez

29

Facultad de Ingeniera

Java

CAPTULO 4. CONTROL DE FLUJO

El control de flujo es la manera que tiene un lenguaje de programacin de hacer que el flujo de la ejecucin avance y se ramifique en funcin de los cambios de estado de los datos. Java, en este aspecto, no utiliza los principios de diseo orientado a objetos, sino que las sentencias de control de flujo del programa se han tomado de C/C++. A continuacin se tratan todos los mecanismos que proporciona Java para conseguir este control y decidir qu partes del cdigo ejecutar. 4.1 Sentencia if-else If (expresin booleana) { sentencias; } [else { sentencias; }] La clusula else es opcional. Cada una de las sentencias puede ser compuesta y la expresin booleana podra ser una variable simple declarada como bolean, o bien una expresin que utilice operadores relacionales para generar el resultado de una comparacin. 4.2 Sentencia switch switch (expresin) { case valor1: sentencias; break; case valor2: sentencias; break; [default: sentencias;] } La expresin puede devolver cualquier tipo bsico, y cada uno de los valores especificados en las sentencias case debe ser de un tipo compatible. 4.3 Bucle for

Ing. Israel Durn Martnez

30

Facultad de Ingeniera for (inicializacin; terminacin; iteracin) { sentencias; } Un bucle for, normalmente, involucra a tres acciones en su ejecucin: Inicializacin de la variable de control.

Java

Comprobacin del valor de la variable de control en una expresin condicional. Actualizacin de la variable de control. La clusula de inicio y la clusula de incremento pueden estar compuestas por

varias expresiones separadas mediante el operador coma (,), que en estos bucles Java tambin soportan. for(a=0, b=1; a < 7; a++; b+=2) 4.4 Bucle while [inicializacin;] while (terminacin expresin booleana) { sentencias; [iteracin;] } El bucle while es la sentencia de bucle ms bsica en Java. Ejecuta repetidamente una vez tras otra una sentencia mientras una expresin booleana sea verdadera. Las partes de inicializacin e iteracin, que se presentan entre corchetes, son opcionales. 4.5 Bucle do-while [inicializacin;] do { sentencias; [iteracin;] } while(terminacin expresin booleana)

Ing. Israel Durn Martnez

31

Facultad de Ingeniera

Java

A veces se puede desear el ejecutar el cuerpo de un bucle while al menos una vez, incluso si la expresin booleana de terminacin tiene el valor false la primera vez; es decir, si se desea evaluar la expresin de terminacin al final del bucle en vez de al principio como en el bucle while. 4.6 Control general de flujo break break [etiqueta]; La sentencia break puede utilizarse en una sentencia switch o en un bucle. Cuando se encuentra en una sentencia switch, break hace que el control del flujo del programa pase a la siguiente sentencia que se encuentra fuera del entorno del switch. Si se encuentra en un bucle, hace que el flujo de ejecucin del programa deje el mbito del bucle y pase a la siguiente sentencia que venga a continuacin del bucle. Java incorpora la posibilidad de etiquetar la sentencia break, de forma que el control pasa a sentencias que no se encuentran inmediatamente despus de la sentencia switch o del bucle, es decir, saltar a la sentencia en donde se encuentre situada la etiqueta. La sintaxis de una sentencia etiquetada es la siguiente: etiqueta: sentencia; continue continue [etiqueta]; La sentencia continue no se puede utilizar en una sentencia switch, sino solamente en bucles. Cuando se encuentra esta sentencia en el discurrir normal de un programa Java, la iteracin en que se encuentre el bucle finaliza y se inicia la siguiente. Java permite el uso de etiquetas en la sentencia continue, de forma que el funcionamiento normal se ve alterado y el salto en la ejecucin del flujo del programa se realizar a la sentencia en la que se encuentra colocada la etiqueta.

Ing. Israel Durn Martnez

32

Facultad de Ingeniera

Java

Ejemplo:
uno: for( ) { dos: for( ) { continue; //seguira en el bucle interno continue uno; //seguira en el bucle principal break uno; //se saldra del bucle principal } }

return return expresin; La sentencia return se utiliza para terminar un mtodo o funcin y

opcionalmente devolver un valor al mtodo de llamada.

Ing. Israel Durn Martnez

33

Facultad de Ingeniera

Java

CAPTULO 5: CLASES

Las clases son lo ms simple de Java. Todo en Java forma parte de una clase, es una clase o describe como funciona una clase. El conocimiento de las clases es fundamental para poder entender los programas Java. 5.1 Definicin de clases Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un Objeto. Un objeto es una instancia de una clase. Todos los mtodos se definen dentro del bloque de la clase, Java no soporta funciones o variables globales. As pues, el esqueleto de cualquier aplicacin Java se basa en la definicin de una clase. Para crear una clase slo se necesita un archivo fuente que contenga la palabra clave reservada class seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase. Ejemplo: class MiClase { //Cuerpo de la clase } Un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele asignar la extensin ".java". Por ejemplo la clase llamada MiClase se guardara en un fichero que se llamase MiClase.java. Hay que tener presente que en Java se diferencia entre maysculas y minsculas; el nombre de la clase y el de archivo fuente han de ser exactamente iguales. Aunque la clase MiClase es sintcticamente correcta, lo que se viene a llamar una clase vaca, es decir, una clase que no hace nada. Las clases tpicas de Java incluirn variables y mtodos de instancia. Los programas en Java completos constarn por lo general de varias clases de Java en distintos archivos fuente.

Ing. Israel Durn Martnez

34

Facultad de Ingeniera La forma general de una definicin de clase es:

Java

En la declaracin de una clase se utiliza la palabra clave extends para especificar la superclase, de la siguiente forma: class MiClase extends SuperClase { // Cuerpo de la clase } Una clase puede implementar una o ms interfaces, declarndose esto utilizando la palabra clave implements, seguida de la lista de interfaces que implementa, separadas por coma (,), de la forma: class MiClase extends SuperClase implements MiInterfaz, TuInterfaz { // Cuerpo de la clase }

Ing. Israel Durn Martnez

35

Facultad de Ingeniera

Java

El cuerpo de la clase contiene las declaraciones, y posiblemente la inicializacin, de todos los datos miembro, tanto variables de clase como variables de instancia, as como la definicin completa de todos los mtodos. 5.2 Tipos de clase public Las clases public son accesibles desde otras clases, bien sea directamente o por herencia, desde clases declaradas fuera del paquete que contiene a esas clases pblicas, ya que, por defecto, las clases solamente son accesibles por otras clases declaradas dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas. La sintaxis es: public class MiClase extends SuperClase implements MiInterfaz, TuInterfaz { // cuerpo de la clase } abstract Una clase abstract tiene al menos un mtodo abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia. final Una clase final se declara como la clase que termina una cadena de herencia, es lo contrario a una clase abstracta. Nadie puede heredar de una clase final. Por ejemplo, la clase Math es una clase final. synchronizable Este modificador especifica que todos los mtodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintas tareas; el sistema se encarga de colocar los flags necesarios para evitarlo.

Ing. Israel Durn Martnez

36

Facultad de Ingeniera

Java

Este mecanismo hace que desde tareas diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobrescriban. Si no se utiliza alguno de los modificadores expuestos, por defecto, Java asume que una clase es: No final No abstracta Subclase de la clase object No implementa interfaz alguna

5.3 Modificadores de acceso El control de acceso se aplica siempre a nivel de clase, no a nivel de objeto. Es decir, los mtodos de instancia de un objeto de una clase determinada tienen acceso directo a los miembros privados de cualquier otro objeto de la misma clase. Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se quiere para las variables de instancia y los mtodos definidos en la clase: private, protected, public y package. La siguiente tabla muestra el nivel de acceso que est permitido a cada uno de los especificadotes:

Nivel de acceso

clase X X X X

subclase

paquete

Todos

private protected public package

X* X

X X X X

Se puede observar en la tabla que la columna clase indica que todos los mtodos de una clase tienen acceso a todos los otros miembros de la misma clase, independientemente del nivel de acceso especificado.

Ing. Israel Durn Martnez

37

Facultad de Ingeniera

Java

La columna subclase se aplica a todas las clases heredadas de la clase, independientemente del paquete en que residan. Los miembros de una subclase tienen acceso a todos los miembros de la superclase que se hayan designado como public. El asterisco (*) en la interseccin subclase-protected quiere decir que si una clase es a la vez subclase y est en el mismo paquete que la clase con un miembro protected, entonces la clase tiene acceso a ese miembro protegido. En general, si la subclase no se encuentra en el mismo paquete que la superclase, no tiene acceso a los miembros protegidos de la superclase. Los miembros de una subclase no tienen acceso a los miembros de la superclase catalogados como private o package, excepto a los miembros de la superclase designados como package. La columna paquete indica que las clases del mismo paquete tienen acceso a los miembros de una clase, independientemente de su rbol de herencia. La tabla indica que todos los miembros protected, public y package de una clase pueden ser accedidos por otra clase que se encuentre en el mismo paquete excepto las descritas como private. La columna todos indica que los privilegios de acceso para mtodos que no estn en la misma clase, ni en una subclase, ni en el mismo paquete, se encuentran restringidos a los miembros pblicos de la clase.

Private
Misma clase Misma subclase de paquete Misma no-subclase de paquete Subclase de diferente paquete No-subclase paquete de

Sin modificador S S S No No

protected S S S S No

Public S S S S S

S No No No

diferente No

Ing. Israel Durn Martnez

38

Facultad de Ingeniera

Java

CAPTULO 6: OBJETOS

6.1 Ciclo de vida de los objetos Un objeto es una instancia de una clase. En Java la creacin de un objeto se realiza en tres pasos: Declaracin, proporcionar un nombre al objeto. NombreClase nombreObjeto; Instanciacin, asignar memoria al objeto. nombreObjeto = new NombreClase(); Inicializacin, opcionalmente se pueden proporcionar valores iniciales a las variables de instancia del objeto. NombreObjeto = new NombreClase(/*parmetros del constructor*/); Cmo obtener valores Para obtener el valor de una variable de instancia se utiliza la notacin de punto. Con la notacin de punto, un nombre de variable de instancia o de clase tendr dos partes: el objeto, al lado izquierdo del punto y la variable, al lado derecho. Por ejemplo, si se tiene un objeto llamado objeto1 y ese objeto tiene una variable llamada var, se referir al valor de esta manera: objeto1.var; Esta forma de tener acceso a las variables es una expresin, asimismo son expresiones a ambos lados del punto. Es decir, puede anidar el acceso a las variables de instancia. Si var mantiene un objeto, y ste tiene su propia variable de instancia llamada estado, puede hacerse referencia a l de esta manera: objeto1.var.estado;

Ing. Israel Durn Martnez

39

Facultad de Ingeniera

Java

Las expresiones de punto se evalan de izquierda a derecha, as que se empieza con la variable var de objeto1, la cual se dirige a otro objeto con la variable estado. Al final se tendr el valor de esa variable. Cmo cambiar valores Asignar un valor a una variable tambin se utiliza el operador punto. Solo se le agrega el operador de asignacin al lado derecho de la expresin. objeto1.var.estado = true; 6.2 Comparacin de objetos Los nicos operadores que nos servirn para comparar objetos sern los de igualdad: == (igual) y != (diferente). Estos operadores cuando se utilizan con objetos, prueban si los dos operandos se refieren con exactitud al mismo objeto. Un buen ejemplo de lo anterior es la clase String. Es posible tener dos cadenas, dos objetos independientes en memoria con los mismos valores; es decir, los mismos caracteres en el mismo orden. De acuerdo con el operador ==, no obstante, estos dos objetos String no sern iguales, ya que aunque su contenido es el mismo, no sern el mismo objeto. En consecuencia, la clase String define un mtodo llamado equals() que examina cada carcter en la cadena true, si las dos cadenas tienen los mismos valores.
class ComparacionObjetos { public static void main(String args[]) { String cad1, cad2; cad1 = "Cadena numero uno"; cad2 = cad1; System.out.println("Cadena 1: " + cad1); System.out.println("Cadena 2: " + cad2 + "\n"); System.out.println("Es el mismo objeto? " + (cad1==cad2) + "\n"); cad2 = new String(cad1); System.out.println("Cadena 1: " + cad1);

Ing. Israel Durn Martnez

40

Facultad de Ingeniera
System.out.println("Cadena 2: " + cad2 + "\n"); System.out.println("Es el mismo objeto? " + (cad1==cad2)); System.out.println("Tienen el mismo valor? " + cad1.equals(cad2)); } }

Java

La salida es la siguiente:
Cadena 1: Cadena numero uno Cadena 2: Cadena numero uno Es el mismo objeto? true Cadena 1: Cadena numero uno Cadena 2: Cadena numero uno Es el mismo objeto? false Tienen el mismo valor? Trae

En la primera parte de este programa se declaran dos variables, cad1 y cad2, asignndole la cadena Cadena numero uno a cad1, y luego asigna ese valor a cad2. entonces cad1 y cad2 apuntan al mismo objeto, y esto se verifica en la siguiente lnea: System.out.println("Es el mismo objeto? " + (cad1==cad2) + "\n"); En la segunda parte se crea un nuevo objeto de cadena, con el valor de cad1 (cad2 = new String(cad1);). Ahora se tienen dos diferentes objetos de cadena con el mismo valor. entonces se prueban con el operador == y los examina con el mtodo equals() para comparar sus valores.

Ing. Israel Durn Martnez

41

Facultad de Ingeniera

Java

CAPTULO 7: MTODOS

Los mtodos son sin duda alguna la parte ms importante de cualquier lenguaje orientado a objetos. Mientras que las clases y los objetos ofrecen la estructura, y las variables de clase y de instancia una manera de contener los atributos y el estado de esa clase u objeto, los mtodos son los que en realidad determinan el comportamiento del objeto y definen como interacta con otros en el sistema . La implementacin de un mtodo consta de dos partes, una declaracin y un cuerpo. 7.1 Implementacin de mtodos La implementacin de mtodos cuenta con cuatro partes bsicas: El nombre del mtodo. El tipo de objeto o tipo primitivo que el mtodo regresa. Una lista de parmetros. El cuerpo del mtodo. La declaracin completa de un mtodo es la que se muestra a continuacin:
controlAcceso static abstract final native synchronized tipoRetorno nombreMetodo(lista_argumentos) { cuerpo del mtodo }

En la parte superior lo que esta en negrillas es la parte que es obligatoria o las partes bsicas que contiene el mtodo a la hora de su declaracin. controlAcceso, determina si otros objetos pueden acceder al mtodo y cmo pueden hacerlo. static, indica que los mtodos pueden ser accedidos sin necesidad de instanciar un objeto del tipo que determina la clase. abstract, indica que el mtodo no est definido en la clase, sino que se encuentra declarado ah para ser definido en una subclase(sobrescrito). final, evita que un mtodo pueda ser sobrescrito.

Ing. Israel Durn Martnez

42

Facultad de Ingeniera

Java

native, son mtodos escritos en otro lenguaje. synchronized, se usa en el soporte de la multitarea. lista_argumentos, es la lista opcional de parmetros a pasar al mtodo. Es un conjunto de declaraciones de variables separadas por comas dentro de los parntesis. Estos parmetros se vuelven variables locales en el cuerpo del mtodo, cuyos valores son los objetos o los valores primitivos transmitidos cuando se llama al mtodo. Dentro del cuerpo de un mtodo puede tener enunciados, expresiones, llamadas de mtodos a otros objetos, condicionales, ciclos y dems. 7.2 Tipos de mtodos En Java existen dos tipos de mtodos. Los mtodos de instancia y los mtodos de clase.

Mtodos de instancia Cuando se incluye un mtodo en una definicin de una clase Java sin utilizar la palabra clave static, se est generando un mtodo de instancia. Aunque cada objeto de la clase no contiene su propia copia de un mtodo, el resultado final es como si fuese as, como si cada objeto dispusiese de su propia copia del mtodo. La llamada a los mtodos de instancia en Java se realiza utilizando el nombre del objeto, el operador punto y el nombre del mtodo. miObjeto.nombreMetodo(); Los mtodos de instancia tienen acceso tanto a las variables de instancia como a las variables de clase.

Mtodos de Clase Cuando en la declaracin de un mtodo se incluye la palabra reservada static, se obtiene un mtodo de clase.

Ing. Israel Durn Martnez

43

Facultad de Ingeniera

Java

Lo ms significativo de los mtodos de clase es que pueden ser invocados sin necesidad de que haya que instanciar ningn objeto de la clase. La llamada a los mtodos de clase se realiza con el nombre de la clase, el operador punto y el nombre del mtodo. MiClase.nombreMetodo(); 7.3 Retorno por valor y por referencia En Java es imprescindible que a la hora de la declaracin de un mtodo, se indique el tipo de dato que ha de devolver. Si no devuelve ningn valor, se indicar el tipo void como retorno. Todos los tipos primitivos en Java se devuelven por valor y todos los objetos se devuelven por referencia. Para devolver un valor se utiliza la palabra clave return. La palabra clave return va seguida de una expresin que ser evaluada para saber el valor de retorno. Esta expresin puede ser compleja o puede ser simplemente el nombre de un objeto, una variable de tipo primitivo o una constante.

Si un programa Java devuelve una referencia a un objeto y esa referencia no es asignada a ninguna variable, o utilizada en una expresin, el objeto se marca inmediatamente para que el reciclador de memoria en su siguiente ejecucin devuelva la memoria ocupada por el objeto al sistema, asumiendo que la direccin no se encuentra ya almacenada en ninguna otra variable. El tipo del valor de retorno debe coincidir con el tipo de retorno que se ha indicado en la declaracin del mtodo; aunque en Java, el tipo actual de retorno puede ser una subclase del tipo que se ha indicado en la declaracin del mtodo. 7.4 Sobreescribir y sobrecargar mtodos Algunas de las caractersticas que hacen de los mtodos sean tan poderosos son las siguientes:

Ing. Israel Durn Martnez

44

Facultad de Ingeniera

Java

Sobrecargar mtodos: mtodos con mltiples identificaciones y definiciones, pero con el mismo nombre. Sobrescribir mtodos: creando una definicin distinta para un mtodo definido en una superclase. Sobrecargar mtodos La sobrecarga de mtodos le permite a las instancias de su clase tener una

interfaz ms sencilla para otros objetos (no hay necesidad de mtodos por completo diferentes que realizan en esencia lo mismo) y comportarse en forma diferente en base a la entrada a ese mtodo. Cuando se llama a un mtodo en un objeto, Java hace coincidir su nombre, nmero y tipo de argumentos para seleccionar que definicin de mtodo ejecutar. Para crear un mtodo sobrecargado, todo lo que se necesita hacer es crear varias definiciones distintas de mtodo en la clase, todas con el mismo nombre, pero con diferentes listas de parmetros (ya sea en nmero o tipo de argumentos). Java permite la sobrecarga de mtodos siempre que cada lista de parmetros sea nica para el mismo nombre del mtodo.

Java diferencia los mtodos sobrecargados con el mismo nombre, basado en el nmero y tipo de parmetros de ese mtodo, no en su tipo de retorno (return). Si se intenta crear dos mtodos con el mismo nombre, la misma lista de parmetros, pero con diferentes tipos de retorno, obtendr un error de compilador. Los nombres de variables que escoja para cada parmetro son irrelevantes, lo que importa es el nmero y el tipo. Sobrescribir Mtodos Cuando se llama a un mtodo en un objeto, Java busca su definicin en la clase de ese objeto, y si no la encuentra, pasa la llamada del mtodo hacia una jerarqua mayor hasta encontrar una definicin del mismo. La herencia le permite definir y utilizar mtodos de forma repetida en las subclases sin tener que duplicar el cdigo.

Ing. Israel Durn Martnez

45

Facultad de Ingeniera

Java

Sin embargo, habr ocasiones en que se desee que un objeto responda a los mismos mtodos, pero que tenga diferente comportamiento cuando llame a un mtodo. En este caso, se puede sobrescribir. Esto implica definir un mtodo en una subclase que tenga la misma identificacin de otro en una superclase. Entonces, cuando se llama al mtodo, el de la subclase se busca y se ejecuta, en lugar del que est en la superclase. Para sobrescribir un mtodo, todo lo que se tiene que hacer es crear uno en la subclase que tenga la misma identificacin (nombre, tipo de retorno, lista de parmetros) de otro definido en una de las superclases. Puesto que Java ejecuta la primera definicin del mtodo que encuentra que coincide con la identificacin, esto en forma eficiente oculta la definicin del original. 7.5 Constructores Un mtodo constructor es una clase especial de mtodo que determina cmo se inicializa un objeto cuando se crea. A diferencia de los mtodos ordinarios, no se puede llamar a un mtodo constructor en forma directa; en su lugar, Java los llama de manera automtica de este modo: cuando usa new para crear una nueva instancia de una clase, Java realiza tres acciones: Asigna memoria para un objeto. Inicializa las variables de instancia de ese objeto, ya sea con sus valores iniciales o por el valor predeterminado( 0 para nmeros, null para objetos, false para booleanos y \0 para caracteres). Llama al mtodo constructor de la clase.

Los constructores son muy parecidos a los mtodos ordinarios, con dos diferencias bsicas: Siempre tienen el mismo nombre de la clase. No tienen un tipo de retorno (return).

Ing. Israel Durn Martnez

46

Facultad de Ingeniera

Java

Al igual que los mtodos ordinarios, los constructores tambin pueden tomar varios nmeros y tipos de parmetros, lo que le permite crear exactamente su objeto con las propiedades que desee que tenga, o para que este pueda calcular propiedades a partir de distintas formas de entrada. 7.6 This y super this En el cuerpo de una definicin de mtodo, tal vez desee referirse al objeto actual (el objeto que el mtodo llam) para referirse a las variables de instancia de ese objeto o para pasar el objeto actual como un argumento a otro mtodo. Para referirse al objeto actual en estos casos se puede usar la palabra this, la cual alude al objeto actual y puede utilizarla en cualquier lugar en que ste aparezca. super super es un concepto que no existe en C++, al menos no con una implementacin similar a Java. Si un mtodo sobrescribe un mtodo de una superclase, se puede utilizar la palabra clave super para eludir la versin sobrescrita de la clase e invocar a la versin original del mtodo en la superclase. Del mismo modo, se puede utilizar super para acceder a variables miembro de la superclase. 7.7 Interfaces Los mtodos abstractos son tiles cuando se quiere que cada implementacin de la clase parezca y funcione igual, pero necesita que se cree una nueva clase para utilizar esos mtodos abstractas. Las interfaces proporcionan un mecanismo para abstraer los mtodos a un nivel superior, lo que permite simular la herencia mltiple de otros lenguajes. Una interfaz sublima el concepto de clase abstracta hasta su grado ms alto. Una interfaz podr verse simplemente como una forma, es como un molde, solamente permite declarar nombres de mtodos, listas de argumentos, tipos de retorno y adicionalmente miembros datos (los cuales podrn ser nicamente tipos bsicos y sern tomados como constantes en tiempo de compilacin, es decir, static y final).

Ing. Israel Durn Martnez

47

Facultad de Ingeniera

Java

Una interfaz contiene una coleccin de mtodos que se implementan en otro lugar. Los mtodos de una interfaz son public, static y final. Para implementar una interfaz en una clase se utiliza la palabra clave implements seguida del nombre de la interfaz. class MiClase implements Interface1, Interface2, ... , IntefaceN { //Cuerpo de la clase. } El aspecto ms importante del uso de interfaces es que mltiples objetos de clases diferentes pueden ser tratados como si fuesen de un mismo tipo comn, en donde este tipo viene indicado por el nombre de la interfaz. Aunque se puede considerar el nombre de la interfaz como un tipo de prototipo de referencia a objetos, no se pueden instanciar objetos en s del tipo interfaz. La definicin de una interfaz no tiene constructor, por lo que no es posible invocar el operador new sobre un tipo interfaz. Una interfaz puede heredar de varios interfaces sin ningn problema. Sin embargo, una clase solamente puede heredar de una clase base, pero puede implementar varias interfaces. La plataforma Java 2 ofrece la posibilidad de definir una interfaz vaca, como es el caso de Serialize, que permite serializar un objeto. Una interfaz vaca se puede utilizar como un marcador para marcar a una clase con una propiedad determinada.

Ing. Israel Durn Martnez

48

Facultad de Ingeniera

Java

CAPTULO 8: EXCEPCIONES

Una excepcin es un evento que ocurre durante la ejecucin de un programa y detiene el flujo normal de la secuencia de instrucciones de ese programa; en otras palabras, una excepcin es una condicin anormal que surge en una secuencia de cdigo durante su ejecucin. Las excepciones en Java estn destinadas, al igual que en resto de los lenguajes que las soportan, para la deteccin y correccin de errores. Si hay un error, la aplicacin no debera morirse. Se debera lanzar (throw) una excepcin que a su vez debera capturarse (catch) y resolver la situacin de error, o bien poder ser tratada finalmente (finally) por un gestor por defecto. Utilizadas en forma adecuada, las excepciones aumentan en gran medida la robustez de las aplicaciones. La gestin de excepciones para en Java proporciona que un mecanismo muchas

excepcionalmente

poderoso

controlar

programas

tengan

caractersticas dinmicas durante su ejecucin. Las excepciones son formas muy limpias de manejar errores y problemas inesperados en la lgica del programa, y no deben considerarse como un mecanismo general de ramificaciones o un tipo de sentencias de salto. Muchas clases de errores pueden utilizar excepciones -- desde serios problemas de hardware, como la avera de un disco duro, a los simples errores de programacin, como tratar de acceder a un elemento de un array fuera de sus lmites. Cuando dicho error ocurre dentro de un mtodo Java, el mtodo crea un objeto 'exception' y lo maneja fuera, en el sistema de ejecucin. Este objeto contiene informacin sobre la excepcin, incluyendo su tipo y el estado del programa cuando ocurri el error. El sistema de ejecucin es el responsable de buscar algn cdigo para manejar el error. En terminologa java, crear una objeto exception y manejarlo por el sistema de ejecucin se llama lanzar una excepcin. Despus de que un mtodo lance una excepcin, el sistema de ejecucin entra en accin para buscar el manejador de la excepcin. El conjunto de "algunos" mtodos posibles para manejar la excepcin es el conjunto de mtodos de la pila de llamadas del mtodo donde ocurri el error. El sistema de ejecucin busca hacia atrs en la pila

Ing. Israel Durn Martnez

49

Facultad de Ingeniera

Java

de llamadas, empezando por el mtodo en el que ocurri el error, hasta que encuentra un mtodo que contiene el "manejador de excepcin" adecuado. Un manejador de excepcin es considerado adecuado si el tipo de la excepcin lanzada es el mismo que el de la excepcin manejada por el manejador. As la excepcin sube sobre la pila de llamadas hasta que encuentra el manejador apropiado y una de las llamadas a mtodos maneja la excepcin, se dice que el manejador de excepcin elegido captura la excepcin. Si el sistema de ejecucin busca exhaustivamente por todos los mtodos de la pila de llamadas sin encontrar el manejador de excepcin adecuado, el sistema de ejecucin finaliza (y consecuentemente y el programa Java tambin). 8.1 Capturar y manejar excepciones Las excepciones lanzadas por un mtodo que pueda hacerlo deben recogerse en un bloque try/catch o try/finally. Bloque try El primer paso en la construccin de un manejador de excepciones es encerrar las sentencias que podran lanzar una excepcin dentro de un bloque try. En general, este bloque se parece a esto. try { Sentencias Java; } El segmento de cdigo etiquetado sentencias java est compuesto por una o ms sentencias legales de Java que podran lanzar una excepcin. Se dice que el bloque try gobierna las sentencias encerradas dentro de l y define el mbito de cualquier manejador de excepcin (establecido por su subsecuente bloque catch) asociado con l. En otras palabras, si ocurre una excepcin dentro del bloque try, esta excepcin ser manejada por el manejador de excepcin asociado con esta sentencia try.

Ing. Israel Durn Martnez

50

Facultad de Ingeniera

Java

Una sentencia try debe ir acompaada de al menos un bloque catch o un bloque finally. Bloque catch Se pueden asociar manejadores de excepcin a una sentencia try

proporcionando uno o ms bloques catch directamente despus del bloque try. Try { . . . } catch(. . .) { . . . } catch(. . .) { . . . } . . . No puede haber ningn cdigo entre el final de la sentencia try y el principio de la primera sentencia catch. La forma general de una sentencia catch en Java es esta. catch (AlgunObjetoThrowable nombreVariable) { Sentencias Java } La sentencia catch requiere un slo argumento formal. Este argumento parece un argumento de una declaracin de mtodo. El tipo del argumento AlgunObjetoThrowable declara el tipo de excepcin que el manejador puede manejar y debe ser el nombre de una clase heredada de la clase

Throwable definida en el

paquete java.lang. (Cuando los programas Java lanzan una excepcin realmente estn lanzado un objeto, slo pueden lanzarse los objetos derivados de la clase Throwable. NombreVariable es el nombre por el que el manejador puede referirse a la excepcin capturada. Se puede acceder a las variables y mtodos de las excepciones en la misma forma que accede a los de cualquier otro objeto. getMessage() es un mtodo

Ing. Israel Durn Martnez

51

Facultad de Ingeniera

Java

proporcionado por la clase Throwable que imprime informacin adicional sobre el error ocurrido. La clase Throwable tambin implementa dos mtodos para rellenar e imprimir el contenido de la pila de ejecucin cuando ocurre la excepcin. Las subclases de Throwable pueden aadir otros mtodos o variables de ejemplar, Para buscar qu mtodos implementar en una excepcin, se puede comprobar la definicin de la clase y las definiciones de las clases antecesoras. Bloque finally El paso final en la creacin de un manejador de excepcin es proporcionar un mecanismo que limpie el estado del mtodo antes (posiblemente) de permitir que el control pase a otra parte diferente del programa. Se puede hacer esto encerrando el cdigo de limpieza dentro de un bloque finally. 8.2 Las sentencias throw

Todos los mtodos Java utilizan la sentencia throw para lanzar una excepcin. Esta sentencia requiere un slo argumento, un objeto Throwable. En el sistema Java, los objetos lanzables son ejemplares de la clase Throwable definida en el paquete java.lang. throw algunObjetoThrowable; Si se intenta lanzar un objeto que no es 'lanzable', el compilador rehusa la compilacin del programa y muestra un mensaje de error similar a ste:
testing.java:10: Cannot throw class java.lang.Integer; it must be a subclass of class java.lang.Throwable. throw new Integer(4);

8.3 La clase throwable y sus subclases

Slo se pueden lanzar objetos que estn derivados de la clase Throwable. Esto incluye descendientes directos (esto es, objetos de la clase Throwable) y descendiente indirectos (objetos derivados de hijos o nietos de la clase Throwable). La clase Throwable tiene dos descendientes directos: Error y Exception.

Ing. Israel Durn Martnez

52

Facultad de Ingeniera Error

Java

Cuando falla un enlace dinmico, y hay algn fallo "hardware" en la mquina virtual, sta lanza un error. Tpicamente los programas Java no capturan los Errores. Pero siempre lanzarn errores.

Exception

La mayora de los programas lanzan y capturan objetos derivados de la clase Exception. Una Excepcin indica que ha ocurrido un problema pero que el problema no es demasiado serio. La mayora de los programas que se escriben lanzarn y capturarn excepciones. La clase Exception tiene muchos descendiente definidos en los paquetes Java. Estos descendientes indican varios tipos de excepciones que pueden ocurrir. Por ejemplo, IllegalAccessException seala que no se puede encontrar un mtodo particular, y NegativeArraySizeException indica que un programa intenta crear un array con tamao negativo. Una subclase de Exception tiene un significado especial en el lenguaje Java: RuntimeException. 8.4 Excepciones en Tiempo de Ejecucin La clase RuntimeException representa las excepciones que ocurren dentro de la mquina virtual Java (durante el tiempo de ejecucin). Un ejemplo de estas excepciones es NullPointerException, que ocurre cuando un mtodo intenta acceder a un miembro de un objeto a travs de una referencia nula. Esta excepcin puede ocurrir en cualquier lugar en que un programa intente desreferenciar una referencia a un objeto. Frecuentemente el coste de chequear estas excepciones sobrepasa los beneficios de capturarlas.

Ing. Israel Durn Martnez

53

Facultad de Ingeniera

Java

Como las excepciones en tiempo de ejecucin estn omnipresentes e intentar capturar o especificarlas todas en todo momento podra ser un ejercicio infructuoso (y un cdigo infructuoso, imposible de leer y de mantener), el compilador permite que estas excepciones no se capturen ni se especifiquen. Los paquetes Java definen varias clases RuntimeException. Se pueden capturar estas excepciones al igual que las otras. Sin embargo, no se require que un mtodo especifique que lanza excepciones en tiempo de ejecucin. Adems puedes crear sus propias subclases de RuntimeException.

Ing. Israel Durn Martnez

54

Facultad de Ingeniera

Java

CAPTULO 9: EJEMPLOS

1. Hola
//Se compila como: javac Hola.java generndose un archivo con extensin (*.class), es decir, Hola.class //Se interpreta como: java Hola /* La clase Hola implementa una aplicacin que despliega " Hola Mundo! " por la salida estandar */ class Hola { public static void main(String[] args) { System.out.println(" Hola Mundo! "); } }

//Despliega la cadena

2. Variables Locales
// Las variables locales siempre deben de inicializarse class InicializaLocales { public static void main(String arg[]) { int a = 2; //Declaracin de una variable local tipo entera. String c = "cadena"; //Declaracin de una variable local tipo cadena. boolean b = true; //Declaracin de una variable local tipo booleana. char h = 'a'; //Declaracin de una variable local tipo carcter. System .out.println("a: " + a + "\n" + "c: " + c + "\n" + "b: " + b + "\n" + "h: " + h); } }

3. Variables de Clase y de instancia


// Valores por default de las variables de instancia y de clase class ValoresDefault { static int a; static String c; boolean b; char h;

//Declaracin de una variable de clase tipo entera. //Declaracin de una variable de clase tipo cadena. //Declaracin de una variable de instancia tipo booleana. //Declaracin de una variable de instancia tipo carcter.

public static void main(String arg[]) { ValoresDefault vd = new ValoresDefault(); System .out.println("a: " + a + "\n" + "c: " + ValoresDefault.c + "\n" + "b: " + vd.b + "\n" + "h: " + vd.h); } }

Ing. Israel Durn Martnez

55

Facultad de Ingeniera

Java

4. Clases y objetos
class Motocicleta { String marca; //VARIABLE DE INSTANCIA String color; //VARIABLE DE INSTANCIA boolean estadoMotor; //VARIABLE DE INSTANCIA static int numeroRuedas=2; //VARIABLE DE CLASE void encenderMotor() { if(estadoMotor==true) System.out.println("Ya estaba encendido"); else { estadoMotor=true; System.out.println("Motor encendido ahora"); } } void mostrarAtributos() { System.out.println("Esta motocicleta es una " + this.marca + " color " + this.color + " numero de ruedas = " + numeroRuedas); if(estadoMotor==true) System.out.println("Motor Encendido"); else System.out.println("Motor Apagado"); } public static void main(String[] args) { Motocicleta m1=new Motocicleta(); int a=Motocicleta.numeroRuedas; //PRUEBA VARIABLE DE CLASE. LA a ES LOCAL System.out.println("EL NUMERO DE RUEDAS ES: " + a + ", MARCA: " + m1.marca); //PRUEBA VARIABLE DE INSTANCIA //PARA UTILIZAR VARIABLES DE INSTANCIA SE DEBE CREAR LA INSTANCIA EN DONDE m1.marca="Yamaha"; m1.color="Roja"; System.out.println("\n*MOSTRANDO ATRIBUTOS DE m1\n"); m1.mostrarAtributos(); System.out.println("\n*ENCENDIENDO MOTOR DE m1\n"); m1.encenderMotor(); System.out.println("\n*MOSTRANDO ATRIBUTOS DE m1\n"); m1.mostrarAtributos(); System.out.println("\n*ENCENDIENDO MOTOR DE m1\n"); m1.encenderMotor(); System.out.println("-----------------------------------------"); Motocicleta m2=new Motocicleta(); m2.marca="Kawasaki"; m2.color="Negra"; System.out.println("\n*MOSTRANDO ATRIBUTOS DE m2\n"); m2.mostrarAtributos(); System.out.println("-----------------------------------------"); Motocicleta m3 = new Motocicleta(); m3.marca = "Dukati"; m3.color = "Amarilla";

RADICA

Ing. Israel Durn Martnez

56

Facultad de Ingeniera
System.out.println("\n*MOSTRANDO ATRIBUTOS DE m3\n"); m3.mostrarAtributos(); System.out.println("\n*ENCENDIENDO MOTOR DE m3\n"); m3.encenderMotor(); System.out.println("\n*MOSTRANDO ATRIBUTOS DE m3\n"); m3.mostrarAtributos(); System.out.println("\n*ENCENDIENDO MOTOR DE m3\n"); m3.encenderMotor(); System.out.println("-----------------------------------------");

Java

5. Mximo valor de las variables


public class MaxVariables { public static void main(String args[]) { // enteros byte maxByte = Byte.MAX_VALUE; short maxShort = Short.MAX_VALUE; int maxInteger = Integer.MAX_VALUE; long maxLong = Long.MAX_VALUE; // reales float maxFloat = Float.MAX_VALUE; double maxDouble = Double.MAX_VALUE; // impresion System.out.println("El System.out.println("El System.out.println("El System.out.println("El System.out.println("El System.out.println("El mximo mximo mximo mximo mximo mximo valor valor valor valor valor valor tipo tipo tipo tipo tipo tipo byte es " + maxByte); short es " + maxShort); int es " + maxInteger); long es " + maxLong); float es " + maxFloat); double es " + maxDouble);

6. Constantes
//Se utiliza la palabra final para declarar constantes. class Constante { static final double PI = 3.1416; final double E = 2.76554; public static void main(String a[]) { Constante c = new Constante(); System.out.println("PI * 2 = " + PI*2); System.out.println("E = " + c.E); } }

Ing. Israel Durn Martnez

57

Facultad de Ingeniera

Java

7. Operadores Aritmticos
public class OpAritmeticos { public static void main(String[] args) { int i=37; int j=42; double x=27.475; double y=7.22; System.out.println("\nVALORES DE LAS VARIABLES\n"); System.out.println(" System.out.println(" System.out.println(" System.out.println(" i= " + i); j= " + j); x= " + x); y= " + y);

//SUMANDO NUMEROS System.out.println("\nSUMANDO\n"); System.out.println(" i+j= " +(i+j)); System.out.println(" x+y= " +(x+y)); //RESTANDO NUMEROS System.out.println("\nRESTANDO\n"); System.out.println(" i-j= " +(i-j)); System.out.println(" x-y= " +(x-y)); //MULTIPLICANDO NUMEROS System.out.println("\nMULTIPLICANDO\n"); System.out.println(" i*j= " +(i*j)); System.out.println(" x*y= " +(x*y)); //DIVIDIENDO NUMEROS System.out.println("\nDIVIDIENDO\n"); System.out.println(" i/j= " +(i/j)); System.out.println(" x/y= " +(x/y)); DIVISION //CALCULANDO EL RESIDUO DE DIVISIONES. DEVUELVE RESIDUO ENTERO DE LA System.out.println("\nRESIDUOS\n"); System.out.println(" i%j= " +(i%j)); System.out.println(" x%y= " +(x%y)); //MEZCLANDO TIPOS System.out.println("\nMEZCLANDO TIPOS\n"); System.out.println(" j+y= " +(j+y)); System.out.println(" i*x= " +(i*x));

8. Incremento y Decremento
public class IndDec { public static void main(String arg[]) { int x=0; int y=0;

Ing. Israel Durn Martnez

58

Facultad de Ingeniera

Java

System.out.println("x = " + x + "; y = " + y); x++; System.out.println("x++ = " + x); ++x; System.out.println("++x = " + x); x = 0; y = x++; System.out.println("x = " + x); System.out.println("y = " + y); y = ++x; System.out.println("x = " + x); System.out.println("y = " + y);

9. Operadores Relacionales
public class OpRelacionales { public static void main(String[] args) { //Declaracin de 3 variables locales int i = 37; int j = 42; int k = 42; System.out.println("Imprimiendo el Valor de las variables..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" k = " + k); //Mayor que System.out.println("Mayor que..."); System.out.println(" i > j es " + (i > j)); System.out.println(" j > i es " + (j > i)); System.out.println(" k > j es " + (k > j));

//false //true //false

//Mayor o igual que System.out.println("Mayor o igual que..."); System.out.println(" i >= j es " + (i >= j)); //false System.out.println(" j >= i es " + (j >= i)); //true System.out.println(" k >= j es " + (k >= j)); //true //Menor que System.out.println("Menor que..."); System.out.println(" i < j es " + (i < j)); System.out.println(" j < i es " + (j < i)); System.out.println(" k < j es " + (k < j));

//true //false //false

//Menor o igual que System.out.println("Menor o igual que..."); System.out.println(" i <= j es " + (i <= j)); //true System.out.println(" j <= i es " + (j <= i)); //false System.out.println(" k <= j es " + (k <= j)); //true //Igual a System.out.println("Igual a..."); System.out.println(" i == j es " + (i == j)); //false System.out.println(" k == j es " + (k == j)); //true //Diferente a System.out.println("Diferente a..."); System.out.println(" i != j es " + (i != j)); //true System.out.println(" k != j es " + (k != j)); //false

Ing. Israel Durn Martnez

59

Facultad de Ingeniera
}

Java

10. Operadores a nivel de Bits


public class Bits { static final static final static final static final

int int int int

VISIBLE = 1; DRAG = 2; SELECTO = 4; EDITABLE = 8;

public static void main(String[] args) { int bandera = 0; bandera = bandera | VISIBLE; bandera = bandera | DRAG; if ((bandera & VISIBLE) == VISIBLE) { if ((bandera & DRAG) == DRAG) { System.out.println("La bandera es Visible y Drag."); } } bandera = bandera | EDITABLE; if ((bandera & EDITABLE) == EDITABLE) { System.out.println("La bandera tambien es Editable."); }

11. Arreglos
public class ArregloCadenas { public static void main(String[] args) { String[] arreglo = { "CADENA UNO", "Cadena Dos", "Cadena Tres" }; for (int i = 0; i < arreglo.length; i++) System.out.println(arreglo[i].toLowerCase()); } }

12. Argumentos desde la pantalla


class ArgumentosMain { public static void main(String arg[]) { System.out.println(arg.length + " ARGUMENTOS INTRODUCIDOS: "); for(int i=0;i<arg.length;i++) System.out.println("args[" + i + "]" + " = " + arg[i]);

Ing. Israel Durn Martnez

60

Facultad de Ingeniera
}

Java

13. Arreglo de Arreglos


public class ArregloDeArreglo { public static void main(String[] args) { String[][] caricaturas = { {"Picapiedra","Fred","Wilma","Pebbles","Dino"}, {"Marmol","Barney","Betty","Bam Bam"}, {"Supersonicos","George","Jane","Elroy","Judy","Rosie","Astro"}, {"Scooby Doo","Shaggy","Velma","Fred","Daphne"} }; for (int i = 0; i < caricaturas.length; i++) { System.out.print(caricaturas[i][0] + ": "); for (int j = 1; j < caricaturas[i].length; j++) { System.out.print(caricaturas[i][j] + " "); } System.out.println(); }

14. Arreglo de Arreglo (2)


public class ArregloDeArreglo2 { public static void main(String[] args) { int[][] matriz = new int[4][];

//Inicializo el numero de Renglones

for (int i = 0; i < matriz.length; i++) { matriz [i] = new int[5]; //Inicializo el numero de columnas for (int j = 0; j < matriz [i].length; j++) { matriz [i][j] = i + j; } } for (int i = 0; i < matriz.length; i++) { for (int j = 0; j < matriz [i].length; j++) { System.out.print(matriz [i][j] + " "); } System.out.println(); }

Ing. Israel Durn Martnez

61

Facultad de Ingeniera

Java

15. Ordena Nmeros


public class OrdenaNumeros { public static void main(String[] args) { int[] arregloEnteros = new int[10]; arregloEnteros[0] arregloEnteros[1] arregloEnteros[2] arregloEnteros[3] arregloEnteros[4] arregloEnteros[5] arregloEnteros[6] arregloEnteros[7] arregloEnteros[8] arregloEnteros[9] = = = = = = = = = = 32; 87; 3; 589; 12; 1076; 2000; 8; 622; 127;

for (int i = arregloEnteros.length; --i >= 0; ) { for (int j = 0; j < i; j++) { if (arregloEnteros [j] > arregloEnteros [j+1]) { int temp = arregloEnteros [j]; arregloEnteros [j] = arregloEnteros [j+1]; arregloEnteros [j+1] = temp; } } } for (int i = 0; i < arregloEnteros.length; i++) System.out.print(arregloEnteros [i] + " ");

16. Mtodos de clase y de instancia


//Mtodos de clase y de instancia class Metodos { static int suma(int a, int b) { return(a + b); } int resta(int a, int b) { return(a - b); } public static void main(String arg[]) { Metodos m = new Metodos(); System.out.println("La suma es: " + suma(2,4));

Ing. Israel Durn Martnez

62

Facultad de Ingeniera
System.out.println("La resta es: " + m.resta(1,3)); System.out.println("La raiz cuadrada es: " + Math.sqrt(4));

Java

17. Retorno por valor y por referencia


/** * Este ejemplo ilustra el retorno de valores tanto por referencia * como por valor */ // Un objeto de esta clase sera devuelto por referencia class MiClase { int varInstancia = 10; } class ValorReferencia { // Metodo que devuelve por Valor int retornoPorValor() { return( 5 ); // Devuelve un tipo primitivo por valor } // Metodo que devuelve por Referencia MiClase retornoPorReferencia() { return( new MiClase() ); // Devuelve un objeto por referencia } public static void main( String args[] ) { // Instancia un objeto ValorReferencia obj = new ValorReferencia(); System.out.println( "El Valor devuelto es "+obj.retornoPorValor() ); System.out.println( "El Valor de la variable de instancia en el objeto devuelto es "+ obj.retornoPorReferencia().varInstancia ); // Atencion a los dos puntos }

18. Sobrecargar Mtodos


/* mtodos con el mismo nombre pero con diferentes listas de parmetros */ import java.awt.Point; class Rect { int int int int

x1=0; y1=0; x2=0; y2=0;

public void construyeRect(int x1, int y1, int x2, int y2) { this.x1=x1;

Ing. Israel Durn Martnez

63

Facultad de Ingeniera
this.y1=y1; this.x2=x2; this.y2=y2;

Java

public void construyeRect(Point i, Point d) { x1=i.x; y1=i.y; x2=d.x; y2=d.y; } public void imprime() { System.out.println(x1 + " " + y1 + " " + x2 + " " + y2); } public static void main(String args[]) { Rect r=new Rect(); r.construyeRect(12,12,34,34); r.imprime(); Point a=new Point(10,10); r.construyeRect(a, new Point(20,20)); r.imprime();

19. Sobrescribir Mtodos, this y super


/******************************************************************************************* *********** public class ImprimeClase { int x = 0; int y = 1; public void imprimeme() { System.out.println("X = " + x); System.out.println("Y = " + y); System.out.println("Soy una instancia de la clase: " + this.getClass().getName()); } } /******************************************************************************************* *********** class ImprimeSubclase extends ImprimeClase { int z = 3; public static void main(String args[]) { ImprimeSubclase obj = new ImprimeSubclase(); obj.imprimeme(); }

Ing. Israel Durn Martnez

64

Facultad de Ingeniera

Java

/******************************************************************************************* *********** class ImprimeSubclase2 extends ImprimeClase { int z = 3; public void imprimeme() { System.out.println("X = " + x); System.out.println("Y = " + y); System.out.println("Z = " + z); System.out.println("Soy una instancia de la clase: " + this.getClass().getName()); } public static void main(String args[]) { ImprimeSubclase2 obj = new ImprimeSubclase2(); obj.imprimeme(); }

/******************************************************************************************* *********** class ImprimeSubclaseSuper extends ImprimeClase { int z = 3; void imprimeme() { super.imprimeme(); System.out.println("Z = " + z); System.out.println("Soy una instancia de la clase: " + this.getClass().getName()); } public static void main(String args[]) { ImprimeSubclaseSuper obj = new ImprimeSubclaseSuper(); obj.imprimeme(); }

/******************************************************************************************* ***********

20. Constructores
/******************************************************************************************* *********** class Persona { String nombre; int edad; Persona() //constructor por default { } Persona(String n, int e) //Un constructor diferente { nombre=n; edad=e;

Ing. Israel Durn Martnez

65

Facultad de Ingeniera
} void imprime() //mtodo imprime { System.out.println("La persona " + nombre + " tiene " + edad + " aos"); }

Java

public static void main(String args[]) { Persona p=new Persona(); //utiliza el constructor por default que no inicializa las variables p.nombre="Pedro"; p.edad=65; p.imprime(); Persona p1=new Persona("Juan", 34); //utiliza un constructor diferente p1.imprime();

/******************************************************************************************* ***********

import java.awt.Point; public class Punto2De { int x; int y; //CONSTRUCTOR public Punto2De(int x, int y) { this.x=x; this.y=y; } public Punto2De(Point p) { x=p.x; y=p.y; } //METODO DE INSTANCIA public void imprimeVal() { System.out.println("(" + x + " , " + y + ")"); } //METODO MAIN public static void main(String args[]) { Punto2De p1=new Punto2De(3,12); Punto2De p2=new Punto2De(5,6); p1.imprimeVal(); p2.imprimeVal(); Point a = new Point(2,1); Punto2De p3=new Punto2De(a); p3.imprimeVal();

Ing. Israel Durn Martnez

66