J
ava2
incluye Swing, Threads,
programación en red,
JavaBeans, JDBC y
JSP / Servlets
Autor: Jorge Sánchez (www.jorgesanchez.net) año 2004
Basado en el lenguaje Java definido por Sun
(http://java.sun.com)
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Orientación Universidad
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Busca documentos
Prepara tus exámenes con los documentos que comparten otros estudiantes como tú en Docsity
Busca tu universidad
Encuentra los documentos específicos para los exámenes de tu universidad
Video Cursos
Estudia con lecciones y exámenes resueltos basados en los programas académicos de las mejores universidades
Quiz
Responde a preguntas de exámenes reales y pon a prueba tu preparación
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Comunidad
Pregúntale a la comunidad
Pide ayuda a la comunidad y resuelve tus dudas de estudio
Ebooks gratuitos
¡Nuestros e-books salva-estudiantes!
Descarga nuestras guías gratuitas sobre técnicas de estudio, métodos para controlar la ansiedad y consejos para la tesis preparadas por los tutores de Docsity
Java proceso para aprender, Ejercicios de Programación Java
en este documento encontramos como podemos aprender a programar y las bases necesarias para programar
Tipo: Ejercicios
2020/2021
1 / 320
Esta página no es visible en la vista previa
¡No te pierdas las partes importantes!
Documentos relacionados
Vista previa parcial del texto
¡Descarga Java proceso para aprender y más Ejercicios en PDF de Programación Java solo en Docsity!
Java
incluye Swing, Threads,
programación en red,
JavaBeans, JDBC y
JSP / Servlets
Autor: Jorge Sánchez (www.jorgesanchez.net) año 2004
Basado en el lenguaje Java definido por Sun (http://java.sun.com)
ín índdiiccee
Manual de Java
- introducción
- historia de Java...............................................................................................................................
- características de Java.....................................................................................................................
- empezar a trabajar con Java............................................................................................................
- escritura de programas Java
- instrucción import
- variables
- introducción
- declaración de variables................................................................................................................
- alcance o ámbito
- tipos de datos primitivos
- operadores...................................................................................................................................
- estructuras de control del flujo
- if
- switch...........................................................................................................................................
- while............................................................................................................................................
- do while
- for
- sentencias de salida de un bucle
- arrays y cadenas.............................................................................................
- arrays
- clase String...................................................................................................................................
- objetos y clases
- programación orientada a objetos
- propiedades de la POO
- introducción al concepto de objeto
- clases...........................................................................................................................................
- objetos.........................................................................................................................................
- especificadores de acceso
- creación de clases.........................................................................................................................
- métodos y propiedades genéricos ( static )
- el método main
- destrucción de objetos...................................................................................................................
- reutilización de clases.....................................................................................
- herencia.......................................................................................................................................
- clases abstractas
- final
- clases internas
- interfaces
- creación de paquetes
- excepciones índice
- introducción a las excepciones.......................................................................................................
- try y catch
- manejo de excepciones
- throws..........................................................................................................................................
- throw
- finally
- clases fundamentales (I).................................................................................
- la clase Object
- clase Class
- reflexión
- clases para tipos básicos
- clase StringBuffer
- números aleatorios
- fechas
- cadenas delimitadas. StringTokenizer
- entrada y salida en Java................................................................................
- clases para la entrada y la salida
- entrada y salida estándar...............................................................................................................
- Ficheros
- clase File......................................................................................................................................
- secuencias de archivo
- RandomAccessFile
- el administrador de seguridad......................................................................................................
- serialización
- clases fundamentales (II) colecciones
- estructuras estáticas de datos y estructuras dinámicas
- interfaz Collection
- Listas enlazadas
- colecciones sin duplicados...........................................................................................................
- árboles. SortedSet
- mapas
- colecciones de la versión 1.0 y 1.1
- la clase Collections
- clases fundamentales (y III)..........................................................................
- números grandes
- internacionalización. clase Locale.................................................................................................
- formatos numéricos.....................................................................................................................
- Propiedades
- temporizador
- © Jorge Sánchez Asenjo’
- Swing.............................................................................................................
- AWT y Swing
- componentes..............................................................................................................................
- Contenedores.............................................................................................................................
- eventos
- mensajes hacia el usuario. clase JOptionPane...............................................................................
- Programación de gráficos. Java2D
- Java2D
- paneles de dibujo
- clases de dibujo y contextos gráficos.............................................................................................
- representación de gráficos con Java 2D........................................................................................
- formas 2D..................................................................................................................................
- áreas
- trazos.........................................................................................................................................
- pintura
- transformaciones
- recorte
- composición...............................................................................................................................
- fuentes
- imágenes de mapas de bits..........................................................................................................
- Threads
- Introducción
- clase Thread y la interfaz Runnable
- creación de threads
- control de Threads
- estados de un thread
- sincronización.............................................................................................................................
- componentes Swing
- introducción
- administración de diseño
- apariencia..................................................................................................................................
- etiquetas
- cuadros de texto
- cuadros de contraseña
- botones......................................................................................................................................
- eventos ActionEvent.....................................................................................................................
- casillas de activación...................................................................................................................
- botones de opción
- viewport
- JScrollPane.................................................................................................................................
- Barras de desplazamiento............................................................................................................
- deslizadores
- listas
- cuadros combinados
- cuadros de diálogo Swing
- applets índice
- introducción
- métodos de una applet................................................................................................................
- la etiqueta applet
- parámetros.................................................................................................................................
- manejar el navegador desde la applet..........................................................................................
- paquetes
- archivos JAR
- el administrador de seguridad......................................................................................................
- programación en red....................................................................................
- introducción
- sockets.......................................................................................................................................
- clientes
- servidores...................................................................................................................................
- métodos de Socket......................................................................................................................
- clase InetAddress
- conexiones URL
- JEditorPane
- conexiones URLConnection..........................................................................................................
- JDBC
- introducción
- conexión
- ejecución de comandos SQL. interfaz Statement
- Excepciones en la base de datos
- resultados con posibilidades de desplazamiento y actualización. JDBC 2.0......................................
- metadatos
- proceso por lotes
- Servlets y JSP
- tecnologías del lado del servidor
- J2EE
- empaquetamiento de las aplicaciones web
- http............................................................................................................................................
- Servlets
- JSP
- colaboración entre Servlets y/o JSPs
- JavaBeans.....................................................................................................
- introducción
- empaquetamiento de JavaBeans
- propiedades de los JavaBeans
Manual de Java introducción
Fortran 1954
Algol 1958
Cobol 1959
Lisp 1958
CPL 1963
B 1969 C 1971
C++ 1983
Logo Pascal 1968 1970
Basic 1964
Oak 1991
Java 1995 Java 2 1998
Delphi 1995
Turbo Pascal 1988
Quick Basic 1984
Visual Basic 1991
JavaScript 1995
PHP 1995
Perl 1987
Simula 1964
C # 2000
Awk 1978
Sh 1971
Modula 1975
Python 1991
VBScript 1993
ASP 1996
SmallTalk 1973
Ilustración 1, Evolución de algunos lenguajes de programación
la llegada de Java
En 1991, la empresa Sun Microsystems crea el lenguaje Oak ( de la mano del llamado proyecto Green ). Mediante este lenguaje se pretendía crear un sistema de televisión interactiva. Este lenguaje sólo se llegó a utilizar de forma interna. Su propósito era crear un lenguaje independiente de la plataforma y para uso en dispositivos electrónicos. Se intentaba con este lenguaje paliar el problema fundamental del C++; que consiste en que al compilar se produce un fichero ejecutable cuyo código sólo vale para la plataforma en la que se realizó la compilación. Sun deseaba un lenguaje para programar
© Jorge Sánchez Asenjo’ 2004
pequeños dispositivos electrónicos. La dificultad de estos dispositivos es que cambian continuamente y para que un programa funcione en el siguiente dispositivo aparecido, hay que rescribir el código. Por eso Sun quería crear un lenguaje independiente del dispositivo. En 1995 pasa a llamarse Java y se da a conocer al público. Adquiere notoriedad rápidamente. Java pasa a ser un lenguaje totalmente independiente de la plataforma y a la vez potente y orientado a objetos. Esa filosofía y su facilidad para crear aplicaciones para redes TCP/IP ha hecho que sea uno de los lenguajes más utilizados en la actualidad. La versión actual de Java es el llamado Java 2. Sus ventajas sobre C++ son:
Su sintaxis es similar a C y C++
No hay punteros (lo que le hace más seguro)
Totalmente orientado a objetos
Muy preparado para aplicaciones TCP/IP
Implementa excepciones de forma nativa
Es interpretado (lo que acelera su ejecución remota, aunque provoca que las
aplicaciones Java se ejecuten más lentamente que las C++ en un ordenador local).
Permite multihilos
Admite firmas digitales
Tipos de datos y control de sintaxis más rigurosa
Es independiente de la plataforma
La última ventaja (quizá la más importante) se consigue ya que el código Java no se compila, sino que se precompila, de tal forma que se crea un código intermedio que no es ejecutable. Para ejecutarle hace falta pasarle por un intérprete que va ejecutando cada línea. Ese intérprete suele ser la máquina virtual de Java,
Java y JavaScript
Una de las confusiones actuales la provoca el parecido nombre que tienen estos dos lenguajes. Sin embargo no tienen nada que ver entre sí; Sun creo Java y Netscape creo JavaScript. Java es un lenguaje completo que permite realizar todo tipo de aplicaciones. JavaScript es código que está inmerso en una página web. La finalidad de JavaScript es mejorar el dinamismo de las páginas web. La finalidad de Java es crear aplicaciones de todo tipo (aunque está muy preparado para crear sobre todo aplicaciones en red). Finalmente la sintaxis de ambos lenguajes apenas se parece,
características de Java
bytecodes
Un programa C o C++ es totalmente ejecutable y eso hace que no sea independiente de la plataforma y que su tamaño normalmente se dispare ya que dentro del código final hay que incluir las librerías de la plataforma
© Jorge Sánchez Asenjo’ 2004
generar programas para atacar sistemas. Tampoco se permite el acceso directo a memoria y además. La primera línea de seguridad de Java es un verificador del bytecode que permite comprobar que el comportamiento del código es correcto y que sigue las reglas de Java. Normalmente los compiladores de Java no pueden generar código que se salte las reglas de seguridad de Java. Pero un programador malévolo podría generar artificialmente código bytecode que se salte las reglas. El verificador intenta eliminar esta posibilidad. Hay un segundo paso que verifica la seguridad del código que es el verificador de clase que es el programa que proporciona las clases necesarias al código. Lo que hace es asegurarse que las clases que se cargan son realmente las del sistema original de Java y no clases creadas reemplazadas artificialmente. Finalmente hay un administrador de seguridad que es un programa configurable que permite al usuario indicar niveles de seguridad a su sistema para todos los programas de Java. Hay también una forma de seguridad relacionada con la confianza. Esto se basa es saber que el código Java procede de un sitio de confianza y no de una fuente no identificada. En Java se permite añadir firmas digitales al código para verificar al autor del mismo.
tipos de aplicaciones Java
applet
Son programas Java pensados para ser colocados dentro de una página web. Pueden ser interpretados por cualquier navegador con capacidades Java. Estos programas se insertan en las páginas usando una etiqueta especial (como también se insertan vídeos, animaciones flash u otros objetos). Los applets son programas independientes, pero al estar incluidos dentro de una página web las reglas de éstas le afectan. Normalmente un applet sólo puede actuar sobre el navegador. Hoy día mediante applets se pueden integrar en las páginas web aplicaciones multimedia avanzadas (incluso con imágenes 3D o sonido y vídeo de alta calidad)
aplicaciones de consola
Son programas independientes al igual que los creados con los lenguajes tradicionales.
aplicaciones gráficas
Aquellas que utilizan las clases con capacidades gráficas (como awt por ejemplo).
servlets
Son aplicaciones que se ejecutan en un servidor de aplicaciones web y que como resultado de su ejecución resulta una página web.
empezar a trabajar con Java
el kit de desarrollo Java (JDK)
Para escribir en Java hacen falta los programas que realizan el precompilado y la interpretación del código, Hay entornos que permiten la creación de los bytecodes y que incluyen herramientas con capacidad de ejecutar aplicaciones de todo tipo. El más famoso
Manual de Java introducción
(que además es gratuito) es el Java Developer Kit (JDK) de Sun, que se encuentra disponible en la dirección http://java.sun.com. Actualmente ya no se le llama así sino que se le llama SDK y en la página se referencia la plataforma en concreto.
versiones de Java
Como se ha comentado anteriormente, para poder crear los bytecodes de un programa Java, hace falta el JDK de Sun. Sin embargo, Sun va renovando este kit actualizando el lenguaje. De ahí que se hable de Java 1.1, Java 1.2, etc. Actualmente se habla de Java 2 para indicar las mejoras en la versión. Desde la versión 1.2 del JDK, el Kit de desarrollo se llama Java 2 Developer Kit en lugar de Java Developer Kit. La última versión es la 1.4.2. Lo que ocurre (como siempre) con las versiones, es que para que un programa que utilice instrucciones del JDK 1.4.1, sólo funcionará si la máquina en la que se ejecutan los bytecodes dispone de un intérprete compatible con esa versión.
Java 1.
Fue la primera versión de Java y propuso el marco general en el que se desenvuelve Java. está oficialmente obsoleto, pero hay todavía muchos clientes con esta versión.
Java 1.
Mejoró la versión anterior incorporando las siguientes mejoras:
El paquete AWT que permite crear interfaces gráficos de usuario, GUI.
JDBC que es por ejemplo. Es soportado de forma nativa tanto por Internet Explorer
como por Netscape Navigator.
RMI llamadas a métodos remotos. Se utilizan por ejemplo para llamar a métodos de
objetos alojados en servidor.
Internacionalización para crear programas adaptables a todos los idiomas
Java 2
Apareció en Diciembre de 1998 al aparecer el JDK 1.2. Incorporó notables mejoras como por ejemplo:
JFC. Java Foundation classes. El conjunto de clases de todo para crear programas
más atractivos de todo tipo. Dentro de este conjunto están:
El paquete Swing. Sin duda la mejora más importante, este paquete permite realizar lo mismo que AWT pero superándole ampliamente.
Java Media
Enterprise Java beans. Para la creación de componentes para aplicaciones
distribuidas del lado del servidor
Java Media. Conjunto de paquetes para crear paquetes multimedia:
Java 2D. Paquete (parte de JFC) que permite crear gráficos de alta calidad en los programas de Java.
Manual de Java introducción
lenguajes, extensiones de todo tipo (CORBA, Servlets,...). Incluye además un servidor de aplicaciones Tomcat para probar aplicaciones de servidor. Se descarga en www.netbeans.org.
Eclipse. Es un entorno completo de código abierto que admite numerosas
extensiones (incluido un módulo para J2EE) y posibilidades. Es uno de los más utilizados por su compatibilidad con todo tipo de aplicaciones Java y sus interesantes opciones de ayuda al escribir código.
Sun ONE Studio. Entorno para la creación de aplicaciones Java creado por la propia
empresa Sun a partir de NetBeans (casi es clavado a éste). la versión Community Edition es gratuita (es más que suficiente), el resto son de pago. Está basado en el anterior. Antes se le conocía con el nombre Forte for Java. Está implicado con los servidores ONE de Java.
Microsoft Visual J++ y Visual J#. Ofrece un compilador. El más recomendable para
los conocedores de los editores y compiladores de Microsoft (como Visual Basic por ejemplo) aunque el Java que edita está más orientado a las plataformas de servidor de Microsoft.
Visual Cafe. Otro entorno veterano completo de edición y compilado. Bastante
utilizado. Es un producto comercial de la empresa Symantec.
JBuilder. Entorno completo creado por la empresa Borland (famosa por su lenguaje
Delphi) para la creación de todo tipo de aplicaciones Java, incluidas aplicaciones para móviles.
JDeveloper. De Oracle. Entorno completo para la construcción de aplicaciones Java
y XML. Uno de los más potentes y completos (ideal para programadores de Oracle).
Visual Age. Entorno de programación en Java desarrollado por IBM. Es de las
herramientas más veteranas. Actualmente en desuso.
IntelliJ Idea. Entorno comercial de programación bastante fácil de utilizar pero a la
vez con características similares al resto. Es menos pesado que los anteriores y muy bueno con el código.
JCreator Pro. Es un editor comercial muy potente y de precio bajo. Ideal (junto con
Kawa) para centrarse en el código Java. No es un IDE completo y eso lo hace más ligero, de hecho funciona casi en cualquier máquina.
Kawa Pro. Muy similar al anterior. Actualmente se ha dejado de fabricar.
escritura de programas Java
codificación del texto
Todos el código fuente Java se escriben en documentos de texto con extensión .java. Al ser un lenguaje para Internet, la codificación de texto debía permitir a todos los programadores de cualquier idioma escribir ese código. Eso significa que Java es compatible con la codificación Unicode. En la práctica significa que los programadores que usen lenguajes distintos del inglés no tendrán problemas para escribir símbolos de su idioma. Y esto se puede extender para nombres de clase, variables, etc.
© Jorge Sánchez Asenjo’ 2004
La codificación Unicode 2 usa 16 bits (2 bytes por carácter) e incluye la mayoría de los códigos del mundo.
notas previas
Los archivos con código fuente en Java deben guardarse con la extensión .java. Como se ha comentado cualquier editor de texto basta para crearle. Algunos detalles importantes son:
En java (como en C) hay diferencia entre mayúsculas y minúsculas.
Cada línea de código debe terminar con ;
Los comentarios; si son de una línea debe comenzar con “//” y si ocupan más de una
línea deben comenzar con “/” y terminar con “/”
/* Comentario de varias líneas */ //Comentario de una línea
También se pueden incluir comentarios javadoc (ver más adelante)
A veces se marcan bloques de código, los cuales comienza con { y terminan con } El
código dentro de esos símbolos se considera interno al bloque { ...código dentro del bloque } código fuera del bloque
el primer programa en Java
public class app { public static void main(String[] args ) { System.out.println(“¡Mi primer programa!”); } }
Este código escribe “¡Mi primer programa!” en la pantalla. El archivo debería llamarse app.java ya que esa es la clase pública. El resto define el método main que es el que se ejecutará al lanzarse la aplicación. Ese método utiliza la instrucción que escribe en pantalla.
proceso de compilación
Hay que entender que Java es estricto en cuanto a la interpretación de la programación orientada a objetos. Así, se sobrentiende que un archivo java crea una (y sólo) clase. Por eso al compilar se dice que lo que se está compilando es una clase.
(^2) Para más información acudir a http://www.unicode.org
© Jorge Sánchez Asenjo’ 2004
javadoc
Javadoc es una herramienta muy interesante del kit de desarrollo de Java para generar automáticamente documentación Java. genera documentación para paquetes completos o para archivos java. Su sintaxis básica es:
javadoc archivo.java o paquete
El funcionamiento es el siguiente. Los comentarios que comienzan con los códigos /**** se llaman comentarios de documento y serán utilizados por los programas de generación de documentación javadoc. Los comentarios javadoc comienzan con el símbolo / y terminan con */ Cada línea javadoc se inicia con un símbolo de asterisco. Dentro se puede incluir cualquier texto. Incluso se pueden utilizar códigos HTML para que al generar la documentación se tenga en cuenta el código HTML indicado. En el código javadoc se pueden usar etiquetas especiales, las cuales comienzan con el símbolo @. Pueden ser:
@author. Tras esa palabra se indica el autor del documento.
@version. Tras lo cual sigue el número de versión de la aplicación
@see. Tras esta palabra se indica una referencia a otro código Java relacionado con
éste.
@since. Indica desde cuándo esta disponible este código
@deprecated. Palabra a la que no sigue ningún otro texto en la línea y que indica
que esta clase o método esta obsoleta u obsoleto.
@throws. Indica las excepciones que pueden lanzarse en ese código.
@param. Palabra a la que le sigue texto qué describe a los parámetros que requiere
el código para su utilización (el código en este caso es un método de clase). Cada parámetro se coloca en una etiqueta @param distinta, por lo que puede haber varios @param para el mismo método.
@return. Tras esta palabra se describe los valores que devuelve el código (el código
en este caso es un método de clase)
El código javadoc hay que colocarle en tres sitios distintos dentro del código java de la aplicación:
1> Al principio del código de la clase (antes de cualquier código Java). En esta
zona se colocan comentarios generales sobre la clase o interfaz que se crea mediante el código Java. Dentro de estos comentarios se pueden utilizar las etiquetas: @author, @version, @see, @since y @deprecated
2> Delante de cada método. Los métodos describen las cosas que puede
realizar una clase. Delante de cada método los comentarios javadoc se usan para describir al método en concreto. Además de los comentarios, en esta zona
Manual de Java introducción
se pueden incluir las etiquetas: @see, @param, @exception, @return, @since y @deprecated
3> Delante de cada atributo. Se describe para qué sirve cada atributo en cada
clase. Puede poseer las etiquetas: @since y @deprecated
Ejemplo:
_/ Esto es un comentario para probar el javadoc
- este texto aparecerá en el archivo HTML generado.
- Realizado en agosto 2003
- @author Jorge Sánchez
- @version 1. /_* public class prueba1 { //Este comentario no aparecerá en el javadoc
_/ Este método contiene el código ejecutable de la clase
- @param args Lista de argumentos de la línea de comandos
- @return void /_*
public static void main( String args[]){ System.out.println("¡Mi segundo programa! "); } }
Tras ejecutar la aplicación javadoc, aparece como resultado la página web de la página siguiente.