analisis tecnologico( diagnostico tecnologico, herramienta de toma de deciones)
Java Lenguaje de programación Orientado a Objetos
1. 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
2. Í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
3. 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
4. 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.
5. 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.
6. 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
7. 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.
8. 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
9. 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.
10. 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)
11. 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.
12. 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
13. 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.
14. 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:
15. 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
16. 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
17. 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.
18. 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
19. 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
20. 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
21. 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
22. 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,
23. 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.).
24. 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).
25. 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.)
26. 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.)
27. 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.
28. 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).
29. 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
30. 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
31. 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
32. 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
33. 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
34. 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
35. 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,
36. 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.
37. 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.
38. 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.
39. 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
40. (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
41. 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.
42. 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);
43. 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)
44. { 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.
45. 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){
. .
46. . } 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.
47. 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.
48. 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.
49. 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
50. 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.
51. 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
52. (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
53. "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.
54. 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.
55. 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 …
56. 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:
57. /** 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
58. 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)
59. 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);
60. } }
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: ");
61. 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))
62. 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();
63. 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)); } }
64. 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.
