Libro en Desarrollo

TABLA DE CONTENIDO
INTRODUCCIÓN DEL LIBRO ............................................................................................................................. 4

CAPITULO 1 –INTRODUCCIÓN AL LENGUAJE DE PROGRAMACIÓN JAVA ........................................ 4
Historia de Java ................................................................................................................................................. 4
Características del lenguaje Java ................................................................................................................... 6
Algunas críticas realizadas al lenguaje Java ................................................................................................ 8
Kit de Desarrollo de Java o Java Development Kit(JDK) ............................................................................ 8
Instalación del Java Development Kit (JDK) en Windows .......................................................................... 9
Arquitectura de librerías de Java (API – Interfaz de Programación de Aplicaciones) .......................... 14
Plataformas de Java ....................................................................................................................................... 15
IDE´s y Editores de desarrollo del lenguaje Java....................................................................................... 15
CAPITULO 2 – FUNDAMENTOS DEL LENGUAJE JAVA ........................................................................... 16
Tokens............................................................................................................................................................... 16
Expresiones ...................................................................................................................................................... 21
Bloques y ámbitos ........................................................................................................................................... 22
Variables ........................................................................................................................................................... 23
Comentarios y espacios en blanco ............................................................................................................... 25
Estructura básica de un programa en Java................................................................................................. 25
Imprimir un mensaje por consola .................................................................................................................. 25
Leer e imprimir un mensaje por consola ...................................................................................................... 26
Estructuras de control ..................................................................................................................................... 32
Contadores ....................................................................................................................................................... 42
Acumuladores o totalizadores ....................................................................................................................... 43
Excepciones en Java ...................................................................................................................................... 43
Concatenación ................................................................................................................................................. 43
TEMA 3 – OBJETOS Y CLASES ...................................................................................................................... 43
Herencia ............................................................................................................................................................ 47
Interfaces .......................................................................................................................................................... 49
Polimorfismo..................................................................................................................................................... 49
Encapsulamiento ............................................................................................................................................. 50
Paquetes ........................................................................................................................................................... 50
Referencia a los miembros o atributos de una clase (this y super) ......................................................... 50
Recursividad de métodos ............................................................................................................................... 50
TEMA 4 – Estructuras de datos en Java ......................................................................................................... 50
Arreglos ............................................................................................................................................................. 50
Matrices............................................................................................................................................................. 50
Pilas ................................................................................................................................................................... 50
Colas.................................................................................................................................................................. 50
Listas ................................................................................................................................................................. 50
Collections (Clases Vector, ArrayList, Interfaces Iterator, Enumeration) ............................................... 50
CAPITULO 5 – ARCHIVOS ............................................................................................................................... 50
CAPITULO 6 – Programación Multihilos ......................................................................................................... 57
CAPITULO 7 – JAVA FUNDATION CLASS (JFC) ........................................................................................ 57
CAPITULO 8 – Imágenes, animaciones y audio ............................................................................................ 90
CAPITULO 9 – Creación de archivos .exe e instaladores ............................................................................ 91
CAPITULO 9 – Redes ........................................................................................................................................ 91
CAPITULO 10 – Conectividad de bases de datos ......................................................................................... 95
INTRODUCCIÓN DEL LIBRO
Bienvenido al conocimiento del lenguaje de programación Java. Este libro se ha diseñado lo más
claro y comprensible posible, apuntándole a que usted avanzase por cada capítuloal entendimiento
de las estructura sintácticas del lenguaje Java y adquiera competencias para crear aplicaciones de
escritorios y orientadas a la web, según cada fase de conocimiento gracias a la metodología teórico
practica que ofrece este libro. En él va a encontrar explicado en texto, graficas y videos referentes,
todo lo referente a lo que el lenguaje Java posibilita hacer, con ejercicios que usted pueda analizar,
resolver y aplicar.
Para asegurar el aprendizaje se recomienda leer detalladamente el libro, analizar las imágenes que
contiene, observar los videos y resolver los ejercicios desarrollados.
.
CAPITULO 1 –INTRODUCCIÓNAL
LENGUAJE DE PROGRAMACIÓN JAVA
Este primer capítulo nos regalara un enfoque general del lenguaje de programación Java,
aportándonos información relevante y detallada para que continuemos nuestro estudio por cada uno
de los capítulos, y podamos resolver los ejercicios que se proponen.
Historia de Java
Java es un lenguaje de programación orientado a objetos desarrollado por un grupo de ingeniero de
Sun Microsystems,cuando en el año 1990 Patrick Naughton, reclutó a varios colegas entre
ellos James Gosling y Mike Sheridan, para trabajar en un proyecto conocido como “El proyecto
Verde”, en el que trabajaron 18 meses dentro de una pequeña oficina en Sand Hill Road en Menlo
Park, California.Intentaban desarrollar una nueva tecnología para programar la futura generación de
dispositivos electrónicos, como calculadoras, hornos microondas y televisores interactivos.
James Gosling intentó en primera instancia extender y modificar el lenguaje C++ el resultando fue 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 español, según la versión más
aceptada, por el roble que veía a través de la ventana de su despacho).
En Agosto de 1991 Oak ya corría sus primeros programas, y para 1992, ya había desarrollado un
sistema en un prototipo llamado Star7 (*7), dispositivo parecido a una PDA (asistente digital
personal).
Scott McNealy, presidente de Sun Microsystems, estableció el Proyecto Verde como una subsidiaria
de Sun y el 3 de septiembre del 1992 se terminó el proyecto verde pero al mismo tiempo nace el
fenómeno mundial de la Web.
De 1993 a 1994, el equipo de Patrick Naughton se lanzó en busca de nuevas oportunidades en el

mercado. Al examinar las dinámicas de Internet, lo realizado por el equipo verde se adecuaba a este
nuevo ambiente (Web). Durante el año 1993Patrick Naughton y su equipo procedió a la construcción
del lenguaje de programación que se pudiera accionar con un browser.
El 29 de septiembre de 1994 se termina el desarrollo del prototipo de HotJava(Permitiendo ofrecer

soporte a applets). Más tarde, en el mismo año, se cambiaría el nombre de Oak a Java, al existir ya
un lenguaje con el nombre de Oak. Se supone que le pusieron ese nombre mientras tomaban café
(Java es nombre de un tipo de café, originario de Asia), aunque otros afirman que el nombre deriva
de las siglas de James Gosling, Arthur Van Hoff, y Andy Bechtolsheim.
En este mismo año se leshace la demostración a los ejecutivos de Sun, esta vez, se reconocen el
potencial de Java y se acepta el proyecto.
En enero de 1995 Sun forma la empresa Java Soft para dedicarse al desarrollo de productos
basados en la tecnología Java, y así trabajar con terceras partes para crear aplicaciones,
herramientas, sistemas de plataforma y servicios para aumentar las capacidades del lenguaje. Ese
mismo año aparece la versión 1.0 del JDK(Kit de desarrollo de Java).
El 23 de Mayo de 1995 Netscape anunció que incluiría soporte para Java en sus navegadores, dando
con esto un buen apoyo a Java.
Actualmente Java paso a propiedad de la empresa Oracle al ser compradorade la mayor parte de las
acciones de Sun Microsystems.
La tecnología Java lo podemos 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: en conclusión hoy día Java está en
todas partes.
Figura Nro 1: Línea de tiempo de hechos relevantes en la historia de Java

Características del lenguaje Java
El lenguaje de programación Java tiene aproximadamente seis características que lo hace llamativo
al ojo de los grandes programadores de software.
a.) SIMPLE
Fácil aprendizaje, La curva de aprendizaje de Java es rápida en este lenguaje, el único

requerimiento para aprenderlo es tener una comprensión de los conceptos básicos de la
programación orientada a objetos.
Completado con utilidades, El paquete de utilidades de Java, más conocido como la API
(Interfaz de programación de aplicaciones), viene con un conjunto completo de estructuras de
datos y sus métodos asociados, que serán de gran ayuda para desarrollar e implementar
aplicaciones. Se dispone también de estructuras de datos habituales, como arreglos, colas y
pilas, como también clases ya implementadas para manejar algunas estructuras de datos.
b.) POTENTE
Orientado a Objetos, En Java el concepto de objeto resulta sencillo y fácil de aplicar.
Riqueza semántica, Cada tarea se puede realizar de un número reducido de formas, se ha

conseguido un gran potencial de expresión e innovación desde el punto de vista del
programador.
Robusto, Java verifica su código al mismo tiempo que lo escribe (depende del IDE o el Editor
que se utilice), y una vez más antes de ejecutarse, de manera que se consigue un alto margen
de codificación sin errores. Se realiza un descubrimiento de la mayor parte de los errores durante
el tiempo de compilación, ya que Java es estricto en cuanto a tipos y declaraciones, y así lo que
es rigidez y falta de flexibilidad se convierte en eficacia.
Gestión de memoria, Java libera al programador del compromiso de tener que controlar
especialmente la asignación de memoria,el mismo administra esta y se hace a ella sus
necesidades específicas. Este lenguaje posee una gestión avanzada de memoria llamada
gestión de basura, y un manejo de excepciones orientado a objetos integrados.
Modelo rico de objetos, Existen varias clases que contienen las abstracciones básicas para
facilitar a los programas en Java. Se contará con un conjunto de clases comunes que pueden
crecer para admitir todas las necesidades del programador (a ese conjunto de clases se les “API”
Interfaz de Programación de Aplicación).
c.) INTERACTIVO Y ORIENTADO A RED
Interactivo y animado, Uno de los requisitos de Java desde sus inicios fue la posibilidad de
crear programas en red interactivos, por lo que es capaz de hacer varias cosas a la vez sin
perder rastro de lo que debería suceder y cuándo. Se da soporte a la utilización de múltiples hilos
de programación (multithread). Las aplicaciones de Java permiten situar figuras animadas en las
páginas Web, y éstas pueden concebirse con logotipos animados o con texto que se desplace
por la pantalla.
Arquitectura neutral, Java está diseñado para que un programa escrito en este lenguaje sea
ejecutado correctamente independientemente de la plataforma en la que se esté actuando
(Macintosh, PC, UNIX…). Para conseguir esto utiliza una compilación en una representación
intermedia que recibe el nombre de códigos de byte, que pueden interpretarse en cualquier
sistema operativo con un intérprete de Java (El intérprete de Java es “JVM” Máquina Virtual de
Java contenida en JRE Java Runtime Evironment).
Trabajo en red, Java anima las páginas Web y hace posible la incorporación de aplicaciones
interactivas y especializadas. Aporta la posibilidad de distribuir contenidos ejecutables, de
manera que los suministradores de información de la Web pueden crear una página de hipertexto
(página Web con código HTML) con una interacción continuada y compleja en tiempo real; el
contenido ejecutable es transferido literalmente al ordenador del usuario. Los protocolos básicos
para trabajar en Internet están encapsulados en unas cuantas clases simples. Se incluyen
implementaciones ampliables de los protocolos FTP, HTTP, NNTP y SMTP junto con conectores
de red de bajo nivel e interfaces de nombrado. Esto le permite interactuar con esos servicios de
red poderosos sin tener que comprender realmente los detalles de bajo nivel de esos protocolos.
Este lenguaje está diseñado para cumplir los requisitos de entrega de contenidos interactivos
mediante el uso de applets insertados en sus páginas HTML. Además, las clases de Java
admiten muy bien estos protocolos y formatos. El envío de las clases de Java a través de Internet
se realiza con gran facilidad, ya que existe una interfaz unificada, resolviendo así los típicos
problemas de diferencia de versiones. Java proporciona un conjunto de clases para tratar con
una abstracción de los conectores de red (sockets) originales de la versión UNIX de Berckley,
encapsular la noción de una dirección de Internet o conectar sockets con flujos de datos de
Entrada/Salida.
Applets, Una applet (miniaplicación) es un pequeño programa en Java transferido

dinámicamente a través de Internet. Presentan un comportamiento inteligente, pudiendo
reaccionar a la entrada de un usuario y cambiar de forma dinámica.
d.) SEGURIDAD
Existe una preocupación lógica en Internet por el tema de la seguridad: virus, caballos de Troya,
y programas similares navegan de forma usual por la red, constituyéndose una amenaza
palpable. Java ha sido diseñado poniendo un énfasis especial en el tema de la seguridad, y se ha
conseguido lograr cierta inmunidad en el aspecto de que un programa realizado en Java no
puede realizar llamadas a funciones globales ni acceder a recursos arbitrarios del sistema, por lo
que el control sobre los programas ejecutables no es comparable a otros lenguajes. Los niveles
de seguridad que presenta son:
• Fuertes restricciones al acceso a memoria, como son la eliminación de punteros aritméticos

y de operadores ilegales de transmisión.
• Rutina de verificación de los códigos de byte que asegura que no se viole ninguna
construcción del lenguaje.
• Verificación del nombre de clase y de restricciones de acceso durante la carga.
e.) GESTIÓN DE LA ENTRADA Y SALIDA
Permiten tratar los ficheros, sockets, teclado y monitor como flujos de datos. De este modo se
pueden utilizar para cualquier operación de Entrada/Salida.
f.) DIFERENTES TIPOS DE APLICACIONES
En el lenguaje de programación Java podemos crear los siguientes tipos de aplicaciones:
• Aplicaciones: Se ejecutan sin necesidad de un navegador (se les conoce como aplicaciones
de escritorio).
• Applets: Se pueden descargar de Internet y se observan en un navegador.
• JavaBeans: Componentes software Java, que se puedan incorporar gráficamente a otros

