1

“Año del centenario del descubrimiento de Macchu Picchu para el mundo”

Facultad de Ingeniería Y Arquitectura

Escuela Académico Profesional de Ingeniería de Sistemas E Informática

Castellano II

Lic. María Subiría R.

Java

Carlos Alberto Porras Porta

2011176027

Semestre II - 2011 IIC

Chosica, diciembre del 2011

2

Dedico este trabajo a mi familia por el apoyo que

me brindan día a día para poder cumplir mis metas,

mis sueños, gracias a ese apoyo eh podido lograr lo

que hasta ahora no hubiese sido posible sin ellos.

3

ÍNDICE

Índice…………………………………………………………………………………………………..………….3

Introducción………………………………………………………………………………………………………4

Capítulo I:

1.1 Origen de Java…………………………………………………………………….…………..………….…5.

1.2 Características de Java…………………………………………………………….

………………………………………….….6

1.2.1 Simplicidad……………………………………………………………………………………..7

1.2.2 Orientada a objetos……………………………………………………………...…………….8

1.2.3 Distribuido ………………………………………………………………………..……………8

1.2.4 Independiente de la plataforma………………………………………………………………8

1.2.5 Robusto…………………………………………………………………………………………9

1.2.6 Multiprogramación……………………………………………………………..………………9

1.3 lo nuevo en java……………………………………………………………………………...………………9

1.4 Tipos de programas en Java………………………………………………………………………………10

Applets……………………………………………………………………………………………………….10

Aplicaciones……………………………………………………………………………….…..……………10

Servlets……………………………………………………………………….….…………...……………..10

Capítulo II:

2.1 Sintaxis de Java…………………………………………………………………….………………………11

2.1.1. Comentarios…………………………………………………………….………………………11

2.1.2. Literales………………………………………………………………….………………………12

2.1.3. Palabras reservadas………………………………………………………...…………………12

2.1.4. Declaración de variables………………………………………………………………………13

2.1.5. Nomenclatura de Variables……………………………………………………………………13

2.1.6. Expresiones y Operadores………………………………………………….…………………14

2.1.7. Controles de Flujo…………………………………………………………..………………….16

2.1.7.1 estructuras de decisión o salto………………………………………….…………………..16

Instrucciones if – else…………………………………………………………………………16

Instrucción switch………………………………………………………….………………….17

2.1.7.2 estructuras de iteración…………………………………………………..………………….17

Instrucción for…………………………………………………………………………………18

Instrucción while…………………………………………………………….………………..18

4

Instrucción do………………………………………………………..………….………………18

Capítulo III:

3.1 clases…………………………………………………………………………………….…….……………20

3.1.1 la clase math…………………………………………………………………….………………20

3.1.1.1 funciones matemáticas………………………………………………….…………….20

3.1.2 la clase carácter…………………………………………………………………………………21

3.1.3 la clase float……………………………………………………………..………………………22

3.1.4 la clase double………………………………………………………….………………………22

3.1.5 la clase integer…………………………………………………………….……………………22

3.1.6 la clase long……………………………………………………………….…………………….23

3.1.7 la clase boolean………………………………………………………….……………………..23

3.1.8 la clase String ……………………………………………………………..……………………24

Capítulo IV:

4.1 Ventajas de Java……………………………………………………………………………...…………….24

4.1.1 Desarrollo rápido de aplicaciones……………………………………………………..………24

4.1.2 Aplicaciones efectivas y eficientes…………………………………………………………….25

4.1.3 Portabilidad para programador y programa……………………………………….…………26

4.1.4 Costes de desarrollo………………………………………………………………..…………..26

4.1.5 Mantenimiento y soporte……………………………………………………………………….27

4.1.6 Aprendizaje………………………………………………………………..…………………….27

4.2 desventajas de java..........................................................................................................................28

4.2.1 El lenguaje………………………………………………………………………..…………….28

4.2.2 Apariencia………………………………………………………………………..……………..28

4.2.3 Rendimiento………………………………………………………………………..……………29

Capitulo V:

5.1 programa básico en java……………………………………………………………...……………………30

5.1.1 una pequeña aplicación en java……………………………………………………….………30

5.2 Conclusiones………………………………………………………………………………..………………32

Bibliografía……………………………………………………………………………………………...………..33

5

INTRODUCCIÓN

Con la necesidad de crear un lenguaje de programación mejor en muchos aspectos que sus

antecesores, java se convierte en una buena opción para este fin, ya que proporciona una forma

diferente de hacer que los navegadores sean capaz de ejecutar programas. Con Java se puede

reproducir sonidos directamente desde el navegador, se pueden visitar páginas web con animaciones,

se puede enseñar al navegador a manejar nuevos formatos de ficheros, e incluso, cuando se pueda

transmitir video por las líneas telefónicas, nuestro navegador estará preparado para mostrar esas

imágenes.

Utilizando Java, se pueden eliminar los inconvenientes de interfaz y también se pueden añadir

aplicaciones que vayan desde experimentos científicos interactivos de propósito educativo a juegos o

aplicaciones especializadas para la televenta. Por ejemplo, alguien podría escribir un programa Java

que implementara una simulación química interactiva (una cadena de adn). Utilizando un navegador

con soporte Java, un usuario podría recibir fácilmente esa simulación e interaccionar con ella, en lugar

de conseguir simplemente un dibujo estático y algo de texto. Lo recibido cobra vida. Además, con

Java podemos estar seguros de que el código que hace funcionar el experimento químico no contiene

ningún trozo de código malicioso que dañe al sistema. El código que intente actuar destructivamente o

que contenga errores, no podrá traspasar los muros defensivos colocados por las características de

seguridad y robustez de Java.

Este trabajo es un resumen de lo que ya hemos llevado hasta ahora en la carrera de ingeniería de

sistemas en la UAP, no hay nada que no hallamos llevado en el transcurso de este ciclo y puede ser

tomado en cuenta como una guía en caso no recordemos o nos falte consolidar alguna tema sobre

JAVA.

6

CAPÍTULO I:

ORIGEN DE JAVA

Sun Microsystems, líder en servidores para Internet, es quien ha desarrollado el lenguaje Java, en un

