Facultad de Ingeniería - FI

Facultad de Ingeniería
Java
Autor:
Ing. Israel Durán Martínez
Facultad de Ingeniería
Java
ÍNDICE
ÍNDICE ........................................................................................................................................................... 2
CAPÍTULO 1:
INTRODUCCIÓN A JAVA ...................................................................................... 4
1.1 ORÍGENES ................................................................................................................................................. 4
1.2 ¿QUÉ ES JAVA? ......................................................................................................................................... 5
1.3 CARACTERÍSTICAS .................................................................................................................................... 7
1.4 ¿QUÉ SE PUEDE HACER CON JAVA? ......................................................................................................... 11
CAPÍTULO 2: PROGRAMACIÓN ORIENTADA A OBJETOS Y JAVA ............................... 12
2.1 CLASES ................................................................................................................................................... 12
2.2 OBJETOS ................................................................................................................................................. 13
2.3 ATRIBUTOS Y MÉTODOS .......................................................................................................................... 13
2.4 HERENCIA............................................................................................................................................... 15
2.5 INTERFACES Y PAQUETES ....................................................................................................................... 18
CAPÍTULO 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
CAPÍTULO 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
CAPÍTULO 5: CLASES ........................................................................................................................... 34
5.1 DEFINICIÓN DE CLASES ........................................................................................................................... 34
5.2 TIPOS DE CLASE ...................................................................................................................................... 36
5.3 MODIFICADORES DE ACCESO .................................................................................................................. 38
CAPÍTULO 6: OBJETOS........................................................................................................................ 41
6.1 CICLO DE VIDA DE LOS OBJETOS ............................................................................................................. 41
6.2 COMPARACIÓN DE OBJETOS .................................................................................................................... 42
CAPÍTULO 7: MÉTODOS ...................................................................................................................... 44
7.1 IMPLEMENTACIÓN DE MÉTODOS ............................................................................................................. 44
7.2 TIPOS DE MÉTODOS ................................................................................................................................. 45
7.3 RETORNO POR VALOR Y POR REFERENCIA............................................................................................... 46
7.4 SOBREESCRIBIR Y SOBRECARGAR MÉTODOS ........................................................................................... 46
7.5 CONSTRUCTORES .................................................................................................................................... 48
7.6 THIS Y SUPER .......................................................................................................................................... 49
7.7 INTERFACES ............................................................................................................................................ 49
CAPÍTULO 8: EXCEPCIONES ............................................................................................................ 51
Ing. Israel Durán Martínez
2
Facultad de Ingeniería
Java
8.1 CAPTURAR Y MANEJAR EXCEPCIONES..................................................................................................... 52
8.2 LAS SENTENCIAS THROW ........................................................................................................................ 54
8.3 LA CLASE THROWABLE Y SUS SUBCLASES .............................................................................................. 54
8.4 EXCEPCIONES EN TIEMPO DE EJECUCIÓN................................................................................................ 56
CAPÍTULO 9: EJEMPLOS ..................................................................................................................... 58
Ing. Israel Durán Martínez
3
Facultad de Ingeniería
CAPÍTULO 1:
Java
INTRODUCCIÓN A JAVA
1.1 Orígenes
Hace algunos años Sun Microsystems decidió intentar introducirse en el
mercado de la electrónica de consumo y desarrollar programas para pequeños
dispositivos electrónicos. 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
domésticos:
microondas,
tostadoras
y,
fundamentalmente,
televisión
interactiva. Este mercado, dada la falta de sofisticación de los usuarios, requería unas
interfaces mucho más cómodas e intuitivas que los sistemas de ventanas que
proliferaban en el momento.
Otros requisitos importantes eran la fiabilidad del código y la facilidad de
desarrollo. James Gosling, el miembro del equipo con más experiencia en lenguajes de
programación, decidió que las ventajas de eficiencia de C++ no compensaban el gran
coste de pruebas y depuración. Gosling había estado trabajando en su tiempo libre en
un lenguaje de programación que él había llamado Oak, el cual, aun partiendo de la
sintaxis de C++, intentaba remediar las deficiencias que había 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 electrónica de
consumo. La aparición de un chip más barato y, generalmente, más eficiente, conduce
inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de
producción, por pequeña 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 características de Oak y utilizarlo.
El primer proyecto en que se aplicó este lenguaje recibió el nombre de proyecto
Green y consistía en un sistema de control completo de los aparatos electrónicos y el
Ing. Israel Durán Martínez
4
Facultad de Ingeniería
Java
entorno de un hogar. Para ello se construyo un computador experimental denominado
*7(start seven). El sistema presentaba una interfaz basada en la representación de la
casa de forma animada y el control se llevaba a cabo mediante un apantalla sensible al
tacto. En le sistema aparecía 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 televisión 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 televisión
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 parecía un olvido definitivo, Bill Joy, cofundador de Sun y uno de
los desarrolladores principales de Unix de Berkeley, juzgó que internet podría llegar a
ser el campo de juego adecuado para disputar a Microsoft su primacía casi absoluta en
el terreno del software, y vio en Oak el instrumento idóneo para llevar a cabo estos
planes. Tras un cambio de nombre y algunos de diseño, el lenguaje Java fue
presentado en agosto de 1995.
1.2 ¿Qué es Java?
La tecnología Java consta de un lenguaje de programación y una plataforma.
Lenguaje de Programación
Java es un lenguaje de programación de alto nivel, además de que es orientado
a objetos tiene las siguientes características:

Simple

Orientado a Objetos

Distribuido

Robusto

Seguro

Portátil

interpretado
Ing. Israel Durán Martínez
5
Facultad de Ingeniería

Independiente de la plataforma

Multihilos

Dinámico
Java
Java tiene la característica de que el compilador es el encargado de convertir el
código fuente de un programa en un código intermedio llamado bytecode que es
independiente de la plataforma en que se trabaje y que es ejecutado por el intérprete
de Java que forma parte de la Máquina Virtual de Java.
Ing. Israel Durán Martínez
6
Facultad de Ingeniería
Java
La plataforma Java
Una plataforma es el ambiente de hardware o software en el cual se ejecutan
los programas. En general, la mayoría de las plataformas pueden ser descritas como
una combinación de hardware y sistema operativo. Algunas de las plataformas más
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 Máquina Virtual de Java (JVM): es la que interactúa con el hardware y el
sistema operativo para interpretar el programa.

La Interfaz de Programación de Aplicaciones de Java (API Java): que
son todas aquellas clases ya definidas.
A continuación se muestra una representación de los elementos que forman
parte de la plataforma Java.
1.3 Características
Al igual que otros lenguajes de programación, Java tiene un compilador que se
encarga de realizar un análisis sintáctico y léxico del texto de nuestro programa, entre
otras etapas de la traducción. Una característica 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 Durán Martínez
7
Facultad de Ingeniería
Java
La mayoría de los lenguajes de programación se caracterizan por ser
interpretados o compilados, lo que determina la manera en como serán ejecutados en
una computadora.
Principales Características:

