Manual-Java-JSE
Manual-Java-JSE
INTRODUCCIÓN
Descripción
Java es un potente lenguaje de programación de propósito general, lo que significa que sirve para el
desarrollo de aplicaciones de todo tipo. Sus principales características son las seguridad y la flexibilidad.
Java es un lenguaje orientado a objetos, que es un paradigma que hace más fácil e intuitivo el desarrollo de
aplicaciones.
El lenguaje Java también es el lenguaje utilizado para la programación de dispositivos móviles con sistema
operativo Android, así como programación de servidores de Internet y servidores empresariales, lo que hace
que dicho lenguaje sea múy útil y solicitado. Java también está fuertemente vinculado al gestor de bases de
datos Oracle.
Todo programa realizado en Java está organizado en clases (archivos con extensión .java). Cada archivo
.java puede contener una o varias clases, aunque lo normal y recomendable es que solo contengan una
sola clase. Cuando se compila un archivo .java, se obtiene un archivo .class (los bytecodes, que es un
código "neutro" independiente de la arquitectura).
Estos bytecodes no pueden ser directamente ejecutados por un sistema operativo. Para ello, el intérprete
(máquina virtual del sistema operativo donde se va a ejecutar la aplicación Java), interpreta dichos
bytecodes, ejecutando así la aplicación Java en dicho sistema operativo.
Hay una máquina virtual Java (JVM) para cada sistema operativo. Cada JVM de cada sistema operativo lee
los bytecodes de la misma manera, pero cada una de ellas realiza la interpretación (traducción)
correspondiente al sistema operativo para el que ha sido diseñada, es decir, para el sistema operativo
donde se va a realizar dicha interpretación.
Es normal hoy en día, encontrar máquinas virtuales para cualquier sistema operativo existente. En muchos
casos, dicha máquina virtual forma parte del propio sistema operativo.
Un programa C o C++ es totalmente ejecutable y eso hace que no sea independiente de la plataforma, ya
que habría que cambiar el código del programa y compilarlo de nuevo para ejecutarlo en las diferentes
plataformas, y que además, su tamaño normalmente es muy grande, ya que dentro del código final hay que
incluir las librerías para dicha plataforma.
1
FORMACIONBIT
Manual: Java JSE
Los programas Java no son ejecutables (EXE), no se compilan como los programas en C o C++. En su
lugar son interpretados por una aplicación conocida como la máquina virtual de Java (JVM). Gracias a ello
no tienen porque incluir todo el código y librerías propias de cada máquina final o sistema.
Previamente, el código fuente en Java (archivos .java) se tiene que precompilar generando un código previo
(que no es directamente ejecutable) conocido como bytecode o J-code (código Java). Dicho código
(bytecode), genera archivos con extensión .class (dichos archivos class son los que contienen las
instrucciones bytecodes) son los archivos que son ejecutados por la máquina virtual de Java (JVM) que
interpreta las instrucciones de dichos bytecodes contenidos en los archivos .class, ejecutando así el código
de la aplicación.
El bytecode se puede ejecutar en cualquier plataforma. Lo único que se requiere es que dicha plataforma
posea un intérprete adecuado a dicha plataforma (es decir, que posea la máquina virtual para dicha
plataforma). La máquina virtual de Java, además es un programa muy pequeño y que se distribuye
gratuitamente para prácticamente todos los sistemas operativos.
Por consiguiente, habrá una máquina virtual Java (JVM) para cada sistema operativo donde se desee
ejecutar la aplicación Java; por ejemplo, habrá una máquina virtual Java para el SO Windows, otra máquina
virtual Java para el SO Macintosh, otra máquina virtual para un dispositivo electrónico en concreto, otra
máquina virtual para un electrodoméstico específico, etc. A este método de ejecución de programas en
tiempo real se le llama Just in Time (JIT).
En Java la unidad fundamental del código es la clase (compilada en archivo .class). Son las clases
compiladas (en archivos .class) las que se distribuyen (ya que contienen el bytecode de Java). Estas clases
(los archivos .class) se cargan dinámicamente durante la ejecución del programa Java (la máquina virtual,
carga dinámicamente los archivos .class durante la ejecución del programa Java).
Proceso de compilación de un programa en Java, suponiendo que se utilice el entorno Eclipse para crear,
compilar y ejecutar el programa:
El JRE proporciona solo el entorno de ejecución para las aplicaciones Java. Se descagará el JRE si
solo se desea ejecutar aplicaciones Java ya construídas, pero no servirá para el desarrollo de
aplicaciones Java.
La JVM es el programa que ejecuta el código Java previamente compilado (bytecode) mientras que
las librerias de clases estándar son las que implementan el API de Java. Ambas (JVM y API) deben
ser consistentes entre sí, de ahí que sean distribuidas de modo conjunto (mediante el JRE).
Un usuario sólo necesita el JRE para ejecutar las aplicaciones desarrolladas en lenguaje Java,
mientras que para desarrollar nuevas aplicaciones en dicho lenguaje es necesario el entorno de
desarrollo JDK, que además del JRE (mínimo imprescindible) incluye, entre otros, un compilador
para Java.
El JRE es lo mínimo que debe contener un sistema para poder ejecutar una aplicación Java.
Por lo que, para ejecutar una aplicación Java, solo se necesita el JRE, que contiene la máquina virtual de
Java y las bibliotecas de Java.
La API de Java
La API (Application Programming Interface [Interfaz de Programación de Aplicaciones]) contiene todo lo
necesario para dotar a los programadores de Java de los medios para desarrollar aplicaciones Java.
La API de Java provee de un conjunto de clases que permiten realizar toda clase de tareas necesarias para
la realización de aplicaciones Java.
La API de Java está organizada en paquetes lógicos (como carpetas), donde cada paquete contiene un
conjunto de clases relacionadas por su utilidad.
http://docs.oracle.com/javase/7/docs/api/
JSE (Java Standard Edition). Está formado por un grupo de paquetes de clases de uso general:
tratamiento de cadenas, colecciones, acceso a datos, aplicaciones gráficas, Applets para internet,
3
FORMACIONBIT
Manual: Java JSE
etc. Éstas clases son las necesarias para cualquier tipo de aplicación de propósito general: consola,
interfaz gráfica o applets.
JEE (Java Enterprise Edition). Está formado por los paquetes y las tecnologías necesarias para la
creación de aplicaciones empresariales multicapa (organización del código de la aplicación en
varias capas); entre ellas, las aplicaciones Web, así como aplicaciones del lado del servidor.
JME (Java Micro Edition). Está formado por los paquetes y las especificaciones necesarias para
crear aplicaciones Java para dispositivos móviles.
La POO utiliza diversas técnicas para el desarrollo de programas orientados a objetos. Surge en los años
70. y su uso se hizo popular en los principios de 1990.
Actualmente, hay multitud de lenguajes de programación que soportan la orientación a objetos, es decir,
que su escritura se realiza con las técnicas de la POO.
La programación orientada a objetos es un paradigma que utiliza objetos como elementos fundamentales en
la construcción de la solución de un programa informático.
Un objeto es una abstracción (extracción de las partes importantes de algo) de algún hecho o ente del
mundo real que tiene atributos que representan sus características o propiedades y métodos que
representan su comportamiento o acciones que realizan. Todas las propiedades y métodos comunes a los
objetos se encapsulan o se agrupan en clases. Una clase es una plantilla o un prototipo para crear objetos,
por eso se dice que los objetos son instancias de clases.
Respecto al trabajo con objetos, la POO está basada se basa en la analogía de los objetos existentes en la
vida real, con el objetivo de la construcción de programas informáticos; de esta forma, la programación se
realiza de una manera más natural e intuitiva.
Cada objeto de la vida real tiene: un nombre, unos atributos (propiedades o características) y puede realizar
una o varias operaciones (acciones). Por ejemplo, en la vida real, existe un objeto llamado Grapadora.
Veamos sus cualidades:
Nombre: Grapadora.
Atributos: modelo, peso, color, longitud, capacidad (de grapas), precio, etc.
Operaciones: grapar, cargar grapas, extraer grapas, vaciar grapas.
Nota: en realidad, la carga, extracción y el vaciado de las grapas las realizaría el ser humano, pero son
operaciones que van ligadas al objeto Grapadora. Éste objeto Grapadora, sería uno de los muchos objetos
que formaría parte de todos los objetos de una oficina.
Bien, pues si se traslada este ejemplo a un programa informático, imaginar que se nececesita realizar un
programa que tenga como objetivo gestionar una tienda. Una de las cosas que hay que realizar en la tienda
es realizar facturas. Pues entonces nuestro programa orientado a objetos, necesitará un objeto llamado
factura, que podría tener las siguientes cualidades:
Nombre: Factura.
Atributos: fecha, concepto, etc.
Operaciones: crear-factura.
Por supuesto, en la tienda hay que realizar mas cosas, aparte de crear facturas. Por ejemplo, también hay
que realizar envíos, por ejemplo de paquetería. Pues podría haber un objeto Envío, con las siguientes
cualidades:
Nombre: Envío.
Atributos: fecha de envío, destino, peso, etc.
Operaciones: enviar, embalar, etc.
4
FORMACIONBIT
Manual: Java JSE
Y así, se debería analizar, con mucha meditación, todos los objetos necesarios en la tienda, ya que
después, una vez analizados y creados todos los objetos, dichos objetos interactuarán unos con otros para
realizar el objetivo, que es el programa informático que controla el negocio de la tienda.
Por ejemplo, en el programa informático de la tienda, cada vez que haya que hacer un envío, se ejecutará el
objeto Envío y se especificarán los datos de dicho envío; después, automáticamente, el objeto envío se
comunicará con el objeto Factura, para emitir la factura correspondiente a dicho envío.
Es mucho más práctico y extendido utilizar un IDE (Integrated Development Environment [Entorno de
desarrollo integrado]).
Codificación.
Compilación.
Depuración.
Ejecución.
Todo ello, dentro de un entorno cómodo y eficiente, así como relativamente fácil de utilizar.
Los IDE de Java utilizan (de forma interna) las herramientas básicas del JDK en la realización de todas las
operaciones. La ventaja de ello, es que el programador no tendrá que utilizar la consola para todas estas
operaciones, dado que el propio IDE permite realizar dichas operaciones con una interfaz gráfica cómoda
de utilizar.
En un IDE, también es sencillo la escritura de código. Los IDE suelen tener un sistema para el resaltado de
las palabras reservadas del lenguaje corresponiente, para diferenciarlas así del resto del código, así como
de otras muchas ventajas. También algunos IDE, como por ejemplo "Eclipse" tienen la característica
Intellisense, que permite la autoescritura del código, es decir, mostrar la lista completa de métodos de un
objeto, cuando se escribe el punto ( . ), y después poder seleccionar cualquier método de dicha lista.
Para el desarrollo en Java existen disponibles muchos entornos (IDE), como por ejemplo:
La mecánica de cualquier IDE es bastante similar. Cualquiera de ellos se basa en el concepto de proyecto.
Dicho proyecto es un conjunto de clases y paquetes bien organizados, que forman la aplicación Java. De
esta forma, en cualquier IDE, lo primero que se suele hacer cuando se comienza una aplicación Java es
crear un proyecto.
Cuando se crea un proyecto, los IDE permiten escoger entre un conjunto de plantillas o tipos de proyecto,
que cada uno de ellos se suele corresponder con un tipo de aplicación en Java: aplicación web, aplicación
de escritorio (de interfaz gráfica o consola), aplicación para dispositivo móvil, etc.
5
FORMACIONBIT
Manual: Java JSE
JDK (Java Depelopment Kit): toda la arquitectura necesaria para el desarrollo en Java.
IDE Eclipse: entorno de desarrollo IDE para facilitar el desarrollo en lenguaje Java.
o Además de Eclipse, existen otros entornos de desarrollo para Java, como por ejemplo:
NetBeans.
6
FORMACIONBIT
Manual: Java JSE
Java Depelopment Kit (Kit de desarrollo de Java) es el Kit de Desarrollo de Java, todo lo correspondiente al
lenguaje de programación Java.
Implementación de la máquina virtual (JRE) para el sistema operativo que se haya indicado en la
descarga de la web.
Herramientas para la compilación y ejecución de programas Java. Todo esto se deberá utilizar
desde la consola de comandos, si no se dispone de un IDE como por ejemplo: Eclipse, Netbeans, ,
etc.
Paquetes de clases del JSE. Por ejemplo, si se tuviese instalado la versión 6 de Java, se tendría lo
siguiente: dentro del directorio de instalación del JDK, en la carpeta: jre/lib, se encuentra el archivo:
rt.jar, donde están contenidas todas las clases que componen JSE.
Para obtener el JDK se podrá descargar de forma gratuíta de la web. En dicha web, se podrá descargar,
respecto al JDK, entre otras cosas, lo siguiente:
7
FORMACIONBIT
Manual: Java JSE
o Otros componentes necesarios para que una aplicación escrita en lenguaje Java pueda ser
ejecutada.
Descarga de JDK
NOTA:
Algún detalle de este proceso puede variar, debido a que las webs se modifican regularmente, pero
lo importante es el proceso general.
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Pulsando en él, aparecerá una ventana similar a la siguiente, que contiene una sección similar a la
siguiente:
Pulsar en la parte superior el botón de radio correspondiente a: aceptar acuerdos, etc. y pulsar en el vínculo
correspondiente al sistema operativo deseado, por ejemplo, para Windows 32 bits, sería el penúltimo
vínculo: Windows x86.
Instalación de JDK
Para instalar JDK, pulsar doble clic en el archivo descargado.
Cuando comience el proceso de instalación, aparecerá una ventana inicial del asistente, entonces pulsar al
botón Next en todas las ventanas que aparezcan. De este modo se dejará todo por defecto en el proceso
de instalación.
Cuando la instalación finalice, en la última ventana que aparece, pulsar el botón Close.
8
FORMACIONBIT
Manual: Java JSE
NOTA:
CON ESTO, HA TERMINADO LA INSTALACIÓN DE Java JDK.
9
FORMACIONBIT
Manual: Java JSE
Eclipse también permite la instalación de Plug-ins, que son aplicaciones complementarias para Eclipse que
permiten realizar tareas específicas complementarias.
Descarga de Eclipse
NOTA:
Algún detalle de este proceso puede variar, debido a que las webs se modifican regularmente, pero
lo importante es el proceso general.
Ubicación de Eclipse
Una vez descargado Eclipse, no se necesita realizar una instalación, sino simplemente una descompresión
del archivo descargado.
NOTA:
CON ESTO, HA TERMINADO DESCARGA Y UBICACIÓN DE Eclipse.
10
FORMACIONBIT
Manual: Java JSE
Ejecutar Eclipse
Para ejecutar Eclipse, dentro de la carpeta eclipse, pulsar doble clic en su archivo ejecutable eclipse.exe.
También se puede crear un acceso directo en el escritorio, para ejecutar Eclipse con más rapidez y
comodidad.
Se puede dejar esa ruta por defecto, pulsando directamente el botón OK.
Para que esta ventana no pregunte esto de nuevo, marcar la casilla Use this as the default….
Después de pulsar el botón OK, aparece Eclipse y su entorno. En su barra de título aparece Java - Eclipse.
También aparece una pantalla de bienvenida que se puede cerrar con la X de su pestaña Welcome (o
botón derecho del ratón en dicha pestaña Welcome - Close), dejando ver así el entorno completo de
Eclipse.
11
FORMACIONBIT
Manual: Java JSE
Entorno general
La interfaz general de Eclipse muestra algunos paneles por defecto, donde el más importante es el
Package Explorer.
Package Explorer
El Package Explorer está situado por defecto en la parte izquierda.
En el Package Explorer es donde se verá toda la estructura de los proyectos de las aplicaciones Java que
se tengan abiertas.
12
FORMACIONBIT
Manual: Java JSE
1. Para saber en que carpeta del disco duro se encuentra el workspace (ya que está ahí la carpeta
del proyecto): Menú File - Switch Workspace - Other.
Aparece la ventana Workspace Launcher, que en la opción Workspace muestra la ruta
del workspace. Fijarse en dicha ruta (que suele ser: "C:\usuarios\pepe\workspace") y
cerrar la ventana Workspace Launcher.
2. En el Explorador de Windows acceder a la carpeta correspondiente a dicha ruta del workspace.
Se apreciará que dentro de la carpeta workspace se encuentra la carpeta correspondiente
al proyecto (que tiene el mismo nombre que dicho proyecto).
3. En el Explorador de Windows pulsar con el botón derecho del ratón dentro de la carpeta del
proyecto - Copiar.
4. Pegar la carpeta en el lugar donde se desee guardar una copia de dicha carpeta correspondiente al
proyecto de Java.
1. Arrancar Eclipse.
2. Crear un proyecto Java llamado Miproyecto.
3. Cerrar Eclipse.
4. Abrir Eclipse.
5. Eliminar el proyecto Miproyecto.
6. En el Explorador de archivos de Windows, crear una carpeta dentro el disco duro C, llamada
Copia-Seguridad.
7. En Eclipse, exportar el y guardarlo en la carpeta creada anteriormente Copia-Seguridad.
8. En Eclipse, eliminar el proyecto Miproyecto.
Quedará el entorno de Eclipse vacío (sin proyectos).
9. En Eclipse, importar el proyecto Miproyecto ubicado en la carpeta creada anteriormente Copia-
Seguridad.
El proyecto Miproyecto quedará cargado en el Package Explorer de Eclipse.
10. En Eclipse, eliminar el proyecto Miproyecto.
11. Cerrar Eclipse.
12. En el Explorador de archivos de Windows, en el disco duro C, eliminar la carpeta llamada Copia-
Seguridad.
14
FORMACIONBIT
Manual: Java JSE
El elemento raíz de un proyecto Java es una carpeta que representa al proyecto y que tiene como nombre,
el nombre que se le dio al proyecto en la opción Project Name, cuando se creó el proyecto Java.
Estructura de la aplicación
Dentro del elemento raiz del proyecto Java, por defecto, aparecerá lo siguiente:
src: (abreviatura de source [código]). Esta carpeta contiene los paquetes, que a su vez, contienen
la clase o clases que contienen el código de la aplicación.
o Cuando se crea un proyecto nuevo, esta carpeta aparece vacía.
o En el momento que se crea, importa o pega una clase, se crea un paquete por defecto (con
el mismo nombre del proyecto) dentro de dicha carpeta src donde se aloja dicha clase.
JRE System Library: contiene las librerías de clases, necesarias para el desarrollo de aplicaciones
Java.
15
FORMACIONBIT
Manual: Java JSE
package paquete;
16
FORMACIONBIT
Manual: Java JSE
A continuación se muestran las partes de una clase básica que arranca una aplicación Java (tiene el
método main). Si la clase no es la que arranca la aplicación, no llevaría dicho método main:
package paquete;
/*
* Declaramos que esta clase (Miclase) pertenece al paquete (package) "paquete".
* La clausula package debe ser la primera sentencia del archivo java
*/
package paquete;
/*
* Cabecera de la clase Miclase
*/
public class Miclase
{
/*
* Declaración de atributos de la clase.
*/
/*
* Método constructor.
* Es el primer método que se ejecuta cuando se
* ejecuta la clase.
* Se llama igual que el archivo de la clase (.java)
* y también igual que la clase
* (el nombre de la cabecera de la clase).
* El método constructor puede recibir parámetros.
*/
public Miclase()
{
/*
17
FORMACIONBIT
Manual: Java JSE
/*
* Éste es el método "main".
* Éste método se ejecuta al lanzarse la aplicación,
* es decir, es el primer método que se ejecuta
* cuando la aplicación arranca.
* La clase que tiene este método main
* es la clase que arranca la aplicación.
* (Ya que hay que tener en cuenta que una aplicación
* está compuesta normalmente por varias clases).
* El resto de clases de la aplicación, lo normal es que no
* tengan este método "main".
*/
public static void main(String[] args)
{
/*
* Aquí se pone todo lo que se desea que se ejecute
* cuando arranca la aplicación.
* Normalmente, aquí se ponen las llamadas
* a otra u otras clases de la aplicación.
*/
/*
* En este ejemplo, se muestra el texto "Hola amigos".
* Para ello, se hace referencia al paquete "System",
* a su clase "out" y a su método "println"
* que permite mostrar un texto por la consola.
*/
System.out.println("Hola amigos");
}
/*
* Declaración de métodos de la clase.
*/
} //Fin de la clase
El método main
Toda aplicación Java debe tener una clase que contenga el método main.
La clase que decidamos que arrancará la aplicación tendrá el modificador de acceso public (escrito en su
cabecera), y dentro de dicha clase deberá existir un un método llamado main() que será de tipo estático
(con el modificador static) y también con su modificador de acceso public.
Cuando se ejecuta una aplicación Java, la JVM (máquina virtual de Java [que es la parte de la arquitectura
Java que ejecuta la aplicación]) busca la clase (entre todas las clases de la aplicación) que contiene un
método estático llamado main() con el formato adecuado (que cumpla todo lo indicado previamente).
Cuando lo encuentra, lo ejecuta como punto de arranque de la aplicación. Dentro del código main() pueden
crearse objetos de otras clases e invocar a sus métodos, en general, se puede incluir cualquier tipo de
lógica que respete las restricciones indicadas para los métodos estáticos.
19
FORMACIONBIT
Manual: Java JSE
EJECUCIÓN DE LA APLICACIÓN
Descripción
Una vez que la aplicación consta de lo básico ya se puede ejecutar para probarla. La aplicación se puede
ejecutar desde la línea de comandos de Java, pero disponiendo de un IDE como Eclipse, es más cómodo,
rápido y efectivo ejecutar dicha aplicación desde Eclipse.
Ejecutar la aplicación
Si es la primera vez que se ejecuta la aplicación:
1. En el Package Explorer, pulsar con el botón derecho del ratón en el elemento raíz del proyecto
correspondiente a la aplicación que se desea ejecutar.
2. Pulsar la opción Run As.
3. Pulsar la opción Java Application.
Se ejecuta la aplicación y se muestra el resultado de dicha ejecución en la vista Console.
Al no ser una aplicación gráfica (con ventanas, botones, etc.), esta aplicación sería de
consola.
1. En el Package Explorer, pulsar con el botón derecho del ratón en la clase deseada.
2. Pulsar la opción Run As.
3. Pulsar la opción Java Application.
Si esta clase no tiene el método main, no aparecerá esta opción, por lo que no se permitirá
su ejecución.
20
FORMACIONBIT
Manual: Java JSE
Codificación
Se crearán las clases de la aplicación. Dichas clases se guardan con la extensión ".java" (estoy lo hace
Eclipse automáticamente).
El nombre del fichero .java tiene que ser exactamente el mismo que el nombre de la clase. Con esto ya se
tendrían todos los archivos fuente, es decir, todas las clases que forman la aplicación Java, en forma de
archivos con extensión .java.
Compilación
Cuando ya se tienen los ficheros fuente .java, Eclipse se encargará de compilarlos. De hecho, cuando en
Eclipse se ejecuta la aplicación se produce una compilación y ejecución.
En el proceso de compilación se transforman los ficheros fuente .java en los bytecodes de Java (archivos
.class. La compilación se realizará con el compilador de Java (javac.exe), que forma parte del JDK (Todo
esto lo hace Eclipse automáticamente de forma transparente para el programador).
NOTA: lo habitual y mas recomendable es que cada fichero fuente java contenga una sola clase,
pero si contuviese más de una, al realizar la compilación, se generarían tantos ficheros .class como
clases tuviese dicho fichero fuente java.
En caso de existir errores sintácticos en el código fuente, el compilador informará de ello en el momento de
compilar, se interrumpiría dicha compilación y por consiguiente, no se generaría el fichero .class necesario
para ejecutar correctamente la aplicación.
Ejecución
Cuando ya se tienen los bytecodes (fichero .class) producto de la compilación, se ejecutará dicho fichero
compilado .class. La ejecución se realizará mediante el intérprete de Java (java.exe), que forma parte del
JDK.
En resumen, tras ejecutarse la compilación (con javac.exe) y la interpretación (con java.exe), el intérprete de
Java (JRE) ejecutará (interpretará) los bytecodes (ficheros ".class"), mostrándose el programa Java
correspondiente.
NOTA: la primera clase que se ejecuta, deberá contener el método main. Éste método main
actuará como inicio de la aplicación. Dicho método main es el método que se ejecutará al lanzarse
la aplicación.
La llamada al intérprete Java (java.exe), insta a la máquina virtual de Java (JVM) a buscar en la
clase indicada un método main() y proceder a su ejecución.
21
FORMACIONBIT
Manual: Java JSE
SINTAXIS BÁSICA
Descripción
La sintaxis básica del lenguaje Java implica una serie de fundamentos básicos de la sintaxis del lenguaje.
Sensibilidad a mayúsculas/minúsculas
El lenguaje Java distingue entre mayúsculas y minúsculas.
El lenguaje Java es Case sensitive (sensible a mayúscula y minúscula). El compilador Java hace distinción
entre mayúsculas y minúsculas, no es lo mismo escribir public que Public, de hecho, utilizar la segunda
forma en vez de la primera provocaría un error de compilación al ser Public una palabra reservada.
La distinción entre mayúsculas y minúsculas no solo se aplica a las palabras reservadas del lenguaje,
también a los nombres de variables y métodos. Es decir, una variable llamada minumero no se le puede
hacer referencia de la forma Minumero.
El código de la clase.
El código del método.
Dentro de los métodos las porciones de código deseado, sentencias condicionales, bucles, etc.
Comentarios
Los comentarios sirven para documentar el programa y comentarlo adecuadamente. Los comentarios no
son compilados, por lo que no ocuparán espacio en los archivos compilados finales.
Los comentarios son muy útiles para que el programador documente y comente los aspectos del código, así
como para que otros programadores también entiendan por qué el código se codificó de cierta manera.
Ejemplo:
Los comentarios de varias líneas debe comenzar con /* y terminar con */.
Ejemplo:
/*
Comentario de varias líneas.
Y sigo escribiendo todas las líneas
que me apetece.
22
FORMACIONBIT
Manual: Java JSE
*/
El IDE Eclipse hace mas elegantes los comentarios de varias líneas, poniendo automáticamente un
asterisco en cada una de las líneas intermedias, quedando de la siguiente forma:
/*
* Comentario de varias líneas.
* Y sigo escribiendo todas las líneas
* que me apetece.
* (Los asteriscos de estas 4 líneas comentadas, no son obligatorios,
* pero eclipse los pone automáticamente).
*/
23
FORMACIONBIT
Manual: Java JSE
SECUENCIAS DE ESCAPE
Descripción
Las secuencias de escape son pequeñas constantes que nos brindan una gran utilidad, ya que permiten
ciertas modificaciones en el código para hacer más cómodas ciertas acciones.
Las secuencias de escape, en su forma directa, se representan entre comillas simples. Entre dichas
comillas simples puede aparecer:
Las secuencias de escape son combinaciones del símbolo contrabarra \ seguido de una letra, y sirven para
representar caracteres que no tienen una equivalencia en forma de símbolo.
Las secuencias de escape también pueden aparecer dentro de las comillas dobles de una cadena tipo
String.
Secuencias de escape
\n Nueva Linea. (Finaliza una línea y comienza una nueva línea).
\t Tabulador.
\r Retorno (Retroceso) de Carro. (Mueve el cursor al primer carácter de la siguiente línea).
\\ El carácter barra inversa ( \ ).
\' El carácter comilla simple ( ' ).
\" El carácter comilla doble ( " ).
System.out.println("En un lugar");
System.out.println("de la");
System.out.println("Mancha.");
Resultado:
En un lugar
de la
Mancha.
Resultado:
En un lugar
de la
Mancha.
Resultado:
24
FORMACIONBIT
Manual: Java JSE
En un lugar de la Mancha.
Resultado:
25
FORMACIONBIT
Manual: Java JSE
TIPOS DE DATOS
Descripción
El tipo de dato de una variable determina los valores que puede contener dicha variable, además de las
operaciones que se puede realizar sobre ella.
A diferencia de otros lenguajes de programación como C, en Java los tipos de datos primitivos no dependen
de la plataforma, microprocesador o sistema operativo. En Java, un dato entero de tipo int siempre tendrá 4
bytes (32 bits), por lo que no tendremos sorpresas al migrar un programa de un sistema operativo a otro. Es
más, ni siquiera hay que volverlo a compilar.
En otros lenguajes de programación, el formato o el tamaño de los tipos primitivos dependen del
microprocesador o del sistema operativo en el que se están ejecutando. En cambio, Java pretende ser
independiente de la plataforma y mantiene los formatos sin cambios.
Para los caracteres alfanuméricos utiliza la codificación UNICODE de 16 bits, para permitir la inclusión de
varios alfabetos.
Un tipo primitivo está predefinido por el lenguaje y utiliza una palabra clave reservada (byte, short, int,
long, etc.).
byte: es un entero de 8 bits. Su valor mínimo es -128 y el máximo 127, ambos inclusive. El tipo de
datos byte se puede utilizar para ahorrar memoria en grandes arrays, donde el ahorro de memoria
realmente importa. También se pueden utilizar en lugar de int donde sus límites ayudan a aclarar el
código. De hecho, el rango de una variable es limitado puede servir como una forma de
documentación.
short: es un entero de 16 bits. Su valor mínimo es -32.768 y el máximo 32.767 ambos inclusive. Se
puede utilizar short para ahorrar memoria en grandes arrays, en situaciones en las que el ahorro
realmente importa.
int: es un entero de 32 bits. Su valor mínimo es -2.147.483.648 y el máximo 2.147.483.647, ambos
inclusive. Generalmente este tipo es la elección predeterminada para valores enteros a no ser que
haya una razón (como las mencionadas anteriormente, de ahorro de memoria) para elegir otro. Este
tipo de dato normalmente será lo suficientemente grande para los números que casi cualquier
programa vaya a utilizar, pero si necesita un rango más amplio, utilice "long".
long: es un entero de 64 bits. Su valor mínimo es -9.223.372.036.854.775.808 y el máximo
9.223.372.036.854.775.807, ambos inclusive. Utilice este tipo de dato cuando necesite un rango de
valores más amplio que el proporcionado por "int".
float: utilizado para valores decimales (y también enteros, por ejemplo, que durante la ejecución del
programa, puedan cambiar a decimal). Es un dato real (entero, decimal ó 0) en coma flotante (o
"punto flotante", es una forma de notación científica usada principalmente en términos
26
FORMACIONBIT
Manual: Java JSE
NOTA: estos datos primitivos (simples) también pueden ser utilizados en Java como objetos, envolviendo
dichos datos primitivos en sus clases equivalentes (java.lang.Integer, java.lang.Double, java.lang.Byte, etc.),
tratando de esta forma a dichos datos primitivos (simples) como si fueran objetos.
Al declarar un objeto, perteneciente a una determinada clase, se está reservando una zona de memoria
donde se almacenarán los atributos y otros datos pertenecientes a dicho objeto. Lo que se almacena en
dicha zona de memoria respecto al objeto, es un puntero (referencia) a dicha zona de memoria.
En realidad, el momento en el que se realiza la reserva física del espacio de memoria es cuando se
instancia el objeto, realizando la llamada a su constructor, y no en el momento de la declaración.
Existe un tipo de dato referencia (referencial) especial nominado por la palabra reservada "null", que
puede ser asignado a cualquier variable de cualquier clase y que indica que el puntero no tiene referencia a
ninguna zona de memoria (el objeto no está inicializado). Sirve para declarar una variable de tipo referencia,
sin todavía asignarle un objeto.
27
FORMACIONBIT
Manual: Java JSE
Además, todos los tipos de datos primitivos (simples) vistos anteriormente, pueden ser declarados como
referenciales (objetos), ya que existen clases que los engloban.
Las interfaces, los vectores y los strings, son unas clases especiales.
Todos los tipos de datos que no son los tipos de datos primitivos, son considerados tipos de datos
referencias (o referenciales), y son principalmente las clases, en las que se basa la programación
orientada a objetos.
Strings en Java
A diferencia de otros lenguajes de programación, los Strings (cadenas) en Java, no son un tipo primitivo
(simple) de datos, sino un dato de tipo referencia, que es un objeto, por lo que cuando se trabaje con
Strings (cadenas), se trabajará con la clase String.
Mencionar que los valores de tipo String van entre comillas dobles, por ejemplo "Aquí estamos", mientras
que los valores de tipo char van entre comillas simples, por ejemplo: 'a'.
Unicode
Para los caracteres alfanuméricos, Java utiliza la codificación Unicode de 16 bits, para permitir la inclusión
de varios alfabetos.
Unicode especifica un nombre e identificador numérico único para cada carácter o símbolo, el code point o
punto de código, además de otras informaciones necesarias para su uso correcto: direccionalidad,
mayúsculas y otros atributos.
Unicode trata los caracteres alfabéticos, ideográficos y símbolos de forma equivalente, lo que significa que
se pueden mezclar en un mismo texto sin la introducción de marcas o caracteres de control.
El objetivo de Unicode es reemplazar los esquemas de codificación de caracteres existentes (por ejemplo
"ASCII"), muchos de los cuales están muy limitados en tamaño y son incompatibles con entornos
plurilingües.
Literales
Son los valores de cadena (que pueden contener cualquier carácter), que pueden asignarse a variables y
que pueden ser utilizados en expresiones del lenguaje.
28
FORMACIONBIT
Manual: Java JSE
Pueden realizarse conversiones entre los distintos tipos de datos (incluso entre los tipos primitivos y
referencias), bien de forma implícita (realizada automáticamente por el programa) o de forma explícita
(realizada por el programador).
29
FORMACIONBIT
Manual: Java JSE
VARIABLES
Descripción
Una variable es un espacio que se reserva en la memoria del ordenador, para almacenar un dato, con el
objeto de utilizar dicho dato posteriormente.
Las variables es la manera en la que indicamos al compilador el espacio en memoria que debe de reservar
para almacenar los datos. Podemos acceder a un dato almacenado en la memoria por medio de una
variable.
Toda variable tiene un nombre para poder identificarla y realizar operaciones con dicha variable.
Identificadores: reglas
Los identificadores son los nombres que se les da a las variables, así como a otros elementos del programa
(clases, interfaces, atributos, métodos, etc.).
Java hace distinción entre mayúsculas y minúsculas, por lo tanto, nombres o identificadores como
var1, Var1 y VAR1 son distintos.
Pueden estar formados por cualquiera de los caracteres del código Unicode, por lo tanto, se
pueden declarar variables como los siguientes ejemplos: añoDeCreación, datoReciente, etc.
o Se acabó la época de los nombres de variable como ano_de_creacion.
El primer carácter no puede ser un dígito numérico.
No puede tener espacios.
No puede tener caracteres que coincidan con los operadores del lenguaje.
o Por ejemplo: *, /.... etc.
La longitud máxima es prácticamente ilimitada.
o Aunque se recomienda que los nombres no sean muy largos por comodidad y legibilidad.
No puede ser una palabra reservada del lenguaje.
o Por ejemplo: if, else, null, true, false, etc.
No pueden existir dos identificadores con el mismo nombre y en el mismo ámbito.
o Por ejemplo, puede haber dos variable "año", si cada una está en ámbitos diferentes, como
por ejemplo, que estén en métodos diferentes.
Identificadores: recomendaciones
30
FORMACIONBIT
Manual: Java JSE
Cada variable debe tener un tipo de dato. Esto determina el tipo de dato que puede almacenar, así como el
rango de valores que puede almacenar y las operaciones que se pueden realizar con dicho dato.
Por ejemplo, una variable de tipo entero (int) puede almacenar números sin decimales y puede realizar
operaciones aritméticas, pero no puede contener texto.
Declaración de variables
Antes de trabajar con alguna variable debemos declararla en el programa.
Ejemplo:
int valor;
Aquí estamos reservando memoria para una variable de tipo entero (int) y la identificamos con el nombre
(identificador) valor. Desde este momento, si en el programa hacemos referencia a la palabra valor,
estamos haciendo referencia a esa porción de memoria y al valor que contiene. (En este ejemplo, la variable
valor, de momento, no contendría ningún dato, ya que solo la hemos declarado, pero todavía no hemos
almacenado ningún valor en ella).
La declaración de una variable se realiza de la misma forma que en el lenguaje C (ya que el lenguaje Java,
deriva del lenguaje C). Siempre contiene el nombre (identificador de la variable) y el tipo de dato al que
pertenece. El ámbito de la variable depende de la localización en el programa donde es declarada.
Asignación
Para asignar un dato a una variable, se realiza de la siguiente forma:
valor = 15;
Por supuesto, primero se ha tenido que declarar la variable, lo que todo (declaración + asignación) nos
quedará como sigue:
// Declaración
int valor;
// Asignación
valor = 15;
Declaración y asignación
Se puede realizar una asignación en el momento de la declaración:
31
FORMACIONBIT
Manual: Java JSE
dato2 = 5;
dato3 = 7;
// Declaración
int valor;
// Asignación
valor = 15;
Ejemplo:
// Declaración
int valor;
// Asignación
valor = 15;
Inicialización de variables
Siempre se debe inicializar una variable que se va a usar, es decir, se le asignará un dato, ya sea en la
misma declaración, o porteriormente, pero siempre antes de usar la variable en una expresión.
Al compilar el programa, el compilador de Java cuando llegue al nombre de una variable, leerá el contenido
de dicha variable y siempre verificará que tenga un dato asignado. Si dicha variable no tiene un dato
asignado, el programa no compilará y mostrará un error del tipo:
Si se declara una variable, no se inicializa, pero después no se utiliza dicha variable en el programa, la
compilación no mostrará error, pero los IDEs de desarrollo, suelen mostrar un aviso de que la variable no
está siendo utilizada:
32
FORMACIONBIT
Manual: Java JSE
Por lo que, siempre se recomienda inicializar variables, de cualquiera de las siguientes formas:
// Declaración y asignación
int valor = 15;
o también de la forma:
// Declaración
int valor;
/*
Asignación.
Esto se escribiría en el lugar deseado del programa,
pero siempre antes de que la variable sea utilizada, por ejemplo,
en una expresión.
*/
valor = 15;
El tipo String no es un tipo de dato primitivo. Pero se comporta como si lo fuera. Para indicar una cadena de
caracteres se encierran entre comillas dobles.
33
FORMACIONBIT
Manual: Java JSE
Una cadena de tipo String va encerrada entre comillas dobles y no puede dividirse en varias líneas (para
dividirlo se puede utilizar el operador de concatenación +).
Ejemplos:
// Declaración
String micadena;
// Asignación
micadena = "Buenas tardes";
// Declaración e inicialización
String micadena = "Buenas tardes";
// Declaración e inicialización
String micadena = "";
// Concatenación de cadenas
micadena = "Hola amigo, " + "estoy en casa," + " nos vemos."
Literales
Es la forma en la que se representa un valor en Java.
Ejemplos:
"Gato" String
"G" String
'G' char
123 int
8000L long
3.14 double
3.14D double
3.14f float
'c' char
34
FORMACIONBIT
Manual: Java JSE
"true" String
true boolean
Sufijos
En los literales numéricos puede forzarse un tipo determinado con un sufijo:
Entero largo: L ó l.
Float: F ó f.
Double: D ó d.
Ejemplos:
En los sufijos que tenemos para identificar el tipo de dato no importa si son en minúscula o mayúscula. Por
convención se utilizan en mayúscula, pues se puede confundir al leer el código una ele minúscula ( l ) con
un uno ( 1 ). Hay que tener cuidado de no olvidarnos los sufijos cuando sean necesarios.
El uso se hace más evidente cuando los primitivos son empleados para realizar operaciones matemáticas
con mayor precisión.
Por ejemplo, si tenemos un número definido como 14D, aunque el número catorce bien pudiera ser un
entero (byte o int), éste se esta definiendo como un número double a través del sufijo D. Esto permite que
el número sea manipulado con otros primitivos de tipo double para el trabajo con decimales (sin perder
precisión).
En estas variables, no siempre es necesario asignar un valor cuando se declara. De esta forma, se declaran
pero no se inicializan, por lo que quedará establecido un valor por defecto predeterminado por el
compilador. En general, este valor suele ser cero o nulo, dependiendo del tipo de datos.
Numeros: 0
boolean: false
Objetos: null
Las variables locales deben inicializarse antes de utilizarse o se producirá un error en tiempo de
compilación.
Constantes
Una constante es una variable del sistema que mantiene un valor inmutable a lo largo de toda la vida del
programa. Una vez que se asigne un valor a dicha constante, este valor no puede ser modificado.
Tiene sentido utilizar una constante cuando sabemos que su valor no cambiará su valor durante toda la
ejecución del programa: DIAS_SEMANA, HORAS_DIA, PI, etc.
No es necesario iniciar el valor de una constante al momento de declararla , pero una vez que se asigne un
valor a dicha constante, este valor no puede ser modificado.
35
FORMACIONBIT
Manual: Java JSE
36
FORMACIONBIT
Manual: Java JSE
VARIABLES: ÁMBITO
Descripción
El ámbito de una variable (scope) es el área del programa donde la variable existe y puede ser utilizada.
Fuera de ese ámbito la variable no puede ser usada.
Cuando se declara una variable, dependiendo del lugar y la manera de declarar dicha variable, definirá el
ámbito de dicha variable.
Una vez que se termina el ámbito de una variable y se sale de dicho lugar, la variable no puede ser usada y
su valor se pierde.
En el caso de los objetos, el ámbito de una variable miembro (variable que pertenece a un objeto) es el de
la usabilidad de un objeto. Un objeto es utilizable desde el momento en que se crea y mientras existe una
referencia que apunte a él. Cuando la última referencia que lo apunta sale de su ámbito el objeto queda
"perdido" y el espacio de memoria ocupado por el objeto puede ser recuperado por la JVM cuando lo
considere oportuno. Esta recuperación de espacio en memoria se denomina recogida de basura.
NOTA IMPORTANTE: no es buena práctica usar variables con un ámbito mayor del que se va a necesitar,
ya que puede originar un código dificil de mantener.
Tipos de ámbito
Dependiendo del lugar donde esté declarada una variable en una aplicación Java, estos son los tipos de
ámbitos (de menor ámbito a mayor ámbito):
Bloque: el bloque de código delimitado entre una pareja de llaves (apertura y cierre). Por ejemplo,
una estructura de control if con sus llaves, las llaves de un método, así como una simple pareja de
llaves puestas en cualquier lugar del código.
o Así como todos los bloques anidados dentro de dicho bloque.
o También se puede decir que la variable tiene un ámbito local respecto al bloque en el que
está declarada.
o El ámbito de la variable comenzará después de la llave de abrir (o llave izquierda) { y
terminará con la llave de cerrar (o llave derecha) }.
Método: el método de una clase.
o Así como todos los bloques que haya dentro de dicho método.
o También se puede decir que la variable tiene un ámbito local respecto al método en el que
está declarada.
Argumento de Método: el método donde se recibe dicho argumento. (el mismo nivel de ámbito que
el anterior de Método).
o Así como todos los bloques que haya dentro de dicho método.
Clase: la clase.
o Así como todos los métodos de dicha clase y todos los bloques y bloques anidados que
haya dentro de dichos métodos. Es decir, la clase completa. Por lo que también tendrá el
ámbito completo, pero independientemente para cada uno de los objetos que se creen de
dicha clase, pero no será común (global) a todos los objetos creados de dicha clase.
o A esta variable de clase, también se le llama variable de instancia o variable de objeto,
ya que cada objeto creado con dicha clase tiene una (cada objeto creado con dicha clase
tiene dicha variable). Son creadas (normalmente al principio de la clase) y permanecerán en
memoria tanto tiempo como dure la instancia (el objeto) de la clase. Estas variables
almacenan el estado del Objeto. Su ámbito ocupa toda la clase entera. Estos valores
existen y conservan su valor desde que la clase es inicializada hasta que la clase es
reinicializada o no se hace referencia a ella mas. Las variables de instancia deben ser
declaradas en la clase (al principio de la clase), no en un método; de esta forma todos los
métodos de dicha clase tendrán acceso a dicha variable.
Global de objeto: (esto es una variable global a todos los objetos creados de la misma clase).
o Ejemplo. Se creará en la clase (en la parte superior): static int mivalor = 6;
o A esta variable global de clase, también se le llama variable de clase, ya que todos los
objetos creado con dicha clase, comparten dicha variable global. Y al ser global para todos
37
FORMACIONBIT
Manual: Java JSE
los objetos creados con dicha clase, desde cualquiera de dichos objetos, se puede tener
acceso a dicha variable global.
NOTAS:
Como puede observarse, NO existen las variables globales de aplicación completa, como ocurre en
otros lenguajes.
Esto no es un defecto del lenguaje, sino todo lo contrario. La utilización de variables globales resulta
peligrosa, ya que puede ser modificada en cualquier parte del programa y por cualquier
procedimiento.
Además, a la hora de utilizarlas hay que buscar dónde están declaradas para conocerlas y dónde
son modificadas para evitar sorpresas en los valores que pueden contener.
38
FORMACIONBIT
Manual: Java JSE
Salida normal
Es la salida normal de Java y se realiza mediante print y println.
Con print se imprime en la misma linea y con println se imprime en una línea nueva.
// Declaración de variables
int edad = 46;
String nombre = "Luisa";
39
FORMACIONBIT
Manual: Java JSE
// Declaración de variables
int edad = 46;
String nombre = "Luisa";
Mediante la clase Scanner se pueden pedir datos al usuario en tiempo de ejecución de un programa que se
muestre por la consola. Por ejemplo, si el programa nos pide nuestros datos para introducirlos en una base
de datos, o nos pide una contraseña para acceder al sistema, deberemos programar que dichos datos se le
pidan al usuario en el momento oportuno.
Para pedir dichos datos al usuario se utiliza la clase Scanner, que nos permitirá recoger dicho dato y
almacenarlo en una variable, para después utilizar dicha variable para trabajar con dicho dato.
Cuando el programa encuentre la clase Scanner, se detendrá y pedirá dicho dato al usuario. Cuando el
usuario escriba dicho dato y pulse la tecla Intro, continuará la ejecución del programa.
Para utilizar la clase Scanner deberemos importar dicha clase Scanner, que se encuentra en el paquete
java.util. Lo haremos de la siguiente manera:
import java.util.Scanner;
Ejemplos:
40
FORMACIONBIT
Manual: Java JSE
// Leer un String
// Con next leemos una palabra (hasta que haya un espacio).
// Con nextLine una línea entera (hasta que haya un Intro).
System.out.print("Ingrese un String: ");
mistring = miescaner.next();
// Leer un int
System.out.print("Ingrese un entero : ");
mientero = miescaner.nextInt();
//Leer un float
System.out.print("Ingrese un float : ");
mifloat = miescaner.nextFloat();
// Leer un double
System.out.print("Ingrese un double : ");
midouble = miescaner.nextDouble();
EJERCICIO: Trabajo con la clase Scanner para recoger datos en tiempo de ejecución.
41
FORMACIONBIT
Manual: Java JSE
CONVERSIONES DE TIPO
Descripción
La conversión de tipos (type casting) consiste en la transformación de un tipo de dato en otro. Esto se hace
para tomar las ventajas que pueda ofrecer el tipo a que se va a convertir.
Por ejemplo, los valores de un conjunto más limitado, como números enteros (por ejemplo int), se pueden
almacenar en un formato más compacto y más tarde convertidos a un formato diferente que permita las
operaciones que anteriormente no eran posibles, tales como trabajo con decimales, (por ejemplo float).
Tipos de conversiones
Hay dos tipos de conversión:
Conversión implícita
La conversión implícita la realiza automáticamente el compilador. En la conversión implícita se convierte un
tipo de dato de menor rango a un supertipo (tipo de dato de mayor rango); este tipo de conversión lo realiza
el compilador, ya que no hay pérdida de datos si, por ejemplo, se pasa dato entero int a dato long.
Si al hacer la conversión de un tipo a otro se da la circunstancia de que los dos tipos son compatibles, y el
tipo de variable destino es de un rango mayor al tipo de la variable que se va a convertir (promoción),
entonces la conversión entre tipos es automática (implícita), es decir, la máquina virtual de Java (JVM) tiene
toda la información necesaria para realizar la conversión sin necesidad de "ayuda" externa (del
programador). A esto se le conoce como conversión implícita (o conversión automática).
Ejemplo:
Se está asignando un valor byte (que puede tener valores entre -128 a 127) a una variable tipo short (que
tiene valores entre -32768 a 32767), sin necesidad de una conversión explicita por parte del programador.
A continuación se presenta un resumen de algunas de las asignaciones que no requieren de una conversión
explicita, es decir, que tienen una conversión implícita (automática) en Java.
Cada tipo de los mostrados a continuación, puede ser asignado de forma implícita a cualquiera de los tipos
que están a su izquierda (de derecha a izquierda).
double <= float <= long <= int <= short <= byte
42
FORMACIONBIT
Manual: Java JSE
String a float:
OJO: hay que tener cuidado al convertir tipos, ya que en este ejemplo se puede convertir a tipos numéricos
porque la cadena tiene las características de un número, si tuviésemos una palabra "lentejas” como cadena
en lugar de "10” surgiría un error ya que no se puede convertir a número "lentejas", ya que lentejas no es un
número.
int a String:
43
FORMACIONBIT
Manual: Java JSE
Es otro tipo de conversión explícita, pero ahora usando el operador "cast", llamado "casting". El operador
"cast" realiza este proceso, es decir convierte datos, variables o expresiones a un nuevo tipo de dato.
Su sintaxis es:
int a float:
Como se aprecia, solo hay que anteponer al dato deseado, el tipo de dato al que se desea convertir, entre
paréntesis.
float a int:
Como se observa, por ejemplo, se puede usar pow(), directamente con los argumentos requeridos (si estos
son numéricos), pero transformándolos con el operador "cast".
44
FORMACIONBIT
Manual: Java JSE
OPERADORES
Descripción
Los operadores son signos que permiten realizar operaciones con los datos. Son parte fundamental de las
expresiones. Los operadores son partes indispensables en la construcción de expresiones.
El valor y tipo que devuelve, depende de cada operador y del tipo de sus operandos. Por ejemplo, los
operadores aritméticos devuelven un número como resultado de su operación.
Expresión
Existen muchas definiciones técnicas para el término expresión. Puede decirse que una expresión es una
combinación de operandos ligados mediante operadores.
Los operandos pueden ser variables, constantes, funciones, literales, etc. y los operadores cualquiera de los
mostrados en este tema.
Operadores unarios
Los operadores que requieren un operando son llamados operadores unarios. Por ejemplo, el operador ++
es un operador unario que incrementa el valor de su operando en una unidad (ejemplo: mivalor++), así
como el operador -- es un operador unario que decrementa el valor de su operando en una unidad (ejemplo:
mivalor--).
Los operadores unarios en Java pueden utilizar tanto la notación prefija (ejemplo: ++mivalor), como la
posfija (ejemplo: mivalor++). Estos operadores ("++" y "--") entran en la categoría de Operadores
aritméticos:
Operadores binarios
Los operadores que requieren dos operandos se llaman operadores binarios. Por ejemplo el operador = es
un operador binario, que asigna el valor del operando del lado derecho al operando del lado izquierdo.
45
FORMACIONBIT
Manual: Java JSE
Todos los operadores binarios en Java utilizan notación infija, lo cual indica que el operador aparece entre
sus operandos:
Operadores ternarios
Los operadores ternarios requieren tres operandos. El lenguaje Java tiene el operador ternario, "?", que es
una sentencia similar a la "if-else".
Este operador ternario usa notación infija; y cada parte del operador aparece entre operandos:
Ejemplo:
//Variables
byte miedad = 15;
String mimenor = "No puedo votar todavía, soy menor de edad.";
String mimayor = "Sí puedo votar, soy mayor de edad.";
Tipos de operadores
Los operadores de Java se pueden dividir en las siguientes cuatro categorías:
Operadores aritméticos.
Operadores de comparación y condicionales.
Operadores de asignación.
Operadores a nivel de bits y lógicos.
Operadores de concatenación.
Operadores aritméticos
Los operadores aritméticos cubren las operaciones aritméticas (suma, resta, multiplicación, división),
además del operador módulo (división entera).
El tipo de los datos devueltos por una operación aritmética depende del tipo de sus operandos; por ejemplo,
si se suman dos enteros, se obtiene un entero, con el valor de la suma de los dos enteros.
Los operadores + y - tienen versiones unarias que realizan las siguientes operaciones:
46
FORMACIONBIT
Manual: Java JSE
Operadores de asignación
El operador de asignación es =, que se utiliza para asignar un valor a otro. Por ejemplo:
int contador = 0;
Java además proporciona varios operadores de asignación, que en combinación con los operadores
aritméticos, permiten realizar atajos en la escritura de código. Permiten realizar operaciones aritméticas,
lógicas y de asignación con un único operador.
Supongamos que necesitamos sumar un número a una variable y almacenar el resultado en la misma
variable:
i = i + 2;
i += 2;
Un operador de comparación compara dos valores y determina la relación existente entre ambos. Por
ejemplo, el operador "!=" devuelve verdadero (true) si los dos operandos son distintos. La siguiente tabla
resume los operadores condicionales (de comparación) de Java:
Además Java soporta un operador ternario ( o condicional): ?. Se comporta como una versión reducida de
la sentencia if-else:
47
FORMACIONBIT
Manual: Java JSE
Operadores lógicos
Operan con valores de tipo booleano (boolean), siendo el resultado también de tipo boolean.
Operadores de concatenación
El lenguaje Java "sobrecarga" la definición del operador + para permitir la concatenación de cadenas.
En una expresión, el valor que esté a la derecha del operador "+" se convierte automáticamente en una
cadena de caracteres.
Ejemplo:
//Variable
byte miedad = 26;
Prioridad de operadores
Cuando en una sentencia aparecen varios operadores el compilador deberá de elegir en qué orden aplica
los operadores. A esto se le llama prioridad o precedencia de operadores.
Los operadores con mayor precedencia son evaluados antes que los operadores con una precedencia
menor.
Cuando en una sentencia aparecen operadores con la misma precedencia, dichos operadores son
evaluados de izquierda a derecha.
Se puede indicar explícitamente al compilador de Java cómo se desea que se evalúe la expresión, mediante
los paréntesis "( )". Para hacer que el código sea más fácil de leer y mantener, es preferible ser explícito e
indicar con paréntesis "( )" los operadores que deben ser evaluados primero.
1. Paréntesis.
2. Unarios.
3. Aritméticos.
4. Condicionales.
5. Relacionales.
6. Booleanos.
7. Asignación.
La siguiente tabla muestra la precedencia asignada a los operadores de Java (de mayor a menor
precedencia). Los operadores en la misma línea tienen la misma precedencia:
Descripción Operadores
Paréntesis ()
suma y resta +-
igualdad == !=
OR (booleano) ||
condicional (ternario) ?:
asignación = += -= *= /= %= ^=
Se puede observar que la última categoría es la de asignación. Esto es lógico, ya que se debe calcular
primeramente la expresión antes de asignar un resultado a una variable.
Si todos los operadores tienen un nivel idéntico de precedencia se evalua la expresión de izquierda a
derecha.
Uso de paréntesis
Se utilizan para aislar una porción de la expresión de forma que el cálculo se ejecute de forma
independiente. Anula cualquier regla de precedencia.
Como en matemáticas, podemos anidar los paréntesis. Se comenzara a evaluar los internos hasta llegar a
los externos.
Los paréntesis no disminuyen el rendimiento de los programas. Por lo tanto, agregar paréntesis no afecta
negativamente al programa, y lo hace mucho mas claro y legible.
Los paréntesis se utilizan para anular la predencia de operadores y/o para aclarar y hacer mas legible el
código de programación.
49
FORMACIONBIT
Manual: Java JSE
ESTRUCTURAS DE CONTROL
Descripción
Las estructuras de control son construcciones hechas a partir de palabras reservadas del lenguaje, que
permiten modificar el flujo de ejecución de un programa.
Si hay una sola instrucción, se pueden omitir las llaves, aunque es recomendable ponerlas en todos los
casos (bloques con una sola instrucción o bloques con varias instrucciones) por claridad en el código de
programación.
50
FORMACIONBIT
Manual: Java JSE
Estructura if simple
Permite ejecutar un bloque de instrucciones si se cumple una determinada condición.
Sintaxis:
if (expresión) {
Bloque instrucciones
}
Ejemplo:
//Variable
byte miedad = 26;
Como solo hay una instrucción dentro del bloque if, no es obligatorio el uso de llaves.
//Variable
byte miedad = 26;
Sintaxis:
if (expresión) {
Bloque instrucciones
}
else {
Bloque instrucciones
}
Ejemplo:
51
FORMACIONBIT
Manual: Java JSE
Estructuras if anidadas
En determinadas ocasiones, se pueden anidar estructuras if-else, de forma que se evalúe una condición
posteriormente, si anteriormente no se ha cumplido otra.
Ejemplo:
//Variable
float nota = 6F;
Esta estructura está indicada para cuando en cada else if se desea evaluar cosas diferentes.
Por ejemplo, para validar un formulario, ya que en cada else if se hace alusión a cada control del
formulario.
if (condición1) {
Acciones1;
}
else if (condición2) {
Acciones2;
}
else if (condición3) {
Acciones3;
}
else {
Acciones si no se cumple ninguna condición anterior;
}
Estructura switch
Permite evaluar la condición de cada uno de los bloques de instrucciones existentes en la estructura. Si se
cumple la condición del primer bloque, se ejecutan sus instrucciones, y si después existe una instrucción
break, finaliza la estructura.
En primer lugar se evalúa la primera expresión. Si dicha expresión coincide con el valor establecido para
dicha primera condición, se ejecutarán sus instrucciones asociadas y terminará la estructura si existe una
instrucción break, si no, también ejecutaría el resto de instrucciones.
Sintaxis:
52
FORMACIONBIT
Manual: Java JSE
switch (expresión) {
case valor1: instrucciones1;
break;
case valor2: instrucciones2;
break;
…
default: instrucciones si no se cumple ninguna de las anteriores.
}
Ejemplo:
//Variables
int micodigo = 7;
int resultado = 0;
1. Crear un programa que recoja del usuario su nombre y su edad, y que dependiendo si la edad es 18
o mayor, o menor que 18, muestre por pantalla el texto:
Hola ---, bienvenido a la web.
2. Crear un programa que recoja del usuario su nombre y su edad, y que dependiendo si la edad es 18
o mayor, o menor que 18, muestre por pantalla el texto:
Hola ---, puedes entrar a la web (en caso de se mayor de edad), o que muestre el texto:
Lo siento ---, no puedes entrar al ser menor de edad (en caso de ser menor de edad).
3. Utilizando una estructura condicional if anidada, crear un programa que recoja un número del
usuario entre 0 y 10, ambos inclusive, y que dependiendo de que número sea, se muestre el
siguiente mensaje de texto por pantalla:
0, 1, 2: La nota es MUY DEFICIENTE.
3: La nota es DEFICIENTE.
4: La nota es INSUFICIENTE.
5: La nota es SUFICIENTE.
6: La nota es BIEN.
7, 8: La nota es NOTABLE.
9, 10: La nota es SOBRESALIENTE.
53
FORMACIONBIT
Manual: Java JSE
4. Crear un programa igual que el anterior, pero que valide la nota introducida por el usuario, de tal
manera que si dicha nota es inferior a 0 o superior a 10, aparezca por pantalla el mensaje: NOTA
NO VÁLIDA.
5. Crear un programa igual que el anterior, pero utilizando una estructura de control condicional
switch, para que de esta forma quede el código más breve y compacto.
54
FORMACIONBIT
Manual: Java JSE
Estructura for
El bucle for se ejecuta un número definido de veces.
Se utilizará el bucle for cuando se conozca el número exacto de veces que ha de repetirse un determinado
bloque de instrucciones.
Sintaxis:
inicialización: es una instrucción que se ejecuta una sola vez al inicio del bucle, es una variable que
inicializa un dicha variable que hará de contador de vueltas, es decir, de contador de veces.
condición: es una expresión lógica, que se evalúa al inicio de cada nueva iteración (vuelta) del
bucle. En el momento en que dicha expresión se evalúe a false (no se cumpla), se dejará de
ejecutar el bucle y el control del programa pasará a la siguiente instrucción (a continuación del bucle
for).
incremento: es una instrucción que se ejecuta en cada iteración del bucle como si fuera la última
instrucción dentro del bloque de instrucciones. Generalmente se trata de una instrucción de
incremento o decremento de alguna variable. Lo más habitual es incrementar la variable contador.
NOTA:
Cualquiera de estas tres cláusulas de la estructura for puede estar vacía, aunque siempre hay que
poner los puntos y coma.
Ejemplo:
Estructura while
Este tipo de bucle se ejecuta mientras se cumpla una condición.
Se utilizará cuando no se conoce exactamente el número de veces que se ejecutará el bucle. En este bucle,
si no se cumple la condición, no se ejecutará ni una sola vez.
Sintaxis:
while (condición) {
55
FORMACIONBIT
Manual: Java JSE
Ejemplo:
//Variable
int mivalor = 7;
int milimite = 10;
OJO:
En este tipo bucle, si la condición nunca se cumple, será un bucle infinito (bucle sin fin).
Estructura do while
Este tipo de bucle se ejecuta mientras se cumpla una condición.
Se utilizará cuando no se conoce exactamente el número de veces que se ejecutará el bucle. En este bucle,
si no se cumple la condición, se ejecutará, por lo menos, una sola vez.
Sintaxis:
do {
bloque instrucciones que se ejecutan mientras se cumpla la "condición"
} while (condición)
Ejemplo:
//Variable
int mivalor = 12;
int milimite = 10;
OJO:
En este tipo de bucle, si la condición nunca se cumple, será un bucle "infinito" ("bucle sin fin").
Sintaxis:
Ejemplo:
57
FORMACIONBIT
Manual: Java JSE
En Java existen dos formas de realizar un salto incondicional en el flujo normal de un programa. Es con las
instrucciones: break y continue.
En el momento que se ejecuta la instrucción break, el control del programa sale de la estructura en la que
se encuentra y continua con la parte siguiente del código.
Ejemplo:
//Bucle que muestra una línea por cada vuelta que da el bucle.
//Cuando i valga 4, sale del bucle.
for (i = 0; i < misveces; i++) {
if (i == 4) {
break;
}
System.out.println("Vuelta del bucle: " + i);
}
Ejemplo:
//Bucle que muestra una línea por cada vuelta que da el bucle.
//Cuando i valga 4, se redirige al principio del bucle, por lo que
//en este ejemplo, la línea 4 no se imprime.
for (i = 0; i < misveces; i++) {
if (i == 4) {
continue;
}
System.out.println("Vuelta del bucle: " + i);
}
58
FORMACIONBIT
Manual: Java JSE
59
FORMACIONBIT
Manual: Java JSE
MATRICES
Descripción
Una matriz es un conjunto de datos del mismo tipo, estructurados en una única variable. En Java, las
matrices son en realidad objetos y por lo tanto se puede llamar a sus métodos.
Los Strings (o cadenas de caracteres) en Java son objetos pertenecientes a las clase String. (NO son
matrices de tipo char como en otros lenguajes).
Declaración de matrices
Existen dos formas equivalentes de declarar matrices en Java:
int matriz1[];
NOTA:
La declaración de una matriz no reserva espacio en memoria, Lo que realmente reserva espacio en
memoria es la asignación de elementos a dicha matriz.
Ejemplo que declara una matriz y reserva espacio en memoria para 5 elementos:
60
FORMACIONBIT
Manual: Java JSE
En este caso, no es necesario especificar el número de elementos máximo reservado, ya que Java "cuenta"
los elementos especificados y así sabe dicho número de elementos. Se reserva así el espacio justo para
almacenar los elementos especificados en dicha declaración.
NOTA:
La declaración de una matriz no reserva espacio en memoria, Lo que realmente reserva espacio en
memoria es la asignación de elementos a dicha matriz.
Cuando los elementos se asignan a la matriz es cuando dichos elementos de la matriz obtienen la
memoria necesaria para ser almacenados.
Índice de la matriz
Es un número que identifica el orden de cada elemento de la matriz.
nombreMatriz[índiceMatriz]
//Se muestra el valor del segundo elemento de la matriz (de índice "1")
System.out.println("Segundo elemento de la matriz: " + personas[1]);
El intento de acceder a un elemento fuera del rango de la matriz, provoca una excepción (error) que, deberá
ser controlado.
Dicho atributo length almacena un número entero correspondiente al número de elementos de la matriz.
Ejemplo:
Ejemplo que utiliza la estructura for para recorrer los elementos de una matriz:
Ejemplo que utiliza la estructura for each para recorrer los elementos de la matriz:
Matrices multidimensionales
También pueden utilizarse matrices de más de una dimensión:
Ejemplo que accede a la matriz llamada mimatriz, al elemento de la tercera fila (índice 2), cuarta columna
(índice 3):
mimatriz[2][3]
Sintaxis:
Ejemplo:
1. Crear un programa que recoja del usuario 6 números enteros que su valor sea del 1 al 100, ambos
inclusive. Para ello, se trabará con una matriz de una dimensión que almacenará dichos 6 números.
Esto es importante, pensando que en el futuro este programa podría recoger muchos más
números, y al estar en la matriz, todo se automatiza mejor y el programa se hace eficiente.
2. Una vez recogidos, se desplegará lo siguiente, y en este orden (esto es un ejemplo de cómo debe
quedar, respetando espacios, puntos, guiones, tabulaciones, saltos de línea, etc.):
---DATOS DE SALIDA
***FIN DE INFORME***
NOTAS:
El programa se realizará utilizando una matriz de una dimensión que almacena los números.
La escritura será elegante con tabulaciones, comentarios, etc.
64
FORMACIONBIT
Manual: Java JSE
POO: INTRODUCCIÓN
Descripción
En Java, todo son clases (trabajo con objetos).
Por esta razón, un programa Java estará formado por uno o varios ficheros fuente (java) y en cada uno de
ellos habrá definida una clase.
NOTA:
Aunque dentro de un fichero .java es posible tener varias clases, es recomendable que haya una
sola clase.
Clases
Desde un punto de vista general, una clase es un conjunto de valores (atributos) junto con las funciones y
procedimientos que operan sobre los mismos (métodos), todo ello tratado como una entidad.
Estas clases constituyen los bloques principales en los cuales se encuentra contenido el código.
El nombre del archivo fuente java también hace distinción entre mayúsculas y minúsculas a la hora de
compilarlo, aunque el sistema operativo empleado no haga esta distinción.
class Clase1 {
...
}
class Clase2 {
...
}
...
Si hay varias clases dentro de un archivo fuente java, solo una puede ser public.
65
FORMACIONBIT
Manual: Java JSE
Declaración de la clase
La declaración de la clase es lo que abre el código de la clase (la cabecera de dicho código).
La declaración de la clase contendrá, como mínimo, la palabra reservada class y el nombre de la clase.
Si no se especifica el modificador de acceso antes del nombre de la clase, dicha clase tendrá el modificador
de acceso por defecto, que es default (en caso de desear el módificador de clase default, no hace falta
escribirlo).
Sintaxis:
Ejemplo de declaración de clase llamada Miclase, con modificador de acceso default (no hace falta escribir
default):
class Miclase
Ejemplo de declaración de clase llamada Miclase, con modificador de acceso public (que es lo habitual):
Ejemplo:
Clase llamada MiClase con modificador de acceso público que hereda de la superclase MiClasePadre y
que implementa dos interfaces: MiInterface1 y MiInterface2.
Cuerpo de la clase
El cuerpo de las clases comienza con una llave abierta { y termina con una llave cerrada }.
66
FORMACIONBIT
Manual: Java JSE
Dentro del cuerpo de la clase se encuentra el contenido de la clase: la declaración de los atributos y los
métodos de dicha clase.
Ejemplo:
NOTA:
Para que un programa Java se pueda ejecutar, debe contener, al menos, una clase que tenga un
método main con la siguiente declaración:
/*
Declaramos que esta clase (Miclase) pertenece al paquete (package) "paquete".
La clausula package debe ser la primera sentencia del archivo java
*/
package paquete;
/*
Importación de paquetes.
Todos los paquetes con sus clases, así como solo clases sueltas
que se vayan a utilizar en esta clase.
*/
// Declaración de la clase
public class Clase
{
//CUERPO DE LA CLASE
/* Método constructor
Es el primer método que se ejecuta cuando se ejecuta la clase.
Se llama igual que el fichero de la clase y también igual que la clase.
El método constructor puede recibir parámetros.
El método constructor es opcional.
public Clase()
{
// Aquí se suelen inicializar los atributos de la clase.
// ...
}
/*
Éste es el método "main".
La clase que tiene este método main es la clase que arranca la aplicación.
Éste método se ejecuta al lanzarse la aplicación, es decir, es el primer
67
FORMACIONBIT
Manual: Java JSE
/*
* En este ejemplo, se muestra el texto "Hola amigos".
* Para ello, se hace referencia a la clase "System",
* contenida en el paquete "java.lang".
* Dicha clase "System" tiene un método "println"
* que permite mostrar un texto por la consola.
*/
System.out.println("Hola amigos");
}
En la parte superior del archivo java correspondiente a la clase, se realizarán todas las importaciones
correspondientes a las clases o paquetes de clases que se deseen usar en esta clase.
Ejemplo para importar un paquete de clases entero (todas las clases de dicho paquete). Se importan todas
las clases del paquete math (ruta de paquetes java.math):
import java.math.*;
Ejemplo para importar una sola clase de un paquete. Se importa la clase Scanner del paquete util (ruta de
paquetes java.util.Scanner [Scanner es la clase]):
68
FORMACIONBIT
Manual: Java JSE
import java.util.Scanner;
NOTA:
Es recomendable importar solo lo necesario, es decir, solo lo que vayamos a utilizar, para ahorrar
recursos.
Método "main"
Consideraciones generales sobre el método main:
El método main está escrito en la clase que arranca la aplicación, es decir, la clase que contenga el
método main es la clase que arrancará la aplicación.
En el método main se pone todo lo que se desea que suceda cuando arranque la aplicación.
En el método main se suelen poner las llamadas a otras clases de la aplicación.
Todo programa independiente escrito en Java empieza a ejecutarse (como en lenguaje C) a partir
del método main().
Se pueden compilar clases que no posean método main(), pero el intérprete Java no podrá
ejecutarlas.
Para poder ejecutar el método main() no se crea ningún objeto de la clase que contenga dicho
método main.
public: indica que el método main() es público y, por tanto, puede ser llamado desde otras clases.
o Todo método main() debe ser público para poder ejecutarse desde el intérprete Java
(JVM), ya que es el primer método que se ejecuta de la aplicación.
static: indica que la clase no necesita ser instanciada para poder utilizar este método main.
o No es necesario crear un objeto de esta clase donde se encuentra el método main para
poder ejecutar dicho método main.
o También indica que, en caso de que se instanciara la clase donde se encuentra dicho
método main (creando así uno o varios objetos de dicha clase donde está dicho método
main), dicho método main sería compartido (global) por todos los objetos pertecientes a
dicha clase donde está dicho método main; es decir, dicho método main es el mismo para
todas las instancias que pudieran crearse de la clase donde está dicho método main.
void: indica que este método main es un método que no devuelve ningún valor.
main: indica el nombre del método. Es un nombre reservado que Java sabe que tiene que buscar
para arrancar la aplicación.
(String[] args): indica que este método main está capacitado para recibir un conjunto de
argumentos, y que los almacenará en una matriz de tipo String, llamada args.
o El método main debe aceptar siempre, como parámetro, una matriz de strings (cadenas),
que contendrá los posibles argumentos que se le pasen al programa.
System.out.println("Hola amigos"): indica que se va a ejecutar el método println(), encargado de
mostrar un valor a través de la salida estándar (en el ejemplo, un String) y después realiza un
retorno de carro automático y nueva línea.
o Este método println pertenece al atributo out. Este atributo se encuentra incluido dentro de
la clase System.
69
FORMACIONBIT
Manual: Java JSE
public.
abstract.
final.
Cuando se crean varias clases, agrupadas dentro de un paquete (package), únicamente las clases
declaradas public pueden ser accedidas desde otro paquete.
En un archivo fuente java puede haber más de una clase, pero sólo puede haber una con el modificador
public.
La clase abstracta es una clase que sirve como clase base COMÚN para que otras clases hijas hereden de
ella sus miembros que se deseen "comunes" (la implementación de dichos miembros [atributos y métodos]
se deja a las subclases).
Esto es importante, por ejemplo, cuando se crean clases que acceden a recursos del sistema o realizan
operaciones críticas o de seguridad. Si estas clases no se declaran como final, cualquiera podría
redefinirlas y aprovecharse para realizar operaciones sólo permitidas a dichas clases pero con nuevas
intenciones, posiblemente oscuras.
70
FORMACIONBIT
Manual: Java JSE
Si no se especifica el modificador de clase en la declaración de una clase, dicha clase tomará el modificador
de clase por defecto, que es default (también llamado package), aunque no es necesario reflejar dicha
palabra default ni package (si se desea aplicar a la clase dicho modificador por defecto).
Una clase con modificador de clase default (o package) será visible en todas las clases declaradas en el
mismo paquete, pero no será visible en las clases de otros paquetes diferentes (externos al paquete actual).
Ejemplo de declaración de clase que no especifica de forma explícita el modificador de clase, por lo que
toma por defecto el modificador de clase default (o package):
class Miclase {
...
}
71
FORMACIONBIT
Manual: Java JSE
Mediante la instanciación, se crea un objeto de dicha clase, que contiene una copia de todos los miembros
de la clase.
Instanciación de la clase
Para crear un objeto a partir de su clase correspondiente, se utiliza la palabra reservada new.
A partir de ese momento, se hará referencia a dicho objeto para acceder a sus datos y para poder ejecutar
sus métodos.
En el momento de la instanciación de la clase (y creación del objeto), también se podrán pasar argumentos
a dicha clase, que servirán para inicializar atributos del objeto, dándole de esta manera un "estado" inicial.
Ejemplo de instanciación de la clase Miclase, creando un objeto llamado miobjeto, correspondienta a dicha
clase Miclase:
Como no se pasan parámetros de inicialización del objeto, los paréntesis están vacíos.
A partir de ese momento, se hará referencia a dicho objeto llamado miobjeto para acceder a sus datos y
para poder ejecutar sus métodos.
72
FORMACIONBIT
Manual: Java JSE
Atributos de objeto: son variables que almacenan valores correspondientes al objeto de su clase.
o Cada objeto correspondiente a su clase, almacena sus propios atributos.
o Un atributo de objeto tendrá tantas copias de ese atributo como objetos se instancien, y
cada una ellas será independiente y solo visible en su objeto correspondiente.
o Es la opción por defecto, es decir, por defecto, todos los atributos son de objeto.
Atributos de clase: son variables que almacenan el valor y dicho valor está disponible para todos los
objetos instanciados a partir de esa clase.
o Es decir, es como una variable global (compartida) a todos los objetos creados
(instanciados) a partir de la misma clase.
o Un atributo de clase tendrá una sola copia de dicho atributo, que será compartido por todos
los objetos que se instancien de la misma clase.
o Se consigue mediante el modificador static.
private.
public.
protected.
Ámbito por defecto.
private
Todo atributo private es visible únicamente dentro de la clase en la que se declara. No existe ninguna forma
de acceder al mismo, si no es desde dentro de su clase, a través de un método (que no sea private) que
permite leer o modificar el valor de dicho atributo private.
Una buena metodología de diseño de clases es declarar los atributos private siempre que sea posible, ya
que esto evita que algún objeto pueda modificar su valor si no es a través de alguno de sus métodos
diseñados para ello.
Por lo que lo adecuado sería crear una pareja de métodos (get y set) para cada atributo private, por
ejemplo: getValor (para obtener el valor del atributo private) y setValor (para modificar el valor del atributo
private).
Si se omite la creación del método setValor, lo que se tendría es un atributo de solo lectura.
NOTA: si no se asigna ningún valor a un atributo int (de clase), se le asigna por defecto 0.
73
FORMACIONBIT
Manual: Java JSE
public
El modificador de ámbito public (público) es el menos restrictivo de todos. Un atributo public será visible en
cualquier clase de cualquier paquete.
Si se desea acceder a un atributo public, simplemente se deberá anteponer a dicho atributo public el
nombre de la clase:
miobjeto.mivalor
Las aplicaciones bien diseñadas minimizan el uso de los atributos public y maximizan el uso de atributos
private.
La forma apropiada de acceder y modificar atributos de objetos es a través de métodos public que accedan
a dichos atributos private.
El único motivo para crear atributos public es acelerar el proceso de programación, permitiendo así
modificar los valores de dichos atributos públicos directamente desde otras clases, pero esto es un "apaño
provisional".
protected
Los atributos protected (protegido) pueden ser accedidos por las clases del mismo paquete (default o
package) y también por las subclases (clases hijas) del mismo paquete. Es decir, que los atributos
protected están disbonibles para las clases del mismo paquete y para las clases hijas que hereden de la
clase donde esté dicho atributo protected.
74
FORMACIONBIT
Manual: Java JSE
Un atributo protected se puede decir que sería como un private hacia el exterior (no se puede acceder
directamente a un atributo protected desde otra clase) y como un public para las subclases (una subclase
que herede de la clase donde está dicho atributo protected, tendrá acceso a dicho atributo protected).
Los atributos que no llevan ningún modificador de ámbito pueden ser accedidos desde las clases del mismo
paquete, pero no desde otros paquetes.
int midato;
Acceso a atributos
Un atributo public será visible en cualquier clase que desee acceder a él, simplemente, desde la clase
deseada, anteponiendo a dicho atributo public el nombre de la clase.
Ejemplo:
miobjeto.mivalor
// Se modifica el atributo
miobjeto.mivalor = 15;
Las aplicaciones bien diseñadas evitan el uso de atributos public y procuran usar atributos private.
La forma apropiada de acceder y modificar atributos de objetos es a través de métodos public que accedan
a dichos atributos private.
75
FORMACIONBIT
Manual: Java JSE
static.
final.
transient.
volatile.
static
Un atributo de clase es compartido por todos los objetos que se crean a partir de la clase. Todos los objetos
de esta clase pueden acceder al mismo atributo y manipularlo.
Para acceder al atributo static desde cualquier objeto creado a partir de la clase donde se declaró dicho
atributo static, se hará anteponiendo a dicho atributo static el nombre de la clase donde se declaró.
Ejemplo que accede al atributo static llamado mivalor desde cualquier objeto correspondiente a la clase
Caja (en dicha clase Caja es donde se declaró dicho atributo static):
Caja.mivalor
Caja.mivalor++
final
La palabra reservada final sirve para declarar constantes, por lo que no se permite la modificación de su
valor posteriormente.
El valor de un atributo final debe ser asignado obligatoriamente en la declaración del mismo (declaración y
asignación obligatoria en la misma línea).
Cualquier intento de modificar su valor posteriormente, generará un error por parte del compilador.
Ejemplo que declara una constante (atributo final) privada (atributo private) y le asigna un valor en la propia
declaración (obligatorio):
transient
Los atributos de un objeto se consideran, por defecto, persistentes (que se controla mediante la
serialización). Esto significa que a la hora de, por ejemplo, almacenar objetos en un fichero, los valores de
dichos atributos deben también almacenarse.
Los atributos transient son los atributos que no forman parte del estado persistente del objeto porque
almacenan estados transitorios o puntuales del objeto, y se denominan transitorios. De esta forma, un
atributo de tipo transient no sería persistente, por lo que no se almacenaría con los datos del objeto.
En este caso, la variable numVecesAlterado almacena el número de veces que se altera el objeto.
76
FORMACIONBIT
Manual: Java JSE
A la hora de almacenar el objeto en un fichero para su posterior recuperación (serialización) puede que no
interese el número de veces que ha sido modificado. Declarando dicho atributo como transient este valor
no se almacenará.
volatile
Si una clase contiene atributos de objeto que son modificados asíncronamente por threads que se ejecutan
concurrentemente, se pueden utilizar atributos volatile que permitan a Java cargar dicho atributo volatile
desde memoria antes de utilizarlo y volver a almacenarlo en memoria después, con el objetivo de que cada
thread pueda "verlo" en un estado coherente.
Esto nos ayudará a mantener la coherencia de las variables que puedan ser utilizadas en threads
(concurrentemente).
77
FORMACIONBIT
Manual: Java JSE
Tipos de métodos
Existen dos tipos de métodos:
Sintaxis general
Declaración de método {
Cuerpo del método
}
Declaración de métodos
Declaración mínima
Donde:
tipoDevuelto/void: es el tipo de dato devuelto por el método (ejemplo: int). Si el método no devuelve
ningún valor, en su lugar se indica la palabra reservada void.
nombreMétodo: es un identificador válido en Java.
listaParámetros: si tiene parámetros, es una sucesión de pares "tipo nombrevariable", separados
por comas. Ejemplo:
o int mayor(int x , int y).
int calcular() {
void mostrar() {
Sintaxis general:
Donde:
78
FORMACIONBIT
Manual: Java JSE
private.
public.
protected.
Ámbito por defecto de los métodos.
static.
abstract.
final.
native.
synchronized.
Métodos abstract:
Los métodos abstract se declaran en las clases abstract. Es decir, si se declara algún método de tipo
abstract, entonces, la clase debe declararse obligatoriamente como abstract.
Cuando se declara un método abstract (en una clase abstract), no se implementa el cuerpo del método,
sólo su signatura.
Las clases que se declaran como subclases de una clase abstract deben implementar los métodos
abstract. Una clase abstract no puede ser instanciada directamente, únicamente sirve para ser utilizada
como superclase de otras clases (subclases).
Métodos final:
Los métodos de una clase que se declaran de tipo final no pueden ser redefinidos por las subclases.
Esta opción puede adoptarse por razones de seguridad, para que ciertos miembros de las clases no puedan
ser extendidas por otros.
Un método final no puede redefinirse en la subclases. Cualquier intento de redefinición de un método final
en una subclase generaría un error del compilador.
79
FORMACIONBIT
Manual: Java JSE
Tipos de argumentos
Variables de tipo primitivo (simple): en este caso, el paso de parámetros se realiza SIEMPRE POR
VALOR.
o Lo que se le pasa al método es una copia del valor. Es decir, el valor del parámetro
recogido en el método, al ser una copia, no puede modificar el método el valor original.
o El método trabaja con una copia del valor pasado en la llamada.
Variables de tipo referencia (objeto, matrices y Strings):
o En este caso, lo que realmente se pasa al método es un objeto (o matriz o String) y, por lo
tanto, el valor del parámetro de llamada sí que puede ser modificado dentro del método (El
método trabaja directamente con el valor utilizado en la llamada, es decir, el objeto [o matriz
o String]).
o Los datos de tipo referencia pueden ser: objeto, matriz y Strings.
Ejemplo de método que declara dos argumentos (uno "String" y otro "int"):
Los tipos primitivos (simples) de datos SIEMPRE SE PASAN POR VALOR y los objetos, matrices y Strings,
por referencia.
Ejemplo de método que realiza una llamada a un método de un objeto, pasándole dos argumentos:
Declaración de método {
Cuerpo del método
}
El cuerpo del método contiene la implementación del mismo y se codifica entre las llaves del método.
80
FORMACIONBIT
Manual: Java JSE
El único caso en el que no se implementa el cuerpo del método es en la declaración de clases abstractas.
Dicha palabra reservada return también declara la salida del método. Es decir, que, por ejemplo, mediante
return midato se sale del método, retornando dicho dato llamado por ejemplo midato.
Si en la declaración de la cabecera del método se ha declarado un tipo de dato devuelto por el mismo,
entonces se devolverá el valor correspondiente al método mediante return seguido de una expresión cuyo
resultado es del mismo tipo que el declarado en la cabecera de dicho método.
Si el método es tipo void, para terminar dicho método, se especificará la palabra reservada return en una
sola línea, normalmente al final.
Si el tipo de dato devuelto del método ha sido declarado void, entonces únicamente se sale del cuerpo del
método mediante la instrucción return.
Llamada a métodos
Para llamar a un método de un objeto, una vez creado el objeto correspondiente, se aplicará la siguiente
sintaxis:
nombreObjeto.nombreMétodo(listaParámetros);
NOTA:
Se puede observar que en este caso, como se llama a un método tipo String que devuelve un valor
(también de tipo String), hace falta ejecutar directamente dicho valor que se recoge, o también se
podría almacenar en una variable dicho valor que se recoge.
81
FORMACIONBIT
Manual: Java JSE
En este caso, en lugar de almacenar en una variable el dato que devuelve el método, se muestra
directamente con System.out.println().
NOTA:
Se puede observar que en este caso, como se llama a un método tipo void que no devuelve valor,
no hace falta recoger dicho valor en una variable, sino simplemente ejecutar dicho método.
Ejemplo completo de implementación y llamada a método que devuelve un tipo de dato (en este caso
String):
IMPLEMENTACIÓN:
String mostrar(String nombre, int edad) {
// Se devuelve la cadena (String)
return "Hola " + nombre + ", tienes " + edad + " años.";
}
LLAMADA:
// Se instancia la clase, creando el objeto "miobjeto"
Miclase miobjeto = new Miclase();
IMPLEMENTACIÓN:
void mostrar(String nombre, int edad) {
// Se muestra la cadena
System.out.println("Hola " + nombre + ", tienes " + edad + " años.");
// Finaliza el método
return;
}
LLAMADA:
// Se instancia la clase, creando el objeto "miobjeto"
Miclase miobjeto = new Miclase();
Método constructor
El constructor es un método especial de las clases que tiene como característica principal ser el primer
método que se ejecuta de forma automática en el momento de crearse el objeto.
82
FORMACIONBIT
Manual: Java JSE
Es el primer método que se ejecuta de forma automática cuando se instancia la clase (creando así
el objeto).
El nombre del método constructor debe ser obligatoriamente el mismo que el nombre de la clase
(así como del archivo fuente java).
El método constructor no tiene tipo, ni void.
Su cometido principal es inicializar los atributos de los objetos, en el momento de crearse dichos
objetos. De esta forma, el objeto ya se crearía con un "estado inicial".
El método constructor siempre es obligatorio, de hecho, todas las clases tienen uno por defecto, ya
que si el programador no lo declara de forma explícita, lo hará Java de forma implicita.
El método constructor puede estar declarado, pero estar vacío.
Pueden existir varios constructores, que se llamarán todos igual, pero que se distinguirán unos de
otros por el número y/o tipo de datos de sus parámetros.
o En este caso se denominará sobrecarga de constructores.
o En caso de sobrecarga de constructores, Java ejecutará el que se corresponda con el
número o tipo de parámetros enviados.
El constructor o constructores pueden recibir parámetros. Estos parámetros serán enviados en el
momento de la creación del objeto.
Ejemplo de declaración de método constructor dentro de su clase, que recibe dos parámetros:
// Declaración de atributos
private int valor1;
private int valor2;
Ejemplo de creación del objeto (llamada al método constructor). Se le envían dos parámetros:
Si por ejemplo, utilizando un IDE como Eclise, se escribe this y despues se escribe un punto, aparecerá
una lista con todos los miembros de la clase actual.
Si por ejemplo, se hiciese referencia a los atributos o métodos (miembros) de la clase actual, se podría
anteponer al nombre de dichos miembros, la palabra reservada this seguida de un punto y después el
nombre del miembro (atributo o método), de la siguiente forma:
83
FORMACIONBIT
Manual: Java JSE
Aunque se aconseja en uso de this, si se omite dicha palabra reservada this, se entiende por defecto como
si la llevase, por lo que se puede omitir:
Es aconsejable utilizar la palabra clave this para hacer referencia a los miembros de la clase actual y así
hacer más legible el código:
/*
Método constructor que recibe dos parámetros de la
instanciación del objeto.
Dichos parámetros se asignan a los atributos privados
declarados al principio de la clase, con lo que
los valores de dichos atributos quedan disponibles
para toda la clase.
Con la palabra clave "this" hacemos referencia a que dichos
atributos ("valor1" y "valor2") son de esta clase y además
se diferencian a simple vista de los parámetros que se
han recogido del constructor ("v1" y "v2" [que no son datos
pertenecientes a esta clase, sino que se han enviado desde el
exterior, aunque se utilicen en el método constructor]).
*/
Si desde dentro de dicho método, se desea hacer referencia al atributo de la clase, en lugar de a la variable
o parámetro de dicho método, se antepone la palabra reservada this seguida de un punto y a continuación
el nombre del atributo de clase.
84
FORMACIONBIT
Manual: Java JSE
// Atributos de la clase
private int valor1 = 5; //QUEDA OCULTADO (OCULTACIÓN)
private int valor2 = 6;
// Método de la clase
void mostrar() {
// Atributo local a este método, que tiene el mismo nombre
// que un atributo de la clase.
int valor1 = 10;
// Se accede al atributo local de este método,
// quedando "ocultado" (ocultación) el atributo
// de la clase que tiene el mismo nombre.
System.out.println(valor1);
}
NOTA:
En el ejemplo anterior, el resultado de la ejecución del programa es: 10.
// Atributos de la clase
private int valor1 = 5;
private int valor2 = 6;
// Método de la clase
void calcular() {
// Atributo local a este método que tiene el mismo nombre
// que el atributo de la clase
int valor1 = 10;
NOTA:
En el ejemplo anterior, el resultado de la ejecución del programa es: 5.
NOTA:
A partir de este momento dentro del método mimetodo se podrá utilizar la matriz pasada como
argumento, de la misma manera que si hubiésemos declarado la matriz dentro del método
mimetodo.
85
FORMACIONBIT
Manual: Java JSE
86
FORMACIONBIT
Manual: Java JSE
87
FORMACIONBIT
Manual: Java JSE
// ATRIBUTOS DE LA CLASE
// =====================
// Dimensiones de la caja
private double largo;
private double ancho;
private double alto;
//MÉTODO CONSTRUCTOR
//RECOGE 3 PARÁMETROS PARA CONSTRUIR LA CAJA
Caja(double miancho, double milargo, double mialto) {
//INICIALIZAMOS LOS ATRIBUTOS DE LA CLASE
//CON LOS VALORES RECOGIDOS EN EL CONSTRUCTOR
this.largo = milargo;
this.ancho = miancho;
this.alto = mialto;
}
// MÉTODOS DE LA CLASE
// ===================
Clase Accesocaja:
89
FORMACIONBIT
Manual: Java JSE
// OBTENEMOS EL LARGO
System.out.println("Largo: " + micaja.getLargo());
// OBTENEMOS EL ANCHO
System.out.println("Ancho: " + micaja.getAncho());
// OBTENEMOS EL ALTO
System.out.println("Alto: " + micaja.getAlto());
// OBTENEMOS LA SUPERFICIE
System.out.println("Superficie: " + micaja.getSuperficie());
// OBTENEMOS EL VOLUMEN
System.out.println("Volumen: " + micaja.getVolumen());
// INSERTAMOS ELEMENTOS
// Y RECOGEMOS Y MOSTRAMOS EL MENSAJE CORRESPONDIENTE
String mensajeInsertar = micaja.insertar(7);
System.out.println(mensajeInsertar);
// EXTRAEMOS ELEMENTOS
// Y RECOGEMOS Y MOSTRAMOS EL MENSAJE CORRESPONDIENTE
String mensajeExtraer = micaja.extraer(3);
System.out.println(mensajeExtraer);
90
FORMACIONBIT
Manual: Java JSE
91
FORMACIONBIT
Manual: Java JSE
POO: ENCAPSULACIÓN
Descripción
La encapsulación es la característica de la orientación a objetos que consisten en que los objetos ocultan
sus atributos (e incluso los métodos), a otros objetos.
Protección de datos
Los datos se protegen, al no hacerlos accesibles directamente desde el exterior, sino accesibles de una
forma controlada por el programador, mediante sus métodos accesibles correspondientes.
La forma natural de construir una clase es la de definir una serie de atributos que, no son accesibles fuera
del mismo objeto (atributos con modificador de ámbito "private"), sino que únicamente pueden modificarse a
través de los métodos que son definidos como accesibles desde el exterior de esa clase.
92
FORMACIONBIT
Manual: Java JSE
Sobrecarga de un método
Por ejemplo, supongamos que se dispone de un método "producto", que multiplica dos números. Si se
desea que el método pueda recibir 3 números o 4 números, se sobrecargaría el método "producto" de la
siguiente manera:
Por ejemplo, se podría crear un objeto coche, inicializando su atributo gasolina, con el valor 0, con el valor
10 ó con el valor 30, lo que daría la posiblidad de inicializar cada coche con los litros de gasolina deseados.
93
FORMACIONBIT
Manual: Java JSE
Ahora se podría llamar al método construtor sobrecargado, de cualquiera las siguientes maneras:
95
FORMACIONBIT
Manual: Java JSE
POO: HERENCIA
Descripción
Es una de las principales ventajas de la POO. La herencia permite definir clases descendientes de otras, de
forma que la nueva clase (la clase descendiente) hereda de la clase antecesora todos sus miembros
(atributos y métodos) que tengan el modificador adecuado para ello (modificador por defecto, "public" o
"protected").
Ventajas de la herencia
La herencia es un mecanismo natural de reutilizar los objetos. Por ejemplo, se podría tener una clase
"Casa" que tuviera unos miembros generales, para que después crear subclases (por ejemplo: apartamento,
chalé, etc [es decir, tipos de casas]) que hereden de dicha clase "Casa" dichos miembros "generales" de
dicha clase "Casa".
Por ejemplo, un chalé es un tipo de casa, que además tiene un jardín. Tiene las mismas características que
una casa, pero además, tiene jardín.
Por ejemplo, un pato es un ave que nada. Mantiene las mismas características que las aves y únicamente
habría que declarar un método (el método nadar).
La superclase es la clase de la cual heredan sus miembros (atributos y métodos) otras subclases.
CLASE QUE CONTIENE LOS MIEMBROS CLASE QUE HEREDA LOS MIEMBROS
Superclase Subclase
Principal Secundaria
Antecesora Sucesora
Reutilización de código
Mediante la herencia, se consigue la reutilización de código, que permite aprovechar el código de clases ya
existentes, modificándo si se desea la subclase, para adaptarla a las nuevas necesidades.
class MiSuperclase {
//Atributo protegido.
//NO accesible desde el exterior para clases de otros paquetes.
//SI accesible desde el exterior para clases del mismo paquete.
//SI lo heredan las clases hijas.
protected int superclase_atributo_protected = 2;
//Atributo publico.
//SI accesible desde el exterior.
//SI lo heredan las clases hijas.
public int superclase_atributo_public = 3;
//Método protegido.
//NO accesible desde el exterior para clases de otros paquetes.
//SI accesible desde el exterior para clases del mismo paquete.
//SÍ lo heredan las clases hijas.
protected void superclase_metodo_protected() {
System.out.println("superclase_metodo_protected, de la SUPERCLASE");
}
//Método público.
//SI accesible desde el exterior.
//SI lo heredan las clases hijas.
public void superclase_metodo_public() {
System.out.println("superclase_metodo_public");
}
Ejemplo de implementación de subclase que heredará los miembros (los no privados) de la superclase:
97
FORMACIONBIT
Manual: Java JSE
...
NOTAS:
Con este sencillo mecanismo de herencia mediante la palabra reservada "extends", sin tener que
escribir nada de código en la subclase, se heredan automáticamente los miembros (no privados) de
la superclase, es decir, los miembros "public" y "protected".
Si ahora en "eclipse" se crea un objeto de la subclase y se escribe el nombre de dicho objeto
seguido de un punto, aparecerá una lista con todos los miembros a los que puede acceder dicha
subclase, que serán los miembros "public" y "protected" de su superclase.
Ejemplo de implementación de subclase que heredará los miembros (los no privados) de la superclase, y
además implementa un atributo y un método nuevos, para así, completar o ampliar el funcionamiento
específico de esta subclase:
NOTAS:
Si ahora en "eclipse", dentro del método de esta subclase se escribe la palabra "this" seguida de un
punto, aparecerá una lista con todos los miembros a los que puede acceder dicha subclase, que
serán los miembros "public" y "protected" heredados de la superclase, y además el atributo y el
método específicos de esta subclase.
La subclase puede redefinir (sobreescribir) los miembros heredados de su superclase. Este mecanismo
sirve para crear miembros en la subclase con el mismo nombre que miembros de la superclase, con el
objetivo de redefinir algún miembro para cambiarle su implementación en la subclase, y con ello, cambiar,
por ejemplo, las acciones que realiza un método heredado de la superclase, para que tenga otro
funcionamiento en la subclase. O también, redefinir un atributo de la superclase. La redefinición se produce,
porque coincide el nombre del miembro que se implementa en la subclase con el nombre de otro miembro
heredado de la superclase.
Mediante la palabra reservada "super" se hace referencia, desde una subclase, a cualquier miembro de la
superclase de los que ha heredado dicha subclase.
Ejemplo que desde una subclase, donde se ha redefinido un método heredado de la superclase, se hace
referencia al método redefinido de la propia subclase, y también se hace referencia al método heredado de
la superclase:
//SUPERCLASE
class Superclase {
...
//MÉTODO DE LA SUPERCLASE
protected void superclase_metodo_protected() {
System.out.println("MÉTODO DE LA SUPERCLASE");
}
...
99
FORMACIONBIT
Manual: Java JSE
//SUBCLASE
class Subclase extends Superclase {
...
En una clase pueden existir métodos "final", sin que la clase que contiene dichos métodos "final", tenga que
ser "final".
Los métodos "final" es un mecanismo que sirve para proteger algunos métodos de la clase (los que sean
"final") para que no puedan ser redefinidos por las subclases. Dichos métodos "final" no podrán ser
redefinidos en las subclases.
Ejemplo de método "final" que no podrá ser redefinido en las subclases. Este método está implementado en
una superclase:
Al intentar redefinir el método "final" del ejemplo anterior, en una subclase de dicha clase del ejemplo
anterior, de esta forma...:
System.out.println("REDEFINIDO EN LA SUBCLASE");
}
Herencia simple
Herencia simple significa que una clase solo puede heredar de solo una superclase, mediante el mecanismo
de herencia con la palabra reservada "extends". Si se desea que una clase implemente los miembros de
varias clases (miembros sin implementación) entonces se necesitará que la clase que desee dicho
funcionamiento "implemente" una o varias interfaces.
101
FORMACIONBIT
Manual: Java JSE
102
FORMACIONBIT
Manual: Java JSE
Se puede declarar una clase como "final", cuando no nos interesa crear clases derivadas (subclases) de
dicha clase.
Para prevenir los posibles daños, se declaran dichas clases críticas del sistema como "final", impidiendo a
cualquier programador la creación de clases derivadas de ésta.
Por ejemplo, la clase "String" (que es una de las más importantes en la programación Java), está declarada
como "final". De esta forma, Java garatiza que siempre que se utilice un string, dicho string sea un objeto de
la clase "String" (que se encuentra en el paquete "java.lang.String").
Si ahora, se intentara crear una subclase que heredara de la superclase "final", de la siguiente manera...:
La subclase "Cuadrado" (que hereda de la superclase "Rectangulo"), se puede declarar como "final", ya
que, se puede dar el caso de que ningún programador necesite crear clases derivadas de esta subclase
"Cuadrado".
103
FORMACIONBIT
Manual: Java JSE
Como una clase abstracta está pensada para servir de "base" o "plantilla" para subclases que hereden de
dicha clase abstracta, dicha clase abstracta no se puede instanciar directamente.
La clase abstracta NO puede instanciarse (es decir no se pueden crear objetos de una clase abstracta).
Esto es coherente, dado que una clase abstracta no tiene completa su implementación (solo tiene
declarados los miembros, no implementados) y encaja bien con la idea de que algo abstracto no puede
materializarse.
Una clase abstracta es útil para crear una jerarquía de clases y tener en cuenta que la clase abstracta
"padre" será la BASE COMÚN para todas sus clases "hijas". Una clase abstracta sólo puede servir como
clase base (sólo se puede heredar de ella). Sus clases hijas SÍ pueden instanciarse.
La clase abstracta define las definiciones "por defecto" esperadas en cada subclase que quiera heredar de
dicha clase abstracta. Las operaciones (métodos) en una clase abstracta es como dejar "moldes" hechos,
para que puedan ser utilizados (implementados) en las subclases que hereden dicha clase abstracta.
La clase abstracta es una clase que sirve como clase base COMÚN para que otras clases hijas
hereden de ella sus miembros que se deseen "comunes". La implementación de dichos miembros
(atributos y métodos) se realiza en las subclases.
Una clase abstracta solo tiene declarados sus métodos, pero no contiene su implementación (es
decir, el código de los métodos), es decir, solo se declara su signatura (su cabecera y sus
parámetros si los lleva), no se deberá declarar todo el código encerrado entre llaves { }.
o La clase abstracta también puede incluir la implementación de sus métodos (el código de
dichos métodos), pero no es lo habitual.
Los miembros de una clase abstracta puede tener cualquier tipo (final, static, etc.).
Las clases abstractas (con el modificador "abstract") no pueden ser instanciadas directamente.
La clase abstracta define las definiciones "por defecto" esperadas en cada subclase que quiera
heredar de dicha clase abstracta. Las operaciones (métodos) en una clase abstracta es como dejar
"moldes" hechos, para que puedan ser utilizados (implementados) en las subclases que hereden
dicha clase abstracta.
Un método abstracto (de una clase abstracta) únicamente declara su signatura o cabecera (su
nombre y parámetros) y no el cuerpo de dicho método.
104
FORMACIONBIT
Manual: Java JSE
No es obligatorio que todos los métodos de una clase abstracta sean abstractos, incluso es posible
que ninguno de ellos lo sea. En el caso de que ningún método de una clase abstracta, sea
abstracto, la clase será considerada como abstracta y no podrán declararse objetos de esta clase,
es decir, no se podrá instanciar directamente.
Cuando se declara un método "abstract", no se implementa el cuerpo del método, sólo su signatura.
Las clases que se declaran como subclases de una clase "abstract" deben implementar
obligatoriamente los métodos abstractos que estén declarados en la clase "abstract".
Una clase abstract no puede ser instanciada, únicamente sirve para ser utilizada como superclase
de otras clases.
Cuando alguno de los métodos de una clase es declarado abstracto, la clase debe ser
obligatoriamente abstracta, de lo contrario, el compilador genera un mensaje de error.
Las clases abstractas se crean para ser superclases de otras clases. En el ejemplo de una clase
abstracta "Animal" se puede declarar el método "habla()" como abstracto, porque se desea que
todos los animales puedan hablar, pero no sabemos qué es lo que van a decir (qué acciones se van
a realizar), por lo que es declarada de tipo abstract. Las clases que heredan de la clase abstracta
"Animal" deben implementar obligatoriamente un método "habla()" para poder heredar las
características de Animal.
105
FORMACIONBIT
Manual: Java JSE
"The type Circulo must implement the inherited abstract method Figura.dibujar()"
"The type Circulo must implement the inherited abstract method Figura.dibujar()"
El editor o compilador ofrecerá la solución de que, o bien, se implementan dichos métodos, o bien se
declara la clase abstracta.
Si se intenta instanciar directamente la clase abstracta, el editor o compilador mostrará el siguiente error:
Lo que se debe hacer es instanciar una subclase de la superclase. Una vez instanciada dicha subclase y
creado el objeto, se podrán utilizar todos los métodos de dicha subclase, es decir, como cualquier subclase
normal y corriente.
106
FORMACIONBIT
Manual: Java JSE
POO: INTERFACES
Descripción
Una interfaz es un conjunto de constantes y métodos, pero de los métodos solamente su signatura, no su
implementación.
Una interfaz es una plantilla que define el contenido que debe aparecer en la clase o clases que
implementen dicha interfaz.
Una interfaz es una especie de "contrato" mediante el cual el programador tiene la obligación de
implementar todos los métodos de una interfaz (signatura + código) o interfaces, que haya implementado en
la clase deseada.
Una interfaz contiene una colección de métodos que se implementan en otro lugar. Siendo estos métodos
implícitamente "abstract" y "public".
El concepto de Interface lleva un paso más adelante la idea de las clases abstractas. En Java una interface
es una clase abstracta pura, es dcir una clase donde todos los métodos son abstractos (no se implementa
ninguno). Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas de
argumentos y tipos de retorno, pero no bloques de código). Una interface puede también contener datos
miembro, pero estos son siempre static y final. Una interface sirve para establecer un "protocolo" entre
clases, es decir, obliga a que las clases implementen ciertas acciones (métodos) para funcionar, es decir,
para cumplir con dicho "protocolo".
Los métodos abstractos son útiles cuando se quiere que cada implementación de la clase parezca y
funcione igual, pero se necesita crear una nueva clase para utilizar los métodos abstractos. 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, parecido a 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).
Las interfaces Java son expresiones puras de diseño. Se trata de auténticas conceptualizaciones no
implementadas que sirven de guía para definir un determinado concepto (clase) y lo que debe hacer, pero
sin desarrollar un mecanismo de solución.
Se trata de declarar métodos abstractos y constantes que posteriormente puedan ser implementados de
diferentes maneras según las necesidades de un programa.
Por ejemplo una misma interfaz podría ser implementada en una versión de prueba de manera poco óptima,
y ser acelerada convenientemente en la versión definitiva tras conocer más a fondo el problema.
107
FORMACIONBIT
Manual: Java JSE
Se deben crear interfaces que contengan declaraciones de métodos (solo su signatura) que
después implementen una o varias clases. Dichas clases que implementen dicha interfaz,
implementarán todos los métodos (con su código correspondiente) que contenga dicha interfaz.
Simular la herencia múltiple.
Las interfaces son útiles para recoger las similitudes entre clases no relacionadas, forzando una
relación entre ellas.
Declarar métodos que forzosamente una o más clases han de implementar.
Tener acceso a un objeto permitiendo el uso de dicho objeto sin revelar su clase, son los llamados
"objetos anónimos" (creados a partir de una clase anónima), que son muy útiles cuando se vende
un paquete de clases a otros desarrolladores.
Una clase abstracta puede tener, o no, la implementación de sus métodos (el código implementado
en sus métodos), sin embargo, las interfaces no pueden implementar código en ninguno de sus
métodos.
En una clase abstracta, sus miembros pueden tener diferentes modificadores de acceso (público,
privado, etc.), sin embargo, los miembros de una interfaz son todos públicos.
En una clase abstracta, sus miembros pueden tener cualquier modificador, sin embargo, en una
interfaz todos los miembros deben ser constantes "final" y de clase "static".
Las interfaces proporcionan una forma de herencia múltiple, ya que pueden implementar múltiples
interfaces. Una clase sólo puede extender a otra clase, incluso aunque esa clase sólo tenga
métodos "abstract".
Una clase "abstract" puede tener una implementación parcial, partes protegidas, métodos estáticos,
etc., mientras que las interfaces están limitadas a constantes públicas y métodos públicos sin
implementación.
La principal diferencia entre una clase abstracta y una interfaz es que una interfaz proporciona un
mecanismo de encapsulación de los protocolos de los métodos de dicha interfaz, y todo ello sin la
necesidad de utilizar herencia.
Declaración de interfaces
Para crear una interfaz, se utiliza la palabra clave "interface" en lugar de "class". La interfaz puede definirse
"public" o sin modificador de acceso (igual que para las clases).
Todos los métodos que declara una interfaz son siempre "public". Una interface puede también contener
datos miembro (atributos), pero estos son siempre "static" y "final".
interface nombre_interface {
tipo_retorno nombre_metodo (lista_argumentos);
...
}
interface Video {
Por defecto, es decir, de forma implícita, los métodos declarados dentro de la interfaz serán
automáticamente "abstract" y "public".
interface Video {
//---------------------------------------------------------
//Solo se declara la signatura de los métodos.
//Su implementación se declara en las clases
//que implementen esta interfaz.
//------------------------------
//De forma implícita, los métodos de la interfaz
//son "abstract" y "public".
void pause() {
System.out.println("Pausa en video");
}
Recordar que por defecto (de forma implícita) los métodos de las interfaces son "abstract" y "public".
NOTA: en las clases abstractas no genera error implementar el código de un método (aunque no es
recomendable hacerlo), pero si se implementa el código de un método en una interfaz, generará error.
El compilador se encargará de verificar que la clase efectivamente declare e implemente todos los métodos
de la interfaz.
NOTA: ya que con el punto y coma se termina la declaración de cada método en la interfaz, y dicho punto y
coma significa que termina la declaración de cada método en la interfaz y en dicha interfaz no se
implementa el código. Pero aquí en la clase hay que implementar el código de cada método.
Uso de la interfaz
Para usar la interfaz, se instanciará la clase que implementa la interfaz:
//Se ejecutan los métodos de dicha clase, que son los métodos de la
//interfaz, que la clase implementó con el código de dichos métodos.
miobjeto.play();
miobjeto.pause();
miobjeto.stop();
La interfaz no se puede instanciar directamente, ya que está diseñada para que otras clases implementen
dicha interfaz.
Si se intenta instanciar directamente una interfaz, el editor o compilador mostrará el siguiente error:
110
FORMACIONBIT
Manual: Java JSE
interface Sonido {
Ejemplo de clase "Miclase" que implementa las interfaces "Video" y "Sonido" y que obligatoriamente
implementa el código correspondiente a todos los métodos existentes en dichas interfaces "Video" y
"Sonido":
Herencia múltiple
111
FORMACIONBIT
Manual: Java JSE
Herencia simple significa que una clase solo puede heredar de solo una superclase, mediante el mecanismo
de herencia con la palabra reservada "extends". Si se desea que una clase implemente los miembros de
varias clases (miembros sin implementación) entonces se necesitará que la clase que desee dicho
funcionamiento "implemente" una o varias interfaces.
Mediante las interfaces se puede "simular" la herencia múltiple de otros lenguajes. Aunque también es
importante saber que el lenguaje Java no implementa la herencia múltiple "pura" ya que considera que
heredar miembros de múltiples clases no es muy recomendable con respecto a la organización y el diseño
de clases.
Ejemplo que muestra el mecanismo de hacer la herencia múltiple en Java, que se representa con la
herencia en forma de diamante:
Para poder llevar a cabo un esquema como el anterior en Java es necesario que las clases A, B y C de la
figura sean interfaces, y que la clase D sea una clase (que recibe la herencia múltiple):
interface A { }
interface B extends A { }
interface C extends A { }
class D implements B,C { }
NOTA: la clase D tendría que implementar el código de los métodos pertenecientes a las interfaces: A, B y
C. (También los de la A).
112
FORMACIONBIT
Manual: Java JSE
POO: POLIMORFISMO
Descripción
Poli = muchos/as
morfismo = formas
"Muchas formas", lo que significa, que por ejemplo, con un solo método, dependiendo del objeto que reciba,
se podrá ejecutar el método perteneciente a dicho objeto recibido.
El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma
general, en lugar de hacerlo en forma específica.
Sirve para programar objetos con características comunes (por ejemplo, que comparten un método, como
"mover") y que dichos objetos compartan la misma superclase en una jerarquía de clases (es decir, que
dichos objetos hereden de dicha superclase), con lo que en estos casos, se simplifica la programación.
Por dicho motivo, al mecanismo del polimorfismo se le denomina también "enlace dinámico" o "ligadura
dinámica", ya que el polimorfismo se produce en "tiempo de ejecución", escogiendo el método adecuado,
dependiendo del objeto que se reciba.
Ejemplo de polimorfismo
Por ejemplo, cinco subclases correspondientes a cinco animales, heredan de una superclase "Animal".
Dicha clase "Animal" implementa un método "mover" que describe como se mueve un animal. Pero como
cada uno de los cinco animales de las subclases se mueve de forma diferente, cada una de dichas
subclases redefine el método "mover" de la subclase, implementando cada forma particular de moverse
cada uno de dichos animales.
Bien, pues mediante el polimorfismo, se podría tener un único método que recibiese como parámetro el
objeto correspondiente al tipo de animal (por ejemplo, gato), pero como tipo de dato "Animal", con lo que se
ejecutaría el método correspondiente al animal que se ha recibido como parámetro. Es decir, por ejemplo,
se envía el objeto correspondiente a un animal (un objeto correspondiente a la clase "Perro") y se le
especifica que es de la clase "Animal" (Animal miperro), y como la clase "Animal" "conoce" que perro es
una subclase de "Animal", se ejecutaría el método correspondiente a la subclase "Perro". Es decir, que
especificando el objeto de la subclase, se ejecutará el método correspondiente a dicha subclase.
Creación de polimorfismo
Ejemplo de una superclase:
//SUPERCLASE
class Animal {
class Polimorfismo {
Ejemplo de ejecución del polimorfismo (este código, por ejemplo se ha puesto en la clase que incluye el
método "main"):
114
FORMACIONBIT
Manual: Java JSE
NOTA: observar que con un único objeto, y pasándole como parámetro el objeto correspondiente a cada
subclase, se ejecuta automáticamente el método asociado a cada uno de dichas subclases.
Sirve para programar objetos con características comunes (por ejemplo, que comparten un método, como
"mover", por medio de herencia) y que dichos objetos compartan la misma superclase en una jerarquía de
clases (es decir, que dichos objetos hereden de dicha superclase), con lo que en estos casos, se simplifica
la programación.
Polimorfismo y sobrecarga
La sobrecarga es un tipo especial de polimorfismo, ya que la sobrecarga permite "muchas formas" de
implementar un mismo método.
115
FORMACIONBIT
Manual: Java JSE
Operador "instanceof"
El operador "instanceof" sirve para conocer si un objeto pertenece a una clase determinada, o a su
superclase. El operador "instanceof" sólo puede usarse con variables que contengan la referencia a un
objeto.
Ejemplo de superclase:
//SUPERCLASE
public class Vehiculo {
116
FORMACIONBIT
Manual: Java JSE
El método "equals", perteneciente a la superclase "Object" sirve para comparar dos objetos, retornando
"true" si dichos objetos son exactamente iguales. Por lo que el método "equals" es un método de tipo
"boolean".
Exactamente iguales significa que dichos dos objetos tienen "el mismo estado", es decir, tienen los mismos
datos en sus atributos en un momento dado.
Ejemplo que comprueba que dos objetos son iguales (que tienen el mismo estado, es decir, que sus
atributos contienen los mismos valores):
//Método constructor
Pieza (int lo, int an) {
this.longitud = lo;
this.anchura = an;
}
117
FORMACIONBIT
Manual: Java JSE
118
FORMACIONBIT
Manual: Java JSE
PAQUETES
Descripción
Los paquetes son grupos relacionados de clases e interfaces. Proporcionan un mecanismo organizado para
el manejo de un gran conjunto de clases e interfaces. También, evitan los conflictos de nombres.
Creación de paquetes
Para crear un paquete se utiliza la sentencia "package". Se escribirá en la parte superior del fichero .java.
package variedades;
La clase o clases definidas en el fichero que contiene dicha sentencia de creación del paquete, serán
miembros de dicho paquete.
package variedades;
class Miclase1 {
class Miclase2 {
class Miclase3 {
Ejemplo de fichero con una sola clase, perteneciente al paquete "variedades" (es lo más habitual, ya que se
recomienda que haya una sola clase por fichero .java):
package variedades;
119
FORMACIONBIT
Manual: Java JSE
Paquetes y carpetas
Cada paquete creado con todas sus clases, creará una carpeta en el disco que contendrá todos los archivos
.java correspondientes a todas las clases del paquete. Dichas carpetas estarán en el disco, dentro de la
carpeta del proyecto.
Estando situados en la clase "Pieza", perteneciente al paquete "paquete", se importa todo el paquete de
clases "variedades", es decir, todas las clases del paquete "variedades":
package paquete;
import variedades.*;
NOTA: en la clase "Pieza" ya se podrían utilizar todas las clases del paquete "variedades".
Importar clases
A veces solo es necesario una o algunas clases, por lo que no será necesario importar todo el paquete de
clases. Java permite importar solo las clases deseadas. Esto es útil para una mejor organización, eficiencia,
así como para no recargar la aplicación con clases cargadas que no se van a usar.
Estando situados en la clase "Pieza", perteneciente al paquete "paquete", se importa solo la clase "Miclase"
del paquete "variedades":
package paquete;
import variedades.Miclase;
NOTA: en la clase "Pieza" ya se podría utilizar la clase "Miclase" (perteneciente al paquete "variedades").
Estando situados en la clase "Pieza", perteneciente al paquete "paquete", se importan las clases "Miclase1"
y "Miclase2" del paquete "variedades":
package paquete;
import variedades.Miclase1;
import variedades.Miclase2;
NOTA: en la clase "Pieza" ya se podrían utilizar las clases "Miclase1" y "Miclase2" (pertenecientes al
paquete "variedades").
Son los paquetes mas comunes que contiene Java, y que son de propósito general.
java.awt: contiene las clases para crear interfaces de usuario, independientes de la plataforma.
java.io: entrada/salida. Contiene las clases para controlar los flujos de datos.
java.util: clases útiles para uso del programador.
etc.
121
FORMACIONBIT
Manual: Java JSE
String micadena;
//Cadena
String micadena = "Hola amigos";
De modo similar, podemos saber si un string finaliza con un conjunto dado de caracteres, mediante la
función miembro "endsWith":
Para obtener las sucesivas posiciones de la letra "p", se llama a otra versión de la misma función:
El segundo argumento le dice a la función "indexOf" que empiece a buscar la primera ocurrencia de la letra
"p" a partir de la posición "pos+1", es decir, a partir del siguiente carácter al encontrado.
Otra versión de "indexOf" busca la primera ocurrencia de un substring dentro del string.
Comparación de cadenas
La comparación de strings nos da la oportunidad de distinguir entre el operador de comparación "==" y el
método "equals" de la clase String:
La salida será:
Distintos objetos
123
FORMACIONBIT
Manual: Java JSE
El mismo contenido
... ya que son distintos objetos (cada cadena es un objeto independiente ["str1" y "str2"], y tienen el mismo
contenido (los dos objetos contienen los mismos caracteres ("El lenguaje Java").
Los dos objetos ocupan posiciones distintas en memoria, pero guardan los mismos datos.
Devuelve:
Los objetos str1 y str2 guardan la misma referencia al objeto de la clase String creado. La expresión (str1 ==
str2) devolverá "true".
Por lo que el método "equals" compara dos objetos, en este caso Strings, y devuelve true cuando dos
objetos (en este caso strings) son iguales, o false si son distintos.
Para extraer un substring desde una posición determinada hasta el final del string escribimos:
Una segunda versión de la función miembro substring, nos permite extraer un substring especificando la
posición de comienzo y la el final:
Se obtendrá el substring "lenguaje". Recuérdese, que las posiciones se empiezan a contar desde cero.
Conversión de cadenas
Para convertir un número en string:
La clase String proporciona versiones de "valueOf" para convertir los datos primitivos: int, long, float, double.
Para convertir un string en número entero (y se aprovecha para recortar espacios que pueda haber a ambos
lados de la cadena:
124
FORMACIONBIT
Manual: Java JSE
125
FORMACIONBIT
Manual: Java JSE
126
FORMACIONBIT
Manual: Java JSE
//Mes (0 - 11)
String mes = Integer.toString(micalendario.get(Calendar.MONTH));
//Año
String año = Integer.toString(micalendario.get(Calendar.YEAR));
127
FORMACIONBIT
Manual: Java JSE
COLECCIONES
Descripción
Una colección es una matriz dinámica que permite almacenar datos de mismo tipo o de diferente tipo.
En Java las colecciones se trabajan con la clase "ArrayList". Dicha clase permite método para crear y
mantener colecciones.
Clase "ArrayList"
Para trabajar con colecciones será necesario importar la clase "ArrayList", que está en el paquete "java.util":
import java.util.ArrayList;
El único objeto de origen es la cadena (String), los demás son tipos primitivos, pero la clase ArrayList
convierte a todos los elementos en objetos.
System.out.println(micoleccion.get(1));
La salida será:
128
FORMACIONBIT
Manual: Java JSE
Método "clear" para eliminar todos los elementos del ArrayList (dejándolo vacío):
MÉTODO DESCRIPCIÓN
size() Devuelve el número de elementos (int)
add(X) Añade el objeto X al final. Devuelve true.
add(posición, X) Inserta el objeto X en la posición indicada.
get(posicion) Devuelve el elemento que está en la posición indicada.
remove(posicion) Elimina el elemento que se encuentra en la posición indicada.
Devuelve el elemento eliminado.
remove(X) Elimina la primera ocurrencia del objeto X. Devuelve true si el
elemento está en la lista.
clear() Elimina todos los elementos.
set(posición, X) Sustituye el elemento que se encuentra en la posición indicada por
el objeto X. Devuelve el elemento sustituido.
contains(X) Comprueba si la colección contiene al objeto X. Devuelve true o
false.
indexOf(X) Devuelve la posición del objeto X. Si no existe devuelve -1
129
FORMACIONBIT
Manual: Java JSE
EXCEPCIONES
Descripción
Una excepción es un objeto, que hereda de su superclase "Exception", que lanza Java cuando ocurre un
problema no controlado en la ejecución de una aplicación.
Cuando se produce un error en tiempo de ejecución que no se controla, Java lanza una excepción.
Las excepciones son el mecanismo por el cual pueden controlarse en un programa Java las condiciones de
error que se producen. Estas condiciones de error pueden ser errores en la lógica del programa como un
índice de un array fuera de su rango, una división por cero o errores disparados por los propios objetos que
denuncian algún tipo de estado no previsto, o condición que no pueden manejar.
Las excepciones son clases, que heredan de la clase genérica "Exception". Dicha clase "Exception"
representa a una excepción genérica, es decir, que engloba a todos las demás tipos de excepciones.
Control de excepciones
Para controlar las posibles excepciones (errores en tiempo de ejecución de la aplicación) que se pueden
producir, se utiliza un controlador de excepciones.
Controlador de excepciones
El controlador de excepciones se implementa mediante una estructura de control (try - catch - finally) que
permite capturar una posible excepción que se pueda producir, y en caso de que se produzca, controlarla,
ejecutando el código que se especifique.
Por ejemplo, si se va a ejecutar un código que posiblemente produzca un error, ya que depende de algún
dato que introduzca el usuario o de alguna acción inesperada, se controlará dicha posible excepción que se
pueda producir y en su lugar, mostrar por ejemplo un mensaje al usuario de que los datos que ha
introducido no son los adecuados.
Realmente, el controlador de excepciones funciona de forma parecida a una sentencia condicional, de tal
manera que:
si se produce una excepción... se captura (controla) y... se realizan las acciones correspondientes.
try {
...
CÓDIGO SENSIBLE A PROVOCAR UNA EXCEPCIÓN
...
} catch (Excepcion miexception) {
. . .
CÓDIGO QUE SE EJECUTA EN CASO DE QUE SE PRODUZCA UNA EXCEPCIÓN.
EN CASO DE QUE SE PRODUZCA DICHA EXCEPCIÓN, SE PUEDE ACCEDER A
INFORMACIÓN RELATIVA A DICHA EXCEPCIÓN, MEDIANTE EL OBJETO DE
TIPO Exception QUE RECIBE ESTA CLAÚSULA catch Y QUE LE ENVÍA
LA PROPIA EXCEPCIÓN.
SI NO SE PRODUCE ALGUNA EXCEPCIÓN, ESTE BLOQUE catch NO SE EJECUTA.
...
} finally {
130
FORMACIONBIT
Manual: Java JSE
...
CÓDIGO QUE SE EJECUTA SIEMPRE, SE PRODUZCA O NO UNA EXCEPCIÓN
...
}
Bloque "try"
En el bloque "try" se implementa el código sensible a provocar alguna excepción. Por ejemplo, conexión con
una base de datos, apertura de un fichero, etc.
Bloque "catch"
El bloque "catch", en caso de que se produzca una excepción, captura dicha excepción.
En el bloque "catch" se implementa el código que se ejecutará en el caso de que se produzca alguna
excepción. Normalmente es una posible solución alternativa o un mensaje de aviso al usuario.
Ejemplo de uso de los bloques "try - catch" para controlar la posible excepción que se producirá al insertar
un elemento en una colección, si se especifica que la posición donde se inserte dicho elemento esté fuera
de una posición posible en dicha colección:
Bloque "finally"
El bloque "finally" es opcional. Implementa el código que se ejecutará siempre, en cualquier caso de que se
produzca una excepción o en caso de que no se produzca.
Normalmente se utiliza para cerrar archivos, cerrar bases de datos, inicializaciones de atributos, etc.
Ejemplo que implementa el bloque "finally" para mostrar la colección de elementos, si se produce la
excepción o si no se produce dicha excepción:
try {
micoleccion.add(1, "hola");
131
FORMACIONBIT
Manual: Java JSE
Ejemplo que utiliza algunos métodos útiles de la clase "Exception" para obtener información acerca de la
excepción:
La salida es la siguiente:
132
FORMACIONBIT
Manual: Java JSE
ARCHIVOS
Descripción
Java permite el trabajo con los archivos, tanto para leerlos como para escribir en ellos.
Lectura de un archivo
Ejemplo que accede a un archivo, lee su contenido y lo muestra:
import java.io.*;
class Archivos {
void leerArchivo() {
try {
// FileReader es la clase que permite trabajar con un archivo.
// Especificamos la ruta y nombre del archivo
// si lo tengo en otra ruta, lo especificaré:
// ("c:\\bbb\\miarchivo.txt")
// lo haré con doble barra para que java no lo
// confunda con una secuencia de escape.
// con la barra que le añadimos, le decimos
// que lo siguiente lo vea como un carácter literal
// y no como una secuencia de escape.
FileReader milector = new FileReader("c:\\aaa\\miarchivo.txt");
// Se cierra el archivo.
// Se cierra el BufferedReader entrada,
// una vez que ya hemos leído todo el archivo.
entrada.close();
}
catch(Exception miexcepcion) {
System.out.println("Error en la carga del archivo");
System.out.println(miexcepcion.getMessage());
}
Escritura en un archivo
Ejemplo de método que accede y escribe en un archivo de texto:
void escribirArchivo() {
try
{
// BufferedWriter se encargará de la escritura del archivo.
// Le pasamos el archivo (su ruta) creando un FileWriter
//(que será el escritor).
//true -> añadimos texto al final del ya existente.
//false -> reemplazamos el texto existente por el nuevo que grabemos.
//(EN CUALQUIER CASO, SIEMPRE CREA EL ARCHIVO, PERO LANZA UNA EXCEPCIÓN).
BufferedWriter miescribir = new BufferedWriter(new FileWriter("c:\\aaa\\miarchivo.txt",
true));
}
catch (Exception miexcepcion)
{
System.out.println("Error en la escritura del archivo");
System.out.println(miexcepcion.getMessage());
}
135
FORMACIONBIT
Manual: Java JSE
BASES DE DATOS
Descripción
Java permite el trabajo con bases de datos: Oracle, Access, etc.
import java.sql.*;
// DECLARACIÓN DE STATEMENT.
// Statement es el objeto que se encarga de ejecutar una consulta SQL.
// Aquí por comodidad y por diferenciarlos en su objetivo, se crean
// dos objetos Statement. uno para las consultas de tipo "SELECT"
// y otro para las consultas de modificación (INSERT, DELETE, UPDATE).
try {
// CARGA DEL DRIVER DE LA BASE DE DATOS DE ACCESS
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
System.out.println("Driver cargado correctamente.");
}
catch(Exception ex) {
System.out.println("No se pudo cargar el Driver");
}
136
FORMACIONBIT
Manual: Java JSE
Para crear un DSN con una base de datos de Access, se seguirá el siguiente proceso:
try {
// Variable que almacena la cadena DSN que permitirá la conexión
// con la base de datos.
// En esta cadena DSN, ponemos el nombre del DSN "miempresa"
// creado anteriormente.
String midsn = "jdbc:odbc:miempresa";
137
FORMACIONBIT
Manual: Java JSE
SELECT *
FROM clientes;
Ejemplo que muestra los campos nombre y edad y todos los registros de la tabla clientes:
Ejemplo que inserta un registro nuevo, especificando los datos correspondientes a los campos de la tabla
clientes: NOMBRE, APELLIDO y EDAD:
Ejemplo que actualiza la edad del registro con ID igual a 32 y establece dicha edad en 31::
UPDATE clientes
SET edad = 31
WHERE ID = 32;
138
FORMACIONBIT
Manual: Java JSE
try {
// Se almacena en "miresulset" (que es el objeto Resulset) el conjunto
// de registros que devuelve la sentencia SQL resultantes de ejecutar
// el método executeQuery del objeto mistatementseleccion de tipo Statement,
// pasándole como parámetro la consulta que tiene que ejecutar
// OJO: el método executeQuery se utiliza para consultas de selección.
// Dicho método executeQuery pertenece al Statement
// (en este caso "mistatementseleccion").
miresulset = mistatementseleccion.executeQuery("SELECT * FROM clientes");
NOTA: ahora los registros están cargados en el Resulset, pero todavía no se han mostrado.
try {
// Nos asegurarnos que nos encontramos en un registro válido.
// Si mostramos el anterior del primero o mostramos el posterior del último,
// es decir, un registro que no existe, nos podría dar error.
if(miresulset.isBeforeFirst() || miresulset.isAfterLast()) {
System.out.println("REGISTRO NO VÁLIDO");
}
Ejemplo que muestra los datos del todos los registros de la consulta:
try {
//Variables para recoger los datos
String minombre = "";
String miapellido = "";
String miedad = "";
140
FORMACIONBIT
Manual: Java JSE
Inserción de registros
Ejemplo que inserta un registro en la tabla clientes:
try {
//Creación de la sentencia SQL de inserción
String laconsulta = "INSERT INTO clientes(NOMBRE, APELLIDO, EDAD) ";
laconsulta += "VALUES('Manuel', 'Mir', 28)";
Después de realizar la inserción del registro, mostramos todos los datos de la tabla clientes:
// Ejecutamos la consulta.
// OJO: para consultas de selección, utilizaremos el método
// executeQuery (este método pertenece al objeto Statement).
miresulset = mistatementseleccion.executeQuery(miconsulta);
141
FORMACIONBIT
Manual: Java JSE
Actualización de registros
Ejemplo que actualiza un registro en la tabla clientes:
try {
//Creación de la sentencia SQL de actualización
String laconsulta = "UPDATE clientes SET edad = 99 WHERE ID = 32";
// Ejecutamos la sql.
// OJO: para consultas de modificación, utilizaremos
// el método executeUpdate, que es un método del objeto
// de tipo Statement (que ejecuta la consulta).
mistatementmodificacion.executeUpdate(laconsulta);
// Ejecutamos la consulta.
// OJO: para consultas de selección, utilizaremos el método
// executeQuery (este método pertenece al objeto Statement).
miresulset = mistatementseleccion.executeQuery(miconsulta);
Eliminación de registros
Ejemplo que elimina un registro en la tabla clientes:
try {
//Creación de la sentencia SQL de inserción
142
FORMACIONBIT
Manual: Java JSE
// Ejecutamos la sql.
// OJO: para consultas de modificación, utilizaremos
// el método executeUpdate, que es un método del objeto
// de tipo Statement (que ejecuta la consulta).
mistatementmodificacion.executeUpdate(laconsulta);
// Ejecutamos la consulta.
// OJO: para consultas de selección, utilizaremos el método
// executeQuery (este método pertenece al objeto Statement).
miresulset = mistatementseleccion.executeQuery(miconsulta);
143
FORMACIONBIT
Manual: Java JSE
MULTITAREA
Descripción
La Máquina Virtual Java (JVM) es un sistema multi-thread (multi-hilo), es decir, es capaz de ejecutar varias
secuencias de ejecución (programas) simultáneamente.
La JVM gestiona todos los detalles, asignación de tiempos de ejecución, prioridades, etc, de forma similar a
como gestiona un Sistema Operativo múltiples procesos.
La diferencia básica entre un proceso de Sistema Operativo y un Thread Java, es que los Threads Java
corren dentro de la JVM, (que la JVM es un proceso del Sistema Operativo) y por tanto comparten todos los
recursos, incluida la memoria y las variables y objetos allí definidos. A este tipo de procesos donde se
comparte los recursos se les llama a veces "procesos ligeros" (lightweight process).
Por lo que:
Aplicación Java no multi-thread: proceso del sistema operativo, que internamente ejecuta un solo
thread (hilo).
Aplicación Java multi-thread: proceso del sistema operativo, que internamente ejecuta mas de un
thread, que cada uno de ellos utiliza una tarea.
Concurrencia
La computación concurrente es la simultaneidad en la ejecución de múltiples tareas. Estas tareas pueden
ser un conjunto de procesos o hilos de ejecución creados por un único programa.
En caso de una aplicación concurrente en Java, sería una aplicación que contiene un conjunto de procesos
(hilos de ejecución). Cada hilo de ejecución ejecuta alguna o algunas acciones en concreto.
Por ejemplo un Thread puede encargarse de la comunicación con el usuario, mientras otros actuan en
segundo plano, realizando la transmisión de un fichero, accediendo a recursos del sistema (cargar sonidos,
leer ficheros ...), etc.
De hecho todos los programas con interface gráfico (AWT o Swing) son multithread de forma implícita,
porque los eventos y las rutinas de dibujado de las ventanas corren en un thread distinto al principal.
144
FORMACIONBIT
Manual: Java JSE
1. NEW THREAD: cuando la subclase hereda de la clase Thread se crea un nuevo Thread que está
en en su estado inicial.
En este estado es simplemente un objeto más. No existe todavía el thread en ejecución. El
único método que puede invocarse sobre él es el método "start".
2. START: cuando se invoca el método start sobre el thread, el sistema crea los recursos necesarios,
planifica al thread, asignándole prioridad e invoca al método "run".
En este momento el thread está corriendo (estado "runnable").
3. RUNNABLE: estando el thread en plena ejecución, es decir, en estado "runnable", si dicho thread
ejecuta internamente el método "sleep" o el método "wait", o dicho thread tiene que esperar por
alguna operación de entrada/salida, entonces, dicho thread pasa al estado "no runnable" (no
corriendo), hasta que finalice dicha condición o estado de espera.
Durante el estado "no runnable" del thread, el sistema puede ceder el control a otros thread
activos.
4. DEAD: por último, cuando el método "run" finaliza el thread termina y pasa a la situación 'Dead'
(muerto, finalizado).
La clase "Thread" está en el package "java.lang", por lo que no es necesaria ninguna importación, ya que
dicho paquete "java.lang" se importa de forma implícita.
La clase "Thread"
La forma más directa para hacer un programa multi-thread es extender la clase "Thread", es decir, heredar
de la clase "Thread", y redefinir el método run() de dicha clase "Thread".
La subclase que herede de la superclase "Thread" será un thread, es decir, un hilo de ejecución.
El método "run"
La clase "Thread" implementa un método llamado "run". Después de heredar de la clase "Thread", se debe
redefinir dicho método "run".
El método "run" contendrá todo lo que se desea que realice el thread (hilo de ejecución). Es decir, el método
"run" contendrá todo el código del thread (hilo de ejecución).
El método "start"
Para ejecutar un thread (hilo de ejecución) es necesario invocar el método "run", y para invocar dicho
método "run" hay que ejecutar el método "start" de la clase "Thread". Una vez hecho esto, el thread
empezará a correr, ejecutándose todo el código que esté dentro del método "run".
Es decir, cuando se ejecuta el método "start" de la clase "Thread", se invoca automáticamente el método
"run" del thread, y se ejecutará. inicia el thread (mediante una llamada al método start() de la clase thread).
El thread se inicia con la llamada al método run y termina cuando termina éste.
El método "start()" inicia el nuevo thread y llama al método "run()" de dicho thread.
Asincronía
La ejecución de los threads es asíncrona, es decir, se realiza la llamada al método "start" (por ejemplo,
desde el método "main"), comenzando la ejecución del thread, y devolviendo la ejecución a dicho método
"main". De esta manera cada thread que se ejecuta funciona de forma independiente.
Síncrono: envío de un flujo continuo de datos. El emisor no espera a que el receptor reciba dichos
datos, es decir, los manda continuamente.
145
FORMACIONBIT
Manual: Java JSE
Asíncrono: el emisor envía unos datos y espera a que el receptor los reciba, antes de enviar los
siguientes o antes de que dicho emisor continue con la ejecución de sus tareas.
Ejemplo completo
Ejemplo de clase que es un thread:
//CONTROLADOR DE EXCEPCIONES.
//(sleep OBLIGA A PONERLO).
try {
//CON sleep HACEMOS UNA PAUSA EN EL HILO.
//(1000 milisegundos -> 1 SEGUNDO)
sleep(500);
}
catch (Exception e) {
}
}
}
}
//CONTROLADOR DE EXCEPCIONES.
//(sleep OBLIGA A PONERLO).
try {
//CON sleep HACEMOS UNA PAUSA EN EL HILO.
//(1000 milisegundos -> 1 SEGUNDO)
sleep(500);
}
catch (Exception e) {
}
}
}
}
146
FORMACIONBIT
Manual: Java JSE
147
FORMACIONBIT
Manual: Java JSE
Juntas, suministran una interfaz de usuario consistente para programas Java, tanto si el sistema de interfaz
gráfica final es para Windows, Mac OS X o Linux.
AWT
Abstract Windows Toolkit. AWT es la más antigua de las APIs de interfaz gráfica, y fue criticada duramente
por ser poco más que una envoltura alrededor de las capacidades gráficas nativas de la plataforma anfitrión.
Esto significa que los elementos gráficos de AWT están bastante unidos a la plataforma en la que se
desarrollen, por lo que su portabilidad es mas inflexible.
Por ejemplo, si se desarrolla en el sistema operativo Windows, una aplicación gráfica Java con AWT y
posteriormente se ejecuta dicha aplicación en otra máquina con Windows, perfecto, ya que se verá
exactamente igual y correrá más rápido. Pero si se ejecuta en una máquina con Linux, la aplicación no
tendrá la misma apariencia y no correrá tan rápido, ya que dicha aplicación no está diseñada 100% para
cualquier tipo de sistema operativo, es decir, no es totalmente portable.
AWT también es muy limitada en tipos de elementos gráficos (en comparación con Swing).
Swing
Swing es la más moderna de las APIs de interfaz gráfica. Es la más utilizada actualmente, por su
flexibilidad, portabilidad, riqueza de elementos y posibilidades inmensas para el desarrollador.
Por ejemplo, si se desarrolla en el sistema operativo Windows, una aplicación gráfica Java con Swing y
posteriormente se ejecuta dicha aplicación en otra máquina con Windows, dicha aplicación se verá
exactamente igual. Si se ejecuta en una máquina con Linux, dicha aplicación Swing adaptará la
visualización de los controles gráficos a dicho entorno de Linux, por ejemplo, la forma de los botones, la
apariencia de las listas desplegables, etc., ya que Swing trata de emular la apariencia del sistema operativo
en el que se ejecuta.
148
FORMACIONBIT
Manual: Java JSE
Por lo que en la parte superior de la clase que desee utilizar Swing, se deberá realizar la importación de
dicho paquete.
import javax.swing.*;
Pero como Swing se apoya en AWT, principalmente en el manejo de los eventos, los paquetes que
habitualmente se importan en una aplicación Swing, son los siguientes:
149
FORMACIONBIT
Manual: Java JSE
// Declaración
ClaseControl miobjeto;
// Asignación
miobjeto = new ClaseControl();
miventana.getContentPane().add(mietiqueta);
150
FORMACIONBIT
Manual: Java JSE
Ventana: JFrame
Ejemplo que crea una ventana llamada "miventana":
// VENTANA
JFrame miventana = new JFrame();
// TÍTULO DE LA VENTANA
miventana.setTitle("Título de la ventana");
Mostrar la ventana
Una vez que están configuradas todas las carácterísticas de la ventana, es el momento de mostrarla en la
aplicación:
151
FORMACIONBIT
Manual: Java JSE
El nombre de todas las clases, correspondientes a todos los controles de Swing, comienzan con "J".
Etiqueta: JLabel
Permite crear etiquetas de texto fijo. Este texto se puede modificar posteriormente en tiempo de ejecución.
Para añadir el texto se utiliza el método "setText".
// CREACIÓN DE LA ETIQUETA
JLabel mietiqueta = new JLabel();
// TEXTO DE LA ETIQUETA
mietiqueta.setText("Mi texto de la etiqueta");
// UBICACIÓN Y TAMAÑO
micuadrotexto.setBounds(20, 50, 200, 25);
Botón: JButton
Permite crear botones. Mediante el método setText se puede modificar el texto del botón. Posteriormente,
habrá que asignar acciones para el evento de pulsar el botón.
// CREAR EL BOTÓN
JButton miboton = new JButton();
// UBICACIÓN Y TAMAÑO
miboton.setBounds(20, 100, 150, 25);
152
FORMACIONBIT
Manual: Java JSE
// UBICACIÓN Y TAMAÑO
micombobox.setBounds(20, 200, 150, 25);
// AÑADIR ELEMENTOS
micombobox.addItem("Uno");
micombobox.addItem("Dos");
micombobox.addItem("Tres");
// CARACTERÍSTICAS DE LA FUENTE
miareatexto.setFont(new Font("Arial",Font.PLAIN,16));
// COLOR DE FONDO
miareatexto.setBackground(new Color(255,255,140));
// COLOR DE TEXTO
miareatexto.setForeground(Color.BLACK);
// ESCRIBIR EN EL TEXTAREA
miareatexto.setText("Estoy en el JTextArea");
// UBICACIÓN Y TAMAÑO
miradio1.setBounds(300, 40, 150, 25);
miradio2.setBounds(300, 70, 150, 25);
miradio3.setBounds(300, 100, 150, 25);
154
FORMACIONBIT
Manual: Java JSE
// UBICACIÓN Y TAMAÑO
micheckbox1.setBounds(300, 150, 150, 25);
micheckbox2.setBounds(300, 180, 150, 25);
micheckbox3.setBounds(300, 210, 150, 25);
Tabla: JTable
Ejemplo que crea una tabla con JTable:
//--------------------
// DATOS PARA LA TABLA
//--------------------
// NOMBRES DE LAS COLUMNAS
String[] miscampos = {"Nombre", "Edad", "Sueldo"};
// DATOS DE LA TABLA
String[][] misdatos =
{
{"Juan", "26", "1100"},
{"Eva", "31", "1300"},
{"Luis", "24", "1000"},
{"Ana", "48", "1200"},
{"Mario", "33", "1000"},
{"Sara", "22", "1000"},
{"Pedro", "54", "1400"},
{"Mar", "44", "1300"}
};
//---------------------
// CREACIÓN DE LA TABLA
//---------------------
// CREACIÓN DEL TABLEMODEL, QUE PERMITIRÁ LA GESTIÓN DEL JTABLE
DefaultTableModel mitablemodel = new DefaultTableModel(misdatos, miscampos);
// CREACIÓN DE LA TABLA
mijtable = new JTable(mitablemodel);
155
FORMACIONBIT
Manual: Java JSE
//====================
// EDICIÓN DE LA TABLA
//====================
// AGREGAR FILA NUEVA
Object[] newRow = {"Jose", "51", "2000"};
mitablemodel.addRow(newRow);
// CREAR EL MENÚ
mimenu = new JMenu("Texto menú");
mimenu.addSeparator(); // SEPARADOR
156
FORMACIONBIT
Manual: Java JSE
Ejemplo de eventos: pulsar un botón, situar el ratón dentro de algún control, pulsar una tecla, etc.
Cada vez que el usuario interactúa con la aplicación, por ejemplo, pulsando un botón, se dispara (se
produce) un evento.
Para que un control determinado reaccione a dicho evento, dicho control debe poseer un escuchador
(listener), con al menos, un método determinado que se ejecutará al escuchar dicho evento en particular.
Por lo que si en una aplicación realizada en Swing se desea funcionar con eventos (que es lo habitual), se
deberá realizar la importación de dicho paquete correspondiente a AWT.
Ejemplo que importa todas las clases del paquete " java.awt.event":
import java.awt.event.*;
Ejemplo de programación de un escuchador (listener) para controlar eventos de tipo "ActinoListener" para el
botón "miboton1". Éste escuchador posee un método que implementa el código de lo que sucederá cuando
se pulse en dicho botón:
Eventos de ratón
Ejemplo que configura los eventos de ratón:
Eventos de teclado
Ejemplo que configura los eventos de teclado:
});
// ESCUCHADOR PARA LOS EVENTOS DEL DEL FOCO DEL CONTROL miboton1.
// IMPLEMENTA LA INTERFAZ FocusListener, CON LO QUE OBLIGA
// A IMPLEMENTAR TODOS LOS MÉTODOS.
// SI NO SE DESEA ALGUNO, SE PUEDE COMENTAR SU CÓDIGO.
miboton1.addFocusListener(new FocusListener() {
public void focusGained(FocusEvent e) {
miventana.setTitle("Cuando se pone el foco en el boton");
}
public void focusLost(FocusEvent e) {
miventana.setTitle("Cuando se quita el foco en el botón");
}
});
159
FORMACIONBIT
Manual: Java JSE
Ejemplo que muestra una ventana de tipo "showConfirmDialog", con el código en su escuchador, que
controla la pulsación de los tres botones:
Ejemplo que muestra una ventana de tipo "showInputDialog", que pide el nombre al usuario:
160