programación para no programadores.pdf by Alvaro Huete Sánchez

Programaci贸n java para no programadores

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

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

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.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

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.

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.

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.

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.

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.

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.

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".

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

1.9.- JDK Y EL D ESARROLLO DE APLICACIONES JAVA Los siguientes componentes JDK son proporcionados para ayudar al desarrollo de aplicaciones de la tecnología Java: COMPONENTES JDK Lenguaje de programación Java

Herramientas de JDK Librerías de JDK

DESCRIPCIÓN 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. Proveen soporte para el desarrollo y despliegue de aplicaciones Java. 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.

A continuación mostramos Ejemplos de herramientas básicas.

algunos

NOMBRE DE HERRAMIENTA

ejemplos

ambas

categorías.

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

DESCRIPCIÓN

HERRAMIENTA Seguridad

Nos ayudan a crear aplicaciones que trabajan con políticas de seguridad.

Invocación de métodos

Nos ayudan a crear aplicaciones que trabajan a través de una red.

remotos (RMI) 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).

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.

1.10.- T ECNOLOGÍ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 Java Plug-in

Java Web Start

DESRIPCIÓN Herramienta utilizada para el despliegue de applets de Java, los cuales se ejecutan en un navegador web. 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. 15

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.

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.

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.

1.14.3.1.- V ARIABLE 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".

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.

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”

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.

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.

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.

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.

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. U NA 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. P OR 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:

Encapsulación Herencia Polimorfismo

CARACTERISTICAS La encapsulación consiste en ocultar la complejidad de una clase e impedir accesos no permitidos. La herencia es la posibilidad de crear clases partiendo de otras. El polimorfismo permite disponer de métodos con un mismo elemento en distintas clases.

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.

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

2.2.3.1.- J ERARQUÍA DE LAS CLASES

2.2.3.2.- T IPOS 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.

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.

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.

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.

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.

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.

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.

2.7.- C ONTANTES 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.

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.

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.

2.7.3.- C ONSTANTES 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.

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.

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; b=+7;

// Asigna el valor -4 a la variable a // Asigna el valor 7 a la variable b

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. a=2+3 a=a-1 a=a*4 a=a/2 a=a%3

EJEMPLO 1 //Se asigna a la variable “a” el valor 5 //Se asigna a la variable “a” el valor 4 //Se asigna a la variable “a” el valor 16 //Se asigna a la variable “a” el valor 8 //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.

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.

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

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). C ONSTRUYE 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.

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.

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 true | true // da como emplean para la comparación de operandos resultado true booleanos: true | false // da como resultado true false | false // da como mbolo |. Da resultado false como resultado un valor true si al menos true & true // da como uno de los operandos es true. resultado true true & false // da como resultado false como resultado un valor true si ambos false & false // da como operandos son true. resultado false true ^ true // da como como resultado un valor true si uno y sólo resultado false true ^ false // da como uno de los operadores es true. 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 ) { // .}

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:

 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.

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.

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.

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 ^=.

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.

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.- C LAUSULA ELSE DE LA IF - ELSE

4.2.1.2.- I NSTRUCCIONES 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.

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.

4.2.2.1.- U TILIZACIÓN DE LA INSTRUCCIÓN BREAK

4.2.2.2.- U TILIZACIÓ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.

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.

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.

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:

4.4.- U TILIZACIÓ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.

4.4.1.1.- E JEMPLO DE LA INSTRUCCIÓN BREAK CON ETIQUETA

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.

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 String(...) String(Stringstr) String(StringBuffer sb)

MÉTODOS NO MODIFICADORES charAt(int) getChars(int, int, char[], int) indexOf(String, [int]) lastIndexOf(String, [int]) length() startsWith(String) substring(int, int) valueOf()

FUNCIÓN QUE REALIZAN Constructores para crear Strings a partir de arrays de bytes o de caracteres. Constructores a partir de un objeto String o StringBuffer.

FUNCIÓN QUE REALIZAN Devuelve el carácter en la posición especificada. Copia los caracteres indicados en la posición indicada de un array de caracteres. Devuelve la posición en la que aparece por primera vez un String dentro de otro y a partir de una posición dada. Devuelve la última vez que un String aparece dentro de otro empezando por el final y a partir de una posición dada. Devuelve el número de caracteres de la cadena. Indica si un String comienza con otro String o no. Devuelve un String extraído de otro. Devuelve la representación como String de su argumento. Admite Object, arrays de caracteres y los tipos primitivos.

MÉTODOS MODIFICADORES replace(char, char) toLowerCase() toUpperCase() trim()

FUNCIÓN QUE REALIZAN Sustituye un carácter por otro en un String. Convierte en minúsculas. Convierte en mayúsculas. 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 capacity() charAt(int) getChars(int, int, char[], int) length() toString() MÉTODOS MODIFICADORES append(X)

insert(int, X)

reverse() setCharAt(int, char) setLength(int)

FUNCIÓN QUE REALIZAN Devuelve el espacio libre del StringBuffer. Devuelve el carácter en la posición especificada. Copia los caracteres indicados en la posición indicada de un array de caracteres. Devuelve el número de caracteres de la cadena. Convierte en objeto de tipo String.

FUNCIÓN QUE REALIZAN 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, ...). 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. Cambia el orden de los caracteres. Cambia el carácter en la posición indicada. Cambia el tamaño de un StringBuffer.

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.

5.3.- C OMENTARIOS 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.

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.

5.3.3.- COMENTARIOS DE DOCUMENTACIÓN

5.3.3.1.- C ONVENIOS 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, como el tipo de letra marcadores HTML 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.

5.3.3.2.-M ARCADORES ESPECIALES DE @ En la siguiente tabla podemos observar los marcadores especiales de @: MARCADORES ESPECIALES DE @ @version

@author

@see

@exception

@returns

@param

@deprecated

DESCRIPCIÓN 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. 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. 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. 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. 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. 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. 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.

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