Simple – Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las
características menos usadas y más confusas de éstos. C++ no es un lenguaje
conveniente por razones de seguridad, pero C y C++ son los lenguajes más
difundidos, por ello Java se diseño para ser parecido a C++ y así facilitar un
rápido y fácil aprendizaje.
Java elimina muchas de las características de otros lenguajes de programación
como C++, para mantener reducidas las especificaciones del lenguaje y añadir
características muy útiles como el garbage collector (reciclador de memoria
dinámica). No es necesario preocuparse de liberar memoria, el reciclador se
encarga de ello y como es de baja prioridad, cuando entra en acción, permite
liberar bloques de memoria muy grandes, lo que limita mucho la fragmentación
de la memoria.
Java reduce en un 50% los errores más comunes de programación con
lenguajes como C y C++ al eliminar muchas de las características de éstos,
entre las que destacan:


Aritmética de punteros.

Registros (struct)

Definición de tipos (typedef)

Macros (#define)

Necesidad de liberar memoria (free)
Orientado a objetos – para algunas personas, la técnica de programación
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, además de poder
reutilizar código.

Distribuido – java se ha construido con extensas capacidades de interconexión
TCP/IP. Existen librerías de rutinas para acceder e interactuar con protocolos
Ing. Israel Durán Martínez
8
Facultad de Ingeniería
Java
como http y ftp. Esto permite a los programadores acceder a la información a
través de la red con tanta facilidad como a los archivos locales.

Robusto – Java realiza verificaciones tanto en tiempo de compilación como en
tiempo de ejecución. La comprobación de tipos en Java ayuda a detectar
errores, lo antes posible, en el ciclo de desarrollo. Java obliga a la declaración
explícita de métodos, reduciendo así las posibilidades de error. Maneja la
memoria para eliminar las preocupaciones por parte del programador de la
liberación o corrupción de memoria.
Además, para asegurar el funcionamiento de la aplicación, realiza una
verificación de los ByteCodes, que son el resultado de la compilación de un
programa Java.

Seguro – el código Java pasa muchas comprobaciones antes de ejecutarse en
una máquina. El código se pasa a través de un verificador de ByteCode que
comprueba el formato de los fragmentos de código y aplica un probador de
teoremas para detectar fragmentos de código ilegal (código que falsea
punteros, viola derechos de acceso sobre objetos o intenta cambiar el tipo o
clase de un objeto).
Java imposibilita, también, abrir archivos de la máquina local (siempre que se
realizan operaciones con archivos, éstas trabajan sobre el disco duro de la
máquina de donde partió el applet), no permite ejecutar ninguna aplicación
nativa de una plataforma e impide que se utilicen otros computadores como
puente, es decir, nadie puede utilizar una máquina para hacer peticiones o
realizar operaciones con otra. Además, los intérpretes que incorporan los
navegadores Web son aún más restrictivos y por lo tanto los applets están
libres de virus.
Respecto a la seguridad del código fuente, no ya del lenguaje, el propio JDK
proporciona un desemsamblador de ByteCode, que hace que cualquier
programa pueda ser convertido a código fuente, lo que para el programador
significa
una
vulnerabilidad
total
a
su
código.
La
protección
de
los
programadores ante esto es utilizar llamadas a programas nativos, externos
(incluso C y C++) de forma que no sea descompilable todo el código; aunque
así se pierda portabilidad.
Ing. Israel Durán Martínez
9
Facultad de Ingeniería

Java
Portátil – más allá de la portabilidad básica por ser de arquitectura
independiente, Java implementa otros estándares de portabilidad para facilitar
el desarrollo. Los enteros son siempre enteros y, además, enteros de 32 bits en
complemento a 2. Además, Java construye sus interfaces de usuario a través
de un sistema abstracto de ventanas de forma que éstas puedan ser
implementadas en entornos Unís, Pc o Mac.

Interpretado
–
el
intérprete
Java
(sistema
run-time)
puede
ejecutar
directamente el código objeto. Enlazar (linkar) un programa normalmente
consume menos recursos que compilarlo, por lo que los desarrolladores con
Java pasarán más tiempo desarrollando y menos esperando por el computador.
No obstante, el compilador actual del JDK es bastante lento. Por ahora, en que
todavía no hay compiladores específicos de Java para las diversas plataformas,
Java es más lento que otros lenguajes de programación, 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 básicamente un lenguaje interpretado, la situación se
acerca mucho a la de los programas compilados, sobre todo en lo que se refiere
a la rapidez en la ejecución del código 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 específico.
 Multi-hilos – con java no tenemos la limitación de escribir programas que solo
hagan una cosa a la vez. El soporte para hilos múltiples y sincronizados está
construido directamente en el lenguaje java y el ambiente de ejecución. Los
hilos sincronizados son extremadamente útiles al crear aplicaciones distribuidas
y con soporte para red. Tal es el caso de una aplicación que establece
comunicación con un servidor remoto en un hilo mientras que interactúa con el
usuario en otro hilo.
 Dinámico - Java se beneficia todo lo posible de la tecnología orientada a
objetos y no intenta conectar todos los módulos que comprenden una aplicación
hasta el mismo tiempo de ejecución. Las librerías nuevas o actualizadas no
Ing. Israel Durán Martínez
10
Facultad de Ingeniería
Java
paralizarán la ejecución 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 pequeño programa creado en java capaz de ejecutarse en la
máquina 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 código HTML en la página de internet, con el fin de que el usuario
que consulte esa página pueda ver en ejecución el applet.
Aplicaciones -
una aplicación en Java es mucho más 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 tecnología 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 tecnología basada en el lenguaje java que da la
posibilidad de desarrollar sitios web dinámicos. Esta tecnología fue desarrollada para
permitir el desarrollo del lado del servidor. Los archivos JSP son archivos HTML con
etiquetas especiales que contienen código fuente en java para proporcional el
contenido dinámico.
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 Durán Martínez
11
Facultad de Ingeniería
Java
CAPÍTULO 2: PROGRAMACIÓN ORIENTADA A OBJETOS Y JAVA
La programación orientada a objetos es una de las más grandes ideas en el
campo de la programación durante los años recientes, y en cierta forma es más fácil
de manejar que la forma antigua de programación. Todo se reduce a organizar sus
programas en formas que reproducen la manera en que las cosas se unen en el mundo
real.
La programación orientada a objetos (OOP) está modelada sobre cómo, en el mundo
real, los objetos están compuestos de muchos otros tipos pequeños objetos. Esta
capacidad de combinar objetos, sin embargo, solo es un aspecto muy general de la
programación orientada a objetos. La OOP proporciona muchos otros conceptos y
características para crear y usar objetos de manera fácil y flexible, y la más importante
de estas características es el concepto de clase.
2.1 Clases
Definición
Una clase es una plantilla para múltiples objetos con características similares.
Las clases engloban todas las características 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 podría tener la clase Árbol que describe las características de todos
los árboles (que tienen hojas y raíces, 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 características diferentes (por ejemplo, altura, tipo, etc.) pero lo
importante de esto es que tiene las características y comportamientos de un árbol.
Ing. Israel Durán Martínez
12
Facultad de Ingeniería
Java
2.2 Objetos
Una instancia de una clase es otra palabra para referirse a los objetos. Si una
clase es la representación genérica de un objeto, una instancia es su representación
concreta.
Entonces, ¿Cuál es la diferencia entre una instancia y un objeto? En realidad
ninguna. Objeto es un término más general, pero tanto las instancias como los objetos
son la representación concreta de una clase. De hecho, los términos instancia y objeto
son usados intercambiablemente en un lenguaje de programación orientado a objetos.
Cuando se escribe un programa en Java, se diseña 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 librería de clases que implementan mucho del comportamiento básico
que necesita, no solo para las tareas de programación básicas (clases que ofrecen
funciones matemáticas elementales, arreglos, cadenas, entre otros), sino también para
complejas tareas de cómputo, por ejemplo gráficos, trabajo en red, etc. En muchos
casos las bibliotecas de clases Java serán suficientes para que sólo se requiera crear
una clase en el programa Java que utiliza las bibliotecas de clase estándares. Para
otros programas Java más complejos, quizá se tenga que crear un conjunto completo
de clases, con interacciones definidas entre ellas.
2.3 Atributos y métodos
Cada clase que se escribe en java esta generalmente compuesta de dos
componentes: atributos y métodos. 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 características 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 podrían incluir los siguientes:
Ing. Israel Durán Martínez
13
Facultad de Ingeniería



Java
Color: rojo, verde, plata, café
Estilo: estándar, moto deportiva
Fabricante: Honda, BMW, Bultaco.
Los atributos de un objeto pueden también incluir información acerca de su
estado; por ejemplo, puede contar con características como condición del motor
(apagado o encendido) o velocidad actual seleccionada.
Los atributos son definidos por variables; de hecho, puede considerarceles
análogos 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.
Definición
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.
Métodos (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í están algunos comportamientos:





Encender el motor
Apagar el motor
Acelerar
Frenar
Cambiar velocidades
Para definir el comportamiento de un objeto, se crean métodos, los cuales se
parecen y comportan como funciones en otros lenguajes de programación, pero son
Ing. Israel Durán Martínez
14
Facultad de Ingeniería
Java
definidos dentro de una clase. Java no tiene funciones definidas fuera de las clases
(como C++ lo hace).
Definición
Los métodos son funciones definidas dentro de las clases que operan en las
instancias de esas clases.
Los métodos no siempre afectan a un solo objeto; los objetos también se
comunican entre sí mediante el uso de métodos. Una clase u objeto puede llamar a
métodos 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 más importantes de la programación
orientada a objetos y tiene un efecto demasiado directo en la forma en que usted
diseña y escribe sus clases Java. La herencia es un poderoso mecanismo, lo que
significa que cuando se escribe una clase, sólo tiene que especificar como esa clase es
diferente de otra case; por tanto, la herencia le dará acceso automático a la
información contenida en esa otra clase.
Con la herencia, todas las clases, están en una jerarquía estricta.
Cada clase tiene una superclase (la clase superior en la jerarquía), y cada clase puede
tener una o más subclases (clases abajo en la jerarquía). Se dice que las clase
inferiores en la jerarquía, heredan de las clases más altas.
Ing. Israel Durán Martínez
15
Facultad de Ingeniería
Java
Jerarquía de Clases




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 métodos 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 código de alguna otra
clase. La clase, en forma automática, obtiene ese comportamiento de la superclase, y
así sucesivamente, hacia arriba de la jerarquía. La clase se convierte entonces en una
combinación de todas las características de las clases arriba de ella, en la jerarquía.
En la cima de la jerarquía de clases en Java esta la clase Object; todas las
clases heredan de esta superclase. Object es la clase más general en la jerarquía de
clases, ya que define el comportamiento heredado por todas las clases en la jerarquía
de clase Java. Cada clase hacia abajo añade más información y se vuelve cada vez
mas de propósito específico. De esta manera se puede pensar en una jerarquía de
clases como la definición de conceptos demasiados abstractos en lo alto de la
jerarquía, y esas ideas se convierten en algo más 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 sólo una superclase aunque cualquier superclase puede
tener múltiples subclases.
Ing. Israel Durán Martínez
16
Facultad de Ingeniería
Java
Si se va a crear un conjunto más grande de clases, tiene sentido que las clases
no sólo hereden de la jerarquía de clases existentes, sino que también hagan por sí
mismas una jerarquía. Esto podría implicar una planeación previa al organizar el código
Java.
Ejemplo:
Object
Vehículo
Vehículo movidos por
Vehículos movidos
el hombre
por motor
De dos ruedas
Motoneta
De cuatro
ruedas
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 después cada objeto llena
el hueco de la información adecuada para su situación.
Los métodos operan en forma similar: los objetos nuevos tienen acceso a todos
los nombres de métodos de su clase y sus superclases, pero las definiciones de
métodos se eligen en forma dinámica cuando se llama a un método. Es decir, si se
llama a un método de un objeto en particular, Java primero revisa en la clase del
objeto al buscar la definición de ese método. Si no esta definida la clase del objeto,
Ing. Israel Durán Martínez
17
Facultad de Ingeniería
Java
busca en la superclase de la clase, y así en lo sucesivo hacia arriba de la cadena, hasta
que encuentra la definición del método.
Definición del método
Clase
Clase
Clase
Clase
Clase
El mensaje se envía al objeto
y se transmite a las clases
superiores de la jerarquía
hasta encontrar una definición
Objet
o
2.5 Interfaces y Paquetes
Interfaces
Las clases en Java tienen sólo una superclase, y heredan variables y métodos
de esa superclase y de todas sus superclases. Aunque la herencia sencilla hace la
relación entre clases, y la funcionalidad que esas clases implantan es fácil de entender
y de diseñar, también puede ser de alguna manera restrictiva; en particular, cuando
tiene un comportamiento similar que necesita duplicarse mediante diferentes ramas de
la jerarquía de clase. Java soluciona este problema al utilizar el concepto de interfaz.
Definición
Una interfaz es una colección de nombres de métodos, sin definición en
realidad, que indican que una clase tiene un conjunto de comportamientos en adición a
los comportamientos que hereda de su superclase.
Ing. Israel Durán Martínez
18
Facultad de Ingeniería
Java
Aunque una clase Java puede tener sólo una superclase (a causa de la herencia
sencilla), esa clase también puede implantar cualquier número de interfaces. Al
implantar una interfaz, una clase proporciona implantaciones de métodos para los
nombres de métodos definidos por la interfaz. Si dos clases muy diferentes implantan
la misma interfaz, ambas pueden responder a la misma llamada del método, aunque lo
que cada clase hace en respuesta a esas llamadas del método 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 más que un contenedor de
clases. Actúan a modo de librerías y existen más que nada por comodidad. Para
agrupar varios ficheros fuente de Java en un sólo paquete incluiremos una línea al
comienzo de los mismos:
package mipaquete;
Y el código resultante (los ficheros con extensión class) se situarían en el
directorio mipaquete. Pertenecerían al paquete mipaquete. Para poder utilizarlos desde
otro programa deberíamos utilizar la sentencia import, que también se coloca al
principio del programa (aunque después 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 comodín *, 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 Durán Martínez
19
Facultad de Ingeniería
Java
Existen muchos paquetes en la librería estándar de Java, paquetes que,
además, han ido variando según se sucedían 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 dinámico de información, 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
menús, botones, áreas de texto, cajas de confirmación, 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 programación de aplicaciones que accedan a bajo nivel
a redes TCP/IP.
Ing. Israel Durán Martínez
20
Facultad de Ingeniería
Java
CAPÍTULO 3: FUNDAMENTOS Y SINTAXIS
3.1 Comentarios
/* Este es un comentario
de varias líneas */
// Este es un comentario de una sola línea
/** Comentario de documentación que interpreta Javadoc */
O
tr
o
s
R
ea
le
s
En
te
ro
s
3.2 Tipos de datos primitivos
Tipo
byte
short
int
long
float
double
char
boolean
Descripción
Entero de 1 Byte
Entero corto
Entero
Entero largo
Punto flotante precisión sencilla
Punto flotante doble precisión
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 según IEEE 754
64 bits según IEEE 754
Código Unicode de 16 bits
En otros lenguajes de programación, el formato y el tamaño de los tipos
primitivos de datos dependerá de la plataforma en la cual se corra el programa. En
contraste, Java especifica el tamaño 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
Declaración
Tipo_dato nombre_variable = valor_inicio;
Tipos de Variables
Ing. Israel Durán Martínez
21
Facultad de Ingeniería
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 excepción 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 métodos.
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 minúscula y los
nombres de las clases empiezan con una letra mayúscula. Si el nombre
de la variable consiste en más de una palabra, las palabras van unidas y
la primera letra después de la primera palabra se empieza con una letra
mayúscula; 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 algún
valor, el compilador de java les asignará los siguientes valores por default:
Cadenas: null;
Números: 0;
Booleanos: false;
Carácter: ‘\0’;
Las variables locales siempre se inicializan.
Ing. Israel Durán Martínez
22
Facultad de Ingeniería
Java
Alcance de las Variables
3.4 Constantes
Las constantes son útiles para definir valores comunes para todos los métodos
de un objeto (para dar nombres significativos a valores de objetos generales que
nunca cambiarán). En Java, puede crear constantes sólo para variables de instancia o
de clase, no para variables locales.
Para declarar una constante se utiliza la palabra clave final antes de la
declaración de la variable.
Ejemplos:
final flota PI = 3.141592;
final bolean DERECHA = true,
final int MAXIMO_VALOR = 100;
3.5 Literales
número
número[l|L]
0[X|x]hex
0octal
[número].número
número[D|d]
número[F|f]
[+|-] número
Ing. Israel Durán Martínez
Tipo int
Tipo long
Entero hexadecimal
Entero octal
Tipo double
Tipo double
Tipo float
Con signo
23
Facultad de Ingeniería
númeroenúmero
númeroEnúmero
‘caracter’
“caracteres”
\b
\t
\n
\r
\”
\’
\\
\uNNNN
true
false
Java
Exponencial
Exponencial
Tipo char
Cadena (String)
Caracter retroceso
Tabulador
Salto de línea (Enter)
Regreso de carro
Comillas
Comilla sencilla
Diagonal inversa
Caracter en Unicode (NNNN es hexadecimal)
Booleano
Booleano
3.6 Palabras reservadas
abstract
boolean
break
byte
case
catch
char
class
const*
continue
default
do
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
3.7 Operadores
Operadores Aritméticos
Operador
+
*
/
%
Sintaxis
op1 + op2
+op
op1 - op2
-op
op1 * op2
op1 / op2
op1 % op2
Ing. Israel Durán Martínez
Descripción
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
Multiplicación de op1 por op2
División de op1 entre op2
Residuo de dividir op1 por op2
24
Facultad de Ingeniería
Java
Operadores Incremento y Decremento
Operador
Sintaxis
++
op++
++
++op
--
op--
--
--op
Descripción
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
después 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 después 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
Regresa true si:
Sintaxis
&&
op1 && op2
op1 y op2 son ambos true. Condicionalmente evalua op2.
||
op1 || op2
op1 ó op2 es true. Condicionalmente evalua op2.
!
!op
op es false
&
op1 & op2
op1 y op2 son ambos true.Siempre evalua op1 y op2.
|
op1 | op2
op1 ó op2 es true.Siempre evalua op1 y op2.
^
op1 ^ op2
op1 y op2 son diferentes
Estas expresiones regresan true o false.
Ing. Israel Durán Martínez
25
Facultad de Ingeniería
Java
Operadores a nivel de bits
Operador
Sintaxis
Operación
&
op1 & op2
and a nivel de bits
|
op1 | op2
or a nivel de bits
^
op1 ^ op2
xor a nivel de bits
~
~op2
complemento a uno
>>
op1 >> op2
Corrimiento de bits a la derecha de op1 en op2 posiciones
<<
op1 << op2
Corrimiento de bits a la izquierda de op1 en op2 posiciones
>>>
op1 >>> op2
Corrimiento de bits a la derecha de op1 en op2 posiciones (unsigned)
Otros Operadores
Operador
Descripción
?:
Operador condicional. Simulación de if-else.
[]
Para declarar, crear y accesar arreglos.
.
Acceso a miembros de instancia y de clase
( params )
Lista de parámetros separados por coma.
( tipo )
Conversión de tipo al tipo específicado (cast)
new
instanceof
Crea un nuevo objeto o arreglo
Determina si un operando es una instancia de otro.
Ing. Israel Durán Martínez
26
Facultad de Ingeniería
Java
Menor precedencia <---------------->Mayor Precedencia
Precedencia de operadores
Operadores posfijos
[] . (params ) expr ++ expr --
Operadores unarios
++expr --expr +expr -expr ~ !
Creación o cast
new (type )expr
Multiplicativos
* / %
Aditivos
+ -
Corrimiento
<< >> >>>
Relacionales
< > <= >= instanceof
Igualdad
== !=
AND a nivel de bits
&
XOR a nivel de bits
^
OR a nivel de bits
|
AND lógico
&&
OR lógico
||
Op. Condicional
Asignación
? :
= += -= *= /= %= &= ^= |= <<= >>= >>>=
3.8 Arreglos
Los arreglos en java son diferentes con respecto a los de otros lenguajes de
programación; 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 según 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 tamaño de un arreglo es establecido cuando el arreglo es creado.
Ing. Israel Durán Martínez
27
Facultad de Ingeniería
Java
Cómo declarar variables de arreglo
El primer paso para crear un arreglo es crear una variable que guarde el
arreglo, justo como lo haría con cualquier otra variable. Así como cuando se declaran
variables de otro tipo, la declaración 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 método alterno para definir una variable de arreglo es colocar los corchetes
después del tipo, en lugar de en seguida de la variable. Estos dos métodos son
equivalentes, pero con frecuencia el segundo es más legible.
Tipo_arreglo[] nombre_arreglo;


String[] palabras;
int[] numeros;
Cómo 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[tamaño_arreglo];
o también:
tipo_arreglo[] nombre_arreglo;
nombre_arreglo = new tipo_arreglo[tamaño_arreglo];
String colores[];  Declaración
colores = new String[5];  Creación del arreglo
Ing. Israel Durán Martínez
28
Facultad de Ingeniería
Java
String[] colores = new String[5];
La línea 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 boléanos, 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 numéricos, false para booleanos, ‘\0’ para
arreglos de caracteres y null para objetos). También 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;
Recuérdese que los índices comienzan desde cero y que el dato a ingresar debe
ser del tipo de dato del arreglo.
Obtener el tamaño de un arreglo
Para obtener el tamaño de un arreglo se hace lo siguiente:
nombreArreglo.length
Se debe de tomar en cuenta que length no es un método sino que es una
propiedad que proviene de la plataforma de java para todos los arreglos.
Ing. Israel Durán Martínez
29
Facultad de Ingeniería
Java
CAPÍTULO 4. CONTROL DE FLUJO
El control de flujo es la manera que tiene un lenguaje de programación de hacer
que el flujo de la ejecución avance y se ramifique en función de los cambios de estado
de los datos. Java, en este aspecto, no utiliza los principios de diseño orientado a
objetos, sino que las sentencias de control de flujo del programa se han tomado de
C/C++. A continuación se tratan todos los mecanismos que proporciona Java para
conseguir este control y decidir qué partes del código ejecutar.
4.1 Sentencia if-else
If (expresión booleana)
{
sentencias;
}
[else
{
sentencias;
}]
La cláusula else es opcional. Cada una de las sentencias puede ser compuesta y
la expresión booleana podría ser una variable simple declarada como bolean, o bien
una expresión que utilice operadores relacionales para generar el resultado de una
comparación.
4.2 Sentencia switch
switch (expresión)
{
case valor1: sentencias;
break;
case valor2: sentencias;
break;
[default: sentencias;]
}
La expresión puede devolver cualquier tipo básico, y cada uno de los valores
especificados en las sentencias case debe ser de un tipo compatible.
4.3 Bucle for
Ing. Israel Durán Martínez
30
Facultad de Ingeniería
Java
for (inicialización; terminación; iteración)
{
sentencias;
}
Un bucle for, normalmente, involucra a tres acciones en su ejecución:

Inicialización de la variable de control.

Comprobación del valor de la variable de control en una expresión condicional.

Actualización de la variable de control.
La cláusula de inicio y la cláusula de incremento pueden estar compuestas por
varias expresiones separadas mediante el operador coma (,), que en estos bucles Java
también soportan.
for(a=0, b=1; a < 7; a++; b+=2)
4.4 Bucle while
[inicialización;]
while (terminación expresión booleana)
{
sentencias;
[iteración;]
}
El bucle while es la sentencia de bucle más básica en Java. Ejecuta
repetidamente una vez tras otra una sentencia mientras una expresión booleana sea
verdadera. Las partes de inicialización e iteración, que se presentan entre corchetes,
son opcionales.
4.5 Bucle do-while
[inicialización;]
do
{
sentencias;
[iteración;]
}
while(terminación expresión booleana)
Ing. Israel Durán Martínez
31
Facultad de Ingeniería
Java
A veces se puede desear el ejecutar el cuerpo de un bucle while al menos una
vez, incluso si la expresión booleana de terminación tiene el valor false la primera vez;
es decir, si se desea evaluar la expresión de terminación 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 ejecución del programa deje el
ámbito del bucle y pase a la siguiente sentencia que venga a continuación del bucle.
Java incorpora la posibilidad de etiquetar la sentencia break, de forma que el
control pasa a sentencias que no se encuentran inmediatamente después 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 iteración 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 ejecución del flujo del programa
se realizará a la sentencia en la que se encuentra colocada la etiqueta.
Ing. Israel Durán Martínez
32
Facultad de Ingeniería
Java
Ejemplo:
uno: for( )
{
dos: for( )
{
continue;
//seguiría en el bucle interno
continue uno; //seguiría en el bucle principal
break uno;
//se saldría del bucle principal
}
}
return
return expresión;
La
sentencia
return
se
utiliza
para
terminar
un
método
o
función
y
opcionalmente devolver un valor al método de llamada.
Ing. Israel Durán Martínez
33
Facultad de Ingeniería
Java
CAPÍTULO 5: CLASES
Las clases son lo más 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 Definición 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 métodos se
definen dentro del bloque de la clase, Java no soporta funciones o variables globales.
Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de una
clase.
Para crear una clase sólo 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 extensión ".java". Por ejemplo la clase llamada MiClase se
guardaría en un fichero que se llamase MiClase.java. Hay que tener presente que en
Java se diferencia entre mayúsculas y minúsculas; el nombre de la clase y el de
archivo fuente han de ser exactamente iguales.
Aunque la clase MiClase es sintácticamente correcta, lo que se viene a llamar
una clase vacía, es decir, una clase que no hace nada. Las clases típicas de Java
incluirán variables y métodos de instancia. Los programas en Java completos
constarán por lo general de varias clases de Java en distintos archivos fuente.
Ing. Israel Durán Martínez
34
Facultad de Ingeniería
Java
La forma general de una definición de clase es:
En la declaración 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 más interfaces, declarándose 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 Durán Martínez
35
Facultad de Ingeniería
Java
El cuerpo de la clase contiene las declaraciones, y posiblemente la inicialización,
de todos los datos miembro, tanto variables de clase como variables de instancia, así
como la definición completa de todos los métodos.
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
públicas, 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 método 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 métodos 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 Durán Martínez
36
Facultad de Ingeniería
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.2.1 Clase Abstractas
Hay ocasiones en las que se quiere definir una superclase en la que se declare
la estructura de una determinada abstracción sin implementar completamente
cada método, es decir, en la que sólo se defina una forma generalizada que
será compartida por todas las subclase, dejando que cada subclase complete los
detalles necesarios. Una clase de este tipo determina la naturaleza de los
métodos que las subclases deben implementar.
Por lo tanto son clases cuya definición es incompleta. Una clase abstracta
declara métodos pero no tiene que implementarlos.

Los métodos no implementados se declaran como abstract.
abstract tipo nombre(parámetros);

Una clase con un método abstracto debe declararse como clase
abstracta.
abstract class NombreClase{}

Una clase puede declararse como abstracta aunque no tenga ningún
método abstracto.

Las subclases de una clase abstracta deben sobreescribir todos los
métodos abstractos de la superclase, o bien, ser declaradas como clases
abstractas.

Una clase abstracta no puede instanciarse.
5.2.2 Interfaces
Ing. Israel Durán Martínez
37
Facultad de Ingeniería
Java
Con el uso de interfaces se puede especificar lo que una clase debe hacer, pero
no cómo hacerlo. Solo se declara el comportamiento pero no se implementa.
Una interfaz se define como una clase pero carecen de variables de instancia.
Una vez definida, cualquier número de clases pueden implementar una interfaz.
modificador_acceso interface NombreInterfaz
{
Código de la interfaz
}
class NombreClase implements NombreInterfaz1, NombreInterfaz2
{
}

Una clase puede implementar cualquier número de interfaces

Por defecto todos sus métodos son públicos y abstractos.
public abstract tipo nombre(parámetros);

Por defecto todos sus atributos son públicos, constantes y de clase.
public static final NOMBRE = valor;

Permite simular algunos aspectos de la herencia múltiple.

La clase que implemente una interfaz debe de hacer la implementación
de todos los métodos de la interfaz.

Si la clase no implementa a todos los métodos de la interfaz debe ser
declarada como abstracta.
5.3 Modificadores de acceso
El control de acceso se aplica siempre a nivel de clase, no a nivel de objeto. Es
decir, los métodos de instancia de un objeto de una clase determinada tienen acceso
directo a los miembros privados de cualquier otro objeto de la misma clase.
Ing. Israel Durán Martínez
38
Facultad de Ingeniería
Java
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 métodos 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
subclase
paquete
private
X
protected
X
X*
X
public
X
X
X
package
X
Todos
X
X
Se puede observar en la tabla que la columna clase indica que todos los
métodos de una clase tienen acceso a todos los otros miembros de la misma clase,
independientemente del nivel de acceso especificado.
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 intersección 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.
Ing. Israel Durán Martínez
39
Facultad de Ingeniería
Java
La columna todos indica que los privilegios de acceso para métodos que no
están en la misma clase, ni en una subclase, ni en el mismo paquete, se encuentran
restringidos a los miembros públicos de la clase.
Private
Sin modificador
protected
Public
Misma clase
Sí
Sí
Sí
Sí
Misma subclase de paquete
No
Sí
Sí
Sí
Misma no-subclase de paquete
No
Sí
Sí
Sí
Subclase de diferente paquete
No
No
Sí
Sí
diferente No
No
No
Sí
No-subclase
de
paquete
Ing. Israel Durán Martínez
40
Facultad de Ingeniería
Java
CAPÍTULO 6: OBJETOS
6.1 Ciclo de vida de los objetos
Un objeto es una instancia de una clase. En Java la creación de un objeto se
realiza en tres pasos:

Declaración, proporcionar un nombre al objeto.
NombreClase nombreObjeto;

Instanciación, asignar memoria al objeto.
nombreObjeto = new NombreClase();

Inicialización, opcionalmente se pueden proporcionar valores iniciales a las
variables de instancia del objeto.
NombreObjeto = new NombreClase(/*parámetros del constructor*/);
Cómo obtener valores
Para obtener el valor de una variable de instancia se utiliza la notación de
punto.
Con la notación 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 expresión, 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 Durán Martínez
41
Facultad de Ingeniería
Java
Las expresiones de punto se evalúan 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.
Cómo cambiar valores
Asignar un valor a una variable también se utiliza el operador punto. Solo se le
agrega el operador de asignación al lado derecho de la expresión.
objeto1.var.estado = true;
6.2 Comparación de objetos
Los únicos operadores que nos servirán para comparar objetos serán 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 serán iguales, ya que aunque su contenido es el mismo, no serán el
mismo objeto.
En consecuencia, la clase String define un método llamado equals() que
examina cada carácter 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 Durán Martínez
42
Facultad de Ingeniería
Java
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));
}
}
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,
asignándole 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 línea:
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 método
equals() para comparar sus valores.
Ing. Israel Durán Martínez
43
Facultad de Ingeniería
Java
CAPÍTULO 7: MÉTODOS
Los métodos son sin duda alguna la parte más 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 métodos son los que en realidad determinan el comportamiento
del objeto y definen como interactúa con otros en el sistema . La implementación de un
método consta de dos partes, una declaración y un cuerpo.
7.1 Implementación de métodos
La implementación de métodos cuenta con cuatro partes básicas:

