Universidad Nororiental Privada

“Gran Mariscal de Ayacucho”

Facultad de Ingeniería

Escuela: Informática

Núcleo Barcelona

Prof.:

Ing. Luz Rodríguez

Realizado por:

Hernández, Aida

C.I. 15.515.206

Octubre; 2014

Índice

Contenido Introducción .............................................................................................................................. 4

Orígenes de Java ....................................................................................................................... 6

Características de Java ............................................................................................................ 10

Es Simple: ............................................................................................................................ 10

Es Orientado a Objetos: ...................................................................................................... 11

Es Distribuido ...................................................................................................................... 12

Es Robusto ........................................................................................................................... 12

Es de Arquitectura Neutral ................................................................................................. 13

Es Seguro: ............................................................................................................................ 16

Es Portable: ......................................................................................................................... 19

Es Interpretado: .................................................................................................................. 19

Es Multithreaded: ............................................................................................................... 21

Es Dinámico: ........................................................................................................................ 21

Versiones de Java .................................................................................................................... 23

Últimas versiones y actualizaciones de la página de java ................................................... 29

Estructura de un programa en Java ........................................................................................ 30

Estructura ............................................................................................................................ 33

Class ................................................................................................................................ 33

Llaves ............................................................................................................................... 34

Variables.......................................................................................................................... 35

Corrección de errores ..................................................................................................... 38

Principales palabras reservadas en Java ................................................................................. 39

Principales funciones en java .................................................................................................. 41

Instrucción Return............................................................................................................... 42

Editores empleados para el trabajo con este lenguaje ........................................................... 46

Editplus ............................................................................................................................... 46

JGrasp .................................................................................................................................. 47

JCreator ............................................................................................................................... 48

NetBeans ............................................................................................................................. 48

Eclipse ................................................................................................................................. 50

Arquitectura .................................................................................................................... 51

Características ................................................................................................................. 53

Historia ............................................................................................................................ 53

Creación de una clase en java ................................................................................................. 54

Ejemplos de programas en Java .............................................................................................. 58

Ejercicio 1 ............................................................................................................................ 58

Ejercicio 2 ............................................................................................................................ 59

Ejercicio 3 ............................................................................................................................ 60

Ejercicio 4 ............................................................................................................................ 60

Ejercicio 5 ............................................................................................................................ 61

Ejercicio 6 ............................................................................................................................ 62

Ejercicio 7 ............................................................................................................................ 63

Conclusión ............................................................................................................................... 64

Bibliografía .............................................................................................................................. 65

Introducción

Java es un lenguaje de programación y una plataforma informática

comercializada por primera vez en 1995 por Sun Microsystems. El uso

principal que se hace de Internet e incluso de las redes internas

(corporativas) es correo electrónico (e-mail), aunque actualmente hay un

auge sorprendente de la navegación web. Los documentos web pueden

contener variedad de texto, gráficos de todas clases y proporcionar enlaces

hipertexto hacia cualquier lugar de la red. Los navegadores utilizan

documentos escritos en lenguaje HTML. La combinación actual de

navegadores HTML/WWW están limitados pues, a texto y gráficos. Si se

quiere reproducir un sonido o ejecutar un programa de demostración, primero

ha de bajarse (download) el fichero en cuestión y luego utilizar un programa

en el computador capaz de entender el formato de ese fichero, o bien cargar

un módulo ( plug-in ) en el navegador para que pueda interpretar el fichero

que se ha bajado.

Hasta ahora, la única forma de realizar una página web con contenido

interactivo, era mediante la interfaz CGI ( Common Gateway Interface ), que

permite pasar parámetros entre formularios definidos en lenguaje HTML y

programas escritos en Perl o en C. Esta interfaz resulta muy incómoda de

programar y es pobre en sus posibilidades.

El lenguaje Java y los navegadores con soporte Java, proporcionan una

forma diferente de hacer que ese navegador sea capaz de ejecutar

programas. Con Java se puede reproducir sonido directamente desde el

navegador, se pueden visitar home pages 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, el navegador

estará preparado para mostrar esas imágenes.

Utilizando Java, se pueden eliminar los inconvenientes de la interfaz CGI 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. Es posible implementar publicidad

interactiva y periódicos personalizados.

A continuación se describirán los conceptos básicos de java, orígenes,

versiones, principales palabras reservadas, principales funciones de java,

editores empleados para el trabajo con este lenguaje, creación de una clase

y ejemplos de programas con sus respectivos códigos.

Orígenes de Java

En Diciembre de 1950 Patrick Naughton, ingeniero de Sun

Microsystems, reclutó a varios colegas entre ellos James Gosling y Mike

Sheridan para trabajar sobre un nuevo proyecto conocido como "El proyecto

verde".

Con la ayuda de otros ingenieros, empezaron a trabajar en una pequeña

oficina en Sand Hill Road en Menlo Park, California. Y así interrumpió todas

las comunicaciones regulares con Sun y trabajó sin descanso durante 18

meses.

Intentaban desarrollar una nueva tecnología para programar la siguiente

generación de dispositivos inteligentes, en los que Sun veía un campo nuevo

a explorar. Crear un lenguaje de programación fácil de aprender y de usar.

En un principio se consideraba C++ como lenguaje a utilizar, pero tanto

Gosling como Bill Joy lo encontraron inadecuado. Gosling intentó primero

extender y modificar C++ resultando el lenguaje C++ ++ - (++ - porque se

añadían y eliminaban características a C++), pero lo abandonó para crear un

nuevo lenguaje desde cero al que llamo Oak (roble en inglés, según la

versión más aceptada, por el roble que veía através de la ventana de su

despacho).

El resultado fue un lenguaje que tenía similitudes con C, C++ y Objetive C y

que no estaba ligado a un tipo de CPU concreta.

Más tarde, se cambiaría el nombre de Oak a Java, por cuestiones de

propiedad intelectual, al existir ya un lenguaje con el nombre de Oak. Se

supone que le pusieron ese nombre mientras tomaban café (Java es nombre

de un tipo de café, originario de Asia), aunque otros afirman que el nombre

deriva de las siglas de James Gosling, Arthur Van Hoff, y Andy Bechtolsheim.

En Agosto de 1991 Oak ya corría sus primeros programas.

Para 1992, el equipo ya había desarrollado un sistema en un prototipo

llamado Star7 (*7), dispositivo parecido a una PDA, cuyo nombre venía de la

combinación de teclas del teléfono de la oficina del Proyecto Green que

permitía a los usuarios responder al teléfono desde cualquier lugar.

Por su parte, el presidente de la compañía Sun, Scott McNealy, se dio cuenta

de forma oportuna y estableció el Proyecto Verde como una subsidiaria de

Sun.

Después de mostrar a Scott McNealy y Bill Joy los prototipos de bajo nivel

del sistema, continuán con el desarrollo, incluyendo sistema operativo, Green

OS; el lenguaje Oak, las librerías, alguna aplicación básica y el hardware,

hasta que el 3 de septiembre de 1992 se termina el desarrollo y con ello el

Proyecto Verde.

De 1993 a 1994, el equipo de Naughton se lanzó en busca de nuevas

oportunidades en el mercado, mismas que se fueron dando mediante el

sistema operativo base.

La incipiente subsidiaria fracasó en sus intentos de ganar una oferta con

Time-Warner, sin embargo el equipo concluyó que el mercado para

consumidores electrónicos smart y las cajas Set-Up en particular, no eran del

todo eficaces. La subsidiaria Proyecto verde fue amortizada por la compañía

Sun a mediados de 1994.

Afortunadamente, el cese del Proyecto Verde coincidió con el nacimiento del

fenómeno mundial WEB. Al examinar las dinámicas de Internet, lo realizado

por el ex equipo verde se adecuaba a este nuevo ambiente.

Patrick Naughton procedió a la construcción del lenguaje de programación

Java que se accionaba con un browser prototipo. El 29 de septiembre de

1994 se termina el desarrollo del prototipo de HotJava. Cuando se hace la

demostración a los ejecutivos de Sun, esta vez, se reconoce el potencial de

Java y se acepta el proyecto.

Con el paso del tiempo HotJava se convirtió en un concepto práctico dentro

del lenguaje Java y demostró que podría proporcionar multiplataformas para

que el código pueda ser bajado y corrido del Host del World Wide Web y que

de otra forma no son seguros.

Una de las características de HotJava fue su soporte para los "applets", que

son las partes de Java que pueden ser cargadas mediante una red de trabajo

para después ejecutarlo localmente y así lograr soluciones dinámicas en

computación acordes al rápido crecimiento del ambiente WEB.