componentes.
• JavaScript: Conjunto del lenguaje Java que puede codificarse directamente sobre cualquier
documento HTML
• Servlets: Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas
CGI (Common Gateway Interface) a la hora de dotar de interactividad a las páginas Web.
Algunas críticas realizadas al lenguaje Java

Existen muchas críticas realizadas al lenguaje de programación Java, pero no vale la pena mencionar
todas pues muchas son sin fundamentos, además el objetivo es que usted quiera aprender el
lenguaje Java. La principal crítica a Java es debido a su lenta velocidad de ejecución, un programa en
Java es aproximadamente unas 20 veces más lento que un programa en lenguaje C, esto se debe a
la transformación de “código bytes a código maquina” que tienen que hacer los ordenadores cada vez
que ejecutan un programa Java. Sun Microsystems y Oracle (Actual socio y accionista de la mayor
cantidad de acciones de Sun Microsystems) están trabajando intensamente en crear versiones de
Java con una velocidad de ejecución mayor.
Kit de Desarrollo de Java o Java Development

Kit(JDK)
Para desarrollar un programa en el lenguaje Java, el Kit de desarrollo de Java (JDK)debe estar
instalado en el computador del programador, este Kit contiene varias aplicaciones adicionales que
apoyan esta tarea, tales como el Java Runtime Enviroment (JRE) y la Máquina virtual de Java (JVM).
El JRE es un conjunto de utilidades que contiene la JVM para poder ejecutar un programa hecho en
Java, es decir que esto es lo único que requiere tener instalado un cliente para ejecutar un aplicativo
en su máquina o PC.
Escribir el programa en
cualquier Editor de texto
Guardar el Archivo en
formato .java
Obtener Documentación
Archivo *.java
(javadoc)
Compilación con (javac) Archivos *.html
Archivo *.class Comprimir archivos a

formato .jar con (jar)
Ejecutar la aplicación con

(java o appletviewer) Archivo *.jar
Transformación a código
maquina (JVM)
Salida en pantalla del

programa escrito
Figura Nro 2: Utilización de la JDK
Los programas Java (archivos *.java) son compilados por medio del comando javac
{nombre_archivo.java} de la JDK creando bytecodes (archivos *.class) compactos, sonestos
bytecodes lo que el JVM por medio del comando java {nombre_archivo.class} lee, interpreta y
convierte a código máquina para ejecutar el programa en el ordenador.
Cuandose descarga una applet Java de la red Internet, lo que realmente está descargandoes un
archivo de bytecodes (archivo *.class) y este es interpretado por la JVM.
La compilación se le debe realizar a la clase que contenga el método principal main() o init() en caso
de que sean applets. El compilador se encargara de ir a las otras clases usadas en estos métodos y
realizar su compilación también.
Instalación del Java Development Kit (JDK) en

Windows
a.) Primeramente se debe descargar de la página el JDK, según la plataforma y la versión que
requiera, (Por legalidad y compras de acciones empresariales actualmente está página hace una
redirección a https://www.oracle.com/java/technologies/downloads/, de Oracle).
FiguraNro 3: Link de descarga desde la página de Oracle
b.) Instalar en su computadora la versión de la JDK descargada (solo sigue cada uno de los pasos).
FiguraNro 4: Programa de instalación dela JDK
c.) Configurar las variables de entono PATH y/o CLASSPATH (classpath es solo para Windows vista
o 7).
1. Pulsa click derecho sobre “Equipo o Mi PC” dependiendo del sistema.
FiguraNro 5: Click derecho sobre el equipo (Mi PC)
2. Pulsar un click sobre el menú izquierdo en “Configuración avanzada de sistema”.

FiguraNro 6: Click sobre configuración avanzada de sistema
3. Pulsar un click en la pestaña opciones avanzadas y variables de entorno.
Figura Nro 7: Opciones avanzadas Figura Nro 8: Variables de entorno
4. Localizo en la zona de variables del sistema una que se llama “Path” y pulso sobre editar.
Figura Nro 9:Abrir para Editar la variable PATH y/o CLASSPATH
5. No borramos nada de lo que contiene la variable Path y/o CLASSPATH, seguido de lo que
contiene colocamos un “;” sin espacios y la dirección donde está instalado nuestra JDK,
especialmente la carpeta “bin”. (en mi caso es C:\Program Files\Java\jdk1.6.0_24\bin),
concluimos pulsando sobre el boton aceptar.
Figura Nro 10: Editar la variable PATH y/o CLASSPATH
6. Este paso aplica es solo para windows vista o 7 y es opcional en algunos equipos, debes
repetir el paso 4 y 5, pero esta vez debes localizar la variable de entorno “CLASSPATH” y a
esta agregar la dirección de los archivos (src.zipytools.jar) según mi caso los valores son
losque está dentro de las comillas “C:\ProgramFiles\Java\jdk1.6.0_10\src.zip;C:\Program
Files\Java\jdk1.6.0_10\lib\tools.jar”. (Por ultimo no olvides presionar el botón aceptar).
7. Es recomendable reiniciar el equipo para que la configuración se afecte correctamente,

aunque esto no siempre es necesario.
d.) Abre una consola de MS–Dos y escribimos el comando de ejecución de programas de Javade la
JRE (java) y de la JDK el compilador (javac), para verificar que la configuración concluyo con
éxito. (no olvide presionar la tecla enter de su teclado).
Figura Nro 11: Prueba de configuración de JDK
e.) Abre un editor de texto y escribo el siguiente programa, al guardarlo le coloco el mismo nombre
que se le asigne a la “clase” más el consecutivo de .java en este caso. (Ejemplo.java).
Programa Nro 1: Programa escrito en un editor de texto
Figura Nro 12: Como guardar el archivo
f.) Desde MS–Dos debo acceder a la carpeta donde se guardó nuestro archivo (Ejemplo.java).
Escribiendo la letra de la unidad de disco seguido de dos punto “:” y la presión de la tecla enter
permite ingresar a la unidad de disco (d:), escribiendo las letras “cd” seguido decarpeta y la
presión de la letra enter permite acceder la carpeta donde está guardado nuestro programa
(cdprogramas).
Figura Nro 13: Acceder a la Figura Nro 14: Acceder a la carpeta

unidad de disco donde está el programa
g.) Compilar el programaescribiendo el comando de ejecución de java (javac) seguido del nombre
del programa y el tipo de archivo (javac Ejemplo.java)luego se debe presionar la tecla enter.
Ejecutar el programa (java Ejemplo).
Figura Nro 15:Compilar el programa
Figura Nro16:Ejecución del
programa
Arquitectura de librerías de Java (API – Interfaz de

Programación de Aplicaciones)
Cada una de las versiones que Sun Microsystems lanza del JDK, se acompaña de una serie de
bibliotecas con clases estándar que valen como referencia para todos los programadores en Java.
Estas clases se pueden incluir en los programas Java, sin temor a fallos de portabilidad. Además,
están bien documentadas (mediante páginas Web), y organizadas en paquetes y en un gran árbol de
herencia.
A este conjunto de paquetes de librerías(o bibliotecas) se le conoce como la API de Java (Application
Programming Interface), es contenidointerno de la JDKo JRE en un archivo comprimido de nombre
src.zip.
Los paquetesbásicos que ofrece la API de Java, son los siguientes:
a. Paquetes de utilidades
• java.lang: Fundamental para el lenguaje Java porque Incluye clases como String o
StringBuffer.
• java.io: Para la entrada y salida a través de flujos de datos, y ficheros del sistema.
• java.util: Contiene colecciones de datos y clases, el modelo de eventos, facilidades horarias,

generación aleatoria de números, y otras clases de utilidad.
• java.math: Clases para realizar aritmética con la precisión que se desee.
• java.text: Clases e interfaces para manejo de texto, fechas, números y mensajes de una
manera independiente a los lenguajes naturales.
• java.security: Clases e interfaces para seguridad en Java: Encriptación RSA.
b. Paquetes para el desarrollo gráfico
• java.applet: Para crear applets y clases que las applets utilizan para comunicarse con su
contexto.
• java.awt: Para crear interfaces con el usuario, y para dibujar imágenes y gráficos.
• javax.swing: Conjunto de componentes gráficos que funcionan igual en todas las plataformas
que Java soporta.
• javax.accesibility: Da soporte a clases de accesibilidad para personas discapacitadas.
• java.beans: Para el desarrollo de JavaBeans.
c. Paquetes para el desarrollo en red
• java.net: Clases para aplicaciones de red.
• java.sql: Paquete que contiene el JDBC, para conexión de programas Java con Bases de
datos.
• java.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e incluso enviar
objetos como parámetros de un objeto a otro.
Plataformas de Java
Java es un lenguaje que actualmente se encuentra en todas partes gracias al soporte que presta
para programar aplicaciones.Java 2 Enterprise Edition (J2EE) permite la creación de programas
para computadoras que prestan servicios a otras aplicaciones, Java 2 Standard Edition (J2SE)
permite la creación de programas a computadores convencionales, Java 2 Micro Edition (J2ME)
permite la programación de aplicación para la tecnología Móvil y Java Card permite la programación
de tarjetas(débitos, créditos, entre otros).
IDE´s y Editores de desarrollo del lenguaje Java

Los Entornos de Desarrollo Integrado (IDE´s) son programasinformáticos compuesto por muchas
herramientas de programación, puede dedicarse exclusivamente a un solo lenguaje o a varios. Un
IDE es un entorno de programación que ha sido empaquetado como un programa de aplicación, es
decir, consiste en un Editor de código, un Compilador, un Depurador y un constructor de Interfaz
Gráfica de Usuario (GUI).
• Eclipse y Netbeans, Soporta múltiples lenguajes como: Java, C/C++, PHP, entre otros.
• JCreator, es un IDE pero que no incorpora un constructor de interfaz gráfica de usuario.
• JBuilder, Soporta múltiples lenguajes como: Java, C/C++, PHP, entre otros.
Los editores solo permiten escribir los códigos de los programas y guardarlos en el formato
establecido para que pueda ser interpretado por el compilador.
• Notepad, Es un editor de múltiples lenguajes como: Java, PHP, entre otros.

CAPITULO 2 – FUNDAMENTOS DEL
LENGUAJEDE PROGRAMACIÓN JAVA
Java es un lenguaje orientado a objetos, que se deriva en alto grado de C++, de tal forma que puede
ser considerado como un C++ nuevo y modernizado o bien como un C++ al que se le han amputado
elementos heredados del lenguaje estructurado C. Con este comentario no se quiere decir que Java
fue desarrollado en C o C++, Java fue desarrollado desde cero,pero los creadores del lenguaje al ser
experto en el lenguajes C y C++ trataron de que Java lo superada, pero evitando causar un duro
impacto en los programadores de C o C++, por eso su parecido en la sintaxis del lenguaje. Es muy
fácil que un programador de C o C++ migre fácilmente a programar en Java.
Tokens
La estructura de un programa Java está definida porTokens, Un token es el elemento más pequeño
de un programa que es significativo para el compilador. Cuando se compila un programa Java, el
compilador analiza el texto, reconoce y elimina los espacios en blanco y comentarios y extrae tokens
individuales. Los tokens resultantes se compilan, traduciéndolos a código de byte Java, que es
independiente del sistema e interpretable dentro de un entorno Java.Los códigos de byte se ajustan al
sistema de Máquina Virtual Java (JVM). Los tokens Java pueden subdividirse en cinco categorías:
Identificadores, palabras clave, constantes, operadores y separadores.
a.) Indicadores, Los identificadores son tokens que representan nombres asignables a variables,
métodos y clases para identificarlos de forma única ante el compilador y darles nombres con
sentido para el programador.
Todos los identificadores de Java diferencian entre mayúsculas y minúsculas (Java es sensible a
mayúsculas y minúsculas),todos los identificadorescomienza con una letra o un subrayado (_).
Los caracteres posteriores del identificador pueden incluir las cifras del 0 al 9. Como nombres de
identificadores no se pueden usar palabras claves reservadas por Java.
Además de las restricciones mencionadas existen propuestas de estilo. Es una práctica estándar
de Java denominar:
• Las clases o interfaces: Iniciar con Letra mayúscula cada comienzo de nueva palabrao
separarlas con un “_”(Clase o MiClase o SumaMultiple o Interfacez o MiInterfaz).
• Los métodos: Iniciar con letra minúscula pero si es un identificador compuesto esta
segunda palabra debe comenzar con mayúscula o un “_”(metodo() o metodoLargo() o
sumaOperativa()).
• Las variables: Iniciar con letra minúscula pero si es un identificador compuesto esta
segunda palabra debe comenzar con mayúscula o un “_” (altura o alturaMedia).
• Las constantes: Se deben escribir todo el identificado con letras mayúsculas(CONSTATE o

CONSTANTE_LARGA).
• Los paquetes: Se deben escribir todo el identificador con letras en minúsculas
(java.paquete.subpaquete).
Sin entrar en más detalle en el siguiente ejemplo se estructuras cada uno de los identificadores.
Programa Nro 2:Ejemplo de identificadores
b.) Palabras claves, Las palabras claves son aquellos identificadores reservados por Java para un
objetivo determinado y se usan sólo de la forma limitada y específica. Java tiene un conjunto de
palabras clave más rico que C o que C++. Las siguientes palabras son reservadas por Java:
abstact boolean break byte byvalue
case cast catch char class
const continue default do double
else extends false final finally
float for future generic goto
if implements import inner instanceof
int interface long native new
null operator outer package private
protected public rest return short
static super switch syncroniced this
throw throws transient true try
var void volatile while
Tabla Nro 1: Palabras reservadas Java