intento de resolver simultáneamente todos los problemas que se le plantean a los desarrolladores de

software por la proliferación de arquitecturas incompatibles, tanto entre las diferentes máquinas como

entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma

máquina, añadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet.

Hemos podido leer más de cinco versiones distintas sobre el origen, concepción y desarrollo de Java,

desde la que dice que este fue un proyecto que rebotó durante mucho tiempo por distintos

departamentos de Sun sin que nadie le prestara ninguna atención, hasta que finalmente encontró su

nicho de mercado en la aldea global que es Internet; hasta la más difundida, que justifica a Java como

lenguaje de pequeños electrodomésticos.

Hace algunos años, Sun Microsystems decidió intentar introducirse en el mercado de la electrónica de

consumo y desarrollar programas para pequeños dispositivos electrónicos. Tras unos comienzos

dudosos, Sun decidió crear una filial, denominada FirstPerson Inc., para dar margen de maniobra al

equipo responsable del proyecto.

El mercado inicialmente previsto para los programas de FirstPerson eran los equipos domésticos:

microondas, tostadoras y, fundamentalmente, televisión interactiva. Este mercado, dada la falta de

pericia de los usuarios para el manejo de estos dispositivos, requería unos interfaces mucho más

cómodos e intuitivos que los sistemas de ventanas que proliferaban en el momento.

Otros requisitos importantes a tener en cuenta eran la fiabilidad del código y la facilidad de desarrollo.

James Gosling, el miembro del equipo con más experiencia en lenguajes de programación, decidió

que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y

depuración. Gosling había estado trabajando en su tiempo libre en un lenguaje de programación que

él había llamado Oak, el cual, aun partiendo de la sintaxis de C++, intentaba remediar las deficiencias

que iba observando.

Los lenguajes al uso, como C o C++, deben ser compilados para un chip, y si se cambia el chip, todo

el software debe compilarse de nuevo. Esto encarece mucho los desarrollos y el problema es

especialmente acusado en el campo de la electrónica de consumo. La aparición de un chip más

barato y, generalmente, más eficiente, conduce inmediatamente a los fabricantes a incluirlo en las

nuevas series de sus cadenas de producción, por pequeña que sea la diferencia en precio ya que,

7

multiplicada por la tirada masiva de los aparatos, supone un ahorro considerable. Por tanto, Gosling

decidió mejorar las características de Oak y utilizarlo.

El primer proyecto en que se aplicó este lenguaje recibió el nombre de proyecto Green y consistía en

un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. Para ello se

construyó un ordenador experimental denominado *7 (Star Seven). El sistema presentaba una interfaz

basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una

pantalla sensible al tacto. En el sistema aparecía Duke, la actual mascota de Java.

Posteriormente se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se

empleaba como interfaz para la televisión interactiva. Ninguno de estos proyectos se convirtió nunca

en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo y fueron como

su bautismo de fuego.

Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran

éxito, urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios.

No lo consiguieron y FirstPerson cerró en la primavera de 1994.

Pese a lo que parecía ya un olvido definitivo, Bill Joy, cofundador de Sun y uno de los desarrolladores

principales del Unix de Berkeley, juzgó que Internet podría llegar a ser el campo de juego adecuado

para disputar a Microsoft su primacía casi absoluta en el terreno del software, y vio en Oak el

instrumento idóneo para llevar a cabo estos planes. Tras un cambio de nombre y modificaciones de

diseño, el lenguaje Java fue presentado en sociedad en agosto de 1995.

Lo mejor será hacer caso omiso de las historias que pretenden dar carta de naturaleza a la

clarividencia industrial de sus protagonistas; porque la cuestión es si independientemente de su origen

y entorno comercial, Java ofrece soluciones a nuestras expectativas. Porque tampoco vamos a

desechar la penicilina aunque haya sido su origen fruto de la casualidad.

Características de Java.

Las características principales que nos ofrece Java respecto a cualquier otro lenguaje de

programación, son:

Simplicidad

Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas y

más confusas de éstos. Java elimina muchas de las características de otros lenguajes como C++,

para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el

garbage collector (reciclador de memoria dinámica).

8

En Java ya no es necesario preocuparse de liberar memoria.

Reduce en un 50% los errores más comunes de programación con lenguajes como C y C++ al

eliminar muchas de las características de éstos, entre las que destacan:

aritmética de punteros

no existen referencias

registros (struct)

definición de tipos (typedef)