El nombre del método.

El tipo de objeto o tipo primitivo que el método regresa.

Una lista de parámetros.

El cuerpo del método.
La declaración completa de un método es la que se muestra a continuación:
controlAcceso static abstract final native synchronized tipoRetorno nombreMetodo(lista_argumentos)
{
cuerpo del método
}
En la parte superior lo que esta en negrillas es la parte que es obligatoria o las
partes básicas que contiene el método a la hora de su declaración.
controlAcceso, determina si otros objetos pueden acceder al método y cómo
pueden hacerlo.
static, indica que los métodos pueden ser accedidos sin necesidad de instanciar
un objeto del tipo que determina la clase.
abstract, indica que el método no está definido en la clase, sino que se
encuentra declarado ahí para ser definido en una subclase(sobrescrito).
final, evita que un método pueda ser sobrescrito.
Ing. Israel Durán Martínez
44
Facultad de Ingeniería
Java
native, son métodos escritos en otro lenguaje.
synchronized, se usa en el soporte de la multitarea.
lista_argumentos, es la lista opcional de parámetros a pasar al método. Es un
conjunto de declaraciones de variables separadas por comas dentro de los paréntesis.
Estos parámetros se vuelven variables locales en el cuerpo del método, cuyos valores
son los objetos o los valores primitivos transmitidos cuando se llama al método.
Dentro del cuerpo de un método puede tener enunciados, expresiones, llamadas de
métodos a otros objetos, condicionales, ciclos y demás.
7.2 Tipos de métodos
En Java existen dos tipos de métodos. Los métodos de instancia y los métodos
de clase.
Métodos de instancia
Cuando se incluye un método en una definición de una clase Java sin utilizar la
palabra clave static, se está generando un método de instancia. Aunque cada objeto de
la clase no contiene su propia copia de un método, el resultado final es como si fuese
así, como si cada objeto dispusiese de su propia copia del método.
La llamada a los métodos de instancia en Java se realiza utilizando el nombre
del objeto, el operador punto y el nombre del método.
miObjeto.nombreMetodo();
Los métodos de instancia tienen acceso tanto a las variables de instancia como
a las variables de clase.
Métodos de Clase
Cuando en la declaración de un método se incluye la palabra reservada static,
se obtiene un método de clase.
Ing. Israel Durán Martínez
45
Facultad de Ingeniería
Java
Lo más significativo de los métodos de clase es que pueden ser invocados sin
necesidad de que haya que instanciar ningún objeto de la clase.
La llamada a los métodos de clase se realiza con el nombre de la clase, el
operador punto y el nombre del método.
MiClase.nombreMetodo();
7.3 Retorno por valor y por referencia
En Java es imprescindible que a la hora de la declaración de un método, se
indique el tipo de dato que ha de devolver. Si no devuelve ningún 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 expresión que será evaluada para saber el valor de retorno. Esta
expresión 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 expresión, el objeto se marca
inmediatamente para que el reciclador de memoria en su siguiente ejecución devuelva
la memoria ocupada por el objeto al sistema, asumiendo que la dirección 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 declaración del método; aunque en Java, el tipo actual de retorno puede
ser una subclase del tipo que se ha indicado en la declaración del método.
7.4 Sobreescribir y sobrecargar métodos
Algunas de las características que hacen de los métodos sean tan poderosos son
las siguientes:
Ing. Israel Durán Martínez
46
Facultad de Ingeniería