Las palabras subrayadas son palabras reservadas pero no se utilizan en Java. La definición de
estas palabras clave no se ha revelado, ni se tiene un calendario respecto a cuándo estará
alguna de ellas en la especificación o en alguna de las implementaciones de Java.
c.) Literales o Constantes, Los literales son sintaxis para asignar valores constantesa las variables.
Cada variable es de un tipo de datos concreto, y dichos tipos de datos tienen sus propios literales
(identificador + constante).Mediante determinados modificadores (static y final) podremos crear
variables constantes, que no modifican su valor durante la ejecución de un programa. Las
constantes pueden ser numéricas, booleanas, caracteres (Unicode) o cadenas (String).
Programa Nro 3: Ejemplodeclaración de literales o constantes
Se puede observar en este ejemplo la utilización de la palabra “final y final static”, con la palabra
reservada “final” se coloca la variable constante por ese motivo no se puede modificar su valor, la
variable “final static” al igual que la anterior es constante pero tiene en particular que esta se
puede acceder desde fuera de cualquier clasey si no tiene la palabra “final” se puede modificar.
Programa Nro 4: Acceso a la constante PI
Programa Nro 5: Acceso a la constante ALTURA_MAXIMA

Programa Nro 6:Declaración variable static que no es constante
Programa Nro 7: Acceso a variable static
d.) Operadores, Conocidos también como operando, indican una evaluación o computación para
ser realizada en objetos o datos, y en definitiva sobre identificadores o constantes. Los
operadores admitidos por Java son de cuatro tipos:
• Operadores Aritméticos
Operador Uso Descripción

+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Calcula el resto de dividir op1 entre op2
Tabla Nro 2: Operadores aritméticos binarios de Java
• Operadores de Asignación
Operador Uso Equivalente a

= op1=op2
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
Tabla Nro 3: Operadores de atajo de asignación en java
• Operadores Relacionales, Esto tipo operador se diferencia de los demás porque

comprobada la operación devuelve un valor de “verdad o falsedad”.
Operador Uso Devuelve verdadero o falso
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos
Tabla Nro 4: Operadores de relacionales en Java
• Operadores especiales
Operador Uso Descripción

++ op++ Incrementa op en 1; se evalúa al valor anterior al incremento
++ ++op Incrementa op en 1; se evalúa al valor posterior al incremento
-- op-- Decrementa op en 1; se evalúa al valor anterior al incremento
-- --op Decrementa op en 1; se evalúa al valor posterior al incremento
Tabla Nro 5: Operaciones especiales en Java
Todos los operadores en Java tienen un nivel de precedenciapara determinar al compilador el

orden de ejecución de los operando.Los operadores mencionados a continuación en la misma
línea tienen igual precedencia.
Tipo de operadores Operadores de este tipo

Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creación o conversión new (tipo) expr
Multiplicación */%
Suma +-
Desplazamiento <<
Comparación <<= = instanceof
Igualdad == !=
AND a nivel de bit &
OR a nivel de bit ^
XOR a nivel de bit |
AND lógico &&
OR lógico ||
Condicional ?:
Asignación = += -= *= /= %= &= ^= |= <<= = =
Tabla Nro 6: Precedencia de operadores en Java
Los operadores binarios tienen la misma prioridad excepto los operadores de asignación, porque
este se evalúa por el compilador de derecha a izquierda, contario a los demás que se evalúan de
izquierda a derecha.
e.) Separadores, Se usan para informar al compilador de Java cómo están agrupadas las cosas en
el código.Los separadores admitidos por Java son: { } () , ; . []
Expresiones
Una expresión es un conjunto o combinación de variables y llamadas de métodos unidas por
operadores,construidas de acuerdo a la sintaxis del lenguaje. El comportamiento real de un programa
Java se logra a través de expresiones, que se agrupan para crear sentencias.
Java identifica dos tipos de expresiones básicas Aritméticas y Lógicas, las expresiones aritméticas
se caracterizan porque los operandos que intervienen son número, los resultados también son
numéricos y los operadores son aritméticos (+,- , *, entre otros); las expresiones lógicas los
operadores son lógicas o relacionales (<=, ==, &&, ||, entre otros) y los resultados solo pueden ser
verdaderos o falsos.
Una sentencia en Java es una expresión que termina con un punto y como “;” y se pueden incluir
varias sentencias en una sola línea. Aunque lo habitual es utilizar una línea por cada sentencia.
Programa Nro 8: Conjunto de sentencias y expresiones
En el ejemplo anterior se muestran seis sentencias, línea 5, 6, 7, 9, 11 y 12, la sentencia de la línea

11 es especial porque es condicional. Dos expresiones en la línea 9 y 11 aunque se podría pensar
que la línea 12 también es una expresión por tener llamada al método println y la concatenación de
caracteres con el operador “+”.
Las expresiones son utilizadas para realizar cálculos, para asignar valores a variables, y para ayudar
a controlar la ejecución del flujo del programa. La tarea de una expresión se compone de dos partes:
realiza el cálculo indicado por los elementos de la expresión y devuelve el valor obtenido como
resultado del cálculo.
El tipo de datos del valor devuelto por una expresión depende de los elementos utilizados en la
expresión. La expresión suma = a + b; devuelve un entero porque a = 10 y b = 5, ambos son
enterospor tanto devuelve un valor del mismo tipo. Otras expresiones devuelven valores booleanos,
cadenas, entre otros, como:x=suma % 2 == 0 en donde aplica un operador aritmética para
determinar el módulo de división y uno relacional para identificar la igualdad, si es igual a cero
devuelve true, caso contrario false.
Una expresión de llamada a un método se evalúa al valor de retorno del método; así el tipo de dato
de la expresión de llamada a un método es el mismo que el tipo de dato del valor de retorno de ese
método.
Como se puede observar, Java permite construir sentencias (expresiones compuestas) a partir de
varias expresiones más pequeñas con tal que los tipos de datos requeridos por una parte de la
expresión concuerden con los tipos de datos de la otra.
Bloques y ámbitos
En Java el código fuente está dividido en partes separadas por llaves, denominas bloques. Cada
bloque existe independiente de lo que está fuera de él, agrupando en su interior sentencias o
expresiones relacionadas.Java presenta una jerarquía de bloques, externos e internos o subbloques.
El concepto de ámbito está estrechamente relacionado con el concepto de bloque y es muy

importante cuando se trabaja con variables en Java. El ámbito se refiere a cómo las secciones de un
programa (bloques) afectan el tiempo de vida de las variables.
Toda variable tiene un ámbito en el que es usada, que viene determinado por los bloques. Una
variable definida en un bloque interno no es visible por el bloque externo.
Las llaves de separación son importantes no sólo en un sentido lógico, ya que son la forma en que el
compilador diferencie dónde acaba una sección de código y dónde comienza otra, sino que tienen
una connotación estética que facilita la lectura de los programas al ser humano.
Así mismo, para identificar los diferentes bloques se utilizan sangrías. Las sangrías se utilizan para el
programador, no para el compilador. La sangría (también denominada indentación o tabulación).
publicclassCalcular{// Bloque externo
int x = 1;
public Calcular(){ // Bloque interno

inty = 2;
}
x = y; // Da error porqueyestá fuera de ámbito al que pertenece
publicvoid suma(){ // Bloque interno

inty = 2;
x=y; // Ejecuta correctamente ya que x si es visible en todos los bloques
o ámbitos internosyestá internamente en el ámbito
}
}// Fin del bloque externo
Programa Nro 9: Función con bloques internos

Tipos de datos
Los tipos de datos aceptados por el lenguaje de programación Java determinan los métodos de
almacenamiento de la información que contendrán las variables.
Los tipos de datos en Java pueden dividirse en dos categorías: Simples o primitivos y Compuesto.
Los tipos de datos simples son tipos nucleares que no se derivan de otros tipos, como los enteros, los
de coma flotante, booleanos y de carácter. Los tipos compuestos se basan en los tipos simples, e
incluyen las cadenas, las matrices y tanto las clases como las interfaces, en general (Ejemplo: un
objeto que utiliza diferentes atributos de tipo “String, double, float y boolean” para realizar sus
operaciones es un tipo de dato compuesto “objeto”).
• Tipo de datos enteros, Se usan para representar números enteros con signo.
Tipo dato Tamaño Valor Mínimo Valor Máximo

Byte 1Byte (8 bits) -128 127
short 2 Bytes (16 bits) -32.768 32.767
Int 4 Bytes (32 bits) -2.147.483.648 2.147.483.647
Long 8 Bytes (64 bits) -9.223.372.036.854.775.808 9.223.372.036.854.775.807
Tabla Nro 7: Tipos de datos enteros
• Tipos de datos decimales, Se usan para representar números con partes fraccionarias. En Java
se pueden usar dos tipos de datos decimales: float y double. El primero reserva almacenamiento
para un número de precisión simple de 4 bytes y el segundo lo hace para un número de precisión
de 8 bytes.
Tipo Tamaño Valor Mínimo Valor Máximo

Float 4 Byte (32 bits) -3.402823 a -1.401298 1.401298 a 3.402823
Doublé 8 Bytes (64 bits)
Tabla Nro 8: Tipos de datos numéricos decimales
• Tipo de datos boolean, Se usa para almacenar variables que presenten dos estados, que serán
representados por los valores true y false.
• Tipo de datos char, Se usa para almacenar caracteres Unicode simples. Debido a que el
conjunto de caracteres Unicode se compone de valores de 16 bits, el tipo de datos char se
almacena en un entero sin signo de 16 bits.
• Tipo de datos String, En Java se tratan como una clase especial llamada String. Las cadenas
se gestionan internamente por medio de una instancia de la clase String. Una instancia de la
clase String es un objeto que ha sido creado siguiendo la descripción de la clase.
Conversión de tipos de dato

La conversión de tipos de datos en Java se refiera a la posibilidad de cambiar de un tipo de dato en
especial a otro, Java ofrece un grupo de clases especiales para crear conversiones de tipos de datos.
Por ejemplo si deseamos convertir un tipo de dato String a int se debe utilizar el la clase Integer con
método parseInt(variable String), y según el tipo de dato que se desee así se llama la clase y el
consecutivo del método “parse”.
Programa Nro 10: Conversión de tipos de datos
Casting a nuevos tipos de datos

El casting es una forma de conversión rápida entre tipos de una misma especificación, grupo o
familia, por ejemplo numéricos (enteros, doublé, float, long, entre otros), caracteres (String y char).
Programa Nro 11: Conversión de tipos de datos por Casting
Variables
Una Variables no es más que un nombre simbólico que identifica una posición en memoria. Para
utilizar una variable en un ámbito de un programa hay que declararla en un bloque de ejecución, Los
identificadores de las variables son los nombres que utilizamos para referirnos a ellas, Al declarar una
variable hay que definirle su tipo y en una misma declaración se pueden declarar varias variables
separadas por coma. Esta acción del programador permite al ordenador prepararlo para los
siguientes:
• El ordenador conoce así como codificar la información que se va a almacenar en la posición

de memoria correspondiente.
• Al declarar una variable, se reserva el espacio de memoria necesario para almacenar el valor
del tipo de la variable.
• El identificador asociado a la variable se puede utilizar para acceder al dato almacenado en

memoria y para modificarlo.
Estructura de declaración de variables en Java
<Tipo de dato> + <nombre del identificador>;

Ejemplo: int x; //Declara una variable x de tipo entero
Comentarios y espacios en blanco

El compilador de Java reconoce y elimina los espacios en blanco, tabuladores, retornos de carro y
comentarios durante el análisis del código fuente. Los comentarios se pueden presentar en tres
formatos distintos:
Formato Forma de uso

/*comentario*/ Se ignoran todos los caracteres entre /* */. Proviene del C
Se ignoran todos los caracteres detrás de // hasta el fin de
//comentario
línea. Proviene del C++
Lo mismo que /* */ pero se podrán utilizar para documentación
/**comentario*/
automática.
Tabla Nro 8: Formatos para comentarios
Estructura básica de un programa en Java

Teniendo en cuenta que Java es un lenguaje de programación orientado a objetos es indispensable
que como mínimo exista en el programa una clase y un método publico estático main, que es el que
el compilador busca para arrancar la ejecución de un programa.
class MiClase{
public static void main(String arg[]){
/*Dentro de este bloque se debe ingresar todo el códigológicoque
debe ejecutar nuestro programa*/
}
}
Programa Nro 12: Estructura básica de un programa en Java
Imprimir un mensaje por consola

