Upload
aida-hernandez
View
587
Download
8
Embed Size (px)
Citation preview
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.