programación para no programadores.pdf
71
Programación java para no programadores
-
Upload
alvaro-huete-sanchez -
Category
Documents
-
view
228 -
download
4
description
libro de programacion para no programadores alvaro huete
Transcript of programación para no programadores.pdf
Programación java para no programadores
2
INDICE DE CONTENIDOS
Tema 1. Introducción a la plataforma. Entorno de trabajo. ..................................................... 6
1.1.- ¿Qué es Java? ................................................................................................................... 6
1.2.- Origen de la Plataforma Java ............................................................................................. 7
1.3.- El Lenguaje Java ................................................................................................................ 8
1.3.1- Características propias de Java ................................................................................ 8
1.4.- La arquitectura de la máquina Java ................................................................................... 9
1.5.- El modelo de Carga ......................................................................................................... 10
1.6.- El formato de ficheros de clases ...................................................................................... 10
1.7.- El entorno de aplicaciones .............................................................................................. 11
1.8.- Examinando el software de JDK ....................................................................................... 11
1.9.- JDK y el Desarrollo de Aplicaciones Java .......................................................................... 12
1.9.1.- Herramientas de JDK ............................................................................................ 12
1.9.2.- Librerías de JDK .................................................................................................... 14
1.10.- Tecnologías de despliegue JDK ...................................................................................... 15
1.11.- Especificación e implementación ................................................................................... 15
1.12.- Dónde se utiliza Java ..................................................................................................... 16
1.13.- ¿Podemos hacerlo todo con Java? ................................................................................. 16
1.14.- ¿El entorno de desarrollo? ............................................................................................ 17
1.14.1.- El compilador de Java ......................................................................................... 17
1.14.2.- El intérprete de java ........................................................................................... 18
1.14.3.- Accesibilidad al entorno...................................................................................... 18
1.14.3.1.- Variable de entorno PATH ............................................................................ 19
1.14.3.2.- Variable de entorno CLASSPATH .................................................................. 19
1.15.- Un ejemplo clásico: hello world! ................................................................................... 21
1.16.- Errores de sintaxis en Java ............................................................................................. 22
1.17.- Un ejemplo de ejecución ............................................................................................... 22
1.18.- Convenciones y nomenclatura en Java .......................................................................... 24
1.19.- Recuerde....................................................................................................................... 25
Tema 2.-Tipos de Datos. Orientación a Objetos. Variables..................................................... 26
2.1.- Palabras claves ................................................................................................................ 26
3
2.2.- Introducción a la Orientación a Objetos. ......................................................................... 26
2.2.1.- Características básicas. ......................................................................................... 26
2.2.2.- Encapsulación ....................................................................................................... 27
2.2.3.- La Herencia........................................................................................................... 28
2.2.3.1.- Jerarquía de las clases .................................................................................... 29
2.2.3.2.- Tipos de herencia........................................................................................... 29
2.2.4 Polimorfismo .......................................................................................................... 30
2.3.- Tipos de datos ................................................................................................................. 31
2.3.1- Tipos primitivos enteros ........................................................................................ 31
2.3.2- Tipos primitivos de coma flotante .......................................................................... 31
2.3.3- Tipo primitivo boolean .......................................................................................... 33
2.4.- Tipos de referencia ......................................................................................................... 33
2.5.- Identificadores ................................................................................................................ 33
2.6.- Variables ......................................................................................................................... 34
2.6.1.- Tipos de variables ................................................................................................. 34
2.7.- Contantes literales .......................................................................................................... 35
2.7.1.- Contantes enteras numéricas ............................................................................... 36
2.7.2.- Constantes enteras no numéricas ........................................................................ 37
2.7.3.- Constantes de coma flotante. ............................................................................... 38
2.7.4.- Constantes de cadenas, booleanas y null .............................................................. 38
2.8.- Recuerde ........................................................................................................................ 38
Tema 3. Operadores ............................................................................................................... 40
3.1.- Papel de los operadores .................................................................................................. 40
3.2.- Operadores numéricos de cambio de signo .................................................................... 40
3.3.- Operadores numéricos aritméticos ................................................................................. 41
3.4.- Operadores numéricos de incremento y decremento ...................................................... 42
3.5.- Operadores numéricos de desplazamiento de bits .......................................................... 42
3.6.- Operadores numéricos complemento de bits .................................................................. 43
3.7.- Operadores numéricos de comparación de bits ............................................................... 43
3.8.- Operadores numéricos de comparación .......................................................................... 44
3.9.- Operador condicional ...................................................................................................... 44
3.10.- Operadores de conversión de tipos. .............................................................................. 45
4
3.11.- Operadores de concatenación de cadenas .................................................................... 45
3.12.- Operadores boleanos .................................................................................................... 46
3.13.- Acceso a campos e invocación de métodos. .................................................................. 47
3.14.- Operadores de conversión: tipos de referencia ............................................................. 47
3.15.- Operadores de tipo de referencia .................................................................................. 47
3.16.- Operadores de comparación de referencias .................................................................. 48
3.17.- Operadores de asignación ............................................................................................. 48
3.17.1.- Operador de asignación simple .......................................................................... 49
3.17.2.- Operador de asignación complejos ..................................................................... 49
3.18.- Orden de evaluación ..................................................................................................... 50
3.19.- Recuerde....................................................................................................................... 51
Tema 4. Estructuras de control de flujo .................................................................................. 52
4.1.-Introduccion .................................................................................................................... 52
4.2.- Estructuras de control de bifurcación .............................................................................. 52
4.2.1.- La instrucción if-else ............................................................................................. 53
4.2.1.1.- Clausula else de la if-else ............................................................................... 53
4.2.1.2.- Instrucciones if-else anidadas ........................................................................ 54
4.2.2.- La instrucción switch ............................................................................................ 55
4.2.2.1.- Utilización de la instrucción break .................................................................. 56
4.2.2.2.- Utilización de la instrucción default ............................................................... 57
4.3.- Estructura de control iterativas ....................................................................................... 57
4.3.1.- Bucles for ............................................................................................................. 58
4.3.2.- Bucles while ......................................................................................................... 60
4.3.3.- Bucles do .............................................................................................................. 60
4.4.- Utilización de etiquetas ................................................................................................... 61
4.4.1.- La instrucción break con etiqueta ......................................................................... 61
4.4.1.1.- Ejemplo de la instrucción break con etiqueta ................................................. 62
4.4.2.- La instrucción continue con etiqueta .................................................................... 63
4.5.- Recuerde ........................................................................................................................ 63
Tema 5. Cadenas y Arrays. Comentarios en Java .................................................................... 64
5.1.- Cadenas .......................................................................................................................... 64
5.1.1.- La clase String ...................................................................................................... 64
5
5.1.2.- La clase de StringBuffer ....................................................................................... 65
5.2.- Arrays ............................................................................................................................. 66
5.2.1.- Arrays bidimensionales ......................................................................................... 66
5.3.- Comentarios Java ............................................................................................................ 67
5.3.1.- Comentarios de una sola línea .............................................................................. 67
5.3.2.- Comentarios de varias líneas ................................................................................ 68
5.3.3.- Comentarios de documentación ........................................................................... 69
5.3.3.1.- Convenios de los comentarios de documentación .......................................... 69
5.3.3.2.-Marcadores especiales de @ .......................................................................... 70
5.4.- Recuerde ........................................................................................................................ 71
6
TEMA 1. INTRODUCCIÓN A LA PLATAFORMA. ENTORNO DE TRABAJO.
1.1.- ¿QUÉ ES JAVA?
Cuando se oye hablar de Java lo primero que se piensa es en un lenguaje de programación, si
bien es cierto que dicha afirmación no se ajusta del todo a la realidad. Se podría responder que
se trata de un lenguaje, una arquitectura de máquina, un modelo de carga, un formato de
ficheros, un entorno de aplicaciones, una especificación y una implementación. Pero Java es
mucho más.
Aplicaciones completas: Java también puede
utilizarse para desarrollar aplicaciones completas.
Éstas se instalan en sistemas concretos y no
tienen las restricciones de los applets. Con ellas
se puede realizar prácticamente cualquier tarea
que pueda hacerse con otros lenguajes de
programación, desde simples aplicaciones locales
hasta complejas aplicaciones distribuidas.
PROGRAMA JAVA: Java es un verdadero lenguaje de programación orientado a objetos.
Applets: Los applets son uno de los tipos de programas Java más conocidos. Un applet es
código Java que se descarga automáticamente de la web y que se ejecuta dentro del
explorador web, en el ordenador del usuario. Este tipo de programas no requiere
instalación, posibilita interfaces de usuario muy ricas y lleva asociado un estricto mecanismo
de seguridad.
DISEÑO SENCILLO: Incorpora algunos de los elementos más modernos y potentes sobre el
diseño de lenguajes de programación. Se diseñó procurando ocultar las complejidades que
en muchos otros lenguajes son visibles, obteniéndose de este modo un mayor rendimiento
por parte de los programadores.
Centro: Entre las capacidades y características que incluye el lenguaje de Java se encuentra:
el desarrollo intrínseco con múltiples hebras, la gestión de excepciones, la recolección de
basura, una colección de clases disponibles muy completa para el desarrollo de todo tipo de
aplicaciones (acceso a bases de datos, construcciones de Interfaces gráficas,
comunicaciones…), etc.
LENGUAJE COMPILADO: A pesar de que Java aplica estrictamente muchas reglas en tiempo
de compilación, también posee características que le permiten escribir en un código muy
dinámico. En este sentido, Java es un lenguaje compilado pero, al contrario que con la
mayoría de los otros lenguajes compilados, su código no es especifico de la maquina ni del
sistema operativo. Cualquier sistema con una maquina virtual de Java puede ejecutar el
mismo Java compilado.
7
Es preciso mencionar que Java tiene un fértil campo en las aplicaciones con tecnología de
servidor. De hecho, actualmente es posible desarrollar aplicaciones web, componentes
distribuidos y servicios web.
1.2.- ORIGEN DE LA PLATAFORMA JAVA
Hace algunos años, Sun Microsystems decidió introducirse en el mercado de la electrónica de
consumo y desarrollar programas para pequeños dispositivos electrónicos. James Gosling, el
miembro del equipo con más experiencia en lenguajes de programación, decidió que las
ventajas de C o C++ no compensaban el coste que suponían los desarrollos. Además, dichos
lenguajes debían ser compilados para un chip concreto, lo cual exigía nuevas compilaciones
cada cierto tiempo.
Para salvar estos inconvenientes, James Gosling desarrolló en su tiempo libre un lenguaje con
una sintaxis similar a la de C++ y en el que intentaba remediar las deficiencias que observaba
en este último. Este lenguaje fue bautizado con el nombre de Oak.
Hace algunos años, Sun Microsystems decidió introducirse en el mercado de la electrónica de
consumo y desarrollar programas para pequeños dispositivos electrónicos. James Gosling, el
miembro del equipo con más experiencia en lenguajes de programación, decidió que las
ventajas de C o C++ no compensaban el coste que suponían los desarrollos. Además, dichos
lenguajes debían ser compilados para un chip concreto, lo cual exigía nuevas compilaciones
cada cierto tiempo.
Para salvar estos inconvenientes, James Gosling desarrolló en su tiempo libre un lenguaje con
una sintaxis similar a la de C++ y en el que intentaba remediar las deficiencias que observaba
en este último. Este lenguaje fue bautizado con el nombre de Oak.
Aunque en un principio no tuvo el éxito esperado y quedó relegado al olvido durante algún
tiempo, más adelante Bill Joy, cofundador de Sun Microsystems, vio en Oak el instrumento
adecuado a través de Internet para disputar a Microsoft su primicia absoluta en el terreno del
software. Tras un cambio de nombre y modificaciones de diseño, Java fue presentado en
agosto de 1995.
8
1.3.- EL LENGUAJE JAVA
REMEDIOS SOBRE C++
Robustecimiento de la programación orientada a objetos y eliminación de todas las
características no orientadas a objetos.
Eliminación de la posibilidad de manipular directamente punteros a memoria.
Eliminación de la confusa gestión de memoria por parte de los diseñadores de
aplicaciones.
Reforzamiento de la seguridad de los tipos.
Realización de comprobaciones en tiempo de ejecución para problemas comunes
como moldeos ilegales y referencias a objetos nulos.
Soporte para programación multihilo directamente en el lenguaje.
Mejora en la gestión de excepciones (manejo de errores).
1.3.1- CARACTERÍSTICAS PROPIAS DE JAVA
CARACTERISTICAS PROPIAS
Simplicidad Ofrece la funcionalidad de un lenguaje potente pero sin las características
menos usadas y más confusas de éstos. El ejemplo más claro puede ser el
recolector de basura, que evita la preocupación de liberar memoria por
parte del programador. Otro ejemplo podría ser la supresión de los
punteros.
Orientado a
objetos
Soporta las tres características básicas de la orientación a objetos:
encapsulación, herencia y polimorfismo.
Distribuido Proporciona las librerías y herramientas necesarias para que las aplicaciones
puedan ser distribuidas. Se ha desarrollado con extensas capacidades de
interconexión a red y soporta varios protocolos de red.
Robusto Realiza variadas comprobaciones tanto en tiempo de compilación como de
ejecución. Entre ellas pueden mencionarse la comprobación de tipos y la
comprobación de límites de arrays.
Portable No se refiere a la independencia de la plataforma, si no a la portabilidad en
cuanto a desarrollo. Por ejemplo, los enteros son siempre enteros de 32 bits
en complemento a 2, con independencia de la plataforma.
Multiplataforma No es necesario recompilar las aplicaciones Java para los distintos sistemas
en que van a ser explotadas.
9
Multihilo Permite múltiples hilos de ejecución, es decir, muchas actividades
simultáneas dentro del mismo programa. Esto proporciona un mayor
rendimiento interactivo (el usuario no percibe tanto la ocupación de la
máquina) y un mejor comportamiento en tiempo real (aunque sea algo muy
limitado por el sistema operativo).
Dinámico Cuando una aplicación se lanza, no se cargan todas las librerías que
requiere, sino que la carga es bajo demanda. Las librerías nuevas o
actualizadas no paralizarán las aplicaciones en funcionamiento.
1.4.- LA ARQUITECTURA DE LA MÁQUINA JAVA
La implantación de la arquitectura se ha dejado a la libre elección de los proveedores. Esta
arquitectura bien podría ser un microprocesador Java (hace unos años se desarrollaron
algunos), o bien, una máquina virtual (software). Actualmente, existen máquinas virtuales para
la mayoría de los entornos existentes (Windows, MacOS, Linux, los diversos UNIX).
Podría hacerse una analogía de la máquina Java con la máquina de Código P (P-Code) que se usó en el desarrollo del Pascal en la década de los 80. En este sentido, además de describir el motor de ejecución, la especificación describe otros comportamientos como el arranque, la carga y el apagado.
10
1.5.- EL MODELO DE CARGA
El modelo de carga Java lo hace un lenguaje único. La carga de las clases tiene lugar
dinámicamente durante la ejecución del programa. Con esto se rompe la dinámica tradicional
de la compilación (enlazado, carga y ejecución) de otros lenguajes que se requiere para crear y
ejecutar sus programas.
La carga de clases tiene lugar en varios pasos. En la siguiente figura se muestra un esquema del
funcionamiento del cargador con una clase de ejemplo.
1.6.- EL FORMATO DE FICHEROS DE CLASES
Java define, para el código, un paquete independiente de la plataforma. Este paquete recibe el
nombre de archivo de clases. Estos archivos se generan por un compilador Java por lo que
pasan a estar disponibles para ser ejecutados. Los archivos de clases se encontrarán,
normalmente, en sistemas de ficheros o empaquetados en archivos (ficheros ".zip" o ".jar"). El
sistema de carga de clases de Java esperará encontrarlos con la extensión ".class".
La carga de clases se produce bajo demanda según se necesite. Este concepto lo vemos
rutinariamente en las librerías dinámicas, los modelos de objeto (CORBA, COM y otros) y
la capacidad plug-in de algunos productos. La novedad la encontramos en la total
integración de la carga de clases con el lenguaje y el entorno. Esto conlleva un gran
adelanto en la programación orientada a objetos, ya que permite tratar los objetos del
código ejecutable con la misma facilidad que antes estaba reservada sólo para los objetos
de datos.
11
1.7.- EL ENTORNO DE APLICACIONES
Actualmente, Java dispone de un entorno de aplicaciones con componentes GUI (Graphic User
Interface), soporte de impresión, métodos de invocación remota, conectividad de bases de
datos, gráficos 2D y 3D, una API de audio, y un largo etcétera que constituyen un entorno muy
completo.
1.8.- EXAMINANDO EL SOFTWARE DE JDK
El software JDK contiene los componentes necesarios para realizar las siguientes actividades:
Desarrollar aplicaciones de la tecnología Java
Desplegar las aplicaciones de la tecnología Java
Ejecutar aplicaciones de la tecnología Java
En la siguiente figura ilustramos los componentes JDK y las actividades con las cuales están
relacionados.
En la siguiente URL podemos encontrar las instrucciones para descargar e instalar tanto el
software JDK como la documentación asociada.
http://java.sun.com/javase/downloads/index.jsp
12
1.9.- JDK Y EL DESARROLLO DE APLICACIONES JAVA
Los siguientes componentes JDK son proporcionados para ayudar al desarrollo de aplicaciones
de la tecnología Java:
COMPONENTES JDK DESCRIPCIÓN
Lenguaje de programación Java
Lenguaje compilado cuyo código no es específico de la máquina ni del sistema operativo. Estrictamente hablando, el Lenguaje de Programación Java no es un componente del software JDK.
Herramientas de JDK
Proveen soporte para el desarrollo y despliegue de aplicaciones Java.
Librerías de JDK Tipos de datos predefinidos conocidos como clases.
1.9.1.- HERRAMIENTAS DE JDK
El JDK provee utilidades para dar soporte al desarrollo y despliegue de aplicaciones de la tecnología Java. Las herramientas de JDK pueden ser clasificadas en dos categorías:
Herramientas básicas: Utilizadas para crear, construir, y ejecutar aplicaciones de la tecnología
Java.
Herramientas avanzadas de usuario: Constan a su vez de varias categorías de herramientas.
Cada categoría nos ayuda aprovechar una tecnología en particular cuando creamos una
aplicación de Java.
13
A continuación mostramos algunos ejemplos de ambas categorías.
Ejemplos de herramientas básicas.
NOMBRE DE
HERRAMIENTA
DESCRIPCIÓN
javac Compilador para el lenguaje de programación Java.
java Ejecuta las aplicaciones de la tecnología Java.
jdb Depurador Java.
javadoc Generador de documentos API.
jar Creador de ficheros JAR (Java Archive) y herramientas de gestión
Ejemplos de herramientas avanzadas de usuario.
CATEGORIA DE
HERRAMIENTA
DESCRIPCIÓN
Seguridad Nos ayudan a crear aplicaciones que trabajan con políticas de
seguridad.
Invocación de métodos
remotos (RMI)
Nos ayudan a crear aplicaciones que trabajan a través de una red.
Herramientas Java
para el despliegue
Proporciona funcionalidades para ayudar al despliegue de
aplicaciones de la tecnología Java.
Java Plug-in Utilidades para usar con los plug-in de Java.
Herramientas CORBA Ayudan a crear aplicaciones de red basadas en le tecnología CORBA
(Common object request broker architecture).
14
1.9.2.- LIBRERÍAS DE JDK
Las librerías de JDK consisten en tipos de datos predefinidos conocidos como clases. Estas
clases son agrupadas según su funcionalidad. En la tecnología Java, una librería es llamada
paquete.
En el siguiente gráfico se destacan las librerías disponibles con Java SE JDK.
Interfaz de usuarios Toolkits: La interfaz de usuario de Toolkits, consiste en un conjunto de
librerías que contienen las clases necesarias para crear interfaces graficas de usuario (GUI).
Librerías de integración: Las librerías de integración dan soporte para el uso de tecnologías de
red que permiten la integración de aplicaciones distribuidas.
Otras librerías: Se trata de una agrupación general de librerías. Esta agrupación incluye
librerías de seguridad, internacionalización, gestión de extensiones Java (Java Management
Extensions, JMX) y otras librerías similares.
Librerías lang y útil: Esta agrupación se compone de las librerías básicas necesarias para crear
aplicaciones. El núcleo de estas son las librerías lang y útil.
15
1.10.- TECNOLOGÍAS DE DESPLIEGUE JDK
El software JDK da soporte para el despliegue aplicaciones Java de escritorio. Este soporte es
proporcionado por los dos tipos de tecnologías de despliegue siguientes:
TECNOLOGÍAS DE DESPLIEGUE
DESRIPCIÓN
Java Plug-in Herramienta utilizada para el despliegue de applets de Java, los cuales se ejecutan en un navegador web.
Java Web Start
Es la implementación de referencia de la especificación JNLP (Java Networking Launching Protocol), mediante la cual permite arrancar aplicaciones Java que están en un servidor web de aplicaciones comprobando previamente si el cliente tiene la versión actualizada de dicha aplicación. Si no es así, descargará la última versión y se ejecutará en local.
1.11.- ESPECIFICACIÓN E IMPLEMENTACIÓN
Java es sobre todo una especificación y a partir de ésta es posible crear o implementar
cualquier parte de ella, por ejemplo, un compilador. Por ello, diversas corporaciones han
creado implementaciones, tanto gratuitas como comerciales.
La especificación Java al completo podemos descargarla de la web de Sun Microsystems en la
dirección http://java.sun.com.
16
1.12.- DÓNDE SE UTILIZA JAVA
Java es una plataforma tan virtuosa que ha encontrado múltiples escenarios en los que
asentarse. En el gráfico que aparece en pantalla podemos ver una relación de algunos de ellos.
1.13.- ¿PODEMOS HACERLO TODO CON JAVA?
El hecho de que Java precise de una interpretación de sus clases por parte de una máquina
virtual, lo hace más lento que otros lenguajes compilados directamente ante la máquina
desnuda. Aunque las mejoras en las implementaciones Java han ido paliando esto, puede
pensarse que nunca podrá competir en velocidad con las aplicaciones nativas compiladas.
Algunos de los problemas que no se pueden manejar actualmente con Java hacen referencia a:
Las
prestaciones
Problemas críticos de prestaciones. Para ello se requieren aplicaciones
nativas o componentes nativos en las aplicaciones Java.
Los requisitos Problemas que implican gran cantidad de memoria o requisitos de
entrada/salida.
La plataforma Problemas específicos de la plataforma. Java logra la independencia de la
plataforma y para ello no aprovecha las características de los lenguajes
nativos. Para intentar solventar este problema existe la librería JNI o lo que
es lo mismo, Java Native Interface, que permite mezclar Java y código nativo.
La GUI GUI significa Graphical User Interface. Java tiene una GUI pero su
rendimiento es inferior al nativo del propio sistema.
17
1.14.- ¿EL ENTORNO DE DESARROLLO?
Un editor válido puede ser el "Bloc de notas" de Windows o el conocido "vi" de los entornos UNIX.
1.14.1.- EL COMPILADOR DE JAVA
El compilador es una de las herramientas incluida en el JDK .Se encarga de analizar los ficheros
fuente y generar los correspondientes ficheros compilados (ficheros de bytecodes). En caso de
encontrar errores mostrará las líneas que los provocan junto con el mensaje de error que
corresponda.
Los ficheros fuente de java tienen la extensión ".java" y los ficheros compilados tienen la
extensión ".class". Invocaremos el compilador con el comando "javac" seguido del nombre del
programa o programas a compilar.
El compilador posee numerosas opciones, las cuales pueden variar de unas versiones a otras
del JDK. En cada caso deberemos de consultar la documentación para conocer los detalles.
18
1.14.2.- EL INTÉRPRETE DE JAVA
Java se diseñó para que el código fuera portable entre plataformas sin necesidad de volver a
compilarlo. Para ello se previó la existencia de un intérprete, llamado Máquina Virtual de Java
(Java Virtual Machine, JVM).
El compilador genera un código que no está relacionado con ninguna plataforma y que,
posteriormente, la JVM interpretará convirtiéndolo al código específico de la plataforma en la
que se ejecuta. El intérprete se invoca con el comando "java" seguido del nombre del
programa a ejecutar.
Al igual que el compilador, el interprete permite usar varias opciones y nuevamente
nos remitiremos a la documentación para saber los detalles de cada una de ellas.
1.14.3.- ACCESIBILIDAD AL ENTORNO
Para poder compilar y ejecutar las aplicaciones Java es necesario tener acceso al
directorio en el que se encuentran el compilador y el intérprete. Además, es necesario, indicar
a Java donde buscar las clases y librerías propias (API de Java) y las clases de usuario. Esto se
consigue mediante el uso de variables de entorno.
VARIABLES DE ENTORNO
PATH Es una variable de entorno del sistema a la cual se debe añadir el directorio
"\bin" del jdk.
CLASSPATH Esta variable de entorno indica a Java dónde buscar las clases y librerías
necesarias para compilar ficheros fuentes o ejecutar programas.
19
1.14.3.1.- VARIABLE DE ENTORNO PATH
Para poder compilar y ejecutar cómodamente deberíamos añadir el directorio "\bin" del JDK a
la variable de entorno PATH. Ésta no es específica de Java, si no que más bien es un
mecanismo de los sistemas operativos para localizar programas que no se encuentran en el
directorio actual:
Para los usuarios de DOS y Windows, desde el símbolo del sistema
tendremos que escribir: set PATH=%PATH%;ruta directorio bin.
Para los usuarios de UNIX y Linux: desde la ventana de terminal
tendremos que escribir: export PATH=$PATH: ruta directorio bin.
De esta forma sólo se cambia la variable de entorno PATH para la sesión en curso (la ventana
actual).
1.14.3.2.- Variable de entorno CLASSPATH
CLASSPATH indica a Java dónde buscar las clases y librerías propias (el API de Java) y las clases
de usuario. De esta forma Java carga dinámicamente las clases según las necesita. Esta variable
es específica de Java y puede incluir tantos elementos de los siguientes tipos como sea
necesario:
Nombre de directorio que contenga ficheros con extensión "class".
Nombre de fichero con extensión "zip" que contenga ficheros con extensión "class".
Nombre de fichero con extensión "jar" que contenga ficheros con extensión "class".
20
Ejemplo:
Si poseemos una librería de clases comprimida en un fichero llamado "milibreria.zip" y un
conjunto de clases sin comprimir en un mismo directorio llamado "misclases", la ubicación
para diferentes usuarios podría ser la siguiente:
PARA USUARIOS DE …
DOS,
WINDOWS
La librería se encuentra en "c:\desarrollo\libreria\" y el conjunto de clases está
en "c:\desarrollo\clases". Desde el símbolo del sistema tendremos que escribir:
set CLASSPATH=.;c:\desarrollo\libreria\ milibreria.zip;c:\desarrollo\misclases
UNIX Y
LINUX
La librería se ubica en "/home/usuariojava/desarrollo/libreria" y el conjunto de
clases está en "/home/usuariojava/desarrollo/clases". Desde la ventana de
terminal tendremos que escribir:
export CLASSPATH=.:/home/usuariojava/desarrollo/libreria/milibreria.zip:
/home/usuariojava/desarrollo/misclases
En la variable de entorno CLASSPATH podemos ver un "punto" como primer elemento, el cual
representa el directorio en curso. Cuando Java necesite cargar una clase de usuario, lo
primero que mirará es si está en el directorio actual, después buscará en el fichero y, por
último, en el directorio.
Podemos usar la opción "-classpath" a la hora de llamar al compilador o al intérprete, usando
la misma sintaxis y reglas que para la variable de entorno CLASSPATH.
21
1.15.- UN EJEMPLO CLÁSICO: HELLO WORLD!
Se ve aquí cómo sería una versión del clásico ejemplo "Hello World!" en el lenguaje Java. En el
siguiente gráfico se muestra el código; piénsese que muchos de los conceptos que aquí
aparecen aún no han sido estudiados, pero servirá para hacerse una idea inicial de cómo será
el código Java.
1.- Esta línea es un simple comentario
de tipo línea en el que se ha colocado el
nombre del fichero. El compilador ignorará
todo lo que va desde los caracteres”//” hasta
el final de la línea. Los comentarios son de
mucha utilidad para posteriores revisiones
del código. De todos modos, no hay que
abusar de ellos por claridad en el contenido.
2.- Esta línea declara el nombre de la clase. Se usa la palabra class seguida del nombre
que se desee dar a clase; en este caso es “HelloWorld”. Como Java es un lenguaje orientado a
objetos, el programa debe definirse como una clase. Por convención, las clases Java se definen
con la primera letra en mayúsculas.
3.- Declara un método de la clase que está definiendo. Este método se llama main, se
define como público (public), estático (static) y no va a devolver nada (void) cuando se
ejecute. Se define como público para pueda conocerse fuera de la clase y como estático para
disponer de él sin tener que crear un objeto. Después del nombre, y encerrada entre
paréntesis vemos la definición de parámetros que puede recibir el método. En este caso se
trata de un parámetro de nombre “args” y de tipo array de cadena de texto. Este método será
el punto de partida inicial del programa cuando se ejecute.
4.-Es una llamada al método printl del flujo de salida (out) estándar del sistema
(System). Dicho método se encarga de mostrar por pantalla la línea que se le indique.
5.-Estas líneas son el cierre de la definición del método main y de la definición de la
clase de HelloWorld respectivamente.
6.- Una vez escrito el código anterior y guardado el archivo con el nombre
“HelloWorld.java”, deberá compilarse. Para ello se usa la herramienta javac indicándole el
nombre del archivo fuente:
Javac HelloWorld.java
Es muy importante tener en cuenta que Java distingue entre mayúsculas y minúsculas. Por
tanto, se contara como error cuando se dan equivocadas. Si se ha hecho todo bien no se recibe
ningún mensaje al terminar la compilación y se obtiene un fichero llamado “HelloWorld.class”
22
7.-Una vez obteniendo el fichero llamado “HelloWorld.class”, se invoca al intérprete
llamado “java”, indicándole que clase queremos ejecutar.
java HelloWorld
Obtendremos como respuesta por consola el texto “Hello World!”. Si no me hubiera definido
la variable de entorno CLASSPATH, se tendría que haber usado la sintaxis siguiente:
java –classpath . HelloWorld
1.16.- ERRORES DE SINTAXIS EN JAVA
Cuando escribimos un nuevo código Java, solemos tener, al menos, un error de sintaxis. Por
sintaxis nos referimos a las normas que determinan la estructura legal del lenguaje.
Para evitar los errores de sintaxis de Java, puede hacer uso de los siguientes consejos:
CONSEJOS
Cuando se produce un error en el código, se muestra un mensaje indicando el
número de línea en donde se produjo dicho error. Sin embargo, el error podría estar
en otra línea distinta a la indicada, por lo que se aconseja comprobar las líneas
anteriores y posteriores.
Asegúrese de que tiene un punto y coma al final de cada declaración.
Asegúrese de que tiene un número par de llaves: una llave de cierre para cada llave
de apertura.
Hacer uso del sangrado de línea en los programas. De este modo el código será
mucho más fácil de leer y depurar.
1.17.- UN EJEMPLO DE EJECUCIÓN
Cuando invocamos al compilador lo hacemos dándole el nombre y extensión del fichero a
compilar. Por su parte, cuando invocamos al intérprete no le indicamos el nombre del fichero
ni la extensión, sino el nombre de una clase. El nombre del fichero que contiene la clase no es
significativo pero por convenio se usa el mismo nombre que el de la clase que contiene. Esto
es así porque un fichero puede contener más de una clase, aunque también por convención no
se suele hacer.
23
Para aclarar todo esto vamos a ver un ejemplo. Vamos a escribir dos clases: "Clase1" y
"Clase2". La primera la guardaremos como "Fichero1.java" y la segunda como "Fichero2.java".
Fichero1.java- class Clase1 {
Public static void main (String [] args) {
System.out.println (“Soy Clase1”);
}}
Fichero2.java- class Clase2 {
Public static void main (String [] args) {
System.out.println (“Soy Clase2”);
}}
Compilación- Usamos la siguiente sintaxis para
ahorrarnos trabajo:
Javac Fichero*.java
Tras esto tendremos los ficheros “Ficheros1.class” y “Fichero2.class”.
Ejecución incorrecta- Intentamos ejecutar “Clase1” indicándole el nombre del fichero que la
contiene. Para ello escribimos “java Fichero1”. Veremos que el mensaje de error que
obtenemos indica que no existe la clase “Fichero1”. Si probamos indicándole que nos ejecute
“Fichero1.class” obtendremos de nuevo un error en el que se nos indica que no encuentra la
clase. Esta vez el mensaje se refiere a una clase llamada “class”.
Ejecución correcta- Intentamos ejecutar indicándole al interprete el nombre de clase, así que
ahora escribiremos “java Clase1”. En esta ocasión observaremos que si ha funcionado. Si
probamos con “java Clase2” vemos que también se encuentra. Ahora podemos entender la
utilidad de indicar el directorio actual (mediante un punto) en la variable de entorno
CLASSPATH, ya que el interprete ha encontrado las clases porque estaban accesibles a través
de ella.
24
1.18.- CONVENCIONES Y NOMENCLATURA EN JAVA
Con respecto a los nombres de variables, las reglas del lenguaje Java son muy amplias y
permiten mucha libertad, pero es habitual seguir ciertas normas que faciliten la lectura y el
mantenimiento de los programas. Por convención, se recomienda seguir las siguientes reglas:
Normalmente se emplean nombres con minúsculas salvo las excepciones que se
enumeran en los siguientes puntos.
En los nombres que se componen de varias palabras es aconsejable colocar una detrás
de otra poniendo en mayúscula la primera letra de cada palabra.
Los nombres de las clases y las interfaces empiezan siempre por mayúscula.
Los nombres de objetos, métodos y variables empiezan siempre por minúscula.
Los nombres de las variables finales (las constantes) se definen siempre con
mayúsculas.
25
1.19.- RECUERDE
Java es una especificación de un lenguaje, una arquitectura de máquina, un modelo de
carga, un formato de ficheros, un entorno de aplicaciones, una especificación y una
implementación.
Para desarrollar y ejecutar aplicaciones Java se necesita un entorno Java.
El entorno java de Sun Microsystems se llama JDK. Suministra varias herramientas con
las cuales podemos compilar los ficheros fuente y posteriormente ejecutarlos.
Para la compilación y ejecución de aplicaciones hemos de establecer adecuadamente
la variable de entorno CLASSPATH.
26
TEMA 2.-TIPOS DE DATOS. ORIENTACIÓN A OBJETOS. VARIABLES
2.1.- PALABRAS CLAVES
Java se diseñó para que fuera familiar a los programadores de C++, y por este motivo, las
palabras clave de java y otros aspectos son muy similares a las de C++.
Palabras clave existentes en Java:
2.2.- INTRODUCCIÓN A LA ORIENTACIÓN A OBJETOS.
UNA CLASE ES UN PROTOTIPO QUE DEFINE LAS PROPIEDADES Y LOS MÉTODOS COMUNES A MÚLTIPLES
ENTES (OBJETOS QUE SERÁN INSTANCIADOS COMO DE ESE MISMO TIPO. POR SU PARTE UN OBJETO ES UNA
INSTANCIA DE UNA CLASE, UN ELEMENTO QUE CUMPLE EL PROTOTIPO QUE ELLA FIJA.
2.2.1.- CARACTERÍSTICAS BÁSICAS.
Java es un lenguaje orientado a objetos, pero ¿qué determina si un lenguaje es orientado a
objetos? Podemos decir que un lenguaje está orientado a objetos si soporta objetos como una
característica fundamental del mismo. Fundamentalmente, soportar objetos consiste en que el
lenguaje permita las siguientes características:
CARACTERISTICAS
Encapsulación La encapsulación consiste en ocultar la complejidad de una clase e impedir accesos no permitidos.
Herencia La herencia es la posibilidad de crear clases partiendo de otras.
Polimorfismo El polimorfismo permite disponer de métodos con un mismo elemento en distintas clases.
27
2.2.2.- ENCAPSULACIÓN
Cada objeto es un conjunto datos y métodos relacionados entre sí como si estuvieran
encerrados en una cápsula. Son inaccesibles e impiden conocer cómo está distribuida la
información dentro de ellos. Por tanto, las peticiones de información a un objeto deben
hacerse mediante mensajes dirigidos a él. Un mensaje es una llamada a un método del objeto
con el que se quiere comunicar.
Ejemplo de comparación del concepto de encapsulación y la vida real:
Cuando un conductor se monta en un coche, se limita a dar a la llave contacto y el motor
arranca. La encapsulación brinda esa sencillez. La realidad es que ocurren muchas cosas:
contacto eléctrico, funcionamiento del motor de arranque, apertura del paso de combustible,
etc. Pero, ¿Necesita saber realmente el conductor lo que ocurre para simplemente conducir?
No, basta con saber que para arrancarlo necesita introducir la llave en el contacto y girarla.
28
2.2.3.- LA HERENCIA
La herencia es una característica que permite la creación de clases a partir de otras. Esto
conlleva los siguientes conceptos que se especifican en la siguiente animación.
La herencia es una característica que
permite la creación de clases a partir
de otras. Esto conlleva los siguientes
conceptos:
Reutilización del
código
Especialización de
las clases
29
2.2.3.1.- JERARQUÍA DE LAS CLASES
2.2.3.2.- TIPOS DE HERENCIA
La herencia puede ser de dos tipos: simple y múltiple. La diferencia entre ambas es que en el
caso de herencia múltiple se permite heredar de más de una clase. En otras palabras, se trata
de que una clase hija pueda tener más de una clase padre.
En la práctica son pocos los lenguajes que permiten herencia múltiple dada la complejidad que
supone soportarla. En el caso de Java no está permitida. Java sólo permite herencia simple
pero dispone de un mecanismo para paliar esta deficiencia, aunque no siempre es suficiente.
Las entidades que lo permiten son las interfaces. El lenguaje Java permite a una clase heredar
de una sola clase, pero podrá implementar varias interfaces.
30
2.2.4 POLIMORFISMO
El polimorfismo consiste en la posibilidad de tener métodos con el mismo nombre en distintas
clases. Esto se refiere a métodos distintos y, por tanto, con comportamientos diferentes, a
pesar de que tengan el mismo nombre.
En esta jerarquía se comprueba que todas las clases que la componen tienen un método
llamado “dibujar()”. Todos tienen el mismo nombre pero cada uno de ellos puede poseer
clases hijas que redefinen el método “dibujar()” de la clase padre es un método abstracto ya
que para dibujar un polígono, es necesario saber qué tiempo de polígono es.
Por tanto, las clases obligadas a implementar el método implementar el método “dibujar()”
que será distinto en cada caso.
Las entidades claves de la programación orientada a objetos
son las clases y los objetos. Las clases son conceptuales
mientras que los objetos son concreciones.
Las tres características básicas de la programación orientada a
objetos son:
El encapsulamiento: consiste en ocultar la complejidad de una clase e impedir accesos
no permitidos.
La herencia: es la posibilidad crear clases partiendo de otras. Un medio para reutilizar
funcionalidad.
El polimorfismo: permite disponer de métodos con un mismo nombre en distintas
clases.
31
2.3.- TIPOS DE DATOS
JAVA ES UN LENGUAJE SENCILLO Y CON POCOS TIPOS DE DATOS, LO CUAL NO IMPLICA QUE NO SEA
POTENTE, DE HECHO, ES UN LENGUAJE MODERNO CON EL QUE PODEMOS CREAR PRÁCTICAMENTE
CUALQUIER TIPO DE APLICACIÓN QUE SE NECESITE.
Las clases (java.lang) que representan tipos primitivos reciben el nombre de "Wrappers" o envoltorios. Asimismo, estas y, en general, todas las clases tienen un método "toString()", que devuelve un representación del contenido del objeto como cadena.
2.3.1- TIPOS PRIMITIVOS ENTEROS
Se usan para almacenar números enteros, la única diferencia entre ellos son los rangos de
valores soportados. Todos los tipos enteros tienen signo y se representan en complemento a
dos, excepto el tipo char, que es un entero sin signo de 16 bits y se usa para representar
caracteres Unicode.
32
2.3.2- TIPOS PRIMITIVOS DE COMA FLOTANTE
Existen sólo dos tipos: float y double, y la diferencia está en los rangos de valores que pueden
almacenar. Ambos pueden representar los siguientes valores:
El infinito positivo. Es representado por la constante POSITIVE_INFINITY.
El infinito negativo. Es representado por la constante NEGATIVE_INFINITY.
El cero positivo.
El cero negativo.
Valores que no son numéricos y que se representan por la constante NaN (Not a
Number). Estos valores son generados por operaciones como la división por cero.
Resto de valores.
Aunque se puedan representar el cero positivo y el negativo, ambos valores se consideran
equivalentes en las comparaciones numéricas.
Float El tipo float es de precisión sencilla.
Double El tipo double es de precisión doble.
Java.lang.Float Las constantes POSITIVE_INFINITY, NEGATIVE_INFINITY y NAN están
declaradas en las clases java.lang.Float, además de las constantes MAX_VALUE y MIN_VALUE
para representar los valores máximo y mínimo que pueden soportar.
Java.lang.Double Las constantes POSITIVE_INFINITY, NEGATIVE_INFINITY y NAN están
declaradas en las clases java.lang.Double, además de las constantes MAX_VALUE y
MIN_VALUE para representar los valores máximo y mínimo que pueden soportar.
33
2.3.3- TIPO PRIMITIVO BOOLEAN
Sólo existe un tipo y puede tomar los valores "true" (cierto) y "false" (falso). Al contrario que
en otros lenguajes, no podemos usar los valores enteros en expresiones que requieran valores
booleanos.
2.3.4.- TIPOS DE REFERENCIA
Los tipos de referencia al contrario que los tipos primitivos se emplean para hacer referencia a
objetos, interfaces implementadas y matrices.
2.4.- IDENTIFICADORES
Los identificadores sirven para nombrar variables, propiedades, métodos, clases, objetos,
interfaces y cualquier otra entidad que sea necesario identificar para poder usar.
En Java, un nombre de identificador debe empezar con una letra, un símbolo de subrayado (_)
o un símbolo dólar ($). El resto de los caracteres empleados pueden ser letras o números. No
existe una longitud máxima y se distinguen las mayúsculas de las minúsculas.
34
2.5.- VARIABLES
Las variables en Java, al igual que en todos los lenguajes de programación, representan
direcciones de memoria en las que alojar temporalmente la información que necesitemos, y
nos ofrecen la facilidad de referirnos a ellas mediante un nombre.
Se denomina visibilidad, ámbito o alcance de una variable, a la parte de una aplicación en la
que dicha variable es accesible. En otras palabras, la parte en la cual puede usarse dicha
variable. Como norma general, podemos decir que las variables declaradas dentro de un
bloque (entre llaves) son visibles y existen dentro de ese bloque.
Una declaración de variable se compone de su tipo y su nombre. Adicionalmente puede
indicarse un valor para su inicialización. El tipo de la variable determina los valores que puede
contener y las operaciones que se podrán realizar con ella.
Las variables miembro de una clase son válidas mientras existe el objeto.
2.6.1.- TIPOS DE VARIABLES
Desde el punto de vista del papel que desempeñan, las variables pueden ser:
Variables miembro de una clase: Se definen dentro de la clase y fuera de cualquier
método.
Variables locales: Se definen dentro de cualquier bloque entre llaves, normalmente
dentro de un método. Se crean dentro del bloque y se destruyen al finalizar dicho
bloque.
35
2.7.- CONTANTES LITERALES
Las constantes literales son representaciones literales de datos en el código fuente. Estos
valores se emplean para inicializar variables o para usarlas en expresiones en las que se
requieren valores constantes.
Pueden usarse para referirse explícitamente a uno de los tipos primitivos siguientes: int, long,
float, double, boolean, char, String y null. Por otra parte, los objetos no pueden ser
representados mediante estas constantes, y por tanto, no existen constantes literales de tipo
de referencia.
Otra característica del lenguaje Java consiste en que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local que ya existiera. La variable declarada dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro oculta sería necesario que usáramos el operador this.
36
2.7.1.- CONTANTES ENTERAS NUMÉRICAS
Las constantes enteras numéricas se representan por un valor que está formado sólo por
dígitos numéricos y no tienen la coma decimal. Si el número no comienza por cero, representa
un número en base 10. Para representar constantes de tipo "long" se emplea el mismo
método pero añadiendo al final la letra "L".
Además, es posible representar constantes en los formatos octal y hexadecimal. Las
constantes octales y hexadecimales son de tipo entero a menos que estén seguidas por la letra
"L", en cuyo caso serían de tipo long.
Las constantes octales se representan anteponiendo un cero al propio número, que
además, sólo podrá estar formado por los dígitos del 0 al 7.
Las constantes hexadecimales se representan anteponiendo 0x o 0X y permitiendo que
los dígitos del número puedan ser del 0 al 9 y las letras de la A a la F (en mayúsculas o
minúsculas).
Para representar constantes de tipo "long" también está permitido el empleo de la letra "L"
en minúsculas, pero no debe usarse ya que puede confundirse con el número uno al releer un
programador el código.
37
2.7.2.- CONSTANTES ENTERAS NO NUMÉRICAS
El tipo char es un tipo entero, no obstante se trata de un tipo especial pensado para almacenar
caracteres Unicode. Estos últimos son similares a los caracteres ASCII que están pensados para
almacenar símbolos, números y caracteres. Sin embargo, el rango del tipo char es mucho
mayor porque permite representar caracteres de casi todos los idiomas del mundo.
Las constantes literales de tipo char pueden representarse de dos formas distintas:
Encerrando un único carácter entre comillas simples.
Utilizando una secuencia de escape representada por una barra inclinada inversa (\)
seguida de un número octal de tres dígitos, o bien por la barra seguida de la letra "u" y
de un número hexadecimal de cuatro dígitos. La secuencia de escape también debe ir
encerrada entre comillas simples.
A continuación se muestran en la siguiente tabla algunas de las secuencias de escape más
comunes que se necesitarán desarrollar.
38
2.7.3.- CONSTANTES DE COMA FLOTANTE.
Por claridad, también pueden expresarse las constantes de tipo double posponiendo la letra "d" o "D" al número.
2.7.4.- CONSTANTES DE CADENAS, BOOLEANAS Y NULL
A continuación se explican las constantes de cadena, booleanas y null:
2.8.- RECUERDE
CONCEPTO DESCRIPCION
Tipos de datos Existen dos categorías de tipos de datos: tipos primitivos y tipos de
referencia. Los primeros son los tipos básicos y no son objetos
propiamente dichos, mientras que los segundos se emplean para
representar tipos complejos (objetos), interfaces y matrices.
Operadores Son símbolos que se utilizan en algunas expresiones para modificar el
valor de expresiones más simples, o bien para crear expresiones nuevas
a partir de otras. Es importante que tengamos en cuenta las reglas de
precedencia de operadores puesto que van a determinar los resultados
que obtengamos.
39
Identificadores Sirven para nombrar variables, propiedades, métodos, clases, objetos,
interfaces y cualquier otra entidad que sea necesario identificar para
poder usar.
Variables Representan direcciones de memoria en las que alojar temporalmente la
información y nos ofrecen la facilidad de referirnos a ellas mediante un
nombre. Una declaración de variable se compone de dos partes: su tipo
y su nombre.
Constantes
literales
Son representaciones literales de datos en el código fuente. Estos
valores se emplean para inicializar variables o para usarlas en
expresiones en las que se requieren valores constantes.
40
TEMA 3. OPERADORES
3.1.- PAPEL DE LOS OPERADORES
Son símbolos que se utilizan en algunas expresiones para modificar el valor de expresiones
más simples, o bien, para crear expresiones nuevas a partir de otras. Los operadores no son
genéricos, sino que se podrán usar dependiendo de las expresiones sobre las que se quiere
operar.
Atendiendo al número de operandos necesitados, los operadores pueden ser de tres tipos:
Unarios: necesitan un único operador.
Binarios: necesitan dos operadores.
Ternarios: necesitan tres operadores.
3.2.- OPERADORES NUMÉRICOS DE CAMBIO DE SIGNO
LOS OPERADORES DE CAMBIO DE SIGNO SON DOS Y SE REPRESENTAN POR LOS SIGNOS + Y - (MÁS Y
MENOS). SON OPERADORES UNARIOS. EL OPERADOR - SE APLICA PARA CAMBIAR EL SIGNO DEL OPERANDO,
MIENTRAS QUE EL OPERADOR + NO TIENE NINGÚN EFECTO.
Estos operadores también existen para los números del tipo de coma flotante. Cada
uno de ellos funciona de forma similar a los correspondientes de los enteros. La principal
diferencia está en que el resultado de las operaciones es del tipo de coma flotante.
a= -4; // Asigna el valor -4 a la variable a
b=+7; // Asigna el valor 7 a la variable b
41
3.3.- OPERADORES NUMÉRICOS ARITMÉTICOS
LOS OPERADORES ARITMÉTICOS SON OPERADORES BINARIOS. SE UTILIZA EL SÍMBOLO + PARA LA SUMA, EL -
PARA LA RESTA, EL * PARA LA MULTIPLICACIÓN, EL / PARA LA DIVISIÓN Y ÉL % PARA EL RESTO DE LA
DIVISIÓN ENTERA.
Las operaciones aritméticas enteras pueden realizarse sobre dos enteros de distinto tipo. En
este caso, la máquina virtual convertirá el tipo más pequeño al tipo mayor o al tipo "int", el
que sea menor (en estas operaciones se obtendrá un tipo "int" o un tipo "long"). Además, el
tipo del resultado de la operación será del mismo tipo al que se ha convertido el tipo menor. A
este proceso de conversión se le denomina moldeo o casting.
Estos operadores, excepto el operador de división entera, también existen para los números
del tipo de coma flotante. Cada uno de ellos funciona de forma similar a los correspondientes
de los enteros.
EJEMPLO 1
a=2+3 //Se asigna a la variable “a” el valor 5
a=a-1 //Se asigna a la variable “a” el valor 4
a=a*4 //Se asigna a la variable “a” el valor 16
a=a/2 //Se asigna a la variable “a” el valor 8
a=a%3 //Se asigna a la variable “a” el valor 2
EJEMPLO 2
byte = b=4
short s=2
int i = b*s
Esta instrucción consiste en la multiplicación de un tipo byte por un tipo short y la asignación
del resultado a una variable de tipo int. En ella tienen lugar las dos conversiones automáticas:
Primera conversión: El operando "b" es de tipo byte y hay que multiplicarlo por un
operando de tipo short. Entre ambos tipos, el mayor es el tipo short, pero el menor
tipo para una conversión automática es el tipo int, por tanto "b" se convierte a tipo
int.
Segunda conversión: El operando "s" es de tipo short y hay que multiplicarlo por un
operando de tipo int. Entre ambos tipos el mayor es de tipo int y, por tanto, "s" se
convierte a tipo int.
Por último, se multiplican ambos operadores de tipo int y el resultado de la operación se almacena en la variable "i" de tipo int.
*Al proceso de conversión de tipos que realiza la maquina virtual de Java se le denomina moldeo o casting.
42
3.4.- OPERADORES NUMÉRICOS DE INCREMENTO Y DECREMENTO
3.5.- OPERADORES NUMÉRICOS DE DESPLAZAMIENTO DE BITS
Los operadores de desplazamiento de bits sirven para desplazar los bits de un número
entero. Son tres, el de desplazamiento a la izquierda con signo, el de desplazamiento a la
derecha con signo y el de desplazamiento a la derecha con inserción de ceros. Los símbolos
empleados son <<, >> y >>> respectivamente. Los dos primeros realizan el desplazamiento de
bits rellenando los bits más significativos con el bit de signo del operador. El tercero realiza el
desplazamiento rellenando a ceros los bits más significativos. Estos operadores requieren de
dos operandos, el primero es el valor en cuestión sobre el que se quiere operar, y el segundo
indica el número de bits de desplazamiento.
Estos operadores no están disponibles para los números en coma flotante.
43
3.6.- OPERADORES NUMÉRICOS COMPLEMENTO DE BITS
Este operador se representa mediante el símbolo ~.
Para operaciones a nivel de bits, también tenemos el operador de complemento de bits. Es un
operador unario que se encarga de realizar una operación de complemento a unos. En ella,
cada bit pasa de 0 a 1 o de 1 a 0.
Este tipo de operador no existe para los números del tipo coma flotante.
EJEMPLO 1
byte a=15; //El valor binario 00001111
byte b= ~a; //Se complementa al valor11110000 que en decimal es el número -15
3.7.- OPERADORES NUMÉRICOS DE COMPARACIÓN DE BITS
Estos operadores no existen para los números de tipo coma flotante
44
3.8.- OPERADORES NUMÉRICOS DE COMPARACIÓN
Estos operadores se utilizan para comparar dos números enteros o en coma flotante y da
como resultado un valor booleano.
En caso de comparar dos números en coma flotante existen ciertas peculiaridades que hemos
de observar:
Ya hemos mencionado que el formato de coma flotante soporta los valores cero
positivo y cero negativos, pero en las comparaciones ambos son equivalentes.
El valor NaN no es realmente un número, por lo que no se puede decir que dos valores
NaN sean equivalentes. Es decir, tanto el operador == como el operador != devolverían
false si los comparáramos.
3.9.- OPERADOR CONDICIONAL
ES UN OPERADOR TERNARIO (TRES OPERADORES). CONSTRUYE EXPRESIONES EN LAS CUALES EL PRIMER Y
SEGUNDO OPERANDO SE SEPARAN USANDO EL SÍMBOLO ? Y EL SEGUNDO Y TERCER OPERANDO SE SEPARAN
USANDO EL SÍMBOLO : EL PRIMER OPERANDO DEBE SER UN VALOR BOOLEANO MIENTRAS QUE EL SEGUNDO
Y TERCERO HAN DE SER VALORES DE CUALQUIER TIPO (PRIMITIVO O REFERENCIA) SIEMPRE QUE SEAN DEL
MISMO TIPO. SI EL VALOR BOOLEANO ES TRUE, LA EXPRESIÓN TOMA COMO VALOR EL DEL SEGUNDO
OPERANDO, EN CASO CONTRARIO, TOMA COMO VALOR EL DEL TERCER OPERANDO.
ES UN OPERADOR MUY USADO, YA QUE PERMITE LA TOMA DE DECISIONES CON EXPRESIONES MUY
COMPACTAS Y ELEGANTES.
1.- Debe ser un valor booleano.
2.- Ambos operadores deben ser valores enteros o en coma flotante.
45
3.10.- OPERADORES DE CONVERSIÓN DE TIPOS.
Las conversiones automáticas entre distintos tipos numéricos al efectuar operaciones como la
suma son conversiones que realiza Java automáticamente. En contraste con éstas están las
conversiones explícitas de tipos, es decir, aquellas que se pueden forzar en el propio código
mediante algún tipo de mecanismo.
Este mecanismo son los operadores de conversión de tipos, que permiten convertir cualquier
expresión numérica a otro tipo distinto. Para cada uno de los tipos numéricos existe un
operador de conversión. Consiste en colocar delante de la expresión a convertir el nombre del
tipo al cual se quiere convertir, encerrado entre paréntesis.
En este tipo de conversiones hemos de tener en cuenta que cuando pasamos de un tipo a
otro de inferior rango podemos encontrarnos con resultados inesperados debido a un valor
que excede del rango del tipo al cual se convierte.
3.11.- OPERADORES DE CONCATENACIÓN DE CADENAS
Cuando una cadena de texto y una expresión que no sea de tipo cadena se combinan usando
el operador de concatenación de cadenas (+), el resultado es una nueva cadena.
Dependiendo de la expresión y de su contenido, podremos obtener los siguientes resultados:
Si la expresión es un tipo de referencia con valor null, se obtendrá una nueva cadena igual a la cadena original más la cadena "null".
Si la expresión es un tipo de referencia con valor distinto de null, se obtendrá una cadena igual a la original más el valor devuelto por el método toString() del tipo de referencia.
Si la expresión es un tipo primitivo, se obtendrá una cadena igual a la original más el valor del tipo primitivo representado como cadena.
46
3.12.- OPERADORES BOLEANOS
CATEGORIA OPERADORES EJEMPLO
Operadores lógicos de comparación
Hay dos operadores de comparación: igual a (==) y distinto de (!=). Ambos requieren dos operandos de tipo booleano. El operador == da como resultado true si ambos operandos son iguales. Por el contrario, el operador != da como resultado true si ambos operandos son distintos.
true == true // da como resultado true true == false // da como resultado false true != true // da como resultado false true != false // da como resultado true
Operadores de complemento lógico
Es un operador unario y se representa por el símbolo !. Da como resultado un valor lógico opuesto al valor lógico del operando sobre el que se aplica.
!true // da como resultado false !false // da como resultado true
Operadores lógicos
Existen tres operadores binarios que se emplean para la comparación de operandos booleanos:
mbolo |. Da como resultado un valor true si al menos uno de los operandos es true.
como resultado un valor true si ambos operandos son true.
como resultado un valor true si uno y sólo uno de los operadores es true.
true | true // da como resultado true true | false // da como resultado true false | false // da como resultado false true & true // da como resultado true true & false // da como resultado false false & false // da como resultado false true ^ true // da como resultado false true ^ false // da como resultado true false ^ false // da como resultado false
Operadores lógicos condicionales
Los operadores lógicos condicionales son dos: OR (||) y AND (&&). Funcionan de forma similar a los operadores lógicos excepto en que no se garantiza la evaluación del segundo operando si el resultado de la expresión puede determinarse directamente a partir del primero. Esto se conoce como lógica booleana cortocircuitada.
int a = 1; int b = 1; if ( 3 > 1 | ++a > 0 ) { // .} if ( 3 > 1 || ++b > 0 ) { // .}
47
3.13.- ACCESO A CAMPOS E INVOCACIÓN DE MÉTODOS.
3.14.- OPERADORES DE CONVERSIÓN: TIPOS DE REFERENCIA
Las operaciones de conversión de tipos se utilizan para convertir una referencia de objeto a un
cierto tipo. Pero existen ciertos requisitos para permitir la conversión. El tipo de un objeto
sólo puede convertirse al de:
su propia clase
una de sus superclases
una interfaz que sea implementada por su propia clase
una interfaz que sea implementada por alguna de sus superclases
Los tipos de referencia se convierten usando como operador el nombre entre paréntesis de la
clase a la cual se quiere convertir y anteponiéndolo a la expresión a convertir:
FiguraGeometrica figura = new Rectangulo ();
3.15.- OPERADORES DE TIPO DE REFERENCIA
Puesto que en Java se permite la conversión entre tipos, se hace necesario poder comprobar
desde el código si una determinada conversión puede realizarse.
Para determinar si un objeto es una instancia de una clase concreta, se dispone del
operador instanceof que devuelve un valor booleano o genera una excepción. Son posibles los
casos siguientes:
48
Si el primer operando es null (no apunta a ningún objeto instanciado), el resultado es
false.
Si el primer operando es distinto de null y es posible convertirlo a la clase que
especifica el segundo operando, el resultado será true.
Si el primer operando es distinto de null y no es un descendiente del tipo especificado
por el segundo operando, la instrucción generaría una excepción.
s1 y s2 El primer operador deber ser un tipo de referencia
String El segundo operador debe ser un nombre de clase.
3.16.- OPERADORES DE COMPARACIÓN DE REFERENCIAS
3.17.- OPERADORES DE ASIGNACIÓN
La asignación es una operación mediante la cual podemos asignar el valor de una expresión a
una variable. La variable a la que se asigna el valor se pone a la izquierda del operador de
asignación, mientras que a la derecha del mismo se pone la expresión. Si la expresión usada
requiere una evaluación, se realiza previa a la asignación.
Existen dos tipos de asignación:
TIPO DE ASIGNACION DESCRIPCION
Simple La expresión es evaluada y asignada a la variable.
Compuesta La variable a la que se asigna el valor también participa en la
expresión que debe asignársele.
49
3.17.1.- OPERADOR DE ASIGNACIÓN SIMPLE
El operador de asignación simple se representa con el símbolo =. Su función es la de evaluar la
expresión de la parte derecha de la expresión de asignación y asignar el resultado a la variable
que figura en la parte izquierda de ella.
Si la expresión y la variable no son compatibles para la asignación, es decir, son de tipos
distintos, la expresión debe convertirse al tipo apropiado antes de la asignación. Si no pudiera
convertirse a un tipo compatible, se produciría un error de compilación.
Este tipo de asignación puede tener lugar, tanto formando parte de la declaración de la
variable, como en cualquier momento posterior a dicha declaración.
3.17.2.- OPERADOR DE ASIGNACIÓN COMPLEJOS
Los operadores de asignación compleja son los siguientes: +=, -=, *=, /=, %=, <<=, >>=, >>>=,
|=, &= y ^=.
En la asignación compleja la variable a la que se asigna el valor también participa en la
expresión que debe asignársele. En consecuencia, ello implica que una asignación compleja
solo puede usarse con posterioridad a la declaración de la variable puesto que necesita
utilizarla.
1.-Se evalua la expresión que hay a la derecha del operador
2.-Se realiza la operación que representa la primera parte del operador sin considerar el signo
“=” utilizando la variable que hay a la derecha del operador como primer operando y la
expresión evaluada en el paso anterior como segundo operando.
3.-El resultado obtenido en el resultado anterior se asigna a la variable.
50
Poder usar un tipo de operador de asignación concreto dependerá de los tipos de los operadores. En otras palabras, los operadores deben ser compatibles con la operación que denota la primera parte del operador de asignación complejo. Estos operadores no son imprescindibles y se suelen usar para crear sentencias más legibles.
3.18.- ORDEN DE EVALUACIÓN
A igualdad de condiciones, Java evalúa las expresiones siguiendo un orden estricto de
izquierda a derecha. No obstante, ciertos operadores tienen precedencia sobre otros, por
tanto, algunas expresiones se evaluarán antes que otras.
Cuando una expresión contiene operadores que tienen mayor precedencia que otros,
se realiza primero la operación de mayor precedencia aunque el operador de menor
precedencia esté a la izquierda.
A continuación se enumeran los operadores de mayor a menor precedencia. Los operadores
que se encuentran a un mismo nivel tienen igual precedencia y se evaluarán de izquierda a
derecha.
51
3.19.- RECUERDE
Pueden resumirse todos los operadores vistos rápidamente en la siguiente tabla:
Operadores Descripción
Numéricos Todos los operadores de uso numérico común: +, -,/, *, %; unarios o
binarios. También los de incremento y decremento; ++, --.
A nivel de bits Operadores de juego numérico a nivel de bits, sean de desplazamiento;
<<, >>, >>>, de complemento; ~ o de comparación de bits; |, &, ^.
Comparación Típicos operadores de comparación; <, >, <=, >=, ==, !=.
Condicional El muy especial operador condicional; a?b:c; donde si a es true se da b; si
no, se da c.
Conversión De Conversión de tipos o casting; (<nombreClase>)<objetoAconvertir>.
Concatenación El símbolo + concatena cadenas, si son de este tipo los operandos.
Booleanos Algunos ya en los grupos anteriores, entran aquí todos los que
devuelven booleanos: !=, ==, &, &&, ||, !, etc.
Acceso Acceso a campos e invocación de métodos; Operador punto; .
Tipo Referencia Operador de comprobación del tipo de referencia; instanceOf. Para
compararlas; ==, !=.
Asignación De asignación simple; =, y de asignación compleja: +=, -=, *=, /=, %=, <<=,
>>=, >>>=, |=, &= y ^=.
52
TEMA 4. ESTRUCTURAS DE CONTROL DE FLUJO
4.1.-INTRODUCCION
Existen dos tipos generales de estructuras de control que hacen desviar el flujo normal
(secuencial) de lectura del código: las estructuras de control de bifurcación y las estructuras de
control iterativas.
Algunas permiten utilizar las palabras clave break y continue, las cuales pueden utilizarse con etiquetas o sin ellas.
4.2.- ESTRUCTURAS DE CONTROL DE BIFURCACIÓN
Existen dos estructuras de bifurcación: if-else y switch. Las estructuras de control de
bifurcación permiten ejecutar condicionalmente sentencias o instrucciones Java.
53
4.2.1.- LA INSTRUCCIÓN IF-ELSE
La cláusula if de la instrucción if-else se utiliza para ejecutar o no un conjunto de sentencias. La
cláusula else es opcional y es posible omitirla si ninguna acción va a ejecutarse cuando la
condición sea falsa. En este caso, si el resultado de la condición es true, se ejecutará el
conjunto de sentencias tras el if. Sin embargo, si la condición da como resultado false, no se
ejecutará nada.
Si ese conjunto a ejecutar condicionalmente contiene más de una sentencia, se encerrarán
éstas entre llaves.
Las especificaciones Java recomiendan el uso de la pareja de llaves con independencia del
número de instrucciones, para resaltar visualmente los bloques de código.
4.2.1.1.- CLAUSULA ELSE DE LA IF-ELSE
54
4.2.1.2.- INSTRUCCIONES IF-ELSE ANIDADAS
Podemos anidar una instrucción if dentro de otra pero, aunque esta característica es muy útil,
puede ser confuso en el caso de que sólo una de las dos instrucciones if incluya una cláusula
else. Esto es debido a que algunas veces es difícil determinar a qué if pertenece una
determinada cláusula else.
Java resuelve esta situación asociando la parte else a la instrucción if más cercana a la que
pueda pertenecer.
En el primer fragmento de código, el método metodo2() se ejecuta si contador es igual a 0. Para asociar la parte else a la instrucción if exterior, encerramos la instrucción if interna entre llaves. En el segundo fragmento de código, el método metodo2() se ejecuta cuando contador sea mayor estricto que 0.
55
4.2.2.- LA INSTRUCCIÓN SWITCH
La instrucción switch permite ejecutar una o más instrucciones según el valor de una
expresión.
Cuando Java ejecuta una instrucción switch, compara el valor de la expresión de bifurcación
con las expresiones constantes de cada una de las instrucciones case, comenzando con la
primera. Si encuentra una instrucción case cuyo valor coincida con el de la condición de
bifurcación, se ejecutan las instrucciones de esa instrucción case. Si hay más de una instrucción
case a continuación de la que ha coincidido, se ejecutan también las instrucciones de las
instrucciones case restantes.
*expresión El tipo de la expresión de bifurcación debe ser: byte, char, int o short.
*expresión constante Los valores de la expresiones constantes deben ser compatibles
con el tipo de la expresión de bifurcación. Las expresiones constantes pueden ser
constantes literales, variables, o expresiones compuestas por constantes literales y/o
variables, siempre que los operadores empleados den como resultado un tipo primitivo que
sea compatible con el tipo de la expresión de bifurcación.
*una o más instrucciones Se ejecutan si el valor de la instrucción case coincide con el de
la condición bifurcación.
56
4.2.2.1.- UTILIZACIÓN DE LA INSTRUCCIÓN BREAK
57
4.2.2.2.- UTILIZACIÓN DE LA INSTRUCCIÓN DEFAULT
Si se incluye la cláusula default en la instrucción switch, se pueden especificar una o más
instrucciones que se ejecutarán cuando ninguna de las expresiones constantes coincida con la
expresión de bifurcación.
En el ejemplo, el método devolverá una cadena con el valor "indefinido", si el argumento no es
un número comprendido entre 1 y 5. Es importante tener en cuenta que si las instrucciones
case individuales no incluyeran la palabra clave break, el método devolvería siempre
"indefinido". Además, la cláusula default debe aparecer como última opción de la instrucción
switch y, por tanto, no requiere instrucción break puesto que no tendría ningún efecto en la
instrucción switch.
4.3.- ESTRUCTURA DE CONTROL ITERATIVAS
Una de las principales diferencias entre las estructuras de control iterativas y las de bifurcación
está en la utilización de la palabra clave continue. La ejecución de las estructuras de control
iterativas puede controlarse mediante continue, mientras que las de bifurcación no. La palabra
clave break puede utilizarse también con las estructuras de control iterativas.
58
4.3.1.- BUCLES FOR
Los bucles for sirven para repetir ninguna, una o varias veces un grupo de sentencias. Al igual
que las estructuras de control de bifurcación, si se desea repetir un conjunto de sentencias se
han de colocar dentro de un bloque a continuación de la instrucción for. La sintaxis sería la
siguiente:
Iniciador La sintaxis del bucle for permite inicializar una variable que suele
denominarse variable de control. También es posible declarar e inicializar la variable en la
instrucción for. Pero, hacemos esto último, el alcance de dicha variable queda restringido
únicamente al bloque de instrucciones del bucle. Cualquier intento de utilizar esta variable
fuera del bloque de la instrucción for produciría un error de compilación:
for (int a = 1;;) {
System.out.println(“Valor de a:” + a);
if (a > 10)
break;
++a;
}
Condición La expresión condición debe ser de tipo boolean. Si al evaluar la condición
da true, el bloque de instrucciones se ejecuta, y después se evalúa de nuevo la condición. Si la
condición vuelve a dar true, se vuelve a ejecutar el bloque. Este proceso se repite mientras se
cumpla la condición (al ser evaluada es distinta de false) y en el bloque de instrucciones no se
encuentre la sentencia break. Cuando termine la ejecución del bucle, el control pasará a la
primera instrucción que siga al bloque de instrucciones del bucle:
for (a = 1;a<10;) {
System.out.println("Valor de a:" + a);
++a;
}
Actualizador Cuando se ejecuta un bucle for, se ejecuta el inicializador la primera vez que
se entra en el bucle. Si la condición da como resultado el valor lógico true, se ejecuta el
bloque de instrucciones del bucle. Después de ejecutarse el bloque de instrucciones, se
ejecuta el actualizador, se evalúa la condición y, si el resultado es true, el proceso se repite.
59
for (int a =0;a<10;++a)
{
System.out.println("Valor de a:" + a);
}
Bloque de instrucción Se corresponde con el bloque de código que será ejecutado cada
vez que se ejecute una iteración. Existen algunas salvedades: las instrucciones break y
continue. Cuando se ejecuta la sentencia break sin etiqueta, la instrucción for termina
inmediatamente, y la ejecución pasa a la primera instrucción que siga al bloque de
instrucciones del bucle for, sin que la condición vuelva a evaluarse o se ejecute de nuevo el
actualizador.
También puede incluir la palabra clave continue. Cuando no lleva etiqueta, se ignoran las
restantes instrucciones del bloque y la ejecución pasa inmediatamente a la instrucción for,
donde se vuelve evaluar la condición.
Las zonas de inicialización, condición y actualización pueden estar vacías: for( ; ; ){ bloque de instrucciones; } También es posible tener bucles en los que la variable de control disminuya. Para ello incluiremos una instrucción de decremento en la sección de actualización de la instrucción for.
60
4.3.2.- BUCLES WHILE
Los bucles while se utilizan para ejecutar ninguna, una o varias veces una instrucción o bloque
de instrucciones. Pero a diferencia de los bucles for, los bucles while no permiten utilizar
variables de control y es una expresión booleana la que controla si la instrucción while se
ejecuta o no.
Si la condición fuera siempre cierta y no se genera ninguna excepción ni se ejecuta alguna instrucción break dentro del bloque de instrucciones, el bucle se ejecutaría indefinidamente.
4.3.3.- BUCLES DO
Los bucles do son casi iguales a los bucles while, con la diferencia de que los bucles do siempre se ejecutan al menos una vez. En los bucles while la condición es evaluada al inicio de cada iteración. Por tanto, un bucle while podría no ejecutarse ni siquiera una vez si la condición es inicialmente falsa. Por el contrario, en los bucles do la condición se evalúa al finalizar cada iteración, motivo por el cual los bucles do se ejecutan al menos una vez. La sintaxis del bucle do es la siguiente.
A continuación, podemos observar un ejemplo práctico:
61
4.4.- UTILIZACIÓN DE ETIQUETAS
Las instrucciones break y continue con etiquetas también permiten interrumpir o continuar la
ejecución de un bucle. Sin embargo, cuando se utilizan etiquetas, las instrucciones break y
continue no asumen que se trata del bucle más cercano; es decir, el más interno. Con el uso de
etiquetas se permite continuar la ejecución transfiriendo el control a una instrucción en la que
esté anidado el bucle actual. Por esta razón, las instrucciones break y continue con etiquetas
proporcionan un alto grado de control sobre el flujo de ejecución del código.
Para poder utilizar las instrucciones break y continue con etiquetas, debemos proporcionar
una etiqueta para la instrucción a la que deseamos que hagan referencia dichas instrucciones.
La etiqueta se crea escribiendo delante de la instrucción un identificador seguido de dos
puntos. El identificador debe ser una combinación de letras y números, pero debe comenzar
con una letra y no puede contener espacios.
4.4.1.- LA INSTRUCCIÓN BREAK CON ETIQUETA
La instrucción break siempre hace que se termine inmediatamente un bucle y que la ejecución
pase a la primera instrucción que siga al bucle. Cuando se usa con etiqueta, el bucle también
termina inmediatamente, pero la ejecución continúa en la primera instrucción que siga a la
instrucción etiquetada. La instrucción etiquetada puede ser un bucle externo (un bucle que
encierra completamente al bucle en el que aparece la instrucción break con etiqueta) o un
bloque de instrucciones en el que esté contenido el bucle.
Por tanto, el uso de la instrucción break con etiqueta permite que se ignoren no sólo las
instrucciones restantes del bucle interno, sino también las instrucciones que le sigan.
No existe un límite para el número de niveles hasta el que puede anidarse la instrucción break con etiqueta.
62
4.4.1.1.- EJEMPLO DE LA INSTRUCCIÓN BREAK CON ETIQUETA
63
4.4.2.- LA INSTRUCCIÓN CONTINUE CON ETIQUETA
La instrucción continue con etiqueta se utiliza sólo con estructuras de control iterativas
etiquetadas. Es decir, desde un bucle anidado dentro de un bucle etiquetado, la instrucción
continue con etiqueta puede usarse para evaluar inmediatamente la condición del bucle
exterior y si el resultado es cierto continuar la ejecución al principio del bucle etiquetado, sin
ejecutar las instrucciones restantes del bucle interno ni las del bucle externo.
No hay un límite para el número de niveles en que puede anidarse una instrucción continue con etiqueta.
4.5.- RECUERDE
1. Existen dos tipos generales de estructuras de control: las estructuras de control de
bifurcación y las estructuras de control iterativas.
2. Las estructuras de control de bifurcación permiten ejecutar condicionalmente
instrucciones de Java. Existen dos estructuras de este tipo: if-else, switch.
3. Las estructuras de control iterativas se utilizan para repetir una o varias instrucciones
ninguna, una o varias veces. En Java se tienen tres: for, while y do.
64
TEMA 5. CADENAS Y ARRAYS. COMENTARIOS EN JAVA
5.1.- CADENAS
Por cadena se entiende a una secuencia de datos del tipo primitivo carácter (char). También se
las conoce como "string". En el entorno Java está implementada mediante las clases String y
StringBuffer, ambas pertenecientes al paquete java.lang.
El operador de concatenación (+) de objetos de tipo String utiliza internamente la clase StringBuffer y el método append(). Además, los métodos de la clase String se pueden usar directamente sobre cadenas entrecomilladas: "cadena".length().
5.1.1.- LA CLASE STRING
Los objetos de la clase String se pueden crear a partir de cadenas constantes o literales,
definidas entre dobles comillas. Java crea siempre un objeto String al encontrar una cadena
entre comillas.
Esto último es lo más eficiente, debido a que al encontrar un texto entre comillas se crea
automáticamente un objeto String. También se pueden crear objetos de la clase String
llamando a constructores de la clase, a partir de objetos StringBuffer, y de arrays de bytes o de
chars.
MÉTODOS CONSTRUCTORES FUNCIÓN QUE REALIZAN String(...) Constructores para crear Strings a partir de arrays de bytes o de
caracteres.
String(Stringstr) String(StringBuffer sb)
Constructores a partir de un objeto String o StringBuffer.
MÉTODOS NO MODIFICADORES
FUNCIÓN QUE REALIZAN
charAt(int) Devuelve el carácter en la posición especificada.
getChars(int, int, char[], int)
Copia los caracteres indicados en la posición indicada de un array de caracteres.
indexOf(String, [int]) Devuelve la posición en la que aparece por primera vez un String dentro de otro y a partir de una posición dada.
lastIndexOf(String, [int]) Devuelve la última vez que un String aparece dentro de otro empezando por el final y a partir de una posición dada.
length() Devuelve el número de caracteres de la cadena.
startsWith(String) Indica si un String comienza con otro String o no.
substring(int, int) Devuelve un String extraído de otro.
valueOf() Devuelve la representación como String de su argumento. Admite Object, arrays de caracteres y los tipos primitivos.
65
MÉTODOS MODIFICADORES
FUNCIÓN QUE REALIZAN
replace(char, char) Sustituye un carácter por otro en un String.
toLowerCase() Convierte en minúsculas.
toUpperCase() Convierte en mayúsculas.
trim() Elimina los espacios en blanco al comienzo y final de la cadena.
5.1.2.- LA CLASE DE STRINGBUFFER
Métodos más utilizados de la clase Java.lang.StringBuffer:
MÉTODOS CONSTRUCTORES FUNCIÓN QUE REALIZAN
StringBuffer() Todos inicializan un objeto de la clase StringBuffer.
StringBuffer(int)
StringBuffer(String)
MÉTODOS NO MODIFICADORES FUNCIÓN QUE REALIZAN
capacity() Devuelve el espacio libre del StringBuffer.
charAt(int) Devuelve el carácter en la posición especificada.
getChars(int, int, char[], int) Copia los caracteres indicados en la posición indicada de un array de caracteres.
length() Devuelve el número de caracteres de la cadena.
toString() Convierte en objeto de tipo String.
MÉTODOS MODIFICADORES FUNCIÓN QUE REALIZAN
append(X) Existirá un método append por cada tipo X, todos ellos para añadir al final del StringBuffer actual una representación como cadena del elemento de tipo X (int, char, char[], Object, ...).
insert(int, X) Análogo a append, existiendo múltiples versiones de este método, pero añadiendo el elemento en la posición especificada por el primer parámetro.
reverse() Cambia el orden de los caracteres.
setCharAt(int, char) Cambia el carácter en la posición indicada.
setLength(int) Cambia el tamaño de un StringBuffer.
66
5.2.- ARRAYS
Los arrays, también llamados vectores o matrices, son un tipo especial de referencias, con independencia de que sean de tipos primitivos o de tipos de referencias. Representan una colección de elementos del mismo tipo. Una variable de tipo array se declara, igual que cualquier otro tipo de variable, pero incluyendo corchetes. Por ejemplo int [ ] myarray; Los elementos de un array se inicializan al valor por defecto del tipo correspondiente. Cero
para valores numéricos, el carácter nulo para el tipo char, el valor false para el tipo boolean y
null para los demás.
Cuando intentamos acceder a un elemento de un array al que no hemos asignado memoria, el compilador da un error indicando que el array puede no estar inicializado. Cuando se igualan dos referencias a un array, realmente no se copia el objeto, si no que pasamos a tener dos referencias que apuntan a un mismo array. Existe un tipo de array que recibe el nombre de array anónimo, y que consiste en la creación de un array como argumento actual en la llamada a un método.
5.2.1.- ARRAYS BIDIMENSIONALES
En Java, una matriz es un vector de vectores fila, o más concretamente, un vector de
referencias a los vectores fila. Con este esquema, cada fila podría tener un número de
elementos diferente.
Si tenemos una matriz de nombre "array", la expresión "array.length" indica el número de filas mientras que la expresión "array[0].length" indica el número de columnas de la primera fila.
67
5.3.- COMENTARIOS JAVA
Los comentarios son instrucciones del código fuente que no son compiladas por el compilador.
Se emplean para documentar la funcionalidad del código y dar las explicaciones aclaratorias
pertinentes. La utilización adecuada de comentarios facilita considerablemente la lectura,
depuración y mantenimiento del código.
Existen tres tipos de comentarios en Java: los comentarios de una sola línea, los comentarios
de varias líneas y los comentarios de documentación.
//Esto es un comentario de línea /*Esto es un comentario de varias líneas*/ /** * Esto es un comentario de documentación */
5.3.1.- COMENTARIOS DE UNA SOLA LÍNEA
Este tipo de comentarios se indica mediante dos barras inclinadas (//). El compilador Java
ignorará cualquier carácter desde el comienzo del comentario hasta el final de la línea. Si el
comentario se encontrara en una línea con código, el código que precede a las barras de
comentario se compilará de forma habitual.
Los comentarios de una sola línea se utilizan generalmente para explicaciones breves. Debido a
que se pueden escribir en líneas de código, son muy interesantes para poner descripciones
sobre la propia línea de código.
Un uso muy práctico es el de poder "eliminar" temporalmente líneas de código durante los
procesos de depuración.
68
5.3.2.- COMENTARIOS DE VARIAS LÍNEAS
Los comentarios de varias líneas empiezan con la secuencia de caracteres /* y termina con la
secuencia */. El compilador Java ignorará cualquier carácter que escribamos dentro de dichas
secuencias.
Cuando el compilador encuentra la secuencia de inicio de comentario, ignora cualquier cosa
que le siga con excepción de la secuencia de fin de comentario. Esto quiere decir que no se
pueden anidar comentarios de este tipo.
Los comentarios de varias líneas son muy útiles para comentarios extensos, como las
descripciones que suelen encabezar las definiciones de clases o de sus métodos.
La función de un comentario es facilitar la lectura del código mediante aclaraciones. No tiene sentido colocar comentarios indicando cosas obvias.
69
5.3.3.- COMENTARIOS DE DOCUMENTACIÓN
5.3.3.1.- CONVENIOS DE LOS COMENTARIOS DE DOCUMENTACIÓN
Por convenio, la primera línea de un comentario de documentación debe ser una frase que
describa la funcionalidad de la declaración. Esta descripción termina con un punto seguido de
un espacio. El texto que sigue a esta descripción puede incluir uno o varios de los siguientes
elementos:
ELEMENTOS UBICADOS TRAS LA DESCRIPCIÓN Texto descriptivo adicional Para explicar o ampliar la descripción inicial. Texto adicional mejorado mediante los marcadores HTML
Marcadores HTML, como el tipo de letra cursiva <I> o negrita <B>, etc. Sin embargo, debemos evitar el uso de las cabeceras <H1>, <H2>, etc., ya que la herramienta JavaDoc emplea estos marcadores en el archivo HTML resultante y su uso puede reducir la claridad de los comentarios.
Marcadores especiales de @ Estos marcadores ayudan a enriquecer los documentos generados por la herramienta JavaDoc.
Después de la primera línea de un comentario de documentación, el resto de las líneas pueden ir precedidas de espacios, de caracteres de tabulación o del carácter *. Estos caracteres se ignorarán todos, con excepción de la secuencia */, que indicará el final del comentario de la documentación.
70
5.3.3.2.-MARCADORES ESPECIALES DE @
En la siguiente tabla podemos observar los marcadores especiales de @:
MARCADORES ESPECIALES DE @
DESCRIPCIÓN
@version Este marcador sirve para indicar la versión de la clase o de la interfaz. Este marcador opcional es particularmente útil cuando tengamos previsto publicar varias versiones de las clases o de las interfaces.
@author Es un marcador opcional que podemos usar para especificar el autor o los autores de una clase o interfaz. A continuación de un marcador @author pueden ir uno o más nombres de autor. No obstante, podemos indicar cada uno de los autores en marcadores @author individuales, si así lo prefiriéramos.
@see Se utiliza en las clases, interfaces, constructores, métodos o variables para hacer referencia a otras fuentes de información relacionada. Con él podemos incluir el nombre de un paquete o clase relacionados, un método o campo concretos de una clase o interfaz, o incluso un URL. Para usar el marcador @see en un paquete de clases, escribiremos el nombre de la clase a continuación del marcador. Si la clase está en un paquete importado, no es necesario que incluyamos el nombre del paquete.
@exception Este marcador lo utilizaremos para documentar un método o constructor cuya declaración indique que puede generar una excepción. A continuación del marcador @exception escribiremos la clase de la excepción, seguida de una descripción de las razones por las cuales el método o el constructor podría generar dicha excepción. Debido a que un único método o constructor puede generar distintos tipos de excepciones, podremos tener varios marcadores @exception. Cada marcador @exception solamente puede especificar una excepción.
@returns El marcador @returns sirve para documentar los métodos de una clase o de una interfaz que devuelven un valor (distinto de null). A continuación de este marcador describiremos el valor que devuelve dicho método.
@param Lo emplearemos para documentar los parámetros de los métodos y de los constructores. Detrás de cada marcador @param especificaremos un nombre de parámetro, seguido de una breve descripción. Como norma general, habremos de especificar un marcador @param para cada uno de los parámetros del método o constructor, y enumerarlos en el mismo orden en el que aparecen en su lista de parámetros.
@deprecated El marcador @deprecated afecta a la compilación del código. Este marcador identifica un método o variable de instancia que debe considerarse obsoleto. Cuando el compilador detecta que se ha utilizado un método o variable de instancia identificado por este marcador, muestra un mensaje de advertencia. El propósito del marcador es permitirnos compilar código pensado para versiones anteriores de Java. Cuando compilemos, se nos indicará que la versión actual suministra instrucciones alternativas que son preferibles.
71
Para especificar un método o campo concretos de una clase con el marcador @see, pondremos a continuación del nombre de la clase el signo #, seguido del nombre de la variable o del método. Si estamos haciendo referencia a un método sobrecargado, debemos incluirse la lista de parámetros para que la herramienta JavaDoc pueda identificar a cuál de los métodos del mismo nombre se está haciendo referencia.
5.4.- RECUERDE