macros (#define)

necesidad de liberar memoria (free)

Orientado a Objetos

Java implementa la tecnología básica de C++ con algunas mejoras, Java trabaja con sus datos como

objetos y con interfaces a esos objetos. Soporta las tres características propias del paradigma de la

orientación a objetos: encapsulación, herencia y polimorfismo.

Distribuido

Java se ha construido con extensas capacidades de interconexión TCP/IP. Existen librerías de rutinas

para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder a

la información a través de la red con tanta facilidad como a los ficheros locales.

Independiente de la Plataforma

Para establecer Java como parte integral de la red, el compilador Java compila su código a un fichero

objeto de formato independiente de la arquitectura de la máquina en que se ejecutará. Cualquier

máquina que tenga el sistema de ejecución (run-time) puede ejecutar ese código objeto, sin importar

en modo alguno la máquina en que ha sido generado.

Actualmente existen sistemas run-time para Solaris 2.x, SunOs 4.1.x, Windows 95, Windows NT,

Linux, Irix, Aix, Mac, Apple y probablemente haya grupos de desarrollo trabajando en el porting a otras

plataformas.

El código fuente Java se "compila" a un código de bytes de alto nivel independiente de la máquina.

Este código (byte-codes) está diseñado para ejecutarse en una máquina hipotética que es

implementada por un sistema run-time, que sí es dependiente de la máquina.

En una representación en que tuviésemos que indicar todos los elementos que forman parte de la

arquitectura de Java sobre una plataforma genérica, obtendríamos una figura como la siguiente:

9

En ella podemos ver que lo verdaderamente dependiente del sistema es la Máquina Virtual Java

(JVM) y las librerías fundamentales, que también nos permitirían acceder directamente al hardware de

la máquina. Además, habrá APIs de Java que también entren en contacto directo con el hardware y

serán dependientes de la máquina.

Robusto

Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de

ejecución. La comprobación de tipos en Java ayuda a detectar errores, lo antes posible, en el ciclo de

desarrollo. Java obliga a la declaración explícita de métodos, reduciendo así las posibilidades de error.

Maneja la memoria para eliminar las preocupaciones por parte del programador de la liberación o

corrupción de memoria. También implementa los arrays auténticos, en vez de listas enlazadas de

punteros, con comprobación de límites, para evitar la posibilidad de sobreescribir o corromper

memoria resultado de punteros que señalan a zonas equivocadas. Estas características reducen

drásticamente el tiempo de desarrollo de aplicaciones en Java.

Además, para asegurar el funcionamiento de la aplicación, realiza una verificación de los byte-codes,

que son el resultado de la compilación de un programa Java. Es un código de máquina virtual que es

interpretado por el intérprete Java. No es el código máquina directamente entendible por el hardware,

pero ya ha pasado todas las fases del compilador: análisis de instrucciones, orden de operadores,

etc., y ya tiene generada la pila de ejecución de órdenes.

Multiprogramación

Al ser multithreaded (multihilvanado, en mala traducción), Java permite muchas actividades

simultáneas en un programa. Los threads (a veces llamados, procesos ligeros), son básicamente

pequeños procesos o piezas independientes de un gran proceso. Al estar los threads construidos en

el lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++.

El beneficio de ser multithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento

en tiempo real. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema

operativo subyacente (Unix, Windows, etc.), aún supera a los entornos de flujo único de programa

(single-threaded) tanto en facilidad de desarrollo como en rendimiento.

Lo nuevo en JAVA

La gran novedad que aporta Java dentro de las nuevas generaciones de navegadores es la capacidad

de desplazar el control de la interactividad de los servidores hacia las máquinas de los usuarios que

se utilizan para recorrer Internet. Por la misma estructura del lenguaje, los nuevos navegadores

permiten la telecarga de "applets", pequeños fragmentos de programas compactos, precompilados,

10

que pueden entonces interpretar de modo distinto los datos telecargados para producir por ejemplo

animaciones, sonido y especialmente la verdadera interactividad.

El lenguaje Java, visto desde un navegador de Internet, es pues un lenguaje que no es ni totalmente

interpretado, ni totalmente compilado. El lenguaje se transforma en un código elemental parecido al

ensamblador, llamado también p-code o byte-code.

Posee la particularidad de ser compacto y por tanto puede ser compilado (traducido a lenguaje

máquina) muy rápidamente, en el transcurso de la propia ejecución del programa. El p-code constituye

una capa intermedia que facilita enormemente la portabilidad de un entorno o de una máquina a otra.

La facilita hasta el punto de lograrla desaparecer.

Aparece entonces la "máquina virtual". Una máquina virtual es una capa lógica que hace creer al

programa Java que se ejecuta en un ordenador real (con registros, memoria y procesador), cuando en

realidad sólo ve una reconstrucción lógica de un ordenador.

Para ejecutar un programa Java compilado (que está en p-code), es preciso también que cuente con

una implementación de la máquina virtual específica donde se desea ejecutar, la cual efectúa la

transformación del p-code en un programa comprensible para la máquina.

Tipos de programas en Java 

Los programas en Java suelen estar en una de las siguientes categorías: 

Applets  

Los applets son pequeños programas que se incorporan en una página Web y que por lo tanto,

necesitan de un Navegador Web compatible con Java para poder ejecutarse. A menudo los applets se

descargan junto con una página HTML desde un Servidor Web y se ejecutan en la máquina cliente. 

Aplicaciones  

Las aplicaciones son programas standalone de propósito general que normalmente se ejecutan desde

la línea de comandos del sistema operativo. Con Java se puede realizar cualquier programa que

normalmente se crearía con algún otro lenguaje de programación. 

Servlets  

Los servlets al contrario de los applets son programas que están pensados para trabajar en el lado del

servidor y desarrollar aplicaciones Web que interactúen con los clientes. Los servlets son una

alternativa de la programación CGI tradicional.

11

Capítulo II:

SINTAXIS DE JAVA

La sintaxis de un lenguaje define cómo se usarán las palabras claves, los operadores y las variables

para construir y evaluar expresiones. La sintaxis de Java especifica como se escribirán los siguientes

elementos:

Comentarios:

Java ofrece tres tipos de comentarios: dos para comentarios regulares en el código fuente y uno para

la documentación especial del sistema javadoc. 

Comentarios de varias líneas.  

Los comentarios de varias líneas se incluyen entre los símbolos /* y */, como en C y C++.

/*

Este es un ejemplo de un comentario de varias líneas.

*/

Comentarios de una sola línea. 

Para comentariar una sola línea se utiliza la doble diagonal //. El comentario se inicia cuando se

encuentra la doble diagonal y continua hasta el final de la línea.

// Este es un comentario de una sola linea

Comentarios para documentación.  

Realmente este tipo de comentario es el mismo que el de varias líneas con la diferencia de que la

información que contenga será usada para un procesamiento especial que lleva a cabo la

herramienta javadoc. 

Se distingue del comentario de varias líneas porque se agrega un asterisco adicional al inicio del

comentario.

/**

Este tipo de comentarios los utiliza la herramienta javadoc

*/

12

Literales:

Un literal es cualquier número, texto o información que representa directamente un valor.

Literales numéricos:

Para representar un literal de tipo long anteponga una L al número (long total = 10L;)

Para representar un literal negativo anteponga un – (long total = -10L;)

Para representar un literal con notación octal anteponga un 0 al número (int total = 010;)

Para representar un literal con notación hexadecimal anteponga un 0x al número (int total

= 0xFF;)

Para representar un literal de punto flotante se utiliza un punto (.) para el punto decimal

(double numero = 2.50;), todas estas literales se consideran double.

Para especificar un literal de punto flotante como float anteponga la letra f (f o F) (float

numero = 3.1416F;)

Para representar notación exponencial utilice la letra e (double x = 12e22;)

Literales booleanos

Los valores true y false son literales, y son los únicos valores posibles para las variables booleanas

Literales de caracteres

Es un carácter sencillo entre comillas sencillas como ‘a’, ‘#’ y ‘3’.

Literales de cadena

Es una cadena de caracteres entre comillas dobles como “Esto es una cadena”.

Como las cadenas en Java son objetos reales, contienen métodos para combinar cadenas,

modificarlas y determinar si dos cadenas poseen el mismo valor.

Java almacena el valor de una cadena como un objeto String, por lo tanto solo se debe crear un

nuevo objeto explícitamente, por lo que son tan fáciles de utilizar como los tipos de dato básicos.

Palabras reservadas

Las siguientes son las palabras reservadas que están definidas en Java y que no se pueden utilizar

como identificadores:

abstract continue for new switch

13

boolean default goto null synchronized

break Do if package this

byte double implements private threadsafe

byvalue Else import protected throw

case extends instanceof public transient

catch False int return true

char Final interface short try

class Finally long static void

const Float native super while

Pero en general Java posee muchas ventajas y se pueden hacer cosas muy interesantes con esto.

Hay que prestar especial atención a lo que está sucediendo en el mundo de la computación, a pesar

de que Java es relativamente nuevo, posee mucha fuerza y es tema de moda en cualquier medio

computacional. Muchas personas apuestan a futuro y piensan en Java.

Declaración de variables

Se declaran anteponiendo el tipo de dato o clase a la cual pertenecen.

Para las variables del mismo tipo, se pueden declarar en la misma línea separándolas por comas..

Ejemplo

int total;

String ciudad, calle, provincia = “Buenos Aires” ;

boolean activo = true;

Nomenclatura de Variables

Los nombres de variables deben comenzar con una letra, un carácter de subrayado ( _ ) o un signo

pesos ($). No pueden empezar con un número. Después del primer carácter pueden incluir cualquier

combinación.

Java es sensible a minúsculas y mayúsculas, esto permite tener una variable llamada X y otra llamada

x.

14

El estándar recomendado es para el nombramiento de variables es:

La primera letra minúscula.

Cada palabra después del nombre de la variable empieza con mayúscula. (Ej. areaCodigo)

Todas las demás letras son minúsculas

Expresiones y Operadores

Una expresión es una instrucción que produce un valor.

Por ejemplo:

int x = 3;

int y = 4;

int z = x * y; // Expresión

Un operador es un símbolo especial utilizado para funciones matemáticas, algunos tipos de

instrucciones de asignación y comparaciones lógicas.

Por ejemplo el * de la expresión anterior.

Operadores Aritméticos

Suma +

Resta -

Multiplicación *

División /

Módulo %

El lado derecho de una expresión siempre se calcula antes de que se dé la asignación. Por esta

razón la siguiente expresión es posible:

int x = 5;

x = x + 2;

Donde x ahora es 7.

Incremento y Decremento

15

Sirven para añadir o sustraer 1 a una variable.

Para incrementar se utiliza ++ (int x = 7; x = x++; ahora x vale 8).

Para decrementar se utiliza - - (int x = 7; x = x - -; ahora x vale 6).

Comparaciones

Son operaciones para hacer comparaciones entre las variables, variables y literales, u otros tipos de

información. Devuelven siempre un valor booleano.

Igual ==

Distinto ¡=

Menor que <

Mayor que >

Menor que o igual a <=

Mayor que o igual a >=

Operadores Lógicos

Las expresiones que producen valores booleanos, como las operaciones de comparación, se pueden

combinar para formar expresiones más complejas. Esto se maneja a través de operadores lógicos, los

cuales para las combinaciones lógicas:

AND: & o && (con && el lado derecho de la expresión nunca se evalúa), devuelve true solo si las dos

expresiones son verdaderas.

OR: | o || (con || el lado derecho de las expresión nunca se evalúa), devuelve true si alguna de las

expresiones son verdaderas.

XOR: ^, devuelve true solo si las dos expresiones booleanas que combina tienen valores opuestos. Si

ambas son true o false, devuelve false.

NOT. !, invierte el valor de una expresión booleana de la misma manera en que un símbolo menos

invierte el signo positivo en un número.

Precedencia de operadores

Es el orden de evaluación que posee Java cuando hay mas de un operador en una expresión.

El orden del primero al último es:

16

Operaciones de incremento y decremento

Operaciones aritméticas

Comparaciones

Operaciones lógicas

Expresiones de asignación

Para cambiar el orden en que se evalúan las operaciones se deben colocar paréntesis en las

expresiones que se quieren evaluar primero.

Aritmética de cadenas

El operador + también puede ser utilizado para concatenar cadenas.

El operador + combina cadenas, objetos y variables para formar una cadena sencilla.

También esta el operador corto += que añade algo al final de la cadena.

Ejemplo

miNombre += “Señor”;

Controles de Flujo

Estructuras de decisión o salto:

Instrucciones if – else

Estructura:

if (expresión boolean) {

//Bloque de código para expresiones verdaderas;

}

else {

// Bloque de código para expresiones falsas;

}

17

Siempre debe tomar una expresión booleana. El else es opcional y puede ser omitido si no existen

acciones a tomar en caso de no cumplirse la condición

Instrucción switch

Estructura:

Switch (expresión 1) {

Case constante2:

Bloque de código;

Break;

Case constante3:

Bloque de código;

Break;

Default:

Bloque de código;

Break;

}

La expresión 1 debe ser compatible con un tipo de dato entero. Los tipos de punto flotante, long o

clases no están permitidas.

El default es opcional, y es utilizado para especificar un segmento de código que es ejecutado si la

variable o expresión no matchea con ninguno de los case.

Si no hubiera un break como última instrucción dentro del código del case, el programa entrara al

código del próximo case sin evaluar la expresión.

Estructuras de Iteración

Las estructuras de lazo permiten repetir la ejecución del bloque de código que contengan.

En java existen tres tipos: for, while y do.

For y while evalúan la condición de lazo antes de ejecutar el bucle.

Do evalúa después de ejecutar el bucle. En este caso el bucle se ejecuta al menos una vez.

18

Instrucción for

Estructura:

For (expresión inicial; expresión booleana; alter_expresion3) {

Bloque de código;

}

En esta estructura está permitido utilizar comas para separar variables,

Ejemplo

for (int i = 0, j = 0; j < 10; i++, j++) {

Bloque de código;

}

La variable i es solo accesible dentro del bloque del for.

Instrucción while

Estructura:

While (boolean) {

Bloque de código;

}

Hay que asegurarse de que la variable utilizada en el while esté definida y sea verdadera antes de la

ejecución del mismo.

Instrucción do

Estructura:

Do {

Bloque de código;

} while (expresión booleana);

Hay que asegurarse de que la variable utilizada en el while esté definida y sea verdadera antes de la

ejecución del mismo.

19

Instrucciones especiales dentro de las estructuras de lazo:

Break [label]; // Es utilizada para salir de las instrucciones del switch, de las estructureas de lazo y de

los bloques con etiqueta de forma prematura.

Continue [label]; // Es usada para saltear el código y llegar hasta el final dentro de las estructuras de

lazo.

Label : instrucción; // Identifica con un nombre una instrucción válida a la que se le tranferirá el

control.

Ejemplo:

Do {

Bloque de código;

If (condición es true)

Break;

}

while (expresión booleana);

Do {

Bloque de código;

If (condición es true)

continue;

}

while (expresión booleana);

loop: //label

Do {

instrucción;

Do {

instrucción;

instrucción;

20

If (condición es true)

Break loop;

}

while (expresión booleana);

instrucción;

}

while (expresión booleana);

CAPITULO III:

CLASES:

La Clase Math

La clase Math representa la librería matemática de Java. Las funciones que contiene son las de todos

los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso

se encapsulan en Math, y lo mismo sucede con las demás clases que corresponden a objetos que

tienen un tipo equivalente (Character, Float, etc.). El constructor de la clase es privado, por los que no

se pueden crear instancias de la clase. Sin embargo, Math es public para que se pueda llamar desde

cualquier sitio y static para que no haya que inicializarla.

Funciones matemáticas

Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar:

Math.abs( x )          para int, long, float y double

Math.sin( double )

Math.cos( double )

Math.tan( double )

Math.asin( double )

Math.acos( double )

Math.atan( double )

Math.atan2( double,double )

Math.exp( double )

Math.log( double )

Math.sqrt( double )

Math.ceil( double )

Math.floor( double )

Math.rint( double )

21

Math.pow( a,b )

Math.round( x )       para double y float

Math.random()         devuelve un double

Math.max( a,b )       para int, long, float y double

Math.min( a,b )       para int, long, float y double

Math.E                para la base exponencial

Math.PI               para PI

He aquí un ejemplo, Mates.java, de uso de algunas funciones de la clase Math:

class Mates {

public static void main( String args[] ) {

int x;

double rand,y,z;

float max;

rand = Math.random();

x = Math.abs( -123 );

y = Math.round( 123.567 );

z = Math.pow( 2,4 );

max = Math.max( (float)1e10,(float)3e9 );

System.out.println( rand );

System.out.println( x );

System.out.println( y );

System.out.println( z );

System.out.println( max );

}

}

La Clase Character

Al trabajar con caracteres se necesitan muchas funciones de comprobación y traslación. Estas

funciones están empleadas en la clase Character. De esta clase sí que se pueden crear instancias, al

contrario que sucede con la clase Math.

Declaraciones

La primera sentencia creará una variable carácter y la segunda un objeto Character:

char c;

Character C;

22

La Clase Float

Cada tipo numérico tiene su propia clase de objetos. Así el tipo float tiene el objeto Float. De la misma

forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos

de la clase Float.

Declaraciones

La primera sentencia creará una variable float y la segunda un objeto Float:

float f;

Float F;

La Clase Double

Cada tipo numérico tiene su propia clase de objetos. Así el tipo double tiene el objeto Double. De la

misma forma que con la clase Character, se han codificado muchas funciones útiles dentro de los

métodos de la clase Double.

Declaraciones

La primera sentencia creará una variable double y la segunda un objeto Double:

double d;

Double D;

La Clase Integer

Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto Integer. De la misma

forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos

de la clase Integer.

Declaraciones

La primera sentencia creará una variable int y la segunda un objeto Integer:

int i;

Integer I;

Métodos de Integer

String Integer.toString( int i,int base );

String Integer.toString( int i );

int I.parseInt( String s,int base );

int I.parseInt( String s );

Integer Integer.valueOf( String s,int base );

Integer Integer.valueOf( String s );

int I.intValue();

long I.longValue();

float I.floatValue();

double I.doubleValue();

String I.toString();

23

int I.hashCode();

boolean I.equals( Object obj );

En los métodos toString(), parseInt() y valueOf() que no se especifica la base sobre la que se trabaja,

se asume que es base 10.

La Clase Long

Cada tipo numérico tiene su propia clase de objetos. Así el tipo long tiene el objeto Long. De la misma

forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos

de la clase Long.

Declaraciones

La primera sentencia creará una variable long y la segunda un objeto Long:

long l;

Long L;

Métodos de Long

String Long.toString( long l,int base );

String Long.toString( long l );

long L.parseLong( String s,int base );

long L.parseLong( String s );

Long Long.valueOf( String s,int base );

Long Long.valueOf( String s );

int L.intValue();

long L.longValue();

float L.floatValue();

double L.doubleValue();

String L.toString();

int L.hashCode();

boolean L.equals( Object obj );

En los métodos toString(), parseInt() y valueOf() que no se especifica la base sobre la que se trabaja,

se asume que es base 10.

La Clase Boolean

Los valores boolean también tienen su tipo asociado Boolean, aunque en este caso hay menos

métodos implementados que para el resto de las clases numéricas.

Declaraciones

La primera sentencia creará una variable boolean y la segunda un objeto Boolean:

boolean b;

Boolean B;

24

Valores de Boolean

Boolean.TRUE;

Boolean.FALSE;

La Clase String

Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer.

Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser

cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño

puede variar.

Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de las

funciones relacionadas con cadenas esperan valores String como argumentos y devuelven valores

String.

Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es

más conveniente usar Character que char. No obstante, char se usa, por ejemplo, para leer ficheros

que están escritos desde otro lenguaje.

Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas

funciones muy útiles para trabajar con ellas y, afortunadamente, la mayoría están codificadas en la

clase String.

CAPITULO IV

Ventajas y desventajas de java :

Desarrollo rápido de aplicaciones

Hace años, se decía que los programadores pronto desaparecerían. Los generadores automáticos de

programas, eliminarían a los generadores humanos y el mundo sería un lugar mejor para vivir.

Desafortunadamente, quienes decían esto no tuvieron en cuenta una acelerada demanda de software

de calidad para muy diferentes aplicaciones. Sin embargo, la tecnología de objetos pronto vino a

intentar facilitar la tarea, adoptando el modelo de "generar parte de un programa", así, generando la

parte básica de un programa (los objetos), se podría conectar con otras partes para proporcionar

diferentes utilidades al usuario.

El lenguaje C++ es una buena herramienta, pero no cumple totalmente la premisa. Visual Basic y

NextStep, se acercan cada vez más al poder de los objetos. Java facilita la creación de entornos de

desarrollo-aplicaciones de modo similar, pero además es flexible, poderoso y efectivo. Los

programadores ahora disponen de herramientas de programación de calidad beta, que apuntan hacia

esa meta, como son el Java WorkShop de SunSoft, el entorno Java de Borland, el Café de Symantec,

25

y pronto, herramientas más sofisticadas como Netcode o FutureTense. Esto proporciona una gran

progresión a los entornos de desarrollo Java.

Aplicaciones efectivas y eficientes

Las aplicaciones que se crean en grandes empresas deben ser más efectivas que eficientes; es decir,

conseguir que el programa funcione y el trabajo salga adelante es más importante que el que lo haga

eficientemente. Esto no es una crítica, es una realidad de la programación corporativa. Al ser un

lenguaje más simple que cualquiera de los que ahora están en el cajón de los programadores, Java

permite a éstos concentrarse en la mecánica de la aplicación, en vez de pasarse horas y horas

incorporando APIs para el control de las ventanas, controlando minuciosamente la memoria,

sincronizando los ficheros de cabecera y corrigiendo los agónicos mensajes del linker. Java tiene su

propio toolkit para interfaces, maneja por sí mismo la memoria que utilice la aplicación, no permite

ficheros de cabecera separados (en aplicaciones puramente Java) y solamente usa enlace dinámico.

Muchas de las implementaciones de Java actuales son puros intérpretes. Los byte-codes son

interpretados por el sistema run-time de Java, la Máquina Virtual Java (JVM), sobre el ordenador del

usuario. Aunque ya hay ciertos proveedores que ofrecen compiladores nativos Just-In-Time (JIT). Si la

Máquina Virtual Java dispone de un compilador instalado, las secciones (clases) del byte-code de la

aplicación se compilarán hacia la arquitectura nativa del ordenador del usuario.

Los programas Java en ese momento rivalizarán con el rendimiento de programas en C++. Los

compiladores JIT no se utilizan en la forma tradicional de un compilador; los programadores no

compilan y distribuyen binarios Java a los usuarios. La compilación JIT tiene lugar a partir del byte-

code Java, en el sistema del usuario, como una parte (opcional) del entorno run-time local de Java.

Muchas veces, los programadores corporativos, ansiosos por exprimir al máximo la eficiencia de su

aplicación, empiezan a hacerlo demasiado pronto en el ciclo de vida de la aplicación. Java permite

algunas técnicas innovadoras de optimización. Por ejemplo, Java es inherentemente multithreaded, a

la vez que ofrece posibilidades de multithread como la clase Thread y mecanismos muy sencillos de

usar de sincronización; Java en sí utiliza threads. Los desarrolladores de compiladores inteligentes

pueden utilizar esta característica de Java para lanzar un thread que compruebe la forma en que se

está utilizando la aplicación. Más específicamente, este thread podría detectar qué métodos de una

clase se están usando con más frecuencia e invocar a sucesivos niveles de optimización en tiempo de

ejecución de la aplicación. Cuanto más tiempo esté corriendo la aplicación o el applet, los métodos

estarán cada vez más optimizados (Guava de Softway es de este tipo).

Si un compilador JIT está embebido en el entorno run-time de Java, el programador no se preocupa

de hacer que la aplicación se ejecute óptimamente. Siempre he pensado que en los Sistemas

26

Operativos tendría que aplicarse esta filosofía; un optimizador progresivo es un paso más hacia esta

idea.

Portabilidad para programador y programa

En una empresa de relativo tamaño hay una pléyade diferente de ordenadores. Probablemente nos

encontremos con estaciones de trabajo Sun para el desarrollo de software, hordas de PCs para cada

empleado, algún Mac en el departamento de documentación, una estación de trabajo HP en

administración y una estación SGI en la sala de demos. Desarrollar aplicaciones corporativas para un

grupo tan diferente de plataformas en excesivamente complejo y caro. Hasta ahora era complicado

convencer a los programadores de cada arquitectura que utilizasen un API común para reducir el

coste de las aplicaciones.

Con un entorno run-time de Java portado a cada una de las arquitecturas de las plataformas

presentes en la empresa y una buena librería de clases ("packages" en Java), los programadores

pueden entenderse y encontrar muy interesante trabajar con Java. Esta posibilidad hará tender a los

programadores hacia Java, justo donde otros intentos anteriores con entornos universales (como

Galaxy o XVT) han fracasado. Estos APIs eran simplemente inadecuados, no orientados a redes y,

verdaderamente, pesados.

Una vez que los programas estén escritos en Java, otro lado interesante del asunto es que los

programadores también son portables. El grupo de programadores de la empresa puede ahora

enfrentarse a un desarrollo para cualquiera de las plataformas. La parte del cliente y del servidor de

una aplicación estarán ahora escritas en el mismo lenguaje. Ya no será necesario tener un grupo que

desarrolle en Solaris en del departamento de I+D, programadores trabajando sobre Visual Basic en el

departamento de documentación y programadores sobre GNU en proyectos especiales; ahora todos

ellos podrán estar juntos y formar el grupo de software de la empresa.

Costes de desarrollo

En contraste con el alto coste de los desarrollos realizados sobre estaciones de trabajo, el coste de

creación de una aplicación Java es similar al de desarrollar sobre un PC.

Desarrollar utilizando un software caro para una estación de trabajo (ahora barata) es un problema en

muchas empresas. La eficiencia del hardware y el poco coste de mantenimiento de una estación de

trabajo Sun, por ejemplo, resulta muy atractivo para las empresas; pero el coste adicional del entorno

de desarrollo con C++ es prohibitivo para la gran mayoría de ellas. La llegada de Java e Intranet

reducen considerablemente estos costes. Las herramientas Java ya no están en el entorno de precios

de millones de pesetas, sino a los niveles confortables de precio de las herramientas de PCs. Y con el

27

crecimiento cada día mayor de la comunidad de desarrolladores de software freeware y shareware

que incluso proporcionan el código fuente, los programadores corporativos tienen un amplio campo

donde moverse y muchas oportunidades de aprender y muchos recursos a su disposición.

El éxito que Internet ha proporcionado a los equipos de software corporativos es un regalo. El precio

del software es ahora el mismo para un poderoso equipo corriendo Unix que para un PC. Incluso

Netscape tiene al mismo precio la versión Unix de su servidor Web SuiteSpot que la versión PC/NT.

Esta es la filosofía de precios que parece ser será la que se siga con las herramientas basadas en

Java.

Mantenimiento y soporte

Un problema bien conocido que ocurre con el software corporativo es la demanda de cuidados y

realimentación. Java no es, ciertamente, la cura para la enfermedad del mantenimiento, pero tiene

varias características que harán la vida del enfermero más fácil.

Uno de los componentes del JDK es javadoc. Si se usan ciertas convenciones en el código fuente

Java (como comenzar un comentario con /** y terminarlo con */), javadoc se puede fácilmente generar

páginas HTML con el contenido de esos comentarios, que pueden visualizarse en cualquier

navegador. La documentación del API de Java ha sido creada de este modo. Esto hace que el trabajo

de documentar el código de nuevas clases Java sea trivial.

Otro gran problema del desarrollador corporativo es la creación y control de makefiles. Leerse un

makefile es como estar leyendo la historia de empresa. Normalmente se pasan de programador a

programador, quitando la información que no es esencial, siempre que se puede. Esto hace que

muchos de los makefiles de las aplicaciones contengan docenas de librerías, una miríada de ficheros

de cabecera y ultra-confusos macros. Es como mirar en el estómago de la ballena de Jonás.

Java reduce las dependencia de complejos makefiles drásticamente. Primero, no hay ficheros de

cabecera. Java necesita que todo el código fuente de una clase se encuentre en un solo fichero. Java

tiene la inteligencia de make en el propio lenguaje para simplificar la compilación de byte-codes.

En el libro Just Java de Peter van der Linden hay un capítulo excelente acerca del compilador de

Java, si tienes oportunidad, no dejes de leerlo.

Aprendizaje

Si la empresa está llena de programadores de C++ con alguna experiencia en el manejo de librería

gráfica, aprenderán rápidamente lo esencial de Java. Si el equipo de ingenieros no conoce C++, pero

28

maneja cualquier otro lenguaje de programación orientada a objetos, les llevará pocas semanas

dominar la base de Java. Lo que sí que no es cierto es que haya que aprender C++ antes de aprender

Java.

Si los ingenieros de la empresa no conocen ningún lenguaje orientado a objetos, sí que tienen que

aprender los fundamentos de esta tecnología antes de nada, y luego aplicarlos a la programación con

Java. El análisis y diseño orientado a objetos debe ser comprendido antes de intentar nada con Java.

Los programadores de Java sin un fondo de conocimientos de OOA/D producirán código pobre.

Además, los libros sobre Java crecen como la espuma, ya hay más de 25 publicados, y si buscas

"Progamming in Java" en la Red, encontrarás 312 Web sites, y 30 más dedicados a "Learning Java". Y

si esto, evidentemente, no es el sustituto de un instructor humano, hay ya varias empresas que

ofrecen enseñanza de Java, entre ellas, Sun.

Desventajas

En 1995 alguien dijo que Java fue creado para abrir una nueva vía en la gestión de software complejo, y es por regla general aceptado que se ha comportado bien en ese aspecto. Sin embargo no puede decirse que Java no tenga grietas, ni que se adapta completamente a todos los estilos de programación, todos los entornos, o todas las necesidades.

El lenguaje

En un sentido estricto, Java no es un lenguaje absolutamente orientado a objetos, a diferencia de,

por ejemplo, Ruby o Smalltalk. Por motivos de eficiencia, Java ha relajado en cierta medida el

paradigma de orientación a objetos, y así por ejemplo, no todos los valores son objetos.

El código Java puede ser a veces redundante en comparación con otros lenguajes. Esto es en

parte debido a las frecuentes declaraciones de tipos y conversiones de tipo manual (casting).

También se debe a que no se dispone de operadores sobrecargados, y a una sintaxis

relativamente simple. Sin embargo, J2SE 5.0 introduce elementos para tratar de reducir la

redundancia, como una nueva construcción para los bucles ‘’’foreach’’’.

A diferencia de C++, Java no dispone de operadores de sobrecarga definidos por el usuario. Los

diseñadores de Java tomaron esta decisión puesto que consideraban que, bajo ciertas

circunstancias, esta característica podía complicar la lectura y mantenimiento de los programas.

Apariencia

La apariencia externa (el ‘‘‘look and feel’’’) de las aplicaciones GUI (Graphical User Interface) escritas

en Java usando la plataforma Swing difiere a menudo de la que muestran aplicaciones nativas.

Aunque el programador puede usar el juego de herramientas AWT (Abstract Windowing Toolkit) que

genera objetos gráficos de la plataforma nativa, el AWT no es capaz de funciones gráficas avanzadas

sin sacrificar la portabilidad entre plataformas; ya que cada una tiene un conjunto de APIs distinto,

29

especialmente para objetos gráficos de alto nivel. Las herramientas de Swing, escritas completamente

en Java, evitan este problema construyendo los objetos gráficos a partir de los mecanismos de dibujo

básicos que deben estar disponibles en todas las plataformas. El inconveniente es el trabajo extra

requerido para conseguir la misma apariencia de la plataforma destino. Aunque esto es posible

(usando GTK+ y el Look-and-Feel de Windows), la mayoría de los usuarios no saben cómo cambiar la

apariencia que se proporciona por defecto por aquella que se adapta a la de la plataforma.

Rendimiento

El rendimiento de una aplicación está determinado por multitud de factores, por lo que no es fácil

hacer una comparación que resulte totalmente objetiva. En tiempo de ejecución, el rendimiento de una

aplicación Java depende más de la eficiencia del compilador, o la JVM, que de las propiedades

intrínsecas del lenguaje. El bytecode de Java puede ser interpretado en tiempo de ejecución por la

máquina virtual, o bien compilado al cargarse el programa, o durante la propia ejecución, para generar

código nativo que se ejecuta directamente sobre el hardware. Si es interpretado, será más lento que

usando el código máquina intrínseco de la plataforma destino. Si es compilado, durante la carga inicial

o la ejecución, la penalización está en el tiempo necesario para llevar a cabo la compilación.

Algunas características del propio lenguaje conllevan una penalización en tiempo, aunque no son

únicas de Java. Algunas de ellas son el chequeo de los límites de arrays, chequeo en tiempo de

ejecución de tipos, y la indirección de funciones virtuales.

El uso de un recolector de basura para eliminar de forma automática aquellos objetos no requeridos,

añade una sobrecarga que puede afectar al rendimiento, o ser apenas apreciable, dependiendo de la

tecnología del recolector y de la aplicación en concreto. Las JVM modernas usan recolectores de

basura que gracias a rápidos algoritmos de manejo de memoria, consiguen que algunas aplicaciones

puedan ejecutarse más eficientemente.

El rendimiento entre un compilador JIT y los compiladores nativos puede ser parecido, aunque la

distinción no está clara en este punto. La compilación mediante el JIT puede consumir un tiempo

apreciable, un inconveniente principalmente para aplicaciones de corta duración o con gran cantidad

de código. Sin embargo, una vez compilado, el rendimiento del programa puede ser comparable al

que consiguen compiladores nativos de la plataforma destino, inclusive en tareas numéricas. Aunque

Java no permite la expansión manual de llamadas a métodos, muchos compiladores JIT realizan esta

optimización durante la carga de la aplicación y pueden aprovechar información del entorno en tiempo

de ejecución para llevar a cabo transformaciones eficientes durante la propia ejecución de la

aplicación. Esta recompilación dinámica, como la que proporciona la máquina virtual HotSpot de Sun,

puede llegar a mejorar el resultado de compiladores estáticos tradicionales, gracias a los datos que

sólo están disponibles durante el tiempo de ejecución.

Java fue diseñado para ofrecer seguridad y portabilidad, y no ofrece acceso directo al hardware de la

arquitectura ni al espacio de direcciones. Java no soporta expansión de código ensamblador, aunque

30

las aplicaciones pueden acceder a características de bajo nivel usando bibliotecas nativas (JNI, Java

Native Interfaces).

CAPITULO V

Programas Básicos En Java

Una pequeña aplicación en java

Sin duda alguna el ejercicio más simple, y a la par, el que nunca puede faltar en cualquier lenguaje de

programación es el programa Hola Mundo. Este consiste en sacar por pantalla la muy conocida frase

de “Hola Mundo”.

Lo primero que tendremos que hacer es crear la estructura base de nuestro codigo que seria algo asi.

public class HolaMundo {

  public static void main(String[] args) {

       //Aqui se coloca el codigo a ejecutar

    }

 }

Solo nos quedará mostrar el texto "Hola Mundo" por la consola. Para ello utilizaremos la clase estática

System.out. Esta clase nos permite acceder a la salida de la consola. En concreto usaremos el

método println(texto).

Finalmente el código nos quedará de la siguiente forma:

public class HolaMundo {

 public static void main(String[] args) {

 System.out.println("Hola Mundo");

 }

}

Se puede hacer los mismo con ventanas usando la libreria swing utilizaremos el complemento

JOptionPane:

import javax.swing.*;

31

public class HolaMundo {

 public static void main(String[] args) {

 JOptionPane.ShowMessageDialog(null, "Hola Mundo");

 }

}

Con este complemento de la libreria swing, tambien se pueden recibir parametros con el InputDialog el

cual quedaria de esta forma:

import javax.swing.*;

public class HolaMundo {

 public static void main(String[] args) {

  String recibido = JOptionPane.showInputDialog("Cual es tu edad");

  JOptionPane.showMessageDialog(null, "Tu edad es "+recibido+" años");

 }

}

32

CONCLUSIONES:

Con todo lo investigado en este trabajo llegamos a la conclusión que para poder entender cualquier

tipo de lenguaje de programación es necesario tener un pensamiento matemático, y como se llega a

eso pues teniendo una buena base matemática, todo lo puesto en este trabajo son algunos

conocimientos adquiridos en este ciclo profundizados con ayuda de algunos libros, revistas, tutoriales,

artículos y seminarios que aportaron esta motivación de seguir aprendiendo este lenguaje de

programación.

33

BIBLIOGRAFÍA

http://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n)#Historia

http://www.taringa.net/posts/info/8556773.R/Curso-Interactivo-Java-al-Extremo_-Todo-sobre-

Java.html

http://clubensayos.com/Tecnolog%C3%ADa/CONCEPTOS-B%C3%81SICOS-DE-JAVA/

98747.html

http://www.oocities.org/gusdelact/cib4132005/Java.txt

http://www.inquisidores.net/tutoriales-y-videotutoriales/tutorial-de-java-desde-cero/+

"Programación en Java", Mora Rodríguez, Frank.Año: 2006

http://www.lawebdelprogramador.com

"Aprenda Java como si estuviera en Primero".García de Jalón, Javier. Rodríguez, José

Ignacio.y otros. Escuela Superior de Ingenieros Industriales. Universidad de Navarra. Marzo,

1999

Java Cómo Programar Quinta edición

Deitel/Deitel

Pearson/Prentice-Hall

Curso de Programación 3ª Edición

Fco. Cevallos

Editorial AlfaOmega

Programación en Java 2

Luis Joyanes Aguilar, Ignacio Zahonero Martínez

Mc Graw-Hill

Java con programación orientada a objetos y apicaciones en la WWW

Paul S. Wang

Internacional Thomson Editores