Java
Sobrecargar métodos: métodos con múltiples identificaciones y definiciones,
pero con el mismo nombre.

Sobrescribir métodos: creando una definición distinta para un método definido
en una superclase.
Sobrecargar métodos
La sobrecarga de métodos le permite a las instancias de su clase tener una
interfaz más sencilla para otros objetos (no hay necesidad de métodos por completo
diferentes que realizan en esencia lo mismo) y comportarse en forma diferente en base
a la entrada a ese método.
Cuando se llama a un método en un objeto, Java hace coincidir su nombre,
número y tipo de argumentos para seleccionar que definición de método ejecutar.
Para crear un método sobrecargado, todo lo que se necesita hacer es crear
varias definiciones distintas de método en la clase, todas con el mismo nombre, pero
con diferentes listas de parámetros (ya sea en número o tipo de argumentos). Java
permite la sobrecarga de métodos siempre que cada lista de parámetros sea única
para el mismo nombre del método.
Java diferencia los métodos sobrecargados con el mismo nombre, basado en el
número y tipo de parámetros de ese método, no en su tipo de retorno (return). Si se
intenta crear dos métodos con el mismo nombre, la misma lista de parámetros, pero
con diferentes tipos de retorno, obtendrá un error de compilador. Los nombres de
variables que escoja para cada parámetro son irrelevantes, lo que importa es el
número y el tipo.
Sobrescribir Métodos
Cuando se llama a un método en un objeto, Java busca su definición en la clase
de ese objeto, y si no la encuentra, pasa la llamada del método hacia una jerarquía
mayor hasta encontrar una definición del mismo. La herencia le permite definir y
utilizar métodos de forma repetida en las subclases sin tener que duplicar el código.
Ing. Israel Durán Martínez
47
Facultad de Ingeniería
Java
Sin embargo, habrá ocasiones en que se desee que un objeto responda a los
mismos métodos, pero que tenga diferente comportamiento cuando llame a un
método. En este caso, se puede sobrescribir. Esto implica definir un método en una
subclase que tenga la misma identificación de otro en una superclase. Entonces,
cuando se llama al método, el de la subclase se busca y se ejecuta, en lugar del que
está en la superclase.
Para sobrescribir un método, todo lo que se tiene que hacer es crear uno en la
subclase que tenga la misma identificación (nombre, tipo de retorno, lista de
parámetros) de otro definido en una de las superclases. Puesto que Java ejecuta la
primera definición del método que encuentra que coincide con la identificación, esto en
forma eficiente oculta la definición del original.
7.5 Constructores
Un método constructor es una clase especial de método que determina cómo se
inicializa un objeto cuando se crea.
A diferencia de los métodos ordinarios, no se puede llamar a un método
constructor en forma directa; en su lugar, Java los llama de manera automática 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 números, null para objetos, false
para booleanos y ´\0´ para caracteres).