La impresión en consola representa muestra los resultados en una pantalla MS-DOS o en la consola
según el editor o IDE que se utilice para hacer las pruebas.
class MiClase{
public static void main(String arg[]){
System.out.print(“Hola mundo!!!”); /*Esta sentencia permite imprimir
un mensaje por consola*/
}
}
Programa Nro 13: Impresión por consola de un mensaje

Leer e imprimir un mensaje por consola
En Java las entradas por el teclado y las salidas en pantalla están reguladas a través de la clase
System, esta clase pertenece al paquete java.lang y agrupo diversos métodos y objetos, entre los
que encuentran tres objetosmásde forma static, por lo que se puede acceder a ellos sin ser
declarados en la clase que se desee usar:
• “in” es un objeto de la clase InputStreampara leer de cualquier dispositivo de entrada

(habitualmente desde el teclado). Se utiliza así: “System.in”.
• “out”es un objeto de la clase PrintStreampara imprimirlos datos en la salida estándar del sistema
(normalmente asociado con la pantalla). Se utiliza así: “System.out”.
• “err” es un objeto de la clasePrintStreamusado para mensajes de error que salen también por
pantalla pero defecto. Se utiliza así: “System.err”.
System
in (InputStream)
out (PrintStream)
err (PrintStream)
Figura Nro 17:Jerarquía de la clase System
System.in solo ofrece un método para leer datos “read()”,este lee un carácter y devuelve un
entero,System.out ofrece dos métodos para imprimir en pantalla el argumento que se le envié por
parámetro print(argumento)y println(argumento), la diferencia entre ellos es que el println coloca
un “\n”o salto de línea, al final.
Figura Nro 18: Clase System.java Objeto “in”

Figura Nro 19: Clase System.java Objeto “out y err”
Figura Nro 20: Clase InputStream.java método “read()”
Figura Nro 21: Clase PrintStream.java método “print(String s)”

Figura Nro 22: Clase PrintStream.java método “println(String x)”
Todas las clases mencionadas anteriormente se encuentran en la JDK “Kit de desarrollo de Java” y
están disponibles para ser utilizadas de forma directa o indirectamente.
Para Java, un InputStream es cualquier cosa de la que se leen bytes. Puede ser del teclado, un
fichero, un socket, un archivo plano, o cualquier otro dispositivo de entrada.
Un InputStream es para leer bytes, es decir que solo tiene métodos para leer tipo de dato bytes (un
byte es un entero de -128 a 127). Nosotros queremos leer palabras o números del teclado, no bytes.
Si escribimos en el teclado la letra A mayúscula y la leemos con System.in, obtendremos un entero
de valor 65, que es el valor del byte correspondiente a la A. Para obtener el carácter ingresado por
consola se debe hacer un casting con el tipo de dato char que me convierta ese entero en un único
carácter.
Programa Nro 14: Lectura (System.in)e impresión (System.out) un dato por consola
Figura Nro 23: Compilación y ejecución del programa de lectura

y escritura de un dato por consola
Programa Nro 15: Lectura (System.in)e impresión (System.out)
de un dato por consola con casting
Figura Nro 24: Compilación y ejecución del programa de lectura

y escritura de un dato por consola
Si se desea crear un aplicativo que lee una cadena de caracteres se debe repetir el método
read()hasta el usuario presiones una salto de línea con la tecla “Enter”.
Programa Nro 16: Lectura (System.in)e impresión (System.out)

una cadena de caracteres
Figura Nro 25: Lectura (System.in)e impresión (System.out)
una cadena de caracteres
Para Java, una clase Reader es un objeto que lee caracteres. Un Reader tiene métodos para leer
caracteres. Con esta clase ya podríamos trabajar. El problema es que seguimos teniendo System.in,
que es un InputStream y no un Reader.
¿Cómo convertimos el System.in en Reader? Hay una clase en Java, la InputStreamReader, que
nos hace esta conversión. Para obtener un Reader, únicamente tenemos que instanciar un
InputStreamReader pasándole en el constructor un InputStream. El código es el siguiente:
InputStreamReader isr = new InputStreamReader(System.in);
Estamos declarando una variable "isr" de tipo InputStreamReader. Creamos un objeto de esta clase
haciendo new InputStreamReader(...). Entre paréntesis le pasamos el InputStream que queremos
convertir a Reader, en este caso, el “System.in”.
Si estamos leyendo de teclado, el que usa el programa puede escribir 10 caracteres o 20 o 13. Si
usamos InputStreamReader, solo lee con el método read()el primer carácter, Tenemos que decirle
cuántos caracteres queremos leer, o bien ir pidiendo de uno en uno hasta que no queramos más. En
realidad el InputStreamReader funciona muy igual al InputStream con el System.in.read(), pero es
requerido de forma especial para poder leer cadenas de caracteres con la utilización de otros objetos.
Programa Nro 17: Lectura (InputStreamReader) e impresión (System.out) una cadena
El resultado de la ejecución de este programa es igual según la figura numero 24, y si se le cambia el
tipo de dato de la variable carácter a int y quitamos el castin con (char) nos devolverá un byte.
Entonces podemos decir que la clase InputStreamReader sola como tal no funciona para recibir
cadenas de caracteres, pero la claseBufferedReader a partir de otro Reader cualquiera (por ejemplo
el InputStreamReader), si nos permite obtener una cadena de caracteres (String). El código es:
BufferedReader br = new BufferedReader (isr);
El funcionamiento de esta clase es igual que el InputStreamReader. Cuando le pedimos una línea
completa de caracteres (un String), ella se lo pide al Readerlo que tenga dentro y los convierte en
String.
Para pedirle un String, se usa el método readLine(). Este método lee todos los caracteres tecleados
(recibidos si fuera otro dispositivo de entrada) hasta que encuentra la pulsación de la tecla <INTRO>,
<RETURN> o como quieras llamarla.
String texto = br.readLine();
Figura Nro 26:Jerarquía necesaria para leer una cadena de caracteres por consola
El siguiente ejemplo leer por teclado una cadena de caracteres y lo guarda en una variable “texto de
tipo de dato String.
Programa Nro 18: Lectura e impresión de una cadena completa

Figura Nro 27:Lectura e impresión de una cadena completa
Ahora con la implementación de esta clase Scanner, nos podemos ahorrar algo de código y hacerlo
de la siguiente forma:
Programa Nro 19: Lectura e impresión de una cadena completa clase Scanner
La clase scanner recibe por parámetro un InputStream (System.in) y con el método next() lee una
cadena de caracteres, es decir con esta clase no se requiere la clase intermedio InputStreamReader,
para convertir un byte a un carácter.
La única excepción que tenemos al utilizar la clase Scanner es que ella nos permite leer una cadena
de caracteres mientras no tenga espacios, es decir que si ingresa en la cadena un espacio, a partir
de él no es leída.
Estructuras de control
Las estructuras de control en un programa permiten modificar la ruta de ejecución de un programa en
Java. El lenguaje Java soporta las siguientes estructuras de control:
Sentencia Clave
Toma de decisión if-else, switch-case
Bucle o ciclos for, while, do-while
Misceláneo break, continue, label:, return, goto
Tabla Nro 10: Estructuras de control
• Las sentencias condicionales: if, Se trata de una estructura de control que permite redirigir un
curso de acción según la evaluación de una condicióno expresiones simple, sea falsa o
verdadera.
/*Estructura condicional simple*/

if (condicion){
//En este bloque se ejecutan las sentencias requeridas
}
Programa Nro 20: Verifica si un número es par
Figura Nro 28:Ejecución programa 20 (Verificación si un número es par)
/*Condicional simple*/
if(condicion){
}else{
}
Programa Nro 21: Verifica si un número es par o impar
Figura Nro 29:Ejecución programa 21 (Verificación si un número es par o impar)
/*Estructura condicional compuesta*/

if(condicion){
}else if(condicion){
}else if(condicion){
}else{
}
Programa Nro 22: Estructura condicional compuesta
El programa anterior determina dado tres lados de un triangulo, si un triangulo es Isósceles,

equilátero y escaleno, sabiendo que los triángulos equiláteros tienen sus tres lados iguales, los
escalenos tienen sus tres lados distintos y los triángulos Isósceles tienen al menos dos lados dos
lados iguales.
Figura Nro 30:Ejecución programa 22
Puede darse el caso en un aplicativo donde toque realizar Condiciones anidadas es decir un
condicional de cualquier tipo con otro condicional interno.
/*Estructura condicional anidados*/

if(condicion){
//Condicional interno
if (condicion){
}
}else{
}
Programa Nro 23: Estructura condicional anidadas
El programa anterior recibe un primer dato por teclado y dependiendo su valor el programa
ejecuta una serie de sentencias más entre estas una estructura condicional compuesta.
• Las sentencias condicionales: switch, Se trata de una alternativa de la Bifurcación de la

sentencia if(condicion){}elseif(condicion){}else{} cuando se compra la misma expresión con
distintos valores. Los case sirven para agrupar en un bloque las sentencias que ha de ejecutar.
switch(op){
case 1:
/*Ejecuta las sentencias */
break;
case 2:
break;
case 3:
break;
case 4:
break;
default:
/*Ejecuta las sentencias por defecto si no se cumple ninguna de los casos anteriores*/
}
La variable “opción” es de tipo entero y recibe un valor de 1 a N y dependiendo de este valor

ejecuta las sentencias programadas en cada caso.
Programa Nro 24: Estructura de control switch
Al ejecutar el programa anterior notara que su funcionamiento será igual al programa numero 23.
Entonces podemos concluir que un switch es una representación condicional que utiliza casos
(case) en vez de if.
• Sentencia condicional en una sola línea, este sentencia representa un if else simple, en está
se estipulada la condición if con el operador “?” y el else un “:”.
expresion Boolean?operación verdadera (sentencias): operación falsa (sentencias);
El siguiente ejemplo utiliza una variable entera identificada con nombre resultado y que toma el
valor de las sentencias (a+b) o (a-b) según el condicional (a<b).
Programa Nro 25: Estructura condicional simple en una sola línea
• Sentencias de iteración o bucles for, while y do - while: un bucle se utiliza para realizar un
proceso repetitivo, las sentencias ejecutadas dentro del bloque del bucle se ejecutan mientras
que la condición de parada sea una verdad.
for(inicialización; condición; incremento){

sentencias;
}
inicialización;
while(condicion){
sentencias;
incremento;
}
do{
sentencias;
}while(condicion);
La diferencia del bucle do – while con respecto a los demás es que este por lo menos deja
ejecutar las sentencias internas en el bloque una sola vez, y la continuación iterativa de ejecución
dependerá de que la condición sea un valor de verdad.
Programa Nro 26: Estructura repetitiva do{ }while();
Como podemos observar en el anterior ejemplo nuestro programa muestra al usuario un menú en
el cual podrá seleccionar entre dos opciones y el programa responderá según la opción
seleccionada, además también pedirá una respuesta sobre si desea o no continuar, según esta
respuesta y la condición de verdad del “while” se repita el ciclo. Podemos ver que la estructura
do{ }while() permite la ejecución de su código interno al menos una vez.
Programa Nro 27: Estructura repetitiva while;
El ejemplo anterior muestra como se implementa la estructura de control repetitiva while, en su

ejecución contrario a la sentencia do{}while(), requiere de que se cumpla desde su primera
ejecución la condición establecida en la línea 12, de lo contrario no entraría a ejecutar sus
sentencias internas. La línea 11 inicializa la variable de control “i” y en la línea 14 esta variable se
incrementa y la línea 12 verifica en cada iteración la condición.
Programa Nro 28: Estructura repetitiva for
• Sentencias de salto, break y continue, este tipo de sentencias permite determinar el lugar
donde continuara una ejecución de un programa, el lugar seleccionado es identificado por una
etiqueta establecida a un bloque “{}”, y el lugar donde se deben incluir es cuando se tienen uno o
más buques dentro de otro.
Programa Nro 29: Estructuras repetitivas con etiquetas y sentencias de salto