El 23 de mayo de 1995, en la conferencia SunWorld `95, John Gage, de Sun

Microsystems, y Marc Andreessen, cofundador y vicepresidente de

Netscape, anunciaban la versión alpha de Java, que en ese momento solo

corría en Solaris, y el hecho de que Java iba a ser incorporado en Netscape

Navigator, el navegador más utilizado de Internet.

Con la segunda alpha de Java en Julio, se añade el soporte para Windows

NT y en la tercera, en Agosto, para Windows 95.

En enero de 1995 Sun formá la empresa Java Soft para dedicarse al

desarrollo de productos basados en la tecnología Java, y así trabajar con

terceras partes para crear aplicaciones, herramientas, sistemas de

plataforma y servicios para aumentar las capacidades del lenguaje. Ese

mismo mes aparece la versión 1.0 del JDK.

Netscape Communications decide apoyar a Java applets en Netscape

Navigator 2.0. Ese fue el factor clave que lanzó a Java a ser conocido y

famoso.

Y como parte de su estrategia de crecimiento mundial y para favorecer la

promoción de la nueva tecnología, Java Soft otorgó permisos para otras

compañías para que pudieran tener acceso al código fuente y al mismo

tiempo mejorar sus navegadores.

También les permitía crear herramientas de desarrollo para programación

Java y los facultaba para acondicionar máquinas virtuales Java (JVM), a

varios sistemas operativos.

Muy pronto las licencias o permisos contemplaban prestigiosas firmas como:

IBM, Microsoft, Symantec, Silicon Graphics, Oracle, Toshiba y Novell.

Los apples Java (basados en JDK 1.02) son apoyados por los dos más

populares navegadores web (Nestcape Navigator 3.0 y Microsoft Internet

Explorer 3.0. I.B.M./Lotus, Computer Asociates, Symantec, Informix, Oracle,

Sybase y otras poderosas empresas de software están construyendo

Software 100% puro JAVA, por ejemplo el Corel Office que actualmente está

en versión Beta.

Los nuevos proyectos de Java son co-patrocinados por cientos de millones

de dólares en capital disponible de recursos tales como la Fundación Java,

un fondo común de capital formado el verano pasado por 11 compañías,

incluyendo Cisco Systems, IBM, Netscape y Oracle.

Características de Java

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

lenguaje de programación, son:

Es Simple:

Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las

características menos usadas y más confusas de éstos. C++ es un lenguaje

que adolece de falta de seguridad, pero C y C++ son lenguajes más

difundidos, por ello Java se diseñó para ser parecido a C++ y así facilitar un

rápido y fácil aprendizaje.

Java elimina muchas de las características de otros lenguajes como C++,

para mantener reducidas las especificaciones del lenguaje y añadir

características muy útiles como el garbage collector (reciclador de memoria

dinámica). No es necesario preocuparse de liberar memoria, el reciclador se

encarga de ello y como es un thread de baja prioridad, cuando entra en

acción, permite liberar bloques de memoria muy grandes, lo que reduce la

fragmentación de la memoria.

Java reduce en un 50% los errores más comunes de programación con

lenguajes como C y C++ al eliminar muchas de las características de éstos,

entre las que destacan:

aritmética de punteros

no existen referencias

registros (struct)

definición de tipos (typedef)

macros (#define)

necesidad de liberar memoria (free)

Aunque, en realidad, lo que hace es eliminar las palabras reservadas (struct,

typedef), ya que las clases son algo parecido.

Además, el intérprete completo de Java que hay en este momento es muy

pequeño, solamente ocupa 215 Kb de RAM.

Es Orientado a Objetos:

Java implementa la tecnología básica de C++ con algunas mejoras y

elimina algunas cosas para mantener el objetivo de la simplicidad del

lenguaje. 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. Las plantillas

de objetos son llamadas, como en C++, clases y sus copias, instancias .

Estas instancias, como en C++, necesitan ser construidas y destruidas en

espacios de memoria.

Java incorpora funcionalidades inexistentes en C++ como por ejemplo, la

resolución dinámica de métodos. Esta característica deriva del lenguaje

Objective C, propietario del sistema operativo Next. En C++ se suele trabajar

con librerías dinámicas (DLLs) que obligan a recompilar la aplicación cuando

se retocan las funciones que se encuentran en su interior. Este inconveniente

es resuelto por Java mediante una interfaz específica llamada RTTI (

RunTime Type Identification ) que define la interacción entre objetos

excluyendo variables de instancias o implementación de métodos. Las clases

en Java tienen una representación en el runtime que permite a los

programadores interrogar por el tipo de clase y enlazar dinámicamente la

clase con el resultado de la búsqueda.

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

La verdad es que Java en sí no es distribuido, sino que proporciona las

librerías y herramientas para que los programas puedan ser distribuidos, es

decir, que se corran en varias máquinas, interactuando.

Es 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 sobre escribir 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.

Java proporciona, pues:

Comprobación de punteros

Comprobación de límites de arrays

Excepciones

Verificación de byte-codes

Es de Arquitectura Neutral:

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:

En ella se puede ver que lo verdaderamente dependiente del sistema es la

Máquina Virtual Java (JVM) y las librerías fundamentales, que también

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, como ejemplo de este tipo de APIs

podemos citar:

Java 2D: gráficos 2D y manipulación de imágenes

Java Media Framework : Elementos críticos en el tiempo: audio,

video...

Java Animation: Animación de objetos en 2D

Java Telephony: Integración con telefonía

Java Share: Interacción entre aplicaciones multiusuario

Java 3D: Gráficos 3D y su manipulación

Es Seguro:

La seguridad en Java tiene dos facetas. En el lenguaje, características

como los punteros o el casting implícito que hacen los compiladores de C y

C++ se eliminan para prevenir el acceso ilegal a la memoria. Cuando se usa

Java para crear un navegador, se combinan las características del lenguaje

con protecciones de sentido común aplicadas al propio navegador.

El lenguaje C, por ejemplo, tiene lagunas de seguridad importantes, como

son los errores de alineación. Los programadores de C utilizan punteros en

conjunción con operaciones aritméticas. Esto le permite al programador que

un puntero referencie a un lugar conocido de la memoria y pueda sumar (o

restar) algún valor, para referirse a otro lugar de la memoria. Si otros

programadores conocen nuestras estructuras de datos pueden extraer

información confidencial del sistema. Con un lenguaje como C, se pueden

tomar números enteros aleatorios y convertirlos en punteros para luego

acceder a la memoria:

printf( "Escribe un valor entero: " );

scanf( "%u",&puntero );

printf( "Cadena de memoria: %sn",puntero );

Otra laguna de seguridad u otro tipo de ataque, es el Caballo de Troya. Se

presenta un programa como una utilidad, resultando tener una funcionalidad

destructiva. Por ejemplo, en UNIX se visualiza el contenido de un directorio

con el comando ls. Si un programador deja un comando destructivo bajo esta

referencia, se puede correr el riesgo de ejecutar código malicioso, aunque el

comando siga haciendo la funcionalidad que se le supone, después de lanzar

su carga destructiva. Por ejemplo, después de que el caballo de Troya haya

enviado por correo el /etc/shadow a su creador, ejecuta la funcionalidad de ls

presentando el contenido del directorio. Se notará un retardo, pero nada

inusual.

El código Java pasa muchos tests antes de ejecutarse en una máquina. El

código se pasa a través de un verificador de byte-codes que comprueba el

formato de los fragmentos de código y aplica un probador de teoremas para

detectar fragmentos de código ilegal -código que falsea punteros, viola

derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un

objeto-.

Si los byte-codes pasan la verificación sin generar ningún mensaje de error,

entonces sabemos que:

El código no produce desbordamiento de operandos en la pila

El tipo de los parámetros de todos los códigos de operación son

conocidos y correctos

No ha ocurrido ninguna conversión ilegal de datos, tal como convertir

enteros en punteros

El acceso a los campos de un objeto se sabe que es legal: public,

private, protected

No hay ningún intento de violar las reglas de acceso y seguridad

establecidas

El Cargador de Clases también ayuda a Java a mantener su seguridad,

separando el espacio de nombres del sistema de ficheros local, del de los

recursos procedentes de la red. Esto limita cualquier aplicación del tipo

Caballo de Troya, ya que las clases se buscan primero entre las locales y

luego entre las procedentes del exterior.

Las clases importadas de la red se almacenan en un espacio de nombres

privado, asociado con el origen. Cuando una clase del espacio de nombres

privado accede a otra clase, primero se busca en las clases predefinidas (del

sistema local) y luego en el espacio de nombres de la clase que hace la

referencia. Esto imposibilita que una clase suplante a una predefinida.

En resumen, las aplicaciones de Java resultan extremadamente seguras, ya

que no acceden a zonas delicadas de memoria o de sistema, con lo cual

evitan la interacción de ciertos virus. Java no posee una semántica

específica para modificar la pila de programa, la memoria libre o utilizar

objetos y métodos de un programa sin los privilegios del kernel del sistema

operativo. Además, para evitar modificaciones por parte de los crackers de la

red, implementa un método ultraseguro de autentificación por clave pública.

El Cargador de Clases puede verificar una firma digital antes de realizar una

instancia de un objeto. Por tanto, ningún objeto se crea y almacena en

memoria, sin que se validen los privilegios de acceso. Es decir, la seguridad

se integra en el momento de compilación, con el nivel de detalle y de

privilegio que sea necesario.

Dada, pues la concepción del lenguaje y si todos los elementos se mantienen

dentro del estándar marcado por Sun, no hay peligro. Java imposibilita,

también, abrir ningún fichero de la máquina local (siempre que se realizan

operaciones con archivos, éstas trabajan sobre el disco duro de la máquina

de donde partió el applet), no permite ejecutar ninguna aplicación nativa de

una plataforma e impide que se utilicen otros ordenadores como puente, es

decir, nadie puede utilizar nuestra máquina para hacer peticiones o realizar

operaciones con otra. Además, los intérpretes que incorporan los

navegadores de la Web son aún más restrictivos. Bajo estas condiciones (y

dentro de la filosofía de que el único ordenador seguro es el que está

apagado, desenchufado, dentro de una cámara acorazada en un bunker y

rodeado por mil soldados de los cuerpos especiales del ejército), se puede

considerar que Java es un lenguaje seguro y que los applets están libres de

virus.

Respecto a la seguridad del código fuente, no ya del lenguaje, JDK

proporciona un desemsamblador de byte-code, que permite que cualquier

programa pueda ser convertido a código fuente, lo que para el programador

significa una vulnerabilidad total a su código. Utilizando javap no se obtiene

el código fuente original, pero sí desmonta el programa mostrando el

algoritmo que se utiliza, que es lo realmente interesante. La protección de los

programadores ante esto es utilizar llamadas a programas nativos, externos

(incluso en C o C++) de forma que no sea descompilable todo el código;

aunque así se pierda portabilidad. Esta es otra de las cuestiones que Java

tiene pendientes.

Es Portable:

Más allá de la portabilidad básica por ser de arquitectura

independiente, Java implementa otros estándares de portabilidad para

facilitar el desarrollo. Los enteros son siempre enteros y además, enteros de

32 bits en complemento a 2. Además, Java construye sus interfaces de

usuario a través de un sistema abstracto de ventanas de forma que las

ventanas puedan ser implantadas en entornos Unix, Pc o Mac.

Es Interpretado:

El intérprete Java (sistema run-time) puede ejecutar directamente el

código objeto. Enlazar (linkar) un programa, normalmente, consume menos

recursos que compilarlo, por lo que los desarrolladores con Java pasarán

más tiempo desarrollando y menos esperando por el ordenador. No obstante,

el compilador actual del JDK es bastante lento. Por ahora, que todavía no

hay compiladores específicos de Java para las diversas plataformas, Java es

más lento que otros lenguajes de programación, como C++, ya que debe ser

interpretado y no ejecutado como sucede en cualquier programa tradicional.

Se dice que Java es de 10 a 30 veces más lento que C, y que tampoco

existen en Java proyectos de gran envergadura como en otros lenguajes. La

verdad es que ya hay comparaciones ventajosas entre Java y el resto de los

lenguajes de programación, y una ingente cantidad de folletos electrónicos

que supuran fanatismo en favor y en contra de los distintos lenguajes

contendientes con Java. Lo que se suele dejar de lado en todo esto, es que

primero habría que decidir hasta que punto Java, un lenguaje en pleno

desarrollo y todavía sin definición definitiva, está maduro como lenguaje de

programación para ser comparado con otros; como por ejemplo con

Smalltalk, que lleva más de 20 años en cancha.

La verdad es que Java para conseguir ser un lenguaje independiente del

sistema operativo y del procesador que incorpore la máquina utilizada, es

tanto interpretado como compilado. Y esto no es ningún contrasentido, me

explico, el código fuente escrito con cualquier editor se compila generando el

byte-code. Este código intermedio es de muy bajo nivel, pero sin alcanzar las

instrucciones máquina propias de cada plataforma y no tiene nada que ver

con el p-code de Visual Basic. El byte-code corresponde al 80% de las

instrucciones de la aplicación. Ese mismo código es el que se puede ejecutar

sobre cualquier plataforma. Para ello hace falta el run-time, que sí es

completamente dependiente de la máquina y del sistema operativo, que

interpreta dinámicamente el byte-code y añade el 20% de instrucciones que

faltaban para su ejecución. Con este sistema es fácil crear aplicaciones

multiplataforma, pero para ejecutarlas es necesario que exista el run-time

correspondiente al sistema operativo utilizado.

Es Multithreaded:

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

Cualquiera que haya utilizado la tecnología de navegación concurrente, sabe

lo frustrante que puede ser esperar por una gran imagen que se está

trayendo. En Java, las imágenes se pueden ir trayendo en un thread

independiente, permitiendo que el usuario pueda acceder a la información en

la página sin tener que esperar por el navegador.

Es Dinámico:

Java se beneficia todo lo posible de la tecnología orientada a objetos.

Java no intenta conectar todos los módulos que comprenden una aplicación

hasta el tiempo de ejecución. Las librerías nuevas o actualizadas no

paralizarán las aplicaciones actuales (siempre que mantengan el API

anterior).

Java también simplifica el uso de protocolos nuevos o actualizados. Si su

sistema ejecuta una aplicación Java sobre la red y encuentra una pieza de la

aplicación que no sabe manejar, tal como se ha explicado en párrafos

anteriores, Java es capaz de traer automáticamente cualquiera de esas

piezas que el sistema necesita para funcionar.

Java, para evitar que los módulos de byte-codes o los objetos o nuevas

clases, haya que estar trayéndolos de la red cada vez que se necesiten,

implementa las opciones de persistencia, para que no se eliminen cuando de

limpie la caché de la máquina.

Versiones de Java

Java, como la mayoría de los lenguajes, ha sufrido cambios a lo largo

de su historia. Además, en cada momento han coexistido distintas

versiones o distribuciones de Java con distintos fines. Actualmente puede

considerarse que el Java vigente se denomina Java 2 y existen 3

distribuciones principales de Java 2, con ciertos aspectos comunes y ciertos

aspectos divergentes.

Estas tres distribuciones son:

a) J2SE o simplemente Java SE: Java 2 Standard Edition o Java Standard

Edition. Orientado al desarrollo de aplicaciones cliente / servidor. No incluye

soporte a tecnologías para internet. Es la base para las otras distribuciones

Java y es la plataforma que utilizaremos nosotros en este curso por ser la

más utilizada.

b) J2EE: Java 2 Enterprise Edition. Orientado a empresas y a la integración

entre sistemas. Incluye soporte a tecnologías para internet. Su base es

J2SE.

c) J2ME: Java 2 Micro Edition. Orientado a pequeños dispositivos móviles

(teléfonos, tabletas, etc.).

En esta imagen se forma, de forma orientativa, como J2EE “expande” a

J2SE, mientras que J2ME “recorta” a J2SE al tiempo que tiene una fracción

de contenido diferenciada exclusiva de J2ME. En realidad hablar de

expansiones y recortes no es correcto, porque cada distribución es en sí

misma distinta puesto que están concebidas con distintas finalidades. Por

tanto no puede decirse que sean expansiones o recortes, pero de forma

coloquial muchas veces se interpreta así.

El lenguaje Java estándar ha experimentado numerosos cambios desde la

versión primigenia, JDK 1.0, así como un enorme incremento en el número

de recursos disponibles para los programadores Java.

JDK 1.0 (23 de enero de 1996)

JDK 1.1 (19 de febrero de 1997). Una reestructuración intensiva del

modelo de eventos AWT (Abstract Windowing Toolkit), clases internas

(inner classes), JavaBeans, JDBC (Java Database Connectivity), para

la integración de bases de datos, RMI (Remote Method Invocation).

J2SE 1.2 (8 de dieciembre de 1998 - Nombre clave Playground. Esta y

las siguientes versiones fueron recogidas bajo la denominación Java 2

y el nombre "J2SE" (Java 2 Platform, Standard Edition), reemplazó a

JDK para distinguir la plataforma base de J2EE (Java 2 Platform,

Enterprise Edition) y J2ME (Java 2 Platform, Micro Edition).

La palabra reservada (keyword) strictfp.

Reflexión en la programación.

La API gráfica (Swing) fue integrada en las clases básicas.

La máquina virtual (JVM) de Sun fue equipada con un

compilador JIT (Just in Time) por primera vez.

Java Plug-in.

Java IDL, una implementación de IDL (Interfaz para Descripción

de Lenguaje) para la interoperabilidad con CORBA

Colecciones (Collections)

2SE 1.3 (8 de mayo de 2000) - Nombre clave Kestrel.

La inclusión de la máquina virtual de HotSpot JVM (la JVM de

HotSpot fue lanzada inicialmente en abril de 1999, para la JVM

de J2SE 1.2)

RMI fue cambiado para que se basara en CORBA.

JavaSound

Se incluyó el Java Naming and Directory Interface (JNDI) en el

paquete de librerías principales (anteriormente disponible como

una extensión).

Java Platform Debugger Architecture (JPDA)

J2SE 1.4 (6 de febrero de 2002) - Nombre Clave Merlin.

Este fue el primer lanzamiento de la plataforma Java desarrollado bajo

el Proceso de la Comunidad Java como JSR 59. Los cambios más

notables fueron: comunicado de prensalista completa de cambios.

Palabra reservada assert (Especificado en JSR 41.)

Expresiones regulares modeladas al estilo de las expresiones

regulares Perl.

Encadenación de excepciones Permite a una excepción

encapsular la excepción de bajo nivel original.

Non-blocking NIO (New Input/Output) (Especificado en JSR 51.)

Logging API (Specified in JSR 47.)

API I/O para la lectura y escritura de imágenes en formatos

como JPEG o PNG

Parser XML integrado y procesador XSLT (JAXP) (Especificado

en JSR 5 y JSR 63.)

Seguridad integrada y extensiones criptográficas (JCE, JSSE,

JAAS) Java Web Start incluido (El primer lanzamiento ocurrió

en Marzo de 2001 para J2SE 1.3) (Especificado en JSR 56.)

J2SE 5.0 (30 de septiembre de 2004) - Nombre clave: Tiger.

(Originalmente numerado 1.5, esta notación aún es usada

internamente.[4]) Desarrollado bajo JSR 176, Tiger añadió un número

significativo de nuevas características comunicado de prensa.

Plantillas (genéricos) - provee conversion de tipos (type safety) en

tiempo de compilación para colecciones y elimina la necesidad de la

mayoría de conversion de tipos (type casting). (Especificado por JSR

14.)

Metadatos - también llamados anotaciones, permite a

estructuras del lenguaje como las clases o los métodos, ser

etiquetados con datos adicionales, que puedan ser procesados

posteriormente por utilidades de proceso de metadatos.

(Especificado por JSR 175.)

Autoboxing/unboxing - Conversiones automáticas entre tipos

primitivos (Como los int) y clases de envoltura primitivas (Como

Integer). (Especificado por JSR 201.)

Enumeraciones - la palabra reservada enum crea una typesafe,

lista ordenada de valores (como Dia.LUNES, Dia.MARTES,

etc.). Anteriormente, esto solo podía ser llevado a cabo por

constantes enteras o clases construidas manualmente (enum

pattern). (Especificado por JSR 201.)

Varargs (número de argumentos variable) - El último parámetro

de un método puede ser declarado con el nombre del tipo

seguido por tres puntos (e.g. void drawtext(String... lines)). En

la llamada al método, puede usarse cualquier número de

parámetros de ese tipo, que serán almacenados en un array

para pasarlos al metodo.

Bucle for mejorado - La sintaxis para el bucle for se ha

extendido con una sintaxis especial para iterar sobre cada

miembro de un array o sobre cualquier clase que implemente

Iterable, como la clase estándar Collection, de la siguiente

forma:

void displayWidgets (Iterable widgets) { for (Widget w : widgets)

{ w.display(); } } Este ejemplo itera sobre el objeto Iterable

widgets, asignando, en orden, cada uno de los elementos a la

variable w, y llamando al método display() de cada uno de ellos.

(Especificado por JSR 201.)

Java SE 6 (11 de diciembre de 2006) - Nombre clave Mustang. Estuvo

en desarrollo bajo la JSR 270. En esta versión, Sun cambió el nombre

"J2SE" por Java SE y eliminó el ".0" del número de versión. Los

cambios más importantes introducidos en esta versión son:

Incluye un nuevo marco de trabajo y APIs que hacen posible la

combinación de Java con lenguajes dinámicos como PHP,

Python, Ruby y JavaScript.

Incluye el motor Rhino, de Mozilla, una implementación de

Javascript en Java.

Incluye un cliente completo de Servicios Web y soporta las

últimas especificaciones para Servicios Web, como JAX-WS

2.0, JAXB 2.0, STAX y JAXP.

Mejoras en la interfaz gráfica y en el rendimiento.

Java SE 7 - Nombre clave Dolphin. En el año 2006 aún se encontraba

en las primeras etapas de planificación. Se espera que su desarrollo

dé comienzo en la primavera de 2006, y se estima su lanzamiento

para 2008.

Soporte para XML dentro del propio lenguaje

Un nuevo concepto de superpaquete

Soporte para closures

Introducción de anotaciones estándar para detectar fallos en el

software.

Además de los cambios en el lenguaje, con el paso de los años se han

efectuado muchos más cambios dramáticos en la librería de clases de Java

(Java class library) que ha crecido de unos pocos cientos de clases en JDK

1.0 hasta más de tres mil en J2SE 5.0. APIs completamente nuevas, como

Swing y Java2D, han sido introducidas y muchos de los métodos y clases

originales de JDK 1.0 están desaprobados.

Java SE 7 (2011): nueva versión que mejora la anterior.

Java SE 8 (2014): nueva versión que mejora la anterior. Incluye la

posibilidad de embeber JavaScript con Java y mejoras en la gestión

de fechas y tiempo.

Java SE 9: nueva versión que mejora la anterior (en difusión).

Java SE 10: nueva versión que mejora la anterior (todavía sin uso

comercial).

En Java todas las versiones siguen los mismos estándares de datos, esto

permite que un programa que se haya hecho con una versión antigua, pueda

ser ejecutado con una versión más nueva sin necesidad de ningún cambio.

Además de los cambios en el lenguaje en sí, con el paso de los años los

recursos disponibles para los programadores Java que ofrece la empresa

que desarrolla el lenguaje (antiguamente Sun MicroSystems, actualmente

Oracle) han crecido enormemente. La denominada “biblioteca de clases de

Java” (Java class library) ha pasado de ofrecer unos pocos cientos de clases

en JDK 1.0 hasta cerca de 6000 en Java SE 8. Se han introducido recursos

completamente nuevos, como Swing y Java2D, mientras que muchos de los

métodos y clases originales de JDK 1.0 han dejado de utilizarse.

Últimas versiones y actualizaciones de la página de java

Versiones de Java Fecha de versión

Java 8 Update 25 CPU Java 7 Update 71 CPU

14 de octubre de 2014

Actualización limitada de Java 7 Update 67 4 de agosto de 2014

Java 8 Update 25 CPU (OTN) Java 7 Update 71 CPU

15 de julio de 2014

Actualización limitada de Java 7 Update 60 28 de mayo de 2014

Java 8 Update 5 CPU (OTN) Java 7 Update 55 CPU

15 de abril de 2014

Java versión 8 (OTN) 18 de marzo de 2014

Java 7 Update 51 CPU 14 de enero de 2014

Java 7 Update 45 CPU 15 de octubre de 2013

Actualización limitada de Java 7 Update 40 10 de septiembre de 2013

Actualización de parches críticos de Java 7 Update 25

18 junio de 2013

Actualización de parches críticos de Java 7 Update 21

16 de abril de 2013

Java 7 Update 17: actualización especial3 4 de marzo de 2013

Actualización de parches críticos de Java 7 Update 15: actualización especial

19 de febrero de 2013

Actualización de parches críticos de Java 7 Update 13

1 de febrero de 2013

Actualización de parches críticos de Java 7 Update 112

13 de enero de 2013

Actualización limitada de Java 7 Update 10 11 de diciembre de 2012

Actualización de parches críticos de Java 7 Update 9

16 de octubre de 2012

Java 7 Update 7: actualización especial 30 de agosto de 2012

Actualización limitada de Java 7 Update 6 14 de agosto de 2012

Actualización de parches críticos de Java 7 Update 5

12 de junio de 2012

Actualización limitada de Java 7 Update 4 26 de abril de 2012

Actualización de parches críticos de Java 7 Update 3

14 de febrero de 2012

Actualización limitada de Java 7 Update 2 12 de diciembre de 2011

Actualización de parches críticos de Java 7 Update 1

18 de octubre de 2011

Java 7 28 de julio de 2011

Estructura de un programa en Java

La estructura de un programa simple en Java es la siguiente:

public class

ClasePrincipal

{

public static void

main

(

String[] args) {

sentencia_1

;

sentencia_2

;

//

...

sentencia_N

;

}

}

Para entender correctamente el funcionamiento de una aplicación

Java, es necesario descomponerla en sus elementos principales para

entender su funcionamiento y su interacción y relación mutua.

Utilizando Netbeans se crea. Pulsar “File”->”New Project” (teclas

May+Ctrl+N) o también se puede pulsar en el icono con forma de carpeta y

un símbolo destinado a tal efecto.

Seleccionar “Categories” (Categorías) y en “Projects” (Proyectos) y pulsar en

“Java Application”. Desactivar “Create Main Class” (crear clase principal

Main). El nombre que se le dará a este proyecto es Estructura, para definir la

estructura de un programa en java. No existe ningún archivo en el proyecto,

por lo que debe añadirse desde “File”->”New File”- También se puede pulsar

en el icono correspondiente o seleccionando las teclas Ctrl+N. Seleccionar

Java

Crear archivo nuevo

A continuación, marcar “Java”->”Empty Java File”, es decir, archivo Java

vacío:

Archivo Java vacío

Para un nuevo archivo se muestra un asistente durante su creación. Como

nombre, escribir Estructura. En “Package” (paquete) también escribir

Estructura. Pulsar en “Finish” y se genera el archivo. En ese archivo vacío,

con el nombre “Estructura.java”, se escribirá el contenido. Lo primero que

hay que hacer es escribir la clase de ese archivo, en este caso “Estructura”, y

abrir las primeras llaves en la que insertar el código. Al hacerlo, el propio

Netbeans sangra en la línea la posición para escribir la siguiente línea de

código y cierra automáticamente esas llaves. Estas sencillas líneas, son los

cimientos de una aplicación Java:

class Estructura{

public static void main(String[]args){

//Mi primer programa Java va aquí

}

}

Estructura

Class

La primera línea, “class Estructura”, se utiliza para decirle a la

máquina que el programa se llamara Estructura. El nombre de la

clase, coincide con el nombre del archivo creado en el proyecto,

también con el nombre Estructura, ya que dependiendo de la

configuración del programa, podría dar error si no existe esa coincidencia

(ten en cuenta la capitalización de las letras, es decir, mayúsculas y

minúsculas) Cada una de las instrucciones que se da al ordenador, es una

declaración o statement (en inglés).

Por lo tanto, es importante recordar, que el nombre de la clase coincide con

el nombre del archivo.

Con la segunda línea, “public static void main(String[]args)” se le indica al

ordenador, que la parte principal del programa empieza a partir de ahí.

Cualquier aplicación Java, está estructurada en distintas secciones, por lo

que es imprescindible esta línea como medio para indicar la parte del

programa que debe ser manejada en primer lugar. Hay excepciones, como

los Applets, que se ejecutan como parte de una página Web, y los Servlets,

programas que se ejecutan en un Servidor Web, pero la mayoría de los

programas en Java, se inician con esa declaración main como punto de

partida.

Llaves

En el código, existen una serie de llaves de apertura y cierre. Pulsando en

ellas, Netbeans, mediante un sombreado amarillo, ayuda a detectar la

relación entra las distintas llaves, simplemente pulsando en cualquiera de

ellas. Las llaves se utilizan en Java, para agrupar las distintas partes del

programa. Todo lo que se encuentre dentro de esas llaves, forma parte de un

mismo grupo, gracias a lo cual, el ordenador sabrá donde empiezan y

finalizan esos grupos.

Agrupamiento en llaves

Los agrupamientos que se generan con las llaves, son conocidos como

bloques. En el caso del ejemplo, el bloque principal comenzaría tras “class

Estructura” y finalizaría con la última llave visible. Internamente, tiene otro

bloque, que se abre tras “public static void main(String[]args)” y finaliza antes

de la última llave (imagen anterior). En el código creado, dentro de esos

bloques, se pueden incluir instrucciones y comandos para la ejecución de las

acciones del programa. En el ejemplo, sólo existe un comentario, no visible

durante la ejecución del programa, al ir precedido de dos barras diagonales

“//”.

Compilar el proyecto pulsando en “Run”-> “Compile Package”, F9 o con el

botón derecho sobre el paquete. Al hacerlo, en la consola te informa de la

construcción y del resultado. Para ejecutar el programa, puedes ir a “Run”->

“Run Main Project”, pulsar F6 o ejecutar el icono del triángulo verde del menú

superior. En el primer caso mostrará la construcción correcta, pero en la

ejecución del programa, no hará nada.

Construcción del programa

Para que el programa haga algo, es necesario introducir el código

correspondiente creando las declaraciones o statements adecuadas.

Variables

En todos los programas que se

desarrollan, es necesario establecer

un lugar donde almacenar

información durante unos periodos

de tiempo determinados. Ese es el cometido de las variables. Las variables,

son lugares de almacenamiento que pueden contener información de distinto

tipo. Puede ser texto, números, decimales, valores verdadero o falso,

caracteres, etc.

En programación, una variable está formada por un espacio en el sistema de

almacenamiento (memoria principal de un ordenador) y un nombre simbólico

(un identificador) que está asociado a dicho espacio. Ese espacio contiene

una cantidad o información conocida o desconocida, es decir, un valor con

un tipo predefinido. Mientras que el nombre, tipo y ubicación de una variable

permanecen fijos, los datos almacenados en la ubicación pueden cambiar. El

propio nombre, variable, hace referencia a que esos datos o valores pueden

ir “variando” o modificándose a lo largo de la ejecución del programa.

Observar la siguiente línea de código con variable String:

String saludo = “¡Bienvenido a Programación en Java!”;

Con esta línea, se indica al ordenador que almacene el contenido del texto

entrecomillado en una variable de tipo String y de nombre saludo. En Java,

hay que declarar siempre el tipo de variable. Cuando se habla de variable de

tipo String, se refiere a una cadena de caracteres, (string en inglés) una

secuencia de elementos que pueden ser letras, números u otros signos o

símbolos. Una cadena podrá estar formada por cualquier combinación finita

de todo el juego de caracteres disponibles (las letras de la „a‟ a la „z‟ y de la

„A‟ a la „Z‟, los números del ‟0′ al ‟9′, el espacio en blanco „ „, símbolos

diversos „!‟, „@‟, „%‟, etc).

Si se añade la siguiente línea de código y se compilay ejecuta a

continuación, observese un mensaje indicando que se ha construido de

forma correcta, pero no aparece nada.

class Estructura{

public static void main (String[]args){

//mi primer programa java

String saludo = “¡Bienvenido a Programación en

Java!”;

}

}

El motivo es claro, se almacena el contenido de la variable pero es necesaria

otra línea para mostrar el contenido de la variable:

System.out.println(saludo);

Con esta línea, se indica al programa que se muestre la información

guardada en la variable saludo y, en esta ocasión, sí se muestra por pantalla

el mensaje almacenado.

Este sería el código completo de 7 líneas:

Código completo

Diseccionándolo línea por línea, esta sería la secuencia y significado de cada

una de esas 7 líneas:

1. Se indica al ordenador el programa se llamara Estructura.

2. El programa Estructura comienza aquí.

3. La parte principal del programa se inicia aquí.

4. Almacena el texto “¡Bienvenido a programación en Java!” en la

variable saludo.

5. Muestra el contenido de la variable saludo.

6. Termina la parte principal del programa.

7. El programa Estructura finaliza.

Esta es la estructura básica de cualquier programa de Java.

Además de la creación, hay que realizar los arreglos correspondientes para

solventar posibles errores (bugs), compilar el programa y ejecutarlo. Cuando

se lleva a cabo la compilación, se crea un nuevo archivo de extensión .class.

Si se abre la carpeta Estructura, en la ruta de almacenamiento de proyectos,

pueden identificarse esos archivos:

Al compilar, se genera un nuevo archivo de extensión.class

Un programa Java suele estar formado por varias clases que funcionan al

unísono.

Corrección de errores

Cuando se comete un error durante la escritura en Netbeans, en el panel

numerado de la izquierda se muestra un círculo amarillo de advertencia o

rojo advirtiendo de un error. Al pulsar encima de él, se obtiene información de

lo que está ocurriendo, mostrando asimismo un mensaje indicativo del lugar

donde se produce ese error o se llama la atención de alguna carencia o

problema.

Línea de código con error

En esos mensajes podrás obtener información del nombre del programa, el

tipo de error y la línea del error, muy útil para detectar y solventar fallos

durante la programación y la escritura del código.

Principales palabras reservadas en Java

Hay un grupo de palabras en Java con las cuales, entre otras cosas, se

realizan las tareas principales, se delimitan los alcances de los objetos, sus

datos y sus métodos, etc. Se pueden clasificar así:

Tipos de datos

Sentencias condicionales

Sentencias iterativas

Tratamiento de las excepciones

Estructura de datos

Modificadores y control de acceso

A continuación, una imagen que esquematiza los elementos en la clase

HolaMundoOO

(Obsérvese que la línea saludo= “Hola mundo”; es, además, una expresión

porque utiliza el operador de igual (=))

La imagen anterior muestra que, a pesar de la sencillez del programa, son

muchos los elementos que están involucrados.

Las palabras reservadas son identificadores predefinidos que tienen un

significado para el compilador y por tanto no pueden usarse como

identificadores creados por el usuario en los programas.

Las palabras reservadas en Java ordenadas alfabéticamente son las

siguientes:

abstract continue for new switch

assert default goto package synchronized

boolean do if private this

break double implements protected throw

byte else import public throws

case enum instanceof return transient

catch extends int short try

char final interface static Void

class finally long strictfp Volatile

const float native super While

Principales funciones en java

En Java una función es un módulo de un programa separado del cuerpo

principal, que realiza una tarea específica y que puede regresar un valor a la

parte principal del programa u otra función o procedimiento que la invoque.

La forma general de una función es:

tipodatoregresa Nom_fun(parametros)

{ cuerpo de instrucciones;

instruccion return;

}

El tipo especifica el tipo de valor que la función regresara utilizando la

instrucción return.

Si no se especifica un tipo se asume de default que el tipo regresado es int.

La lista de parámetros formales es una lista de variables separadas por

comas (,) que almacenaran los valores que reciba la función, estas variables

actúan como locales dentro del cuerpo de la función.

Aunque no se ocupen parámetros los paréntesis son requeridos.

La declaración de parámetros es la especificación de cada tipo de parámetro

recibido.

Instrucción Return

Dentro del cuerpo de la función deber haber una instrucción return cuando

menos, para regresar el valor, esta instrucción permite regresar datos.

Prog.java ejemplo;

import java.io.*; import javax.servlet.*;

import javax.servlet.http.*;

public class prog26 extends HttpServlet

{ public void doPost (HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException

{ int x=10;

x = funcion1(x,20);

PrintWriter pagina;

response.setContentType("text/html");

pagina = response.getWriter();

pagina.println("<HTML>");

pagina.println("x="+x);

pagina.println("</HTML>");

pagina.close();

}; // termina dopost

public int funcion1(int a, int b){return a+b;};

public void destroy(){super.destroy();};

}// termina class

codigo.html

<HTML> <FORM

ACTION=http://www.programacionfacil.com:9090/servlet/lauro.prog26

METHOD=POST>

<INPUT TYPE=SUBMIT VALUE=OK>

</FORM></HTML>

corrida:

Es permitido poner mas de un return en el cuerpo de instrucciones sobre

todo en condiciones, pero solo un return se ejecutara.

Ejemplo;

if (suma >= 10)

{ return 10; }

else

{ return 20; }

En Java existen 3 clases usuales de funciones.

Las primeras son de tipo computacional que son diseñadas para

realizar operaciones con los argumentos y regresan un valor basado

en el resultado de esa operación.

Las segundas funciones son aquellas que manipulan información y

regresan un valor que indican la terminación o la falla de esa

manipulación.

Las terceras son aquellas que no regresan ningún valor, es decir son

estrictamente procedurales.

Otra forma de ver la estructura de una función es: TIPOACCESO TIPOSALIDA NOMBRE(PARAMETROS){

instruccion1;

instruccion2;

.

.

.

instruccionN;

return SALIDA;

}

Tipo acceso puede ser:

private: significa que puede ser usada solo en esa clase y no por

subclases.

protected: significa que puede ser usada solo en esa paquete y

tambien por subclases; pero no en otro paquete.

public: significa que puede ser usada por cualquier clase en

cualquier paquete.

Tipo Salida puede ser:

float: siempre que la salida sea un real de precisión simple.

double: siempre que la salida sea un real de doble precisión.

int: siempre que la salida sea un entero de precisión simple.

long: siempre que la salida sea un entero de doble precisión.

String: siempre que la salida sea una cadena alfanumérica.

boolean: siempre que la salida sea un valor booleano (true, false).

Double [ ]: siempre que la salida sea un vector real de doble precisión.

Double [ ][ ]: siempre que la salida sea una matriz real de doble

precisión.

Int [ ]: siempre que la salida sea un vector entera de doble precisión.

Int [ ][ ]: siempre que la salida sea una matriz entera de doble

precisión.

Nombre puede ser el que usted quiera pero no debe tener espacios ni usar

palabras reservadas de java, por ejemplo la palabra main está reservada

para el procedimiento principal.

Parametros son los datos de entrada, deben declararse los tipos de datos

requeridos uno por uno y separarlos por comas.

ejemplo:

int mcm(int n, int m){

.

.

.

}

es incorrecto

int mcm(int n,m){

.

.

.

}

Editores empleados para el trabajo con este lenguaje

Existen muchos editores para java, a continuación se describen los mas

usados:

Editplus

EditPlus es un editor de texto 32-bit para

Windows. No sólo es un buen reemplazo para

el bloc de notas de Windows, sino que además

ofrece varias potentes funciones para autores

y programadores de páginas web.

Algunas de las funciones más importantes es

el resalto de errores de sintaxis, una barra de

herramientas de HTML, herramientas definibles por el usuario, y archivos de

ayuda; potente rehacer y deshacer, soporte para arrastrar y soltar, búsqueda

y reemplazo de palabras, corrector ortográfico, teclas rápidas, y muchas

cosas más, entre las que destaca las funciones de FTP incluidas en esta

última versión y la posibilidad de ver páginas web.

EditPlus también incluye resalto de errores sintéticos para HTML, ASP,

JavaScript, VBScript, Perl, Java, PHP, CSS, y C/C++.

Con esta aplicación, podrás crear tus propios archivos en HTML, CSS, PHP,

ASP, Perl, C/C++, Java, JavaScript and VBScript y usarlo para visualizar

como un navegador las páginas en HTML y los comandos FTP para subir

archivos a un servidor FTP.

También funciona con otros lenguajes de programas basados en sintaxis

personalizables.

Permite, además, añadir elementos directamente con varios lenguajes como

HTML y CSS sin saber la etiqueta; selección automática de columnas; y

demás utilidades que harán mucho más fácil la labor del programador de

webs.

Es un software ideal para quienes se inicien en la programación en algunos

de los lenguajes soportados por EditPlus puesto que es fácil de utilizar evita

el estrés de usar el bloc de notas.

JGrasp

jGrasp es un entorno de

programación ligero surgido

en el ámbito universitario,

concretamente en la

universidad de Auburn. Te

permitirá trabajar con distintos

lenguajes de programación, aunque lógicamente en el contexto de este

monográfico nos centraremos en sus posibilidades de cara al lenguaje Java.

JCreator

Es un entorno de desarrollo integrado (IDE) para programación en

lenguaje Java en entorno Windows.

Es un producto comercial de la compañía Xinox

Software. Utiliza el J2SDK de Sun Microsystems para

compilar y ejecutar los programas, pero no es necesario

para ejecutar el JCreator, ya que a diferencia de otros

IDEs para Java como Netbeans o Eclipse este programa

no es una aplicación nativa Java.

Hay dos ediciones, una gratuita, llamada LE y otra de pago llamada Pro, que

entre otras cosas añade completamiento de comandos, plantillas, depuración

y soporte de CVS.

NetBeans

Es un entorno de desarrollo integrado libre, hecho principalmente para el

lenguaje de programación Java. Existe además un número importante de

módulos para extenderlo. NetBeans IDE2 es un producto libre y gratuito sin

restricciones de uso.

NetBeans es un proyecto de

código abierto de gran éxito con

una gran base de usuarios, una

comunidad en constante

crecimiento, y con cerca de 100

socios en todo el mundo. Sun MicroSystems fundó el proyecto de código

abierto NetBeans en junio de 2000 y continúa siendo el patrocinador principal

de los proyectos.

La plataforma NetBeans permite que las aplicaciones sean desarrolladas a

partir de un conjunto de componentes de software llamados módulos. Un

módulo es un archivo Java que contiene clases de java escritas para

interactuar con las APIs de NetBeans y un archivo especial (manifest file) que

lo identifica como módulo. Las aplicaciones construidas a partir de módulos

pueden ser extendidas agregándole nuevos módulos. Debido a que los

módulos pueden ser desarrollados independientemente, las aplicaciones

basadas en la plataforma NetBeans pueden ser extendidas fácilmente por

otros desarrolladores de software.

El NetBeans IDE es un IDE de código abierto escrito completamente en Java

usando la plataforma NetBeans. El NetBeans IDE soporta el desarrollo de

todos los tipos de aplicación Java (J2SE, web, EJB y aplicaciones móviles).

Entre sus características se encuentra un sistema de proyectos basado en

Ant, control de versiones y refactoring.

NetBeans IDE 6.5, la cual fue publicada el 19 de noviembre de 2008,

extiende las características existentes del Java EE (incluyendo Soporte a

Persistencia, EJB 3 y JAX-WS). Adicionalmente, el NetBeans Enterprise

Pack soporta el desarrollo de Aplicaciones empresariales con Java EE 5,

incluyendo herramientas de desarrollo visuales de SOA, herramientas de

esquemas XML, orientación a web servicies (for BPEL), y modelado UML. El

NetBeans C/C++ Pack soporta proyectos de C/C++, mientras el PHP Pack,

soporta PHP 5.

Modularidad. Todas las funciones del IDE son provistas por módulos. Cada

módulo provee una función bien definida, tales como el soporte de Java,

edición, o soporte para el sistema de control de versiones. NetBeans

contiene todos los módulos necesarios para el desarrollo de aplicaciones

Java en una sola descarga, permitiéndole al usuario comenzar a trabajar

inmediatamente.

Sun Studio, Sun Java Studio Enterprise, y Sun Java Studio Creator de Sun

Microsystems han sido todos basados en el IDE NetBeans.

Desde julio de 2006, NetBeans IDE es licenciado bajo la Common

Development and Distribution License (CDDL), una licencia basada en la

Mozilla Public License (MPL). En octubre de 2007, Sun anunció que

NetBeans desde entonces se ofrecerá bajo licenciamiento dual de Licencia

CDDL y la GPL versión 2.

Eclipse

Eclipse es un programa informático

compuesto por un conjunto de

herramientas de programación de

código abierto multiplataforma para

desarrollar lo que el proyecto llama

"Aplicaciones de Cliente Enriquecido",

opuesto a las aplicaciones "Cliente-

liviano" basadas en navegadores. Esta

plataforma, típicamente ha sido usada

para desarrollar entornos de desarrollo

integrados (del inglés IDE), como el IDE de Java llamado Java Development

Toolkit (JDT) y el compilador (ECJ) que se entrega como parte de Eclipse (y

que son usados también para desarrollar el mismo Eclipse). Sin embargo,

también se puede usar para otros tipos de aplicaciones cliente, como

BitTorrent o Azureus.

Eclipse es también una comunidad de usuarios, extendiendo constantemente

las áreas de aplicación cubiertas. Un ejemplo es el recientemente creado

Eclipse Modeling Project, cubriendo casi todas las áreas de Model Driven

Engineering.

Eclipse fue desarrollado originalmente por IBM como el sucesor de su familia

de herramientas para VisualAge. Eclipse es ahora desarrollado por la

Fundación Eclipse, una organización independiente sin ánimo de lucro que

fomenta una comunidad de código abierto y un conjunto de productos

complementarios, capacidades y servicios.

Eclipse fue liberado originalmente bajo la Common Public License, pero

después fue re-licenciado bajo la Eclipse Public License. La Free Software

Foundation ha dicho que ambas licencias son licencias de software libre,

pero son incompatibles con Licencia pública general de GNU (GNU GPL).

Arquitectura

La base para Eclipse es la Plataforma de cliente enriquecido (del Inglés Rich

Client Platform RCP). Los siguientes componentes constituyen la plataforma

de cliente enriquecido:

Plataforma principal - inicio de Eclipse, ejecución de plugins

OSGi - una plataforma para bundling estándar.

El Standard Widget Toolkit (SWT) - Un widget toolkit portable.

JFace - manejo de archivos, manejo de texto, editores de texto

El Workbench de Eclipse - vistas, editores, perspectivas, asistentes

Los widgets de Eclipse están implementados por una herramienta de widget

para Java llamada Standard Widget Toolkit, a diferencia de la mayoría de las

aplicaciones Java, que usan las opciones estándar Abstract Window Toolkit

(AWT) o Swing. La interfaz de usuario de Eclipse también tiene una capa

GUI intermedia llamada JFace, la cual simplifica la construcción de

aplicaciones basadas en SWT.

El entorno de desarrollo integrado (IDE) de Eclipse emplea módulos (en

inglés plug-in) para proporcionar toda su funcionalidad al frente de la

plataforma de cliente enriquecido, a diferencia de otros entornos monolíticos

donde las funcionalidades están todas incluidas, las necesite el usuario o no.

Este mecanismo de módulos es una plataforma ligera para componentes de

software. Adicionalmente a permitirle a Eclipse extenderse usando otros

lenguajes de programación como son C/C++ y Python, permite a Eclipse

trabajar con lenguajes para procesado de texto como LaTeX, aplicaciones en

red como Telnet y Sistema de gestión de base de datos. La arquitectura

plugin permite escribir cualquier extensión deseada en el ambiente, como

sería Gestión de la configuración. Se provee soporte para Java y CVS en el

SDK de Eclipse. Y no tiene por qué ser usado únicamente con estos

lenguajes, ya que soporta otros lenguajes de programación.

La definición que da el proyecto Eclipse acerca de su software es: "una

especie de herramienta universal - un IDE abierto y extensible para todo y

nada en particular".

En cuanto a las aplicaciones clientes, Eclipse provee al programador con

frameworks muy ricos para el desarrollo de aplicaciones gráficas, definición y

manipulación de modelos de software, aplicaciones web, etc. Por ejemplo,

GEF (Graphic Editing Framework - Framework para la edición gráfica) es un

plugin de Eclipse para el desarrollo de editores visuales que pueden ir desde

procesadores de texto wysiwyg hasta editores de diagramas UML, interfaces

gráficas para el usuario (GUI), etc. Dado que los editores realizados con GEF

"viven" dentro de Eclipse, además de poder ser usados conjuntamente con

otros plugins, hacen uso de su interfaz gráfica personalizable y profesional.

El SDK de Eclipse incluye las herramientas de desarrollo de Java, ofreciendo

un IDE con un compilador de Java interno y un modelo completo de los

archivos fuente de Java. Esto permite técnicas avanzadas de refactorización

y análisis de código. Mediante diversos plugins estas herramientas están

también disponibles para otros lenguajes como C/C++ (Eclipse CDT) y en la

medida de lo posible para lenguajes de script no tipados como PHP o

Javascript. El IDE también hace uso de un espacio de trabajo, en este caso

un grupo de metadatos en un espacio para archivos plano, permitiendo

modificaciones externas a los archivos en tanto se refresque el espacio de

trabajo correspondiente.

Características

Eclipse dispone de un Editor de texto con resaltado de sintaxis. La

compilación es en tiempo real. Tiene pruebas unitarias con JUnit, control de

versiones con CVS, integración con Ant, asistentes (wizards) para creación

de proyectos, clases, tests, etc., y refactorización.

Asimismo, a través de "plugins" libremente disponibles es posible añadir

control de versiones con Subversion. e integración con Hibernate.

Historia

Eclipse comenzó como un proyecto de IBM Canadá. Fue desarrollado por

OTI (Object Technology International) como reemplazo de VisualAge también

desarrollado por OTI. En noviembre del 2001, se formó un consorcio para el

desarrollo futuro de Eclipse como código abierto. En 2003, fue creada la

fundación independiente de IBM.

Resumen de las versiones de Eclipse:

Versión Fecha de lanzamiento Versión de plataforma

Proyectos

Mars Junio de 2015 (planeado)

? Mars projects

Luna 25 Junio 2014 4.4 Luna projects

Kepler 26 de junio de 2013 4.3 Kepler projects

Juno 27 de junio de 2012 4.2 Juno projects

Indigo 22 de junio de 2011 3.7 Indigo projects

Helios 23 junio de 2010 3.6 Helios projects

Galileo 24 de junio de 2009 3.5 Galileo projects

Ganymede 25 junio de 2008 3.4 Ganymede projects

Europa 29 de junio de 2007 3.3 Europa projects

Callisto 30 de junio de 2006 3.2 Callisto projects

Eclipse 3.1

28 de junio 2005 3.1

Eclipse 3.0

28 de junio de 2004 3.0

Creación de una clase en java

Una clase define un tipo de objeto concreto.

Por ejemplo, si se quisiera escribir un programa en Java para gestionar los

libros de una biblioteca, se crearia la clase Libro, y luego un objeto de esta

clase, por cada libro que tengamosse tenga en la biblioteca.

Una clase en Java está formada por:

Atributos: (o campos/propiedades) Almacenan algún tipo de

información del objeto. Definen su estado.

Constructor(es): Método que se utiliza para inicializar un

objeto.

Métodos: Son utilizados para modificar o consultar el estado de

un objeto. Equivalentes a las funciones o procedimientos de

otros lenguajes.

En Java solo hay dos excepciones al uso de objetos, además de estos

podemos utilizar variables simples y arrays. La forma de hacerlo es muy

similar a como se haría en C o C++. En la siguiente tabla se muestra una

tabla con los tipos simples disponibles en Java.

Para crear una nueva clase, lo primero que se debe hacer es crear un fichero

que ha de llamarse exactamente igual que la clase y con extensión .java.

Siempre usar un fichero por clase.

Al principio de este fichero se suele indicar el paquete al que pertenecerá

esta clase. Por ejemplo:

package org.upv.cursoandroid.unidad0;

Seguido de otros paquetes definidos previamente que se quieren utilizar:

import android.app.Activity;

import android.content.BroadcastReceiver;

import …

Para declarar una clase sigue el siguiente esquema:

class <Clase> {

//declaración de atributos

[visibilidad] [modificadores] <tipo> <atributo> [=

valor];

...

//declaración de constructor public <Clase>(<argumentos>) {

<instrucciones>;

}

//declaración de métodos

[visibilidad] [modificadores] <tipo>

<método>(<argumentos>) {

<instrucciones>;

} ...

}

dónde: [visibilidad] = public, protected o private

[modificadores] = final, static y abstract

Una clase comienza por la palabra reservada class seguida del nombre de la

clase. Por convenio los nombres con la inicial mayúsculas. Si se usan varias

palabras, se concatenan sin espacios con las iniciales en mayúscula. A

continuación se definen los atributos, seguido del constructor/es y de la

declaración de métodos.

Un ejemplo de una clase se muestra a continuación:

/** Clase que representa un número complejo. */ class Complejo {

//declaración de atributos private double real, imaginario;

//declaración de constructor public Complejo(double real, double imaginario) { this.real= real; this.imaginario= imaginario;

}

//declaración de métodos /** Transcribe el complejo a String. * @returnun string con la parte entera y la imaginaria

*/

public String toString() {

return real + "+"+ imaginario + "i";

}

/** Suma al complejo de este objeto otro complejo. * @param v el complejo que sumamos

*/

public void suma(Complejo v) {

real = real + v.real; imaginario = imaginario + v.imaginario;

} }

Una clase necesita almacenar algún tipo de información que defina el objeto

en cuestión. Esto se hará en los atributos o campos de la clase. En el

ejemplo se quiere representar un número complejo, y por lo tanto va a

necesitarse almacenar la parte real y la parte imaginaria del número.

El siguiente paso suele ser declarar el constructor. Un constructor es un

método que tiene el mismo nombre de la clase y que se utiliza para inicializar

un objeto. Tiene una serie de parámetros separados por comas, en el

ejemplo, la parte real y la parte imaginaria del número complejo. El código de

este método (las instrucciones entre {…} ) se limita a copiar estos valores en

los atributos del objeto. Aunque aquí aparece un problema, los parámetros

del método (real, imaginario) y los atributos de la clase (real,

imaginario) se llaman igual. Para resolverlo se pueden anteponer a los

atributos la palabra reservada this. De esta forma se indica que se refieren

a los atributos del objeto.

Para terminar se declaran los métodos de la clase. Los métodos son

equivalentes a las funciones o procedimientos de otros lenguajes y son

utilizados para modificar o consultar el estado del objeto.

Los métodos suelen comenzar indicando su visibilidad

(public,protected o private). A continuación los métodos indican el

tipo de datos que devuelven. En el ejemplo el primer método devuelve un

String y el segundo void, o lo que es lo mismo nada. Luego sigue el

nombre del método y los parámetros. Dentro del primer método se utiliza la

palabra reservada return para indicar el valor devuelto por el método.

Ejemplos de programas en Java

Ejercicio 1

Programa que lea una cantidad de grados centígrados y la pase a

grados Fahrenheit.

La fórmula correspondiente para pasar de grados centígrados a fahrenheit

es:

F = 32 + ( 9 * C / 5)

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double gradosC, gradosF;

System.out.println("Introduce grados Centígrados:");

gradosC = sc.nextDouble();

gradosF = 32 + (9 * gradosC / 5);

System.out.println(gradosC +" ºC = " + gradosF + " ºF");

}

}

Ejercicio 2

Programa que lee por teclado el valor del radio de una circunferencia y

calcula y muestra por pantalla la longitud y el área de la circunferencia.

Longitud de la circunferencia = 2*PI*Radio, Area de la circunferencia =

PI*Radio^2

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double radio, longitud, area;

System.out.println("Introduce radio de la circunferencia:");

radio = sc.nextDouble();

longitud = 2 * Math.PI * radio;

area = Math.PI * Math.pow(radio, 2);

System.out.println("Longitud de la circunferencia -> " + longitud);

System.out.println("Area de la circunferencia -> " + area);

}

}

Ejercicio 3

Programa que pase una velocidad en Km/h a m/s. La velocidad se lee

por teclado.

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double velocidad;

System.out.println("Introduzca velocidad en Km/h: ");

velocidad = sc.nextDouble();

System.out.println(velocidad + " Km/h -> " + velocidad*1000/3600 + "

m/s");

}

Ejercicio 4

Programa lea la longitud de los catetos de un triángulo rectángulo y

calcule la longitud de la hipotenusa según el teorema de Pitágoras.

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double cateto1, cateto2;

System.out.print("Introduzca longitud del primer cateto: ");

cateto1 = sc.nextDouble();

System.out.print("Introduzca longitud del segundo cateto: ");

cateto2 = sc.nextDouble();

System.out.println("Hipotenusa -> " + Math.sqrt(Math.pow(cateto1,2)+

Math.pow(cateto2, 2)));

}

}

Ejercicio 5

Programa que tome como dato de entrada un número que

corresponde a la longitud del radio una esfera y calcule y escribe el volumen

de la esfera que se corresponden con dicho radio.

La fórmula para calcular el volumen de la esfera es v = (4/3)*PI*r^3

/*

* Programa que calcula el volumen de una esfera

*/

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double radio, volumen;

System.out.print("Introduzca radio de la esfera: ");

radio = sc.nextDouble();

System.out.println("Volumen de la esfera de radio " + radio + " = "

+ (4.0/3)* Math.PI * Math.pow(radio, 3));

}

}

La operación para calcular el volumen es: (4.0/3)* Math.PI * Math.pow(radio,

3))

Debe tenerse cuidado con la división entre números enteros. Si se hace 4/3

dará como resultado 1, por eso se debe escribir al menos uno de los dos

números como double. En este caso se ha puesto el numerador como double

simplemente escribiendo 4.0 y de esta forma el resultado de la división 4.0/3

será de tipo double.

Ejercicio 6

Programa Java que calcule el área de un triángulo en función de las

longitudes de sus lados (a, b, c), según la siguiente fórmula:

Area = RaizCuadrada(p*(p-a)*(p-b)*(p-c))

donde p = (a+b+c)/2

Para calcular la raíz cuadrada se utiliza el método Math.sqrt()

/*

* Programa que calcule el área de un triángulo en función de las longitudes

de sus lados (a, b, c)

* según la siguiente fórmula: area=raiz2(p(p-a)(p-b)(p-c)) donde p =

(a+b+c)/2

*/

import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double a,b,c,p;

System.out.print("Introduzca longitud del primer lado del triángulo: ");

a = sc.nextDouble();

System.out.print("Introduzca longitud del segundo lado del triángulo: ");

b = sc.nextDouble();

System.out.print("Introduzca longitud del tercer lado del triángulo: ");

c = sc.nextDouble();

p = (a+b+c)/2;

System.out.println("Area -> " + Math.sqrt(p*(p-a)*(p-b)*(p-c)));

}

}

Ejercicio 7

Programa Java que lea un número entero de 3 cifras y muestre por

separado las cifras del número.

/*

* Programa que lea un número de 3 cifras y muestre por pantalla las cifras

del número

*/

import java.util.*;

public class Main{

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int N;

System.out.print("Introduzca valor de N: ");

N = sc.nextInt(); //supondremos que el número introducido tiene 3 cifras

System.out.println("Primera cifra de " + N + " -> " + (N/100));

System.out.println("Cifra central de " + N + " -> " + (N/10)%10);

System.out.println("Última cifra de " + N + " -> " + (N%10));

}

}

Conclusión

Hay muchas aplicaciones y sitios web que no funcionarán a menos

que tenga Java instalado y cada día se crean más. Java es rápido, seguro y

fiable. Desde portátiles hasta centros de datos, desde consolas para juegos

hasta súper computadoras, desde teléfonos móviles hasta Internet, Java está

en todas partes. Además, Java proporciona una nueva forma de acceder a

las aplicaciones. El software viaja transparentemente a través de la red. No

hay necesidad de instalar las aplicaciones, ellas mismas vienen cuando se

necesitan.

Un navegador con soporte Java puede enlazar con el servidor que contiene

el algoritmo que procesa ese nuevo formato y mostrar la imagen. Por lo

tanto, si alguien inventa un nuevo algoritmo de compresión para imágenes, el

inventor sólo necesita estar seguro de que hay una copia en código Java de

ese algoritmo instalado en el servidor que contiene las imágenes que quiere

publicar. Es decir, los navegadores con soporte Java se actualizan a sí

mismos sobre la marcha, cuando encuentran un nuevo tipo de fichero o

algoritmo

Hoy en día, puede encontrarse la tecnología Java en redes y dispositivos que

comprenden desde Internet y superordenadores científicos hasta portátiles y

teléfonos móviles; desde simuladores de mercado en Wall Street hasta

juegos de uso doméstico y tarjetas de crédito: Java está en todas partes.

Bibliografía

http://www.cad.com.mx/historia_del_lenguaje_java.htm

http://www.webtaller.com/manual-java/origen-java.php

http://www.taringa.net/posts/humor/8445617/Las-mejores-50-frases-

del-mundo-de-la-programacion.html

https://www.java.com/es/download/faq/whatis_java.xml

https://www.java.com/es/download/faq/release_dates.xml

http://www.aprenderaprogramar.com/index.php?option=com_content&

view=article&id=377:versiones-y-distribuciones-java-j2se-j2ee-j2me-

ijava-7-java-8-java9-cual-es-mejor-cu00606b&catid=68:curso-

aprender-programacion-java-desde-cero&Itemid=188

http://es.wikipedia.org/wiki/Eclipse_%28software%29

http://es.wikipedia.org/wiki/NetBeans

http://www.programacionfacil.com/java/funciones#sthash.52J4YUrL.dp

uf

http://www.mibqyyo.com/articulos/2014/02/06/programacion-en-java-2-

estructura-de-un-programa-

java/#/vanilla/discussion/embed/?vanilla_discussion_id=0

http://recursostic.educacion.es/observatorio/web/en/software/programa

cion/911-monografico-java?start=1

http://www.e-coffeetech.com/articulos/desarrollo-de-software/106-

editplus-editor-de-texto-para-programadores.html

http://es.wikipedia.org/wiki/JCreator

http://www.androidcurso.com/index.php/tutoriales-java-esencial/24-

creacion-de-clases-en-java.

http://puntocomnoesunlenguaje.blogspot.com.es/2012/11/java-

ejercicios-basicos-resueltos-4.html.