Llama al método constructor de la clase.
Los constructores son muy parecidos a los métodos ordinarios, con dos diferencias
básicas:

Siempre tienen el mismo nombre de la clase.

No tienen un tipo de retorno (return).
Ing. Israel Durán Martínez
48
Facultad de Ingeniería
Java
Al igual que los métodos ordinarios, los constructores también pueden tomar
varios números y tipos de parámetros, 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 definición de método, tal vez desee referirse al objeto
actual (el objeto que el método llamó) para referirse a las variables de instancia de ese
objeto o para pasar el objeto actual como un argumento a otro método. 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
implementación similar a Java. Si un método sobrescribe un método de una
superclase, se puede utilizar la palabra clave super para eludir la versión sobrescrita de
la clase e invocar a la versión original del método en la superclase. Del mismo modo,
se puede utilizar super para acceder a variables miembro de la superclase.
7.7 Interfaces
Los métodos abstractos son útiles cuando se quiere que cada implementación
de la clase parezca y funcione igual, pero necesita que se cree una nueva clase para
utilizar esos métodos abstractas. Las interfaces proporcionan un mecanismo para
abstraer los métodos a un nivel superior, lo que permite simular la herencia múltiple
de otros lenguajes.
Una interfaz sublima el concepto de clase abstracta hasta su grado más alto.
Una interfaz podrá verse simplemente como una forma, es como un molde, solamente
permite declarar nombres de métodos, listas de argumentos, tipos de retorno y
adicionalmente miembros datos (los cuales podrán ser únicamente tipos básicos y
serán tomados como constantes en tiempo de compilación, es decir, static y final).
Ing. Israel Durán Martínez
49
Facultad de Ingeniería
Java
Una interfaz contiene una colección de métodos que se implementan en otro
lugar. Los métodos 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 más importante del uso de interfaces es que múltiples objetos de
clases diferentes pueden ser tratados como si fuesen de un mismo tipo común, 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
definición 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 ningún 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 vacía, como es el caso de Serialize, que permite serializar un objeto. Una
interfaz vacía se puede utilizar como un marcador para marcar a una clase con una
propiedad determinada.
Ing. Israel Durán Martínez
50
Facultad de Ingeniería
Java
CAPÍTULO 8: EXCEPCIONES
Una excepción es un objeto que describe una condición excepcional, es decir un
error que ha ocurrido en una parte del código. Cuando surge una condición
excepcional, se crea un objeto que representa esa excepción y se envía al método que
ha originado el error. Ese método puede decidir entre gestionar el mismo la excepción
o pasarla. En cualquiera de los dos casos, en algún punto, la excepción es capturada y
procesada. Las excepciones pueden ser generadas por el intérprete Java o por el
propio código. Las excepciones generadas por java se refieren a errores fundamentales
que violan las reglas del lenguaje Java o las restricciones del entorno de ejecución de
Java.
Las excepciones en Java están destinadas, al igual que en resto de los lenguajes
que las soportan, para la detección y corrección de errores. Si hay un error, la
aplicación no debería morirse. Se debería lanzar (throw) una excepción que a su vez
debería capturarse (catch) y resolver la situación 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
gestión
excepcionalmente
de
excepciones
poderoso
para
en
controlar
Java
proporciona
programas
que
un
mecanismo
tengan
muchas
características dinámicas durante su ejecución. Las excepciones son formas muy
limpias de manejar errores y problemas inesperados en la lógica 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 avería de un disco duro, a los simples errores de programación,
como tratar de acceder a un elemento de un array fuera de sus límites. Cuando dicho
error ocurre dentro de un método Java, el método crea un objeto 'exception' y lo
maneja fuera, en el sistema de ejecución. Este objeto contiene información sobre la
excepción, incluyendo su tipo y el estado del programa cuando ocurrió el error. El
sistema de ejecución es el responsable de buscar algún código para manejar el error.
En terminología java, crear una objeto exception y manejarlo por el sistema de
ejecución se llama lanzar una excepción.
Ing. Israel Durán Martínez
51
Facultad de Ingeniería
Java
Después de que un método lance una excepción, el sistema de ejecución entra
en acción para buscar el manejador de la excepción. El conjunto de "algunos" métodos
posibles para manejar la excepción es el conjunto de métodos de la pila de llamadas
del método donde ocurrió el error. El sistema de ejecución busca hacia atrás en la pila
de llamadas, empezando por el método en el que ocurrió el error, hasta que encuentra
un método que contiene el "manejador de excepción" adecuado.
Un manejador de excepción es considerado adecuado si el tipo de la excepción
lanzada es el mismo que el de la excepción manejada por el manejador. Así la
excepción sube sobre la pila de llamadas hasta que encuentra el manejador apropiado
y una de las llamadas a métodos maneja la excepción, se dice que el manejador de
excepción elegido captura la excepción.
Si el sistema de ejecución busca exhaustivamente por todos los métodos de la
pila de llamadas sin encontrar el manejador de excepción adecuado, el sistema de
ejecución finaliza (y consecuentemente y el programa Java también).
8.1 Capturar y manejar excepciones
Las excepciones lanzadas por un método que pueda hacerlo deben recogerse en
un bloque try/catch o try/finally.
Bloque try
El primer paso en la construcción de un manejador de excepciones es encerrar
las sentencias que podrían lanzar una excepción dentro de un bloque try. En general,
este bloque se parece a esto.
try
{
Sentencias Java;
}
El segmento de código etiquetado sentencias java está compuesto por una o
más sentencias legales de Java que podrían lanzar una excepción.
Ing. Israel Durán Martínez
52
Facultad de Ingeniería
Java
Se dice que el bloque try gobierna las sentencias encerradas dentro de él y
define el ámbito de cualquier manejador de excepción (establecido por su subsecuente
bloque catch) asociado con él. En otras palabras, si ocurre una excepción dentro del
bloque try, esta excepción será manejada por el manejador de excepción asociado con
esta sentencia try.
Una sentencia try debe ir acompañada de al menos un bloque catch o un bloque
finally.
Bloque catch
Se
pueden
asociar
manejadores
de
excepción
a
una
sentencia
try
proporcionando uno o más bloques catch directamente después del bloque try.
try
{
. . .
}
catch(. . .)
{
. . .
}
catch(. . .)
{
. . .
}
. . .
No puede haber ningún código 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 sólo argumento formal. Este argumento parece
un
argumento
de
una
declaración
de
método.
El
tipo
del
argumento
AlgunObjetoThrowable declara el tipo de excepción 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 excepción realmente están
lanzado un objeto, sólo pueden lanzarse los objetos derivados de la clase Throwable.
Ing. Israel Durán Martínez
53
Facultad de Ingeniería
Java
NombreVariable es el nombre por el que el manejador puede referirse a la
excepción capturada.
Se puede acceder a las variables y métodos de las excepciones en la misma
forma que accede a los de cualquier otro objeto. getMessage() es un método
proporcionado por la clase Throwable que imprime información adicional sobre el error
ocurrido. La clase Throwable también implementa dos métodos para rellenar e
imprimir el contenido de la pila de ejecución cuando ocurre la excepción. Las subclases
de Throwable pueden añadir otros métodos o variables de ejemplar, Para buscar qué
métodos implementar en una excepción, se puede comprobar la definición de la clase y
las definiciones de las clases antecesoras.
Bloque finally
El paso final en la creación de un manejador de excepción es proporcionar un
mecanismo que limpie el estado del método antes (posiblemente) de permitir que el
control pase a otra parte diferente del programa. Se puede hacer esto encerrando el
código de limpieza dentro de un bloque finally.
8.2 Las sentencias throw
Todos los métodos Java utilizan la sentencia throw para lanzar una excepción.
Esta sentencia requiere un sólo 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
compilación 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
Ing. Israel Durán Martínez
54
Facultad de Ingeniería
Java
Sólo se pueden lanzar objetos que estén 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.
Error
Cuando falla un enlace dinámico, y hay algún fallo "hardware" en la máquina
virtual, ésta lanza un error. Típicamente los programas Java no capturan los Errores.
Pero siempre lanzarán errores.
Exception
La mayoría de los programas lanzan y capturan objetos derivados de la clase
Exception.
Una Excepción indica que ha ocurrido un problema pero que el problema no es
demasiado serio.
La mayoría de los programas que se escriben lanzarán y capturarán
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 señala que no se puede encontrar un método
particular, y NegativeArraySizeException indica que un programa intenta crear un
array con tamaño negativo.
Una subclase de Exception tiene un significado especial en el lenguaje Java:
RuntimeException.
Ing. Israel Durán Martínez
55
Facultad de Ingeniería
Java
8.4 Excepciones en Tiempo de Ejecución
La clase RuntimeException representa las excepciones que ocurren dentro de la
máquina virtual Java (durante el tiempo de ejecución). Un ejemplo de estas
excepciones es NullPointerException, que ocurre cuando un método intenta acceder a
un miembro de un objeto a través de una referencia nula. Esta excepción 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.
Como las excepciones en tiempo de ejecución están omnipresentes e intentar
capturar o especificarlas todas en todo momento podría ser un ejercicio infructuoso (y
un código 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 método
especifique que lanza excepciones en tiempo de ejecución. Además puedes crear sus
propias subclases de RuntimeException.
Ing. Israel Durán Martínez
56
Facultad de Ingeniería
Ing. Israel Durán Martínez
Java
57
Facultad de Ingeniería
Java
CAPÍTULO 9: EJEMPLOS
1. Hola
//Se compila como: javac Hola.java generándose un archivo con extensión (*.class), es decir, Hola.class
//Se interpreta como: java Hola
/*
La clase Hola implementa una aplicación 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;
//Declaración de una variable local tipo entera.
String c = "cadena"; //Declaración de una variable local tipo cadena.
boolean b = true;
//Declaración de una variable local tipo booleana.
char h = 'a';
//Declaración de una variable local tipo carácter.
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;
//Declaración de una variable de clase tipo entera.
//Declaración de una variable de clase tipo cadena.
//Declaración de una variable de instancia tipo booleana.
//Declaración de una variable de instancia tipo carácter.
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 Durán Martínez
58
Facultad de Ingeniería
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");
}
RADICA
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";
Ing. Israel Durán Martínez
59
Facultad de Ingeniería
}
}
Java
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("-----------------------------------------");
5. Máximo 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
máximo
máximo
máximo
máximo
máximo
máximo
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 Durán Martínez
60
Facultad de Ingeniería
Java
7. Operadores Aritméticos
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 Durán Martínez
61
Facultad de Ingeniería
}
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)
{
//Declaración 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 Durán Martínez
62
Facultad de Ingeniería
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 Durán Martínez
63
Facultad de Ingeniería
}
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 Durán Martínez
64
Facultad de Ingeniería
Java
15. Ordena Números
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. Métodos de clase y de instancia
//Métodos 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 Durán Martínez
65
Facultad de Ingeniería
}
}
Java
System.out.println("La resta es: " + m.resta(1,3));
System.out.println("La raiz cuadrada es: " + Math.sqrt(4));
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 Métodos
/* métodos con el mismo nombre pero con diferentes listas de parámetros */
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 Durán Martínez
66
Facultad de Ingeniería
}
Java
this.y1=y1;
this.x2=x2;
this.y2=y2;
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 Métodos, 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 Durán Martínez
67
Facultad de Ingeniería
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 Durán Martínez
68
Facultad de Ingeniería
Java
}
void imprime() //método imprime
{
System.out.println("La persona " + nombre + " tiene " + edad + " años");
}
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 Durán Martínez
69