Este pequeño programa permitirá detener la ejecución cuando se ejecuta un break llevándolo a
una etiqueta llamada “etiqueta”. El break solo detiene un bucle en ejecución.
Programa Nro 30: Estructuras repetitivas con etiquetas y sentencias de salto
En este ejemplo el continue salta a una etiqueta pero continúa la ejecución del programa, es
decir no detiene el número de iteraciones que se planearon realizar.
Contadores
Un contador es una variable cuyo valor es incrementado o decrementado en una cantidad constante
cada vez que se produce un determinado suceso o acción. Los contadores se utilizan con la finalidad
de contar sucesos o acciones internas de un bucle; deben realizar una operación de inicialización y
posteriormente las sucesivas de incremento o decremento del mismo. La inicialización consiste en
asignarle al contador un valor.
Representación:
<nombre del contador>=<nombre del contador> + <valor constante>
Si en vez de incremento es decremento se coloca un menos en lugar del más.
Ejemplo: i = i + 1
Acumuladores o totalizadores
Es una variable que suma sobre sí misma un conjunto de valores, de esta manera tener la suma de
todos ellos en una sola variable. La diferencia entre un contador y un acumulador es que mientras el
primero va aumentando de uno en uno, el acumulador va aumentando en una cantidad variable.
Representación: <Nombre del acumulador> = <nombre del acumulador> + <valor variable>
Valores de inicialización
Suma = 0
Producto = 1 // especialmente para multiplicaciones.
Excepciones en Java
Las excepciones son otra forma más avanzada de controlar el flujo de un programa. Con ellas se
podrán realizar acciones especiales si se dan determinadas condiciones, justo en el momento en que
esas condiciones se den.
Concatenación
La concatenación es la acción de unir cosas, en Java esta acción es permitida utilizando el operador
aritmético “+”, con este podemos unir dos o más cadenas. Por ejemplo:
String a=”Hola”;
String b=”Valentina”;
String cadena=a+b+”!!!”;
System.out.print(cadena);
Este ejemplo nos imprimirá en pantalla el resultado la cadena “Hola Valentina!!!”. De igual forma
podemos concatenar otro tipo de dato, ya sea entero, flotante, doublé, entre otro.
TEMA 3 – OBJETOS Y CLASES
Un objeto es cualquier cosa de la vida cotidiana que tiene atributos y acciones, por ejemplo el objeto
Carro tiene atributos tales como color, lámparas, tipo de llantas (grandes, medianas y
pequeñas),mecanismo (automático o mecánico), número de pasajeros, entre otros. Cada vez que se
crea un objeto carro hay que definir los valores que tienen estos atributos.
El elemento básico de la programación orientada a objetos en Java es la Clase. Una clase define la
forma y comportamiento de un objeto.
Para crear una clase sólo se necesita un archivo fuente que contenga la palabra clave reservada
class seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la
clase.
class Carro {
La programación orientada a objetos se basa en la programación de clases, estas tienen dospartes

especiales que no deben faltar en una clase: Atributos y Métodos.
• Atributos, Los datos se encapsulan dentro de una clase declarando variables dentro de las
llaves de apertura y cierre de la declaración de la clase, variables que se conocen como
atributos. Se declaran igual que las variables locales de un método en concreto.
Por ejemplo, este es un programa que declara una clase Aritmética, con dos atributos enteros
llamados n1 e n2.
classAritmética {
doublé n1,n2;
Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la memoria
un espacio para un conjunto de datos como el que definen los atributos de una clase. A este
conjunto de variables se le denomina variables de instancia.
• Métodos, Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y
comportamiento.
Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por
los nombres de la clase en que está definido. Los métodos se declaran al mismo nivel que las
variables de instancia dentro de una definición de clase.
En la declaración de los métodos se define el tipo de valor que devuelven y a una lista formal de
parámetros de entrada, de sintaxis tipo identificador separadas por comas. La forma general de
una declaración de método es:
tipo_dato_devuelto nombre_de_método( lista-formal-de-parámetros ) {
cuerpo_del_método;
Por ejemplo el siguiente método devuelve la suma de dos enteros:
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}
En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra
reservada void. Así mismo, si no se desean parámetros, la declaración del método debería
incluir un par de paréntesis vacíos ():
void metodoVacio( ) {
Los métodos son llamados indicando una instancia individual de la clase, que tendrá su propio
conjunto único de variables de instancia, por lo que los métodos se pueden referir directamente a
ellas.
Por ejemplo el método inicia() establecer valores a las dos variables de instancia:
void inicia( double paramX, doublé paramY ) {
n1 = paramX;
n2 = paramY;
También podemos definir métodos set para ingresarle valores a los atributos y métodos get para
obtener los valores que poseen esos atributos pertenecientes de la clase.
Todo objeto o clase debe tener como mínimo un método al que se le llama constructor, este método
es el primero que se llama cuando se crea una instancia de un objeto con el operador new,pero a
diferencia de los demás métodos este debe tener el mismo nombre de la clase.
Class Aritmetica{
Aritmetica(){
//Método constructor de la clase Aritmética
}
}
Ejemplo de una clase completa:
Class Aritmetica{
double n1,n2;//Atributos de la clase
//metodo constructor de la clase
Aritmetica(){
//métodos para asignar y obtener valores a los atributos
void setN1(double a){

n1=a;
double getN1(){
return n1;
void setN2(double b){
n2=b;
double getN2(){
return n2;
//métodos para hacer operaciones con los atributos
double suma(){
return n1+n2;
double resta(){
return n1-n2;
double mutiplicacion(){
return n1*n2;
double division(){
return n1/n2;
}
La clase Aritmética puede ser utilizada desde cualquier parte de otra clase, creando una instancia de
ella, por ejemplo desde una clase que contenga el método main. Las funciones pueden ser accesible
utilizando el operador “.” (punto).
El siguiente ejemplo muestra como instanciar una clase Aritmetica desde una clase Main y utilizar sus
funciones.
class Main{
public static void main(String a[]){
System.out.println(“Inicio del programa”);
Aritmetica a=new Aritmetica();//Creacion de un objeto de tipo Aritmetica
a.setN1(5);//Ingresa los valores que tendrá el atributo n1
a.setN2(10); //Ingresa los valores que tendrá el atributo n2
/*Obtiene e imprime en pantalla los valores que se le asignaron a los atributo n1 y

n2*/
System.out.println(“El valor de N1 es: ”+a.getN1());
System.out.println(“El valor de N2 es: ”+a.getN2());
//Obtiene las operaciones realizadas con estos atributos
System.out.println(“La suma de N1 y N2 es: ”+a.suma());
System.out.println(“La resta de N1 y N2 es: ”+a.resta());
System.out.println(“La mutiplicacion de N1 y N2 es: ”+a.mutiplicacion());
System.out.println(“La division de N1 y N2 es: ”+a.division());
System.out.println(“Fin del programa”);
Herencia
La herencia es el mecanismo fundamental de relación entre clases en la orientación a objetos.

Relacionando las clases de manera jerárquica; una clase padre o superclase sobre otras clases hijas
o subclases. Un ejemplo simple de herencia es el caso en el cual tengamos una Súper clase llamada
Animal sabiendo que un animal tiene atributos como numero de patas, color, especie, peso, entre
otros; esta clase puede ser herencia respecto otras clases por ejemplo la clase Ave heredaría todos o
algunos atributos y métodos de la clase Animal y además puede tener sus propios atributos y
métodos como: forma del pico, entre otros.
Los descendientes de una clase heredan todas las variables y métodos que sus ascendientes hayan
especificado como heredables, además de crear los suyos propios.
La característica de herencia, nos permite definir nuevas clases derivadas de otra ya existente, que la
especializan de alguna manera. Así logramos definir una jerarquía de clases, que se puede mostrar
mediante un árbol de herencia.
En todo lenguaje orientado a objetos existe una jerarquía, mediante la que las clases se relacionan en
términos de herencia. En Java, el punto más alto de la jerarquía es la clase Objectde la cual derivan
todas las demás clases.
En la orientación a objetos, se consideran dos tipos de herencia, simple y múltiple. En el caso de la

primera, una clase sólo puede derivar de una única superclase. Para el segundo tipo, una clase
puede descender de varias superclases.
En Java sólo se dispone de herencia simple, para una mayor sencillez del lenguaje, si bien se
compensa de cierta manera la inexistencia de herencia múltiple con un concepto denominado
interface, que estudiaremos más adelante.
Para indicar que una clase deriva de otra, heredando sus propiedades (métodos y atributos), se usa
el término extends, como en el siguiente ejemplo:
public class SubClase extends SuperClase {
// Contenido de la clase
Todos los campos y métodos de una clase son siempre accesibles para el código de la misma clase.
Para controlar el acceso desde otras clases, y para controlar la herencia por las subclases, los
miembros (atributos y métodos) de las clases tienen tres modificadores posibles de control de acceso:
• public: Los miembros declarados public son accesibles en cualquier lugar en que sea accesible
la clase, y son heredados por las subclases.
• private: Los miembros declarados private son accesibles sólo en la propia clase.
• protected: Los miembros declarados protected son accesibles sólo para sus subclases.
La clase Object es la superclase de todas las clases de Java. Todas las clases derivan, directa o
indirectamente de ella. Si al definir una nueva clase, no aparece la cláusula extends, Java considera
que dicha clase desciende directamente de Object.
La clase Object aporta una serie de funciones básicas comunes a todas las clases:
• public boolean equals( Object obj ): Se utiliza para comparar, en valor, dos objetos. Devuelve
true si el objeto que recibe por parámetro es igual, en valor, que el objeto desde el que se llama
al método. Si se desean comparar dos referencias a objeto se pueden utilizar los operadores de
comparación == y !=.
• public int hashCode(): Devuelve un código hash para ese objeto, para poder almacenarlo en
una Hashtable.
• protected Object clone() throws CloneNotSupportedException: Devuelve una copia de ese

objeto.
• public final Class getClass(): Devuelve el objeto concreto, de tipo Class, que representa la
clase de ese objeto.
• protected void finalize() throws Trowable: Realiza acciones durante la recogida de basura.
Interfaces
Una interfaz en Java es una colección de métodos abstractos y propiedades. En ellas se especifica
qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las
que describan la lógica del comportamiento de los métodos.
La implantación de interfaces es el medio utilizado por Java para permitir el funcionamiento de

herencia múltiple. Por ejemplo: podemos tener un objeto llamada Figura con atributos nombre y color,
otro objeto llamado Área que estipula como una interfaz con métodos como areaTriangulo,
areaCuadrado y areaRectangulo, podemos crear un objeto llamado Triángulo y que utilizando
herencia múltiple pues requiere de los atributos del objeto Figura y de algunas de las funciones de
Área.
El uso de interfaces proporciona las siguientes ventajas:
• Organizar la programación.
• Obligar a que ciertas clases utilicen los mismos métodos (nombres y parámetros).
• Establecer relaciones entre clases que no estén relacionadas.
Java proporciona dos palabras reservadas para trabajar con interfaces: interface e implements.La
primera palabra se utiliza para declarar las interfaces y la segunda para implementarlas en las clases
que las usaran, se pueden implementar más de una interfaz al mismo tiempo.
Polimorfismo
El concepto de Polimorfismo es uno de los fundamentos para cualquier lenguaje orientado a Objetos,
las mismas raíces de la palabra pueden ser una fuerte pista de su significado: Poli = Multiple,
morfismo= Formas, esto implica que un mismo Objeto puede tomar diversas formas y
comportamientos. Por ejemplo podemos declarar una Súper Clase llama Animal y esta será heredada
en diferentes Subclases con comportamientos diferentes tales como Pez, Ave y Perro.
Encapsulamiento
El encapsulamiento es una técnica de la programación orientada a objetos que permite en una misma
clase crear diferentes clases e interactuar directamente entre ellas.
Paquetes
Referencia a los miembros o atributos de una clase (this y super)
Recursividad de métodos
TEMA 4 – Estructuras de datos en Java
Arreglos
Matrices
Pilas
Colas
Listas
Collections (Clases Vector, ArrayList, Interfaces Iterator, Enumeration)
CAPITULO 5 – ARCHIVOS
Los programas en Java necesitan comunicarse con su entorno, tanto para recordar datos e
información que debe procesar, como para devolver los resultados obtenidos.
El paquete java.io contiene todos lo necesario para comunicarse con el exterior, y dentro de este
encontramos dos familias para la entrada/salida de datos. La entrada se datos se puede hacer con
las clases derivadas de InputStreamy para escribir con OutputStream, estas clases tienen dos
métodos básicos read() y write().
InputStream OutputStream
FileInputStream FileOuputStream
PipedInputStream PipedOutputStream
ByteArrayInputStream
FilterOutputStream
StringBufferInputStream
DataOutputStream
SequienceInputStream
PrintStream
FilterInputStream
BufferedOutputStream
DataInputStream
PushbackOutputStream
LineNumberInputStream
ByteArrayOutputStream
BufferedInputStream
ObjectOutputStream
PushbackInputStream
ObjectInputStream
JerarquíaNro 5 – InputStream y PrintStream
Dos nuevas clases aparecieron desde la JDK 1.1 Reader y Writer, estas resultan más prácticas para
las aplicaciones que manejan textos.
Reader Writer
BufferedReader BufferedWriter
LineNumberReader CharArrayWriter
CharArrayReader
OutputStreamWriter
InputStreamReader
FileWriter
FileReader
FilterWriter
FilterReader
PipedWriter
PushbackReader
StringWriter
PipedReader
PrintWriter
StringReader
JerarquíaNro 5 – Reader y Writer
Para leer y escribir archivos existen las clases FileInputSteam y FileOutputStream (Extendidas de
InputSteam y OutputSteam) que permiten leer y escribir bytes en archivos. Para archivos textos es
preferible FileReader y FileWriter (Extendidas de Reader y Writer). Por ejemplo de lectura de un
archivo de texto:
FileReader fl1=new FileReader(“archivo.txt”);
Equivalente a:
File f=new File(“archivo.txt”);
FileReader fl1=new FileReader(f);
Si por algún motivo en la ejecucióndel programa no se encuentra el “archivo.txt” este lanza una
excepción de java.io.FileNotFoundException por este motivo el código de lectura de archivo se
debe colocar dentro de un estructura de excepciones try{}catch(){}.
Los constructoresFileWriter y FileOutputStream pueden lanzar excepciones java.io.IOException.

Sino encuentra el archivo indicado lo crean de nuevo. Para escribir dentro de lo que ya existe en el
archivo se utiliza “append” y al FileWriter se le manda un segundo argumento boolean con valor
true.
FileWriter fw=new FileWriter(“archivo.txt”,true);
El objeto File puede representar un archivo o un directorio y tienen los siguientes argumentos que
recibe para localizar el archivo o directorio:
File(String name)
File(String dir, String name)
File(File dir, String name)
Ejemplo:
File f1=new File(“c:\\windows\\notepad.exe”); // la barra ‘\’ se escriber as ‘\\’

o ‘/’ o ‘//’
File f2=new File(“c:\\windows”); // directorio raiz
File f3=new File(f2, “notepad.exe”); // es igual a f1
Métodos Función
boolean isFile() true si el archivo existe
long length() Tamaño del archivo en bytes
long lastModified Fecha de la última modificación
boolean canRead() true si se puede leer
boolean canWrite() true si se puede escribir
delete() Borrar el archivo
RenameTo(File) Cambiar el nombre
TablaNro 5 – Métodos de File para archivo
Métodos Función
boolean isDirectory() true si existe el directorio
mkdir() Crea un directorio
delete() Eliminar el directorio
String[] list() Devuelve los archivos que tiene el directorio
TablaNro 5 – Métodos de File para directorios
Escritura de archivos de texto

La clase PrintWriter (extendida de Writer)es la más práctica para escribir un archivo de texto porque
posee los métodos print(cualquier tipo) y println(cualquier tipo)idéntico a los de System.out de la
clase PrintSteam.
Un objeto PrintStream se puede crear a partir de un objeto BufferedWriter (para disponer buffer
“espacio en memoria”), que se crea a partir del FileWriter al que se le pasa por parámetro el nombre
del archivo y después se escribe en el archivo.
Código Nro 27 – Creación de un archivo plano
Imagen Nro 27 – Archivo creado y en el directorio
Este ejemplo tiene algo en particular y es que lo que en él se escribe se pierde cuando se intenta
escribir otra línea, para solucionar esto solo se le tiene que colocar otro argumento al FileWriter de
tipo boolean con valor true.
Código Nro 28 – Creación de un archivo plano sin perder lo que el contenía
Imagen Nro 28 – Archivo creado y en el directorio sin perder lo escrito anteriormente
Lectura de archivos de texto

Utilizando el objeto BufferedReader se puede conseguir lo que el archivo contiene en cada una de
sus líneas con el método readLine().
Código Nro 29 – Lectura de un archivo de texto
Aplicación Nro 29 – Lectura de un archivo de texto
Serialización
La Serializacion es un proceso por el cual un objeto cualquiera se puede convertir en una seria de
bytes con la que más tarde se puede construir dicho objeto manteniendo el valor de sus variables, es
concepto permite guardar un objeto en un archivo o mandarlo por una red. La realización hace los
objetos persistentes en un archivo.
Para que una clase pueda utilizar la Serialización tiene que implementar la interfaz Serializable que
no define ningún método.
public class MiClase implements Serializable{
}
Para escribir y leer archivos o datos de un objeto serializable se utilizanlas clases
ObjectOutputStream y ObjectInputStream que cuentan con los métodos writeObject() y
readObject(). Estos Objetos requieren de un parámetro del tipo FileOutputStream y
FileInputStream.
CAPITULO 6 – Programación Multihilos
Un hilo es un flujo de ejecución decódigo y, mediante el uso de hilos, podemos hacer que nuestros
programasaparentemente realicen varias tareas al mismo tiempo. Por ejemplo, su códigopodría
interaccionar con el usuario mientras realiza tareas en segundoplano de gran consumo de tiempo.
Los hilos separados realmente no seejecutan al mismo tiempo, por supuesto (a menos que tenga una
máquinamultiprocesadora); en realidad, cada hilo obtiene secuencias de tiempo delmismo
procesador. El resultado aparente, no obstante, es que los diversoshilos se ejecutan al mismo tiempo
y puede resultar impresionante. De hecho,Java es uno de los pocos lenguajes que soportan hilos.
Cuando se inicia un programa Java, éste tiene un hilo: el hilo principal.Podemos interaccionar con el
hilo principal de diversas formas, como veremosen este capítulo, por ejemplo obteniendo o asignando
su nombre, deteniéndoloy mucho más. Sin embargo, podemos también iniciar otros hilos.Podemos
iniciar el código en esos hilos llamando al método start del objeto ysituando el código que queremos
que utilice el hilo en el método run.
Hay dos formas claves de crear hilos, una es declarando una clase que herede el objeto Thread y
otra es que implemente la interfaz Runnable.
Los hilos tienen varios estados, (en ejecución, detenido, )
CAPITULO 7 – JAVA FUNDATION CLASS

(JFC)
La Java Fundation Class (JFC) es un conjunto de paquetes que son parte de la Interfaz de
Programación de Aplicación (API)de Java, compuesto por clases u objetos que sirven para crear
Interfaces Gráficas de Usuarios (GUI) de forma visuales para las aplicaciones y applets de Java.Las
JFC contienen dos paquetes gráficos en especial: AWT y Swing.
Abstract Windowing Toolkit (AWT)

El paquete AWT presenta componentes pesados, que en cada plataforma sólo pueden tener una
representación determinada. Está disponible desde la versión 1.1 del JDK como java.awt.
Todas las clases en Java, creadas personalmente o importada de la API, derivan de la

superclaseObjectque es la jerarquía de herenciamayor en el lenguaje.
La clase Component representa a cualquier objeto que puede ser parte de una interfaz gráfica de
usuario. Es la clase padre de muchas de las clases del AWT.Su propósito grafica de usuario y que
representar algo que tiene una posición y un tamaño, que puede ser dibujado en la pantalla y que
pueda recibir eventos de entrada (que responda a las interacciones con el usuario).
Los componentes en Java poseen un grupo de propiedades básicas con la que el usuario puede
jugar para darle mejor apariencias visuales a sus aplicaciones.
Button
Label
java.lang CheckBo
x
Font Choic
TextArea
Object CheckboxGroup e
TextComponent
TextField
Component Canva
sList
Panel
Container ScrollPane
Dialog FileDialog
Image Window
Fram
PopupMenuu
e
Menu
Imagen Nro 11– Jerarquía de componentes del paquete AWT
La clase Objetct se encuentra en el paquete java.lang y el resto de los componentes mostrados en

el cuadro sinóptico se localiza el paquete java.awt.
En una interfaz gráfica de usuario (GUI) el elemento más básico que suele emplearse es la creación
de ventanas. La AWT proporciona la clase Window, aunque para simplificar los desarrollos acudieron
a la clase Frame (Marco) derivada de Window y por tanto más especializada para la experiencia del
usuario, la clase Window muestra ventanas sin bordes, mientras que la clase Frame presenta
ventanas con bordes y barra de título con botones de acción (minimizar, maximizar y cerrar).
Ejercicio Nro 8– Creación de una ventana con AWT
En el ejemplo anterior se creó una ventana con la clase Frame, le aplicamos un título, tamaño y la
hacemos visible, y además le agregamos un evento del tipo “WindowListener” con un objeto de
parametro “WindowAdapter” que llama al método “windowClosing” de la interfaz
WindowListener,para permitir que el botón de acción cerrar de la barra de título funciones y permita
cerrar la ventana cuando el usuario lo presione.
Ejercicio Nro 9– Creación de una ventana con AWT con herencia
La diferencia con el Ejercicio Nro 8es que en este se creó un objeto tipo Ventana que heredaba todos
los atributos y métodos de la clase Frame, la clase ventana requiere de constructores que permita
inicializar el objeto cuando se requiera su utilización, en este caso se crearon dos constructores un
sin parámetro y otro con parámetro, podemos ahora crear todos las ventanas que queramos con tan
solo creando objetos del tipo “Ventana”.
Ejercicio Nro 10– Creación de una ventana con AWT y herenciamúltiple
El ejercicio anterior se diferencia de los demás por tener implementado el concepto de herencia
múltiple, pues no solo hereda los atributos y métodos de la clase Frame sino también de la Clase
WindowListener, este por ser implementado como interfaz, todos los métodos y atributos de
WindowListener se tienen sé que colocar en la clase Ventana.
Ejercicio Nro 11– Creación de una ventana con AWT y encapsulamiento
En el Ejercicio Nro 11 se creó una clase “Ventana”, y esta hace uso de otra clase llamada
“CerrarVentana” que contiene los eventos de un Frame implementado la interfaz “WindowListener”.
Los siguientes ejercicios utilizando la clase Frame es dividiendo los códigos para hacer más legible el
programa, creando un archivo MiFrame y desde otros archivos poder aplicar herencia o la creación
de un objeto de tipo MiFrame. (Las clases creadas en encapsulamiento también son accesibles
desde otra clase o archivo.java)
Ejercicio Nro 12– Creación de una ventana con AWT en archivo separado
Ejercicio Nro 13– Uso de la clase MiFrame
La clase Component presenta diversos métodos, organizados para responder a diversos propósitos
sobre los componentes utilizados en una interfaz gráfica de usuario, estos métodos se dividen en
tres:
a.) Tamaño y posicionamiento del componente
• getSize(), Devuelve la anchura y altura del componente como un objeto de la clase

Dimension, que tiene como campos: width (anchura) y heigth (altura).
• setSize(int ancho, int largo), Establece la anchura y altura del componente.
• getPreferredSize(),Devuelve la anchura y altura del componente como un objeto de la clase

Dimension, que tiene como campos: width (anchura) y heigth (altura).
• setPreferredSize(),Establece la anchura y altura del componente.
• getMinimumSize(), Devuelve el tamaño mínimo de un componente como un objeto de la

clase Dimension.
• setMinimumSize(int ancho, int largo), Establece el tamaño mínimo que este componente
debería tener.
• getBounds(), Devuelve las coordenadas de un componente como un objeto de la clase

Rectangle, que tiene como campos: x, y, width y heigth.
• setBounds(int x, int y, int ancho, int largo), Establece las coordenadas de ubicación de un
componente.
b.) Acción sobre el componente
• getEnabled(),Comprueba si el componente está o no activo, retornando un valor boolean.
• setEnabled(boolean),Establece el componente a activo o inactivo.
• getVisible(),Comprueba si el componente está o no visible, retornando un valor boolean.
• setVisible(boolean),Establece si el componente está visible o invisible.
• paint(Graphics g),Indica al AWT que ha de dibujar el componente g.
• repaint(),Indica al AWT que ha de volver a dibujar el componente lo pintado por el método

paint.
• update(Graphics g),Es llamado por AWT cuando se invoca el método repaint(). Por defecto
llama a paint().
c.) Eventos e interacción con el usuario
La clase Component proporciona tres tipos de métodos, para la gestión de eventos mediante el nuevo
modelo de eventos de AWT.
• add_Tipo_Listener(_Tipo_Listener l),Añade un oyente a la espera de algún tipo de eventos

sobre este componente.
• remove_Tipo_Listener(_Tipo_Listener l),Elimina algún oyente que estaba a la espera de algún

tipo de eventos sobre este componente.
En estos métodos la palabra _Tipo_puede ser cualquiera de los siguientes:Component, Focus,

InputMethod, Key, Mouse, MouseMotion, Window, entre otros.
Tanto AWT como Swing tienen en común un sistema para gestionar los eventos que se producen al
interactuar con el usuario de la interfaz gráfica, aunque el paquete Swing presenta mejoras de
algunos de los eventos.
Cada objeto de componentes represente una interfaz gráfica de usuario, a la que se le pueden definir
objetos "oyentes" (Listener), que esperen a que suceda un determinado evento sobre la interfaz. Por
ejemplo se puede crear un objeto oyente que esté a la espera de que el usuario pulse sobre un botón
de la interfaz, y si esto sucede, él es avisado, ejecutando determinada acción.
La clase base para todos estos eventos que se pueden lanzar es la clase AWTEvent (perteneciente
dentro del paquete java.awt).
El modelo de eventos de AWT depende del paquete java.awt.event, que en Swing se amplía con el
paquete javax.swing.event.En Java los eventos son dos tipos básicos, Físicos y Semánticos:
• Físicos: Corresponden a un evento hardware claramente identificable. Ejemplo: se ha pulsado

una tecla.
• Semánticos: Se componen de un conjunto de eventos físicos, que sucedidos en un determinado
orden, estos tienen un significado más abstracto: El usuario ha elegido un elemento de una lista
desplegable.
La clase containerañade la funcionalidad de poder contener otros componentes como (Button, Label,
TextFiel, entre otros) y hacer las Interfaces de Graficas de Usuario (GUI) más llamativa para los que
interactuaran con nuestros sistemas.
Java proporciona un conjunto de contenedores para agrupar los componentes de una interfaz gráfica
de usuario.Los siguientes contenedores ubican los componentes según la dirección que se le asigne,
pero también se le pueden agregarrellenos o bordes externos para evitar que los componentes se
visualicen pegados unos o a al mismo Frame. El contenedor GridBagLayout utiliza la expresión ipadx
y ipady, los demás contenedores utilizan las funciones setHgap(int x) y setVgap(int x).
Aceptar
Imagen Nro 12 – Panel con border de relleno externo
• FlowLayout, Permite ubicar los componentes de forma consecutiva en una misma fila de
izquierda a derecha, de derecha a izquierda o centrado, al terminar el tamaño del Frame o Panel
continua ubicando los componentes en la línea siguiente, según como se le estipule (CENTER,
LEFT, RIGHT, TRAILING O LEADING).
Ejercicio Nro 14– Contenedor FlowLayout
En el ejercicio anterior se crea un conjunto de componentes de tipo “Button” y al marco que es

de tipo “Frame” se le asigna el tipo de contenedor que va a manejar “FlowLayout - CENTER” y
se agregan todos los componentes creados al marco – Frame.
Imagen Nro 12 – CENTER Imagen Nro 13 – RIGHT Imagen Nro 14 – LETF
• BorderLayout, Es el contenedor o LayoutManager por defecto de cualquier Panel o Frame, y

permite ubicar los componentes en cinco áreas, Centro, Norte, Sur, Este y Oeste. (NORTH,
SOUTH, WEST, EAST, O CENTER).
Ejercicio Nro 15– Contenedor BorderLayout
En el ejercicio anterior se crea un conjunto de componentes de tipo “Button” y al marco que es de

tipo “Frame” se le asigna el tipo de contenedor que va a manejar “BorderLayout ” y se agregan
todos los componentes creados al marco – Frame.
Imagen Nro 15– Aplicación con BorderLayout
• GridLayout, Permite dividir el contenedor en filas y columnas del mismo tamaño, y cada
componente que se agregue va llenando cada posición del Grid, los componentes se sitúan de
forma secuencial de izquierda a derecha y de arriba abajo.
Ejercicio Nro 16– Contenedor GridLayout
En el ejercicio anterior se crea un conjunto de componentes de tipo “Button” y al marco que es de

tipo “Frame” se le asigna el tipo de contenedor que va a manejar “GridLayout con 2 Filas y 3
Columnas” y se agregan todos los componentes creados al marco – Frame.
Imagen Nro 16– Aplicación con GridLayout
Analicemos que a nuestro marco hemos agregado cinco botones y nuestro Grid al ser de 2 x 3 =
6 permite agregar seis componentes, en el ejercicio solo agregamos cinco, es por eso que queda
en espacio en blanco reservado, en espera de recibir otro componente.
• GridBagLayout, Permite ubicar los componentes en una línea horizontal o vertical, sin dejar
espacio entre los componentes. Este contenedor es una réplica del GridLayout a diferencia que
las columnas y filas se le pueden asignar longitudes de ancho y alto diferentes.
Aplicación Nro 17– Aplicación con GridBagLayout
Ejemplo Nro 17– Creación de una clase Ventana con contenedor GridBagLayout
• BoxLayout, Permite organizar los contenedor en una line vertical o horizontal, dejar espacios
entre ellos. Este contenedor es proporcionado por el paquete swing y tal se profundiza en detalla
más adelante.
Aplicación Nro 18– Aplicación con BoxLayout
Ejemplo Nro 18– Uso de BoxLayout
• CardLayout, Permite visualizar los contenedores que se le pasan como tarjetas, a cada una se
le da un nombre y luego se puede mover de una a la otra con el método show();
Aplicación Nro 18– Uso de CardLayout
Ejemplo Nro 17.1– Creación de una clase que hereda a un Panel

Ejemplo Nro 17.2– Creación de una clase Ventana con contenedor CardLayout
La clase Panel es otro de los componentes de la AWT que permite contener múltiples componentes
al igual que el objeto Frame. En el ejemplo siguiente se crean componentes de tipo “Label, TextField,
Button y Panel” todos estos son agregados dentro del marco principal Frame, pero algunos de estos
solo son agregados dentro del Panel.
Ejercicio Nro 17– Paneles
Imagen Nro 17– Aplicación con Panel
Cada uno de los componentes en Java se les puede agregar ciertas propiedades como (color, tipos
de letras, bordes eimágenes) para mejorar la visibilidad o presentación de nuestros diseños. Nota: el
paquete “swing” provee a los componentes mejores manejo de imágenes y bordes.
Imagen Nro 18 – Antes de mejorar

el diseño Imagen Nro 19 – Después de mejorar
el diseño
Ejercicio Nro 18– Cambiar el icono de taza de café a barra de titulo
Ejercicio Nro 19– Agrega fondo, tipo de letra y color a las letras
Ejercicio Nro 20– Agrega evento del ratón al componente TextField
El ejercicio anterior agrega al componente TextField el tipo de evento del Ratón, y utiliza dos métodos
de acción del ratón, uno entra al componente y otro cuando el ratón sale del componente, en cada
uno de estos se generan acciones de cambio de fondo y color.
Si analizamos el objeto TextField vemos que tiene antepuesto la palabra reservada final, estipulando
este objeto como una constante, esto se requiere porque se está tratando de acceder a él desde un
método externo como lo son mouseEntered() y mouseExited(),(estudiar el concepto de bloques y
ámbitos), si se hubiese declarado como atributo propio de la clase este no fuera necesario la palabra
final (estudiar concepto de acceso a atributos miembros de un objeto).
Imagen Nro 20 – Ratón fuera del Imagen Nro 21 – Ratón dentro del
componente componente
El siguiente ejemplo es una aplicación que contiene cuatro componentes (Frame, Label, TextField y
Button)al componente Button y TextField se le activara un evento que muestre un mensaje en un
Label al hacer un click sobre el ratón o al presionar la tecla enter.
Imagen Nro 22 – Aplicación con eventos (WindowListener y ActionListener).
Clase importadas
Declaración de los atributos y definir las
funciones del constructor
Crear los atributos y asigna a estos Font, color, fondo, Eventos del mouse y eventos de acción
Fin del constructor e inicio del método actionPerformed de la interfaz ActionEvent
Clase Main con creación de un objeto ventana

Ejercicio Nro 21 –Código de aplicación con eventos (WindowListener y ActionListener)
Aplicación Nro 22 – Calculadora digital
El anterior programa crea una calculadora digital en un Frame con un tipo de contenedor
GridBagLayout, dos componentes TextField para mostrar los datos de operaciones y resultados, un
Panel con un contenedor GridLayout de 6 filas por 4 columnas para contener los Button; a GridLayout
se le asigna la propieda setHgap(int) y setVgap para dar el espacio que tiene los botones.
El siguiente ejemplo ilustra una ventana con una barra de menú, respectivos menuce asociados y
cada uno de ellos con ítem dentro de los menuces.
Aplicación Nro 23 – Otros componentes

Código Nro 20 – Otros componentes de la AWT
El paquete AWT también ofrece varios métodos para dibujar en pantalla figuras geométricas como
rectángulos, cuadrados, triángulos entre otros, textos con estilos y apariencias e imágenes.
• paint: Llamado automática cuando se va a dibujar.
• repaint y update: Se llama a este método para forzar quesea pintado.
• drawString: Dibuja una cadena de texto.
• setBackground: Fija el color de fondo.
• setForeground: Fija el color de primer plano.
• draw3Drect: Dibuja un rectángulo 3D.

• drawBytes: Dibuja texto, dado un array de bytes.
• drawlmage: Dibuja una imagen.
• drawoval: Dibuja un óvalo (incluyendo círculos).
• drawPolyLine: Dibuja una línea con múltiples segmentos.
• drawRoundRect: Dibuja un rectángulo redondeado.
• drawArc: Dibuja un arco.
• drawlhars: Dibuja texto, dado un array de caracteres.
• drawline: Dibuja una recta.
• drawPolygon: Dibuja un polígono.
• drawRect: Dibuja un rectángulo.
Aplicación Nro 24 – Pintar una imagen de fondo al Frame
Para lograr el resultado de la aplicación anterior solo tenemos a agregar en cualquier parte de nuestro
programa la siguiente línea de código representada en un método. Este método es llamado por el
compilador de forma automática y repetitivamente cada vez que se maximiza, minimiza o se mueve el
Frame.
Código Nro 21 – Dibujar una imagen de fondo a un Panel, Canvas o Frame
La AWT ofrece un componente especial llamado “Canvas” para crear animaciones gráficas,este es
él recomiendocuando esto es lo que desea.
Swing
El paquete swing presenta componentes ligeros, que pueden tomar diferente aspecto y
comportamiento pues lo toman de una biblioteca de clases. Está disponible desde la versión 1.2 del
JDK como javax.swing. (Ver listado de algunos componentes). Este paquete ofrece aplicaciones
más llamativas, funcionales y amigables para con el usuario.
Imagen Nro 23 – Jerarquía del paquete Swing
Aplicación Nro 24 – Editor de texto
Código Nro 24 – Programa editor de texto (aplicando los componentes del paquete swing)
Skins
Los Skins son temas o que contienen una serie de elementos gráficos que al aplicarse a una
aplicación de software modifica su apariencia visual.
Las aplicaciones de Java también se le pueden agregar apariencias visuales osea Skins y para
lograr esta operación se requiere que importemos en nuestra aplicativo una librería llama skinlf.jar
para poder hacer uso del objeto SkinLookAndFeel que es la que permite cargar un archivo .zip
correspondiente a quien contiene imágenes y estilos del tema de aplicación.
Imagen Nro 24 - Carga de librería skinlf.jar

Aplicación Nro 24 – Sin apariencia visual Aplicación Nro 25 – Apariencia visual de
Windows 7
Para lograr aplicar la apariencia de nuestros Skins en nuestras aplicaciones se recomienda colocar el
código en el método main, y de esta forma aplica a todos los marcos o JFrame o Frame de nuestro
software.
Código Nro 24 – Apariencia de Windows
El código anterior aplica apariencia de tipo Windows a nuestra aplicación, es decir según la que tenga
su sistema operativo, así se visualizaran sus desarrollos. Las dos formas que muestra el código son
aceptadas, la línea 2 funciona igual que la línea 3.
Aplicación Nro 25 Aplicación con un Skins determinados
Código Nro 24 – Apariencia de Windows
El código anterior resalta en la línea 5 la ruta donde tengo almacenado mi tema, en este caso tengo
una carpeta skin en mi proyecto que contiene un archivo con extensión “.zip”. de nombre
“underlingthemepack.zip”.
CAPITULO 8 – Imágenes, animaciones y
audio
La Java Fundation Class (JFC) es un conjunto de paquetes que son parte de la Interfaz de
Programación de Aplicación (API)de Java, compuesto por clases u objetos que sirven para crear
Interfaces Gráficas de Usuarios (GUI) de forma visuales para las aplicaciones y applets de Java.Las
JFC contienen dos paquetes gráficos en especial: AWT y Swing.
Cargar, mostrar y escalar imágenes

En ocasiones deseamos que nuestras aplicaciones tengan imágenes no solo en los componentes
sino también en el fondo.
Java nos ofrece un método llamado paint(Graphics) que recibe un argumento un objeto Graphics y
es el permite que nosotros podamos dibujar sobre nuestro contenedor. Con este podemos pintar
figuras de cualquier tipo como: cuadrados, rectángulos, círculos, líneas, entre otros, estas pueden
tener fuentes, colores entre otros.El método paint(Graphics) es propio para pintar sobre
componentes de la librería awto sobre un Frame, JFrame o Canvasy paintComponent(Graphics)
para dibujar sobre componentes de la swing como JPanel.
El siguiente ejemplo nos muestra cómocolocar una imagen de fondo con el método drawImage() de
la clase Graphics, este tiene varios constructores que reciben varios argumentos como: un objeto
Image, posición X y Y desde donde se va a iniciar a pintar la imagen y un objeto ImageOberver que
puede ser el mismo panel o frame sobre el que se va colocar la imagen.
Animación con una seria de imágenes (Thread,

Runnable y Timer)
Mapa de imágenes
Cargar y reproducir de audio
El audio es una de las fuentes indispensables para que nuestras aplicaciones reproduzcan sonidos
de notificación o alerta a los usuarios de nuestros sistemas.
Existen diferentes formas de cargar audio en nuestras aplicaciones, pero hemos tomado una de las
muchas posibles, que involucra tres objetos, File, AudioInputStream, AudioSystem y Clip,
ubicados los tres últimos en el paquete javax.sound.sampled, File como ya hemos vistos capítulos
anteriores pertenece al paquete java.io.
Código Nro 24 – Reproducir un audio
El objeto File permitirá abrir el archivo en la ruta donde este almacenado, el AudioInputStream
prepara el archivo para convertirlo a un Clip de audio y poder abrirlo con el método open() y el
método start() reproducirlo.Clip contiene otros métodos como stop() para detener la reproducción y
loop(int) para repetirla un numero veces establecido en el entero enviado por parámetro.
Graficas
CAPITULO 9 – Creación de archivos .exe

e instaladores
CAPITULO 9 – Redes
La portabilidad que ofrece el lenguaje Java en sus programas es una de las grandes potencias que
posee, gracias a la “JVM maquina virtual”. Esto adquiere una importancia aún mayor en Internet
donde existen tipos de computadoras muy dispares.
La API de Java contiene una serie de clases que son interesantes de cara a la creación de
aplicaciones que trabajen en red. Estasse encuentran almacenadas en los paquetes mencionadas a
continuación.
• java.net: Clases para redes. Dan acceso al protocolo de comunicación TCP/IP, sockets y URLs.
• java.applet: Da soporte a las applets.
Además de los anteriores paquetescabedestacar la existencia de otros paquetes más complejos,

orientadas también a la programación en red, que serán estudiadas en capítulos siguientes.
• java.sql: Paquete que contiene el JDBC Java DataBase Connectivity, para conexión de
programas Java con Bases de datos.
• java.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e incluso enviar
objetos como parámetros de un objeto a otro.
• org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la conexión entre objetos
distribuidos, aunque estén codificados en distintos lenguajes.
• org.omb.CosNaming: Da servicio al IDL de Java, similar al RMI pero en CORBA.
Una de las características de Java que lo hacen especialmente interesante para Internet es que sus
programas objeto (códigos de byte) son verificables para poder detectar posibles virus en sus
contenidos. Estos programas Códigos de byte no necesitan ser recompilados, y una vez verificados,
se transforman en direcciones físicas “bits” de la máquina destino.
Imagen Nro 24 – Jerarquía de ejecución de un programa en internet
El paquete java.net
Java ofrece un conjunto de clases que permiten utilizar los URLs (Identificadores Uniformes de
Recursos). Un URL es una dirección electrónica que permite encontrar o identificar una información
en Internet o la red. Las URLs estánespecificada por:
• El nombre del protocolo que permitirá leer la información. Por ejemplo HTTP (Protocolos de
transferencia de hipertexto) que forma la base de la Word Wide Web “WWW”.
• El nombre del servidor que proporciona la información. Por ejemplo sunsite.unc.edu,
google.como bien una dirección IP directamente209.85.195.104.
• El nombre del fichero en el servidor. Por ejemplo http://www.chuidiang.com/java/rmi/rmi.php.
Los Sockets en Java

Los sockets son un sistema de comunicación entre procesos de diferentes máquinas de una red. Más
exactamente, un socket es un punto de comunicación por el cual se puede emitir o recibir
información.
Fueron popularizados por BerckleySoftware Distribution, de la universidad norteamericana de

Berkley. Los sockets han de ser capaces de utilizar el protocolo de comunicación TCP (Transfer
Contro Protocol) y el UDP (User Datagram Protocol).
Imagen Nro 25 – Funcionamiento de una conexión con Sockets
El siguiente ejemplo muestra detalladamente el funcionamiento de los sockets. Establece un pequeño

diálogo entre un programa servidor y sus clientes, que intercambian cadenas de información.
Código Nro 25 – Socket Servidor
Código Nro 25 – Socket Cliente

Aplicación Nro 25 – Ejecución de la Aplicación Nro 26 – Ejecución de la
aplicación Socket Servidor aplicación Socket Cliente
La aplicación servidor está en espera de que un cliente se comunique con él para enviarle un
mensaje de bienvenida y es lo que se muestra en el ejemplo anterior, además el servidor imprime un
mensaje para notificar que se está sirviendo a un cliente.
El paquete java.applet
Una applet es un pequeño programa en Java transferido dinámicamente a través de Internet, se
puede visualizar desde un navegador al cargar una página HTML que incluye información desde una
etiquete <APPLET></APPLET>, lo que se carga en la pagina es el fichero compilado .class y que la
maquina del cliente interpreta gracias a la JVM para poder ejecutar.
El paquete java.appletcontiene la clase Applet que forma la base para la creación de applets, el
paquete swing también establece la clase JApplet para la creación applet. Solo se debe heredar
esta clase para convertir nuestra aplicación a un applet y cambiar el nombre del constructor por el
método init(),los métodos start(), stop() y destroy() son los posibles estados en los que se encuentra
un applet, además son llamados de forma automática.
En una aplicación applet se puede hacer todo lo ya anteriormente se realiza en una aplicación de
escritorio, utilización de paneles, botones, label, textField, imágenes, animaciones, pintar con el
método paint() o paintComponent(), entre otros.
Las aplicaciones apples se deferencias de las demás porque estas no utilizan el método main para
pode ejecutar, hacen un llamado al método start() de forma automática.
CAPITULO 10 – Conectividad de bases de

datos
En ocasiones deseamos que nuestras aplicaciones interactúen con información almacenada en un

Sistema Gestor de Base de Datos (SGBD), Java nos proporciona dos tipos de conexiones y JDBC
ODBC.
Java DataBase Connectivity (JDBC)

Java DataBase Connectivity (JDBC), más conocida por sus siglas JDBC, es una API que permite la
ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java,
independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se
accede, utilizando el dialecto SQL del modelo de base de datos que se utilice.
El API JDBC se presenta como una colección de interfaces Java y métodos de gestión de
manejadores de conexión hacia cada modelo específico de base de datos. Un manejador de
conexiones hacia un modelo de base de datos en particular es un conjunto de clases que
implementan las interfaces Java y que utilizan los métodos de registro para declarar los tipos de
localizadores a base de datos (URL) que pueden manejar. Para utilizar una base de datos particular,
el usuario ejecuta su programa junto con la biblioteca de conexión apropiada al modelo de su base de
datos, y accede a ella estableciendo una conexión, para ello provee el localizador a la base de datos
y los parámetros de conexión específicos. A partir de allí puede realizar con cualquier tipo de tareas
con la base de datos a las que tenga permiso: consulta, actualización, creación, modificación y
borrado de tablas, ejecución de procedimientos almacenados en la base de datos, etc.
La JDK permite el tipo de conexión JDBC ofreciendo el paquete java.sql en el que existen clases
muy útiles para trabajar con bases de datos.
Clases Descripción
DriverManager Cargar un controlador o driver
Connection Establece conexión con una base de datos
Statement Permite crear consultas SQL y enviar a la base de datos
ResultSet Almacena el resultado de una consulta
Tabla Nro 20 – Clases ofrecidas por JDBC
Para garantizar la conexión con una Sistema Gestor de Base de Datos (SGBD) se requiere
importar un Driver o manejador de conexión según él tipo (este driver en Java no es más que
un archivo .jar, que se debe agregar al proyecto). Si esto no se hace es posible que el código
de nuestra aplicación no marque ningún error pero cuando se intente establecer la conexión
este mostrar un error como el siguiente.
Imagen Nro 25 – Error al intentar localizar el Driver de conexión

Imagen Nro 25 – Agregar un driver de conexión a nuestra aplicación
Java Database Connectivity (JDBC) es un derivado inspirado en ODBC, proporciona una

API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de
programación Java independientemente del sistema operativo donde se ejecute o de la base
de datos a la cual se accede utilizando el dialecto SQL del modelo de base de datos que se
utilice.
Open DataBase Connectivity (ODBC)

Open DataBase Connectivity (ODBC)es un estándar de acceso a bases de datos desarrollado por
SQL Access Group en 1992, el objetivo de ODBC es hacer posible el acceder a cualquier dato desde
cualquier aplicación, sin importar en qué sistema de gestión de bases de datos (SGBD) se almacene
los datos, ODBC logra esto al insertar una capa intermedia (CLI) denominada nivel de Interfaz de
Cliente SQL, entre la aplicación y el SGBD, el propósito de esta capa es traducir las consultas de
datos de la aplicación en comandos que el SGBS entienda. Para que esto funcione tanto la aplicación
como el SGBD deben ser compatibles con ODBC, esto es lo que hace que la aplicación sea capaz
de producir comandos ODBC y el SGBD debe ser capaz de responder a ellos.
El software funciona de dos modos, con un software manejador en el cliente, en una filosofía cliente-
servidor. En el primero modo, el driver interpreta las conexiones y llamadas SQL y las traduce desde
el API ODBC hacia el SGBD. En el segundo modo para conectarse a la base de datos se crea una
DSN dentro del ODBC que define los parámetros, ruta y características de la conexión según los
datos que solicite el fabricante.
Para conectar con el Sistema gestor de base de datos MYSLQ según este tipo de conexión ODBC
con Java se requiere de la instalación del driver MyODBC-3.51.10-x86-win-32bit.exe. Su instalación
es fácil solo es siguiente tras siguiente.
Imagen Nro 25: Driver de conexión con MYSQL
Después de instalado el driver de configuración de MYSQL para conexión por el método ODBC se
debe establecer una conexión desde el sistema operativo cliente, entrando a Panel de control,
Herramientas administrativas y Origenes de datos ODBC.
Imagen Nro 25: Ubicación de la ventana de orígenes de datos ODBC

Imagen Nro 25: Establecer conexión ODBC con el SGBD MYSQL
Después de establecida la conexión ODBC desde el cliente como se muestra anteriormente y a la

que se le coloco el nombre de “MYSQL” respecto el campo Data Source Name. Se utiliza este desde
el código de nuestra aplicación Java.

Libro en Desarrollo

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Libro en Desarrollo

Cargado por

Copyright:

Formatos disponibles

TABLA DE CONTENIDO

INTRODUCCIÓN DEL LIBRO ............................................................................................................................. 4

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

El 29 de septiembre de 1994 se termina el desarrollo del prototipo de HotJava(Permitiendo ofrecer

La tecnología Java lo podemos en redes y dispositivos que comprenden desde Internet y

Figura Nro 1: Línea de tiempo de hechos relevantes en la historia de Java

Fácil aprendizaje, La curva de aprendizaje de Java es rápida en este lenguaje, el único

Orientado a Objetos, En Java el concepto de objeto resulta sencillo y fácil de aplicar.

Riqueza semántica, Cada tarea se puede realizar de un número reducido de formas, se ha

c.) INTERACTIVO Y ORIENTADO A RED

Applets, Una applet (miniaplicación) es un pequeño programa en Java transferido

• Fuertes restricciones al acceso a memoria, como son la eliminación de punteros aritméticos

• Verificación del nombre de clase y de restricciones de acceso durante la carga.

e.) GESTIÓN DE LA ENTRADA Y SALIDA

En el lenguaje de programación Java podemos crear los siguientes tipos de aplicaciones:

• Applets: Se pueden descargar de Internet y se observan en un navegador.

• JavaBeans: Componentes software Java, que se puedan incorporar gráficamente a otros

Algunas críticas realizadas al lenguaje Java

Kit de Desarrollo de Java o Java Development

Compilación con (javac) Archivos *.html

Archivo *.class Comprimir archivos a

Ejecutar la aplicación con

Salida en pantalla del

Figura Nro 2: Utilización de la JDK

Instalación del Java Development Kit (JDK) en

FiguraNro 3: Link de descarga desde la página de Oracle

FiguraNro 4: Programa de instalación dela JDK

1. Pulsa click derecho sobre “Equipo o Mi PC” dependiendo del sistema.

FiguraNro 5: Click derecho sobre el equipo (Mi PC)

2. Pulsar un click sobre el menú izquierdo en “Configuración avanzada de sistema”.

3. Pulsar un click en la pestaña opciones avanzadas y variables de entorno.

Figura Nro 7: Opciones avanzadas Figura Nro 8: Variables de entorno

Figura Nro 9:Abrir para Editar la variable PATH y/o CLASSPATH

7. Es recomendable reiniciar el equipo para que la configuración se afecte correctamente,

Figura Nro 11: Prueba de configuración de JDK

Figura Nro 12: Como guardar el archivo

Figura Nro 13: Acceder a la Figura Nro 14: Acceder a la carpeta

Arquitectura de librerías de Java (API – Interfaz de

Los paquetesbásicos que ofrece la API de Java, son los siguientes:

• java.util: Contiene colecciones de datos y clases, el modelo de eventos, facilidades horarias,

• java.math: Clases para realizar aritmética con la precisión que se desee.

• java.security: Clases e interfaces para seguridad en Java: Encriptación RSA.

b. Paquetes para el desarrollo gráfico

• javax.accesibility: Da soporte a clases de accesibilidad para personas discapacitadas.

• java.beans: Para el desarrollo de JavaBeans.

c. Paquetes para el desarrollo en red

• java.net: Clases para aplicaciones de red.

IDE´s y Editores de desarrollo del lenguaje Java

• JCreator, es un IDE pero que no incorpora un constructor de interfaz gráfica de usuario.

• Notepad, Es un editor de múltiples lenguajes como: Java, PHP, entre otros.

• Las constantes: Se deben escribir todo el identificado con letras mayúsculas(CONSTATE o

Programa Nro 2:Ejemplo de identificadores

abstact boolean break byte byvalue

case cast catch char class

const continue default do double

else extends false final finally

float for future generic goto

if implements import inner instanceof

int interface long native new

null operator outer package private

protected public rest return short

static super switch syncroniced this

/Estructura condicional simple/

/Estructura condicional compuesta/

/Estructura condicional anidados/