Introduccion_a_Java_Anton_Alarcon_Luna_S

Vista previa del material en texto

I
III
Christian Roberto Antón Cedeño
José Abel Alarcón Salvatierra
Harry Luna Aveiga
Jimmy Ignacio Sornoza Moreira
INTRODUCCIÓN A JAVA
Guía práctica para programar en 10 días.
IV V
Christian Roberto Antón Cedeño
José Abel Alarcón Salvatierra
Harry Luna Aveiga
Jimmy Ignacio Sornoza Moreira
INTRODUCCIÓN A JAVA
GUÍA PRÁCTICA PARA PROGRAMAR EN 10 DÍAS.
Editado por:
Centro de Investigación y Desarrollo Profesional
CIDEPRO
Babahoyo, Ecuador
Móvil - (Whatsapp): (+593) 9 8 52-92-824
E-mail: editorial@cidepro.org
www.cidepro.org
ISBN: 
1° Edición, Mayo 2018
Libro sometido a revisión de pares académicos.
VI VII
Está prohibido, bajo las sanciones 
penales vigentes que ninguna 
parte de este libro puede ser 
reproducida, grabada en sistemas 
de almacenamiento o transmitida 
en forma alguna ni por cualquier 
procedimiento, ya sea electrónico, 
mecánico, reprográfico, magnético 
o cualquier otro sin autorización 
previa y por escrito del Centro 
de Investigación y Desarrollo 
Profesional (CIDEPRO).
Todos los derechos reservados © CIDEPRO, 2018
Nuestro agradecimiento al Ser Supremo que nos ha permitido concretar 
la publicación de esta obra, la cual está dedicada con mucho amor para 
nuestras familias.
Los autores
VIII IX
ÍNDICE GENERAL
Índice general..................................................................................VIII
Índice de imágenes............................................................................XI
Índice de ejemplo............................................................................XIV
Capítulo 1 
INTRODUCCIÓN Y CONOCIMIENTOS BÁSICOS.................19
Breve historia.....................................................................................19
Evolución de Java y sus tecnologías..................................................26
Notas importantes antes de empezar..................................................33
Tipos de datos en Java.......................................................................38
Jerarquía y conversión de tipos de datos............................................41
Declaración e inicialización de variables primitivas en Java. ...........42
Cast....................................................................................................43
Operadores en Java............................................................................46
Funciones geométricas y trigonométricas..........................................49
Creación de funciones........................................................................51
Clase String, manejo de cadena de caracteres....................................53
Comparación de cadenas de caracteres..............................................54
Subcadenamiento...............................................................................55
Búsquedas en cadenas de caracteres..................................................56
Estructuras de control........................................................................57
Tipo de datos complejos en Java. Manejo de arreglos.......................61
Ámbito de las variables......................................................................62
Capítulo 2 
PILARES DE LA PROGRAMACION ORIENTADA A OBJETOS: 
ABSTRACCIÓN...............................................................................68
Concepto de abstracción....................................................................68
Clase y objeto: Definición.................................................................69
Método constructor............................................................................73
Interface.............................................................................................80
Capítulo 3 
PILARES DE LA PROGRAMACION ORIENTADA A OBJETOS: 
ENCAPSULAMIENTO....................................................................84
Concepto de encapsulamiento...........................................................84
Modificadores....................................................................................84
Métodos get y set...............................................................................87
Comando this.....................................................................................88
Capítulo 4
PILARES DE LA PROGRAMACION ORIENTADA A OBJETOS: 
HERENCIA.......................................................................................92
Comandos package e import..............................................................92
Concepto de herencia .......................................................................94
Capítulo 5 
PILARES DE LA PROGRAMACIÓN ORIENTADA A OBJETOS: 
POLIMORFISMO...........................................................................101
Concepto de polimorfismo...............................................................101
Sobreescritura..................................................................................101
X XI
ÍNDICE DE ILUSTRACIONES
Ilustración 1: Esquema de la ejecución del código en Java...............21
Ilustración 2: Estructura de una aplicación básica de ventas en los
dos Paradigmas..................................................................................23
Ilustración 3: Incorporar una nueva sección en una aplicación 
estructurada .......................................................................................24
Ilustración 4: Incorporar un nuevo módulo a una aplicación orientada 
a objetos.............................................................................................25
Ilustración 5: Diversas tecnologías de Java........................................31
Ilustración 6: Analogía de la introducción al mundo de Java ...........32
Ilustración 7: Sintaxis para agregar la ruta de Java en el path del 
CMD de Windows..............................................................................34
Ilustración 8: Como agregar la ruta de Java en la variable de entorno 
PATH del OS Windows......................................................................34
Ilustración 9: Pantalla de error por no estar la ruta de Java agregada 
a la variable de entorno Path..............................................................36
Ilustración 10: Descripción del comando javac.................................36
Ilustración 11: Estructura mínima de una clase en Java.....................37
Ilustración 12: Clasificación de los tipos de datos.............................38
Ilustración 13: Tipos de datos simples numéricos enteros en Java....40
Ilustración 14: : Tipos de datos simples numéricos reales en Java....40
Ilustración 15: Compilación y ejecución del código 1.......................44
Ilustración 16: Operadores matemáticos en Java...............................46
Ilustración 17: Operadores relacionales y lógicos en Java.................46
Sobrecarga.......................................................................................102
Acerca de los autores.......................................................................106
Referencias Bibliográficas...............................................................111
XII XIII
Ilustración 18: Compilación y ejecución del código 2.......................47
Ilustración 19: Compilación y ejecución del código 3.......................49
Ilustración 20: Compilación y ejecución del código 4.......................50
Ilustración 21: Compilación y ejecución del código 5.......................53
Ilustración 22: Compilación y ejecución del código 6.......................55
Ilustración 23: Compilación y ejecución del código 7.......................56
Ilustración 24: Compilación y ejecución del código 8.......................57
Ilustración 25: Compilación y ejecución del código 9.......................58
Ilustración 26: Compilación y ejecución del código 10.....................59
Ilustración 27: Compilación y ejecución de los códigos 10, 
11 y 12................................................................................................61Ilustración 28: Ámbito de las variables en Java.................................62
Ilustración 29: Compilación y ejecución del código 13.....................63
Ilustración 30: Compilación y ejecución del código 14.....................65
Ilustración 31: Comparación entre la PE y la POO...........................68
Ilustración 32: Estructura promedio de una clase..............................71
Ilustración 33: Mapa conceptual........................................................75
Ilustración 34: Monigotes de fin de año.............................................76
Ilustración 35: Monigotes de fin de año.............................................76
Ilustración 36: Monigotes de fin de año.............................................76
Ilustración 37: Compilación y ejecución de los códigos 15 y 16......80
Ilustración 38: Relación clase interface.............................................81
Ilustración 39: Ejemplo básico y sencillo del uso de interfaces........82
Ilustración 40: Tabla de resumen de modificadores...........................85
Ilustración 41: Compilación y ejecución de los códigos 17 y 18.......90
Ilustración 42: Estructura del ejercicio de los monigotes utilizando 
paquetes y herencia............................................................................95
Ilustración 43: Compilación y ejecución de los códigos 19, 20,
21 y 22................................................................................................99
Ilustración 44: Compilación y ejecución de los códigos 23, 24,
25 y 26..............................................................................................105
XIV XV
INDICE DE EJEMPLOS
Código 1: Ejemplo de Cast................................................................44
Código 2: Uso de operadores matemáticos........................................47
Código 3: División entera y real........................................................49
Código 4: Llamado a funciones de la clase Math..............................50
Código 5: Creación de funciones.......................................................53
Código 6: Comparación de cadenas de caracteres.............................55
Código 7: Subcadenamiento..............................................................55
Código 8: Búsquedas en cadenas.......................................................56
Código 9: Estructuras de control selectivas.......................................57
Código 10: Estructuras repetitivas.....................................................59
Código 11: Estructuras repetitivas.....................................................60
Código 12: Estructuras repetitivas.....................................................60
Código 13: Ejercicio de aplicación de conocimientos adquiridos.....63
Código 14: Ejercicio de aplicación de conocimientos adquiridos.....64
Código 15: Clase molde para monigotes...........................................78
Código 16: Creación y referencia a objetos de la clase molde..........79
Código 17: Aplicando encapsulamiento............................................89
Código 18: Aplicando encapsulamiento............................................90
Código 19: Aplicación de la herencia en el ejercicio del monigote...96
Código 20: Aplicación de la herencia en el ejercicio del monigote...97
Código 21: Aplicación de la herencia en el ejercicio del monigote...98
Código 22: Aplicación de la herencia en el ejercicio del monigote...99
Código 23: Aplicación de polimorfismo sobre ejercicio de 
monigotes........................................................................................103
Código 24: Aplicación de polimorfismo sobre ejercicio de 
monigotes........................................................................................104
Código 25: Aplicación de polimorfismo sobre ejercicio de 
monigotes........................................................................................105
Código 26: Aplicación de polimorfismo sobre ejercicio de 
monigotes........................................................................................105
XVI XVII
PREFACIO
Java es una tecnología muy extensa de la cual se pueden escribir 
cientos de obras que expliquen la variada gama de recursos que nos 
ofrece para el desarrollo de aplicaciones de distinta naturaleza, sin 
embargo, en algún momento esto puede terminar aturdiendo a una 
persona que recién desea iniciarse en el manejo de esta herramienta.
La experiencia que los autores de la presente han adquirido, a 
través de los años, en la enseñanza de la Programación Orientada a 
Objetos mediante el uso de Java ha permitido notar que es necesario 
que el aprendiz conozca y tenga claro cómo nació la herramienta y 
cómo evolucionó a través del tiempo. Sólo así empiezan a entender 
la estructura, naturaleza y la lógica de algo que empezó como un 
lenguaje, pero que en la actualidad es un mundo de tecnologías.
En la presente obra se ha tratado de ser muy prácticos y de 
encaminar al lector desde el inicio a programar, siendo concretos 
en muchos temas, explicando estrictamente lo necesario y 
dejando claro al lector sobre los temas en los cuales puede 
profundizar consultando otras obras, ya sea en paralelo a la lectura 
del presente libro o al finalizar para reforzar conocimientos.
El propósito principal es que esta obra sea leída en diez días y 
que al finalizar el décimo día el lector esté en capacidad y pueda 
construir una pequeña solución basada en los cuatro pilares de la 
programación orientada a objetos. Por supuesto que la solución 
es básica y en modo consola, que es hasta donde cubre el presente 
libro. Sin embargo, estamos seguros que será un sólido punto de 
partida para el recorrido por el basto mundo de Java y para futuras 
especializaciones que se desee hacer en algunas de sus tecnologías.
Finalmente es válido indicar que el presente libro no enseña a programar, 
sino que es una guía práctica para iniciarse en el mundo de Java y más 
bien, por el contrario, el lector debe tener conocimientos previos de 
programación estructurada y desarrollada su lógica de programación.
19
INTRODUCCIÓN Y 
CONOCIMIENTOS 
BÁSICOS
Capítulo 1
INTRODUCCIÓN Y CONOCIMIENTOS BÁSICOS
Toda tecnología, por más sencilla y amigable que parezca, requiere 
para su uso, necesariamente el conocimiento de una mínima base de 
los conceptos, teorías y leyes que la sustentan.
Este capítulo ofrece al lector los conocimientos mínimos que debería 
adquirir para empezar a programar en Java, por supuesto haciendo 
énfasis y sugerencia en los temas que luego deberá profundizar para 
un uso óptimo de la herramienta.
Breve historia
Para poder utilizar una tecnología, es necesario conocer su 
naturaleza y evolución, sólo así se podrá entender de mejor 
forma su funcionamiento y luego adquirir la destreza necesaria 
para su operación.
Java es creado por James Gosling en 1991 como parte de un proyecto 
denominado Green de la Empresa Sun Microsystem, el nombre original 
del lenguaje fue OAK pero fue luego cambiado porque la marca ya 
estaba registrada, se le denominó entonces Java en referencia a una 
variedad de café, de ahí que su logo sea una taza de café.
Para el año en que fue creado Java, el paradigma de programación 
usado por excelencia era la programación estructurada, sin embargo, un 
nuevo paradigma tomaba fuerza: la Programación Orientada a Objetos. 
El primer lenguaje que se aventuró al desarrollo de aplicaciones bajo 
el nuevo paradigma, fue C++ que era una mejora del Lenguaje C 
tradicional y que tenía como propósito extender las funcionalidades 
20 21
de lenguaje C hacia la creación de aplicaciones orientadas a objetos, 
tornándose así en un lenguaje híbrido, por cuanto a pesar de que tenía 
la facultad de generar este nuevo tipo de aplicaciones su estructura 
como tal, seguía obedeciendo a una lógica lineal estructurada.
En este contexto Gosling decide que el lenguaje Java sea construidoutilizando lenguaje C++ pero su estructura debía estar completamente 
orientada a objetos y poseer su propia máquina virtual, lo que le 
permitiría una arquitectura WORA (Write Once, Run Anywhere – 
Escríbelo una vez, ejecútalo en cualquiera) la base conceptual de la 
multiplataforma.
A pesar de que el proyecto Green y con el Java estuvo a punto de ser 
cancelado fue oportunamente repotenciado y su lanzamiento oficial 
se dio en el año de 1995 y supuso el punto de partida de la que hoy 
es una de las herramientas de programación más difundidas a nivel 
mundial con un alto grado de madurez y robustez y con una inmensa y 
creciente comunidad. En el año 2010 Sun Microsystems fue adquirida 
por Oracle Corporation, quien es la propietaria actual de Java.
Existen dos preguntas claves que ayudan a comprender la potencia de 
Java.
¿Qué lo hace a Java Multiplataforma?
La mayoría de los lenguajes anteriores a Java, especialmente aquellos 
que funcionaban sobre sistemas operativos Windows, convertían 
el código fuente en código binario o de máquina el cual sólo podía 
ser ejecutado por el sistema operativo donde se había realizado la 
compilación. Java puso una capa entre el archivo compilado, al que le 
llamó Bytecode y el sistema operativo. Esta capa recibe el nombre de 
Máquina Virtual de Java o Java Virtual Machine, JVM que funciona 
como un intérprete entre el Bytecode y el sistema operativo.
De tal forma que sin importar sobre qué sistema operativo se ejecute 
nuestro Bytecode vamos a obtener el mismo funcionamiento y 
resultado, es decir lo escribimos una vez y lo ejecutamos en cualquier 
parte en la que esté presente la JVM. 
Claro que de este último punto se encargan las grandes corporaciones 
liberando al desarrollador de esta tarea., es común en la actualidad 
ver como los sistemas operativos traen preinstalado Java en su 
configuración por default.
Ilustración 1: Esquema de la ejecución del código en Java
22 23
¿Cuál es la ventaja de que Java sea un software 100% orientado a 
objeto y no una aplicación lineal estructurada con capacidades de 
orientación a objetos como lo es/era C++?
Este es un tema debatible, sin embargo para entenderlo de mejor 
forma es necesario comparar las características clásicas de ambos 
paradigmas.
La programación estructurada es tradicionalmente monolítica y lineal, 
es decir que por lo general las aplicaciones se caracterizan por ser un 
solo archivo extenso que contiene toda la funcionalidad en un flujo 
gestionado por las estructuras de control.
Por el contrario las aplicaciones orientadas a objetos se caracterizan 
por ser ampliamente modulares y se construyen a partir de múltiples 
archivos que tienen dos características esenciales y claves: primero 
son entes autónomos con sus propias características y comportamiento 
y segundo tienen la capacidad de interrelacionarse entre sí de tal forma 
que puedan construir bloques de mayor capacidad.
Esta segunda característica que no la poseen los programas lineales 
hacen que las aplicaciones orientadas a objetos tengan un crecimiento 
exponencial que se conoce como expansibilidad lo cual los hace 
prevalecer en el tiempo porque les permite adaptarse a los nuevos 
desafíos que propone la tecnología. Mientras que las aplicaciones 
lineales eventualmente su crecimiento tendrá un tope en el cual 
inevitablemente colapsará.
Por ejemplo, supongamos una aplicación básica de ventas que 
cubre tres áreas: facturación, cobranzas y bodegas hecha en los dos 
paradigmas tendrían por lo general estas formas:
Ilustración 2: Estructura de una aplicación básica 
de ventas en los dos paradigmas
Es cierto que la primera impresión es que se trata de lo mismo pero por 
separado. En cierta forma habría algo de verdad en aquella afirmación, 
sin embargo supongamos el siguiente escenario: 
La aplicación está instalada en una tienda en tres equipos que se 
encuentran uno en cada área respectiva y de pronto se nos solicita 
incorporar la facturación electrónica. Para el equipo que desarrolla 
la aplicación en modo estructurado supondría las clásicas molestias 
que genera la inserción de nuevo código en secciones que ya estaban 
estables. Quien haya desarrollado aplicaciones estructuradas sabe muy 
bien a lo que se enfrentaría el equipo.
24 25
Ilustración 3: Incorporar una nueva secciòn en una 
aplicación estructurada
Pero el equipo a cargo de la aplicación en modo orientado a objetos no 
tendría esos problemas, por cuanto, tendrían que construir un módulo 
o archivo con las características que ya se mencionaron en párrafos 
anteriores y que solucione el tema de la facturación electrónica, sin 
la necesidad de alterar los otros archivos. Al momento que el nuevo 
módulo se interrelaciona con los demás transforma la solución, 
haciéndola más grande y robusta -expansibilidad en su forma más 
básica-.
Ilustración 4: Incorporar un nuevo módulo a 
una aplicaciòn orientada a objetos
Bien y que pasa al momento de actualizar la aplicación en la tienda 
del ejemplo. Al momento de colocar la nueva versión de la aplicación 
estructurada y como no es nada recomendable tener versiones 
distintas en cada equipo, le toca al personal de soporte instalar en los 
3 computadores, pero resulta que se interrumpe el trabajo del usuario 
de bodega a quien esa actualización no le incumbe.
Bien, ahora, para la tienda que tiene la aplicación en orientación a 
objetos, la incorporación del nuevo módulo es transparente para todos, 
incluso para el usuario de ventas, dado que al no topar los archivos 
con que están trabajando como consecuencia la actualización no los 
interrumpe.
En resumen, las ventajas más importantes de la POO sobre PE son:
1. Mayor escalabilidad y expansibilidad.
2. Bajo costo de desarrollo, implementación y soporte.
26 27
Ahora pensemos que en vez de tratarse de una aplicación de ventas 
la que está desarrollada en orientación a objetos sea un lenguaje de 
programación. Las posibilidades de crecimiento y vigencia a través 
del tiempo para dicho lenguaje serían muy altas. Es lo que sucedió con 
Java.
Los módulos o archivos de orientación a objetos que hemos 
estado mencionando es lo que se conoce como CLASES; por 
tanto se concluye que las clases son entes autónomos con sus 
propias características y funcionalidad y que tienen una alta 
capacidad para interrelacionarse con otras clases.
Evolución de Java y sus tecnologías.
A través de los años como profesores de la materia de Programación 
Orientada a Objetos en la Universidad de Guayaquil en Ecuador 
hemos notado 2 situaciones que comúnmente le suceden a muchos 
estudiantes que se inician en el uso de la materia:
1. La tendencia a confundir Java con alguno de los IDE más 
populares. Es común escuchar esta pregunta: Profesor ¿qué 
versión de Java vamos a utilizar NetBeans o Eclipse?. Es como 
si se estuviese preguntando con qué fruta vamos a hacer el jugo 
de naranja, con la sandía o con la pera?.
2. Cuando recurren a la página de Oracle o de Java, no les resulta 
muy fácil descargar la herramienta por cuanto se topan con una 
variada gama de términos y tecnologías que les pone en duda 
sobre a qué deben hacerle download.
Por supuesto que no sucede en todos los casos, pero si se nota que son 
los errores o dudas iniciales más frecuentes.
En esta sección explicaremos en una breve línea de tiempo cómo y por 
qué fueron apareciendo las distintas tecnologías de Java, así como su 
propósito y aplicación.
Java se inició con la incorporación de múltiples clases, cada una con 
un fin específico. Ante la necesidad de clasificar el vasto volumen de 
clases que se estaban construyendo se las organizó en carpetas a las 
que se le denominó paquete dando origen al primer gran concepto de 
java, los “package”. Estos paquetes agrupaban las clases en base a su 
funcionalidad, así por ejemplo todas las clases que estaban relacionadas 
con el movimiento de datos fueron alojadas en elpaquete IO (input/
output), las clases relacionadas al trabajo en red fueron ubicadas en el 
paquete NET y así con las demás.
En un momento determinado hubo la necesidad ahora de clasificar 
los paquetes dentro de otras carpetas mayores que los contengan, 
obviamente el criterio ya no podía ser la funcionalidad, así que el nuevo 
criterio fue en base al perfil de quien necesitaba Java. Se identificó tres 
perfiles básicos: el primero aquellos usuarios no programadores que 
querían ejecutar una aplicación hecha en Java en sus computadores, en 
pocas palabras, lo mínimo que requeriría un equipo para ejecutar una 
aplicación escrita en Java, nace entonces el paquete más importante de 
Java, su nombre es Java Runtime Environment - JRE.
El JRE es el encargado de que Java y sus aplicaciones puedan 
28 29
funcionar en una computadora, como es obvio suponer dentro de este 
gran paquete se encuentra la JVM.
El segundo perfil fue destinado para aquellos programadores en Java 
desde nivel principiante hasta desarrolladores con algo de experiencia, 
a este paquete le pusieron de nombre Java Development Kit – JDK.
Al JDK en la actualidad también se lo conoce como JSE o Java Standar 
Edition y dentro de este se encuentra el paquete JRE, por tanto, si se 
instala el JDK ya no es necesario instalar a parte el JRE, porque ya lo 
trae incorporado.
Finalmente el tercer perfil que se implementó tenía como propósito 
contener todas aquellas nuevas tecnologías que se desarrollaban y 
en términos generales toda la tecnología Java regulada por la Sun. 
A este paquete se le llamó Java Enterprice Edition – JEE. Sin 
embargo el rápido crecimiento del lenguaje y la aparición de múltiples 
tecnologías hizo que su papel de gran contenedor le resultase corto, 
en la actualidad la mayor parte de las nuevas tecnologías aparecen 
como paquetes independientes que no están dentro del JEE; por lo que 
esta tecnología actualmente está solamente orientada al desarrollo de 
aplicaciones empresariales de alta gama.
El rápido desarrollo del Internet dio origen a múltiples tecnologías 
asociadas a la gran red y en la cual Java ha tenido presencia y que a 
continuación se irán enumerando las más importantes.
Aplicaciones RIA (Rich Internet Application).- Este tipo de 
aplicaciones nacieron ante la necesidad de darle mayor prestaciones, 
tanto en lo funcional como en lo estético a las páginas o aplicaciones 
web que se ejecutaban en el navegador del cliente, las más conocida 
inicialmente fueron Flash de Macromedia luego adquirida por Adobe, 
SilverLight de Microsoft y Java presentó su paquete llamado Java 
Flex – JFX.
Aplicaciones CGI (Common Gateway Interface).- Inicialmente 
las aplicaciones Web del lado del Servidor se ejecutaban por medio 
de archivos con pequeños scripts de programación que se guardaban 
en los servidores en una carpeta llamada CGI. Java propuso una 
alternativa para el desarrollo de aplicaciones del lado del servidor, la 
misma que ha tenido mucho éxito y se mantienen vigente hasta la 
actualidad. Esta tecnología se llama SERVLETS. Es válido aclarar 
que los Servlets no son CGI.
Invocación de métodos remotos.- Por muchos años el RPC (Remote 
Procedure Call) de lenguaje C ha sido uno de los protocolos más 
utilizados al momento de construir aplicaciones distribuidas. Java saco 
su propia tecnología para esta área a la que le llamó Remote Method 
Invocation – RMI aunque posteriormente los esfuerzos de la Sun se 
concentraron en CORBA que ofrece un mejor soporte para este tipo 
de comunicaciones.
Scripts que se ejecutan del lado del cliente.- JavaScript que aunque 
lleva el nombre de Java no guarda ningún tipo de relación con el 
lenguaje a más de tener una sintaxis muy similar y nada más, ha 
sido por muchos años uno de los lenguajes de scripts más utilizados 
30 31
para dar dinamismo a las páginas web, sin embargo la aparición del 
lenguaje PHP hizo que un mercado muy importante se migre a dicho 
lenguaje, Microsoft también aporto a este tipo de lenguajes con su 
ASP y como no podía ser de otra manera Java sacó también su versión 
a cuyo paquete le llamó Java Server Pages – JSP.
En la actualidad muchos desarrolladores de aplicaciones en la Web 
hacen una combinación de SERVLETS con JSP para programar 
soluciones Servidor/Cliente basadas completamente en Java.
Esta combinación se hizo tan popular que se crearon marcos de 
trabajos (Framework) que fusionaban en un solo ambiente ambos 
paquetes, otorgándole mayor comodidad y eficiencia al trabajo de 
los programadores. Uno de los framework más populares, basado en 
Sevlets y Jsp, es un paquete al que se le conoce con el nombre de Java 
Server Faces – JSF. Otro muy popular que trabaja sobre JSF es un 
paquete llamado PRIMEFACES.
Para el trabajo con las bases de datos se tiene los paquetes JDBC 
que es la equivalencia en Java al ODBC de Microsoft, pero si lo que 
se desea es un trabajo más avanzado sobre la persistencia de datos 
entonces se tiene el framework HIBERNATE.
Para la programación en dispositivos de gama baja, como por 
ejemplo teléfonos celulares con OS Symbian, ciertas refrigeradoras o 
microondas se tiene el paquete de Java Micro Edition – JME.
La programación de tarjeta inteligentes está a cargo del paquete 
JCARD y la televisión digital terrestre también recibe su aporte por 
medio del paquete JTV.
El caso de ANDROID es un tema a parte, si bien es cierto que este 
OS para celulares fue creado en Java, no obstante, su máquina virtual 
no es la misma de java, es decir la JVM, sino que ANDROID tiene 
su propia virtual machine llamada DALVIK, es por eso que las 
aplicaciones escritas en Java no se pueden ejecutar en ANDROID y 
viceversa. Sin embargo, ANDROID es considerado como uno de los 
más significantes avances de Java en la tecnología.
Seguir mencionando las tecnologías de Java tomaría muchas más hojas 
del presente libro y se estaría alejando al lector del principal objetivo 
que es la introducción a la programación en Java, sin embargo, hemos 
considerado pertinente mencionar todas las tecnologías que han sido 
citadas; por cuanto en la medida que el lector vaya profundizando en el 
conocimiento del lenguaje se va a ir encontrando con esta terminología 
y teniendo como base esta breve explicación, le será más fácil entender 
e ir recorriendo el fascinante universo de Java.
Ilustración 5: Diversas tecnologías de Java
32 33
Una vez que ya hemos conocido una breve historia de la creación 
de Java y la evolución de sus tecnologías podríamos resumir esta 
introducción al mundo de Java con la siguiente analogía.
Java es como un gran árbol con múltiples ramas al cual nos 
queremos subir, sabemos que este árbol tiene fuertes raíces 
sobre las que se soporta toda la estructura pero no es por ahí 
por donde vamos a empezar a subir, sino por el tronco que 
es la parte más visible y que está a nuestro alcance. Una vez 
que hemos dominado el tronco y llegado al final del mismo 
podremos acceder fácilmente a cualquiera de las ramas de este 
árbol.
Pues bien, las raíces representan al JRE, el tronco al JDK y las 
múltiples ramas son las diversas tecnologías donde Java está presente, 
en resumen, para empezar en el universo Java debemos entender el 
JDK y posterior a ello podremos profundizar en cualquiera de las 
tecnologías avanzadas que Java nos ofrece.
Ilustración 6: Analogía de la introducción al mundo de Java
Notas importantes antes de empezar
Recuerde estas cuatro extensiones de archivos de Java que son 
importantes.
*.java: Para los archivos de código fuente, cualquier editor de texto 
plano los puede manipular, por ejemplo el bloc de notas.
*.class: Para los archivos objeto o Bytecode generados a partir de la 
compilación del archivo fuente. Estos archivos son los que interpreta 
la JVM.
*.jar (Java ARchive): Es el equivalente a los archivos ejecutables o 
extensión EXE de los sistemas operativos Windows. Este archivo es 
la versióntransportable o distribuible de nuestro proyecto o solución 
escrita en Java. En la práctica es una carpeta comprimida como lo es 
cualquier archivo RAR o ZIP.
*.jad (Java Application Descriptor): Normalmente acompaña al 
archivo JAR. Este archivo JAD propone una suerte de Checklist de 
todos los requisitos mínimos que debería tener el equipo que desea 
ejecutar el archivo JAR que viene en conjunto al JAD.
Recuerde estos dos comandos:
javac: Es el que llamaremos para que compile nuestro código fuente.
java: Es el que invocaremos para ejecutar nuestro archivo Bytecode.
Como se va a trabajar en modo consola en un OS Windows, entonces 
recuerde que deberá indicarle al CMD de Windows el path o ruta donde 
se encuentra instalado Java y sus comandos, que será una sintaxis 
parecida a la siguiente línea:
34 35
Ilustración 7: Sintaxis para agregar la ruta de 
Java en el path del CMD de Windows
Note que la ruta, que está entre comillas, puede cambiar dependiendo 
la instalación de Java en el equipo donde vaya a desarrollar. Recuerde 
también que si usted cierra el CMD pierde la ruta y debe volver a 
escribir la línea, por aquello es recomendable mantener el CMD 
abierto durante todo el tiempo que vaya a trabajar. Hay alternativas 
como por ejemplo escribir la línea indicada en un archivo por lotes 
(*.bat) y simplemente ejecutar este archivo las veces que se desee. 
También se puede modificar las variables de entorno del OS Windows, 
obviamente la variable path y agregar la ruta del Java, esto lo puede 
hacer desde las propiedades del equipo, pestaña opciones avanzadas, 
botón variables de entorno se marca la variable path y el botón editar.
Ilustración 8: Como agregar la ruta de Java en la 
variable de entorno PATH del OS Windows
Si se tiene problemas para modificar la variable path ya sea en 
ambiente visual o de consola, se puede buscar en Internet tutoriales 
más detallados de cómo realizar esta tarea.
Descargamos el JDK de la página de descarga de Java, sugerimos el 
siguiente enlace:
http://www.oracle.com/technetwork/es/java/javase/downloads/index.
html
Es válido hacer la siguiente recomendación: nuestra experiencia nos 
ha mostrado que no es recomendable utilizar las herramientas IDE 
más populares como por ejemplo Netbeans, Eclipse, JCreator o IntelliJ 
para enseñar a programar en Java a principiantes; esto es debido a 
que la facilidad que ofrecen estas herramientas en la creación de 
aplicaciones los hace dependientes del editor y les da una percepción 
errada de creer que saben Java, al momento en que se les retira el 
editor el rendimiento del aprendiz cae notoriamente. En síntesis, es 
como si se enseñase a niños la operación de la suma empleando para 
ello una calculadora, el resultado será que los niños aprenderán a usar 
la calculadora, pero no a sumar.
Recomendamos el uso de editores de texto mejorados como por 
ejemplo Notepad++, LightTables, Brackets, Sublime Text, Atom, 
entre otros. 
Los ejemplos que encontrará en este libro fueron desarrollados usando 
Atom, el cual puede ser descargado desde la siguiente ubicación:
https://atom.io/
36 37
Sin embargo, el lector puede utilizar cualquiera de los mencionados o 
el de su elección, incluso si desea hasta el bloc de notas sirve.
Probamos si las rutas colocadas en el path están correctas escribiendo 
javac en el CMD y damos enter. Si el ejercicio del path no fue bien 
hecho obtendremos el siguiente error:
Ilustración 9: Pantalla de error por no estar la ruta de 
Java agregada a la variable de entorno Path
Pero si el ejercicio fue bien desarrollado obtendremos la siguiente 
pantalla:
Ilustración 10: Descripción del comando javac
Finalmente, para efectos de poder realizar los primeros ejercicios, en 
la siguiente imagen se muestra una estructura muy básica de una clase 
en Java, más adelante veremos una estructura estándar de una clase en 
Java, la cual obviamente lleva más elementos.
Ilustración 11: Estructura mínima de una clase en Java.
La primera línea consiste en la declaración del nombre de la clase 
–ClaseEjemplo- las llaves determinan los límites de la clase. Dentro 
vemos la codificación del método main que al igual que en lenguaje C 
es el método principal de la clase por donde se empieza la ejecución 
de un programa. Las llaves también determinan los límites del método.
Aún no explicaremos los comandos que acompañan la declaración 
tanto de la clase como del main, estos se verán más adelante.
Algo que es muy importante puntualizar es que por ley el 
nombre del archivo físico debe ser el mismo nombre de la clase 
y respetando las mayúsculas y minúsculas empleadas.
La sintaxis de Java es muy similar a la de C++ y toda línea de código 
termina con el punto y coma. Los comentarios van precedidos de 
doble barra //.
Para presentar información en la consola del computador se utiliza la 
siguiente expresión:
System.out.println(mensaje o valor que se desea presentar);
38 39
Se puede apreciar que esta expresión es el llamado a una función de 
nombre println() y que recibe como parámetro lo que se desea presentar 
por consola, el resto de la sentencia lo estudiaremos más adelante.
Java es lenguaje muy sensitivo con respecto a las letras 
mayúsculas y minúsculas. Sea muy cuidadoso con la escritura 
de la sintaxis en Java. Una letra que no esté en mayúscula o 
minúscula muchas veces es la causante de pérdida de tiempo y 
dolores de cabeza tratando de encontrar el error.
A lo largo del libro en todos los códigos fuente se podrá apreciar la 
correcta escritura de los comandos de Java.
Tipos de datos en Java.
Java opera con la mayoría de los tipos de datos conocidos, pero 
previamente recordemos la clasificación de los tipos de datos.
Ilustración 12: Clasificación de los tipos de datos.
Recordemos los conceptos básicos de la clasificación de los tipos de 
datos. 
Simples o primitivos.- Denominados así debido a que sólo cumplen 
con un propósito: almacenar o representar un único valor y nada más. 
Por ej. int x nos indica que la variable x puede almacenar y representar 
un único valor entero.
Compuestos o complejos.- Denominados así debido a que su propósito 
es de almacenar, pero a diferencia de los primitivos estos pueden 
representar a uno o más valores, con la restricción de que todas los 
cantidades guardadas deben ser del mismo tipo de dato. Por ejemplo: 
int[10] x nos indica que la variable x puede almacenar y representar 
hasta 10 valores enteros. 
Definidos por el usuario.- Este tipo de datos se denominan así 
debido a que son construidos por el programador para un propósito 
específico. Este tipo de datos también se les suele llamar inteligentes 
debido a que a diferencia de los otros tipos de datos que sólo tienen un 
propósito que es el de almacenar. Los definidos por el usuario tienen 
dos propósitos: almacenar y tener funcionalidad, lo que les da cierto 
grado de inteligencia. En este grupo se ubican las clases. Por ejemplo 
String x nos indica que x es una variable que almacenará una cadena 
de caracteres, pero adicionalmente la clase String almacena una serie 
de métodos que nos permite trabajar con la cadena de caracteres 
guardada realizando con ella múltiples tareas como comparaciones, 
extraer caracteres, búsquedas, etc. Por ejemplo para saber el tamaño 
de la cadena contenida en x invocaríamos el método length() de la 
siguiente forma x.length().
Para empezar a trabajar en Java con los primitivos podemos notar 
que tenemos dos tipos de datos simples numéricos que son los 
40 41
enteros y los reales, sin embargo, Java nos ofrece seis tipos de datos 
para representarlos, cuatro para los enteros y dos para los reales. Se 
diferencian básicamente en el espacio que ocupan en la memoria del 
computador y la cantidad numérica capaces de representar.
El objetivo de ofrecernos esta variada gama de tipos de datos numéricos 
radica en el uso óptimo que le demos a la memoria del computador, 
por ejemplo:Si se deseara almacenar edades de personas en una variable, esta 
bastaría con ser declarada de tipo byte puesto que las edades son valores 
positivos que muy difícilmente pasaran los 127 años, declararla como 
tipo short reservaría un byte más a la memoria el cual nunca sería 
utilizado. El siguiente cuadro muestra los cuatro tipos para representar 
los enteros en Java.
TIPOS DE DATOS ENTEROS
Ilustración 13: Tipos de datos simples numéricos enteros en Java
El siguiente cuadro muestra los dos tipos para representar los reales 
en Java.
TIPOS DE DATOS REALES
Ilustración 14: Tipos de datos simples numéricos reales en Java
El tipo de dato CHAR está destinado, al igual que en lenguaje C, a 
representar un único carácter en formato UNICODE y almacenándolo 
siempre entre comillas simples. 
Si lo que se desea es manipular cadenas de caracteres se tiene la clase 
STRING de la cual se tratará más adelante.
Para el manejo de tipos de daos lógicos de verdadero o falso se tiene 
el tipo BOOLEAN que almacena valores TRUE y FALSE o también 
1 y 0 respectivamente.
Hasta ahí los tipos primitivos en Java, más adelante explicaremos el 
uso de los arreglos con lo cual estaríamos abarcando los tipos de datos 
complejos. Finalmente trabajaremos con clases, las cuales como se 
pudieron apreciar en la tabla de tipos de datos se ubica en el grupo de 
tipos definidos por el usuario.
Jerarquía y conversión de tipos de datos
Al ser el double el tipo de datos con la mayor capacidad de representar 
cantidades, por ende puede receptar cualquier valor que se encuentre 
en los demás tipos de datos numéricos. La jerarquía de datos se da 
de mayor a menor y no viceversa. Esto quiere decir que se puede 
almacenar un float en un double pero no al revés. Se puede almacenar 
un long en un float pero no al revés. De tal forma que podemos indicar 
que:
byte < short < int < long < float < double
Por tanto si se tendría que resolver una expresión aritmética compleja 
en la cual estén presentes todos los tipos de datos, la variable a utilizar 
42 43
debería ser double, porque Java siempre resolverá estas expresiones 
arrojando el resultado en el tipo de datos de mayor jerarquía presente 
en la expresión.
Si se tiene una expresión aritmética donde están presente todos los tipos 
de datos a excepción del double, entonces la variable que almacenará 
el resultado deberá ser de tipo float.
Si se tiene una expresión aritmética donde están presente todos los tipos 
de enteros, pero no hay reales, entonces la variable que almacenará el 
resultado deberá ser long.
Si la expresión no tiene números reales ni datos long, la respuesta será 
dada en int. Para cualquier combinación donde sólo estén presentes 
tipos short y byte la respuesta siempre será dada en int.
Declaración e inicialización de variables primitivas en Java
La declaración de variable primitivas en Java es muy flexible, es decir 
de las siguientes formas:
Declaración individual
int x;
Declaración múltiple
int x, y, z;
Declaración e inicialización
int x=0;
Declaración múltiple e inicialización
int x=0, y, z;
Declaración primero e inicialización después
int x;
 x=0;
Cast
Hemos visto que por jerarquía de datos es posible transportar valores 
desde tipos de menos hacia mayor jerarquía, por ejemplo llevar un 
valor float a una variable double es perfectamente posible. Pero qué 
sucede cuando lo que necesitamos hacer es al revés, es decir transportar 
valores de datos de mayor jerarquía hacia datos de menor jerarquía. 
En primera instancia, por simple lógica, no se podría por cuanto no 
es posible colocar algo de mayor capacidad dentro de algo de menor 
capacidad. Sin embargo, existe una técnica en Java que permite realizar 
este tipo de conversiones. Esa técnica se llama CAST.
El CAST consiste en colocar en la expresión de asignación entre el 
signo igual y la variable a transformar, entre paréntesis el tipo de dato 
al cual vamos a transformar dicha variable. Por ejemplo:
Nota: Recuerde que el nombre del archivo físico debe ser el mismo 
nombre de la clase.
Nota: Los valores float deben ir acompañados de la letra F para poder 
ser almacenados en variables.
Nota: En el CMD ubíquese en la carpeta donde tiene sus archivos para 
que pueda compilar.
44 45
Código 1: Ejemplo de Cast
El resultado de la compilación y ejecución del código se muestra a 
continuación:
Ilustración 15: Compilación y ejecución del código 1
Notemos como fue el proceso de compilación, luego de escribir el 
nombre del comando javac hemos puesto el nombre del archivo fuente 
incluida la extensión.
Ahora veamos como fue el proceso de ejecución, luego de escribir el 
nombre del comando java hemos puesto el nombre del archivo, pero 
sin ninguna extensión.
Ahora analicemos el código fuente desde la línea 3:
Línea 3: Declaración de 2 variables enteras, una es inicializada.
Línea 4: Declaración e inicialización de 1 variable real.
Línea 5: Se presenta por consola el valor de la variable i, es decir debe 
salir por pantalla el número 9.
Línea 6: Se presenta por consola el valor de la variable j, es decir debe 
salir por pantalla el número 37,9.
Línea 7: Se hace una conversión de menor a mayor, la cual es posible 
por cuanto un tipo int es soportado por una variable tipo float (j=i), no 
se necesita el empleo de Cast.
Línea 8: Se presenta por consola el valor de la variable j, debería 
salir 9.0, recordar que por ser un dato real deberá aparecer el decimal 
aunque sea cero.
Línea 9: Asignación de un valor float a la variable, nótese el empleo 
de la letra F.
Línea 10: Conversión de un tipo de mayor a menor jerarquía, se trata 
de almacenar el valor de una variable float en una variable entera. Se 
debe hacer uso del Cast. Nótese que al lado de la variable float se está 
colocando entre paréntesis el tipo de dato int que es la variable que va 
a recibir el valor, es decir, a la que queremos llevar el valor float.
Finalmente la línea 11 presenta por consola el nuevo valor de la 
variable i, deberá salir 37.
 Existen técnicas más avanzadas de casting, la que se muestra en 
este libro es la más básica, se recomienda al lector profundizar 
sobre este tema puesto que es un recurso de programación muy 
útil y por ende muy utilizado.
46 47
Operadores en Java
Ilustración 16: Operadores matemáticos en Java
Ilustración 17: Operadores relacionales y lógicos en Java
Ejemplo del uso de operadores matemáticos, el operador de división y 
el de módulo serán analizados en un ejercicio a parte.
Código 2: Uso de operadores matemáticos
Ilustración 18: Compilación y ejecución del código 2
El operador de división tiene la facultad de poder hacer divisiones 
reales como divisiones enteras, todo dependerá de los términos u 
operando que se ubiquen a sus costados. Si los dos términos son enteros 
entonces el operador realiza una división entera, por el contrario, basta 
que uno de los términos sea real para que entonces el operador realice 
una división real.
48 49
Código 3: División entera y real
Ilustración 19: Compilación y ejecución del código 3
Funciones geométricas y trigonométricas
Estas funciones se encuentran en Java dentro de una clase llamada 
Math que trabaja como una biblioteca de la cual se puede utilizar/
invocar sus funciones internas, la forma de hacerlo es colocando un 
punto luego del nombre de la clase y escribiendo después del punto el 
nombre de la función que se desea invocar, hay que tener en cuenta el 
tipo de dato que devuelve la función y la cantidad y tipo de datos que 
recibe como parámetro. Se puede revisar en la web de Java u Oracle la 
referencia bibliográfica de la clase Math.
La característica que poseen ciertos operadores mediante la 
cual tienen la capacidad de comportarse de distintas formas o 
realizar distintas tareas u operaciones se conoce con el nombre 
de SOBRECARGA. Se dice entonces que EL OPERADOR 
ESTÁ SOBRECARGADO.
Esta misma característica la pueden adquirirlos métodos 
o funciones, es decir que pueden tener la capacidad de 
comportarse de distintas formas. Entonces se dice que EL 
MÉTODO ESTÁ SOBRECARGADO.
El operador de módulo o residuo de una división entera requiere 
necesariamente que ambos términos sean enteros.
50 51
Código 4: Llamado a funciones de la clase Math
 Ilustración 20: Compilación y ejecución del código 4
En este Ejemplo 4 es importante observar que algunas de las funciones 
de la clase Math están sobrecargadas (este concepto ya se explicó en 
párrafos anteriores), de igual forma este ejemplo sólo presenta unas 
cuantas funciones, la clase Math tiene muchas más funciones.
De igual forma notemos que es posible enviar a la función println() no 
sólo valores o variables, sino también expresiones, éstas las resolverá 
primero Java y el resultado de dichas expresiones será el argumento 
final que se envíe a la función println(). Con lo cual es posible optimizar 
mucho código. Esta es una de las grandes ventajas de Java, la alta 
capacidad del lenguaje de optimizar líneas de código.
Creación de funciones.
Hasta el momento hemos estado trabajando con una única función 
dentro de las clases, nos referimos al main. En el siguiente ejercicio 
vamos a escribir cuatro funciones adicionales al main(), las cuales se 
llamarán: suma(), resta(), multiplicación() y división().
Pero antes analicemos brevemente las cabecera de la función main().
public static void main(String[] args)
public y static son palabras reservadas de Java a las que se les llama 
modificadores, que es un tema que veremos más adelante.
void representa el tipo de dato que retorna la función, se podría decir 
que void es un tipo de dato que representa a la nada, por tanto se está 
indicando que la función no retorna valor.
main que es el nombre de la función.
String[] que es un arreglo de cadena de caracteres. Ya habíamos 
explicado en párrafos anteriores que String es una clase que sirve para 
el manejo de cadena de caracteres, al colocarle los corchetes estamos 
indicando que recibiremos un arreglo de clases String.
Finalmente, args es el nombre de la variable que gestionará el arreglo 
de cadena de caracteres.
Para la creación de las funciones vamos a utilizar los mismos 
modificadores, de la función main.
52 53
Código 5: Creación de funciones
 Ilustración 21: Compilación y ejecución del código 5
Clase String, manejo de cadena de caracteres.
Como ya se indicó en párrafos anteriores, para el manejo de cadena de 
caracteres Java nos ofrece la clase String con la cual podemos crear 
variables de este tipo (objetos en Programación Orientada a Objetos), 
por ejemplo:
String nombre = “Carlos”;
La variable/objeto llamada nombre contiene una cadena de caracteres 
de valor “Carlos”, nótese que las cadenas de caracteres deben ir siempre 
entre comillas dobles, pero esta variable/objeto tiene almacenados a 
más de la cadena, una serie de métodos con los que podemos hacer 
múltiples tareas con dicha cadena. En este libro veremos tres métodos 
que nos permitirán hacer comparaciones, subcadenamiento y búsqueda.
La clase String es una de las clases más utilizadas en Java 
El tipo de datos de retorno será float en todos los métodos.
La cantidad de parámetros serán dos en todos los métodos y el tipo de 
datos de los parámetros serán enteros los dos parámetros y en todos 
los cuatro métodos.
A diferencia de Lenguaje C++ no es obligación que el main se 
encuentre al final, puede ser el primer método e invocarse desde ahí a 
otros métodos que estén codificados posterior al main. 
No obstante, las buenas prácticas de programación indican que es 
recomendable que el main se lo codifique al final de la clase.
54 55
Código 6: Comparación de cadenas de caracteres.
Ilustración 22: Compilación y ejecución del código 6
Subcadenamiento
Otro de los métodos que nos ofrece la clase String es substring(int 
desde, int hasta), este método nos devuelve un String que contiene 
una subcadena extraída de la cadena original que contiene la variable/
objeto String.
Recibe como parámetro 2 enteros que representan la posición de 
partida y de llegada del conjunto de caracteres que se van a extraer.
Código 7: Subcadenamiento
y tiene múltiples métodos que facilitan mucho el trabajo con 
cadenas de texto. Es muy importante que el lector profundice 
sobre el estudio de esta clase.
Nota: Este libro parte de la premisa de suponer que el lector 
está iniciándose no sólo en el lenguaje Java, sino también en la 
Programación Orientada a Objetos POO, por tanto, hay ciertos 
conceptos que no son tratados ampliamente porque se asume que no 
podrían quedar muy claros sin un conocimiento previo de la POO. 
Así también existen ciertas comparaciones o analogías que se emplean 
con fines didácticos en el proceso de transición que experimenta el 
lector que está pasando desde la Programación Estructurada PE 
hacia la POO, por ejemplo: decir variable/objeto. Recordemos que el 
propósito de esta obra es únicamente una introducción al mundo Java.
Comparación de cadenas de caracteres.
La clase String nos ofrece dos métodos para cuando se desean comparar 
cadenas de caracteres.
1. equals(-cadena con la que se va a comparar-)
2. equalsIgnoreCase(-cadena con la que se va a comparar-)
Ambos métodos retornan un valor booleano indicando la igualdad o no 
entre las cadenas. La diferencia que existe entre ambos métodos está 
determinada por la presencia de caracteres escritos en mayúscula o 
minúscula, es decir el primer método es sensitivo a este tema, mientras 
que el segundo no lo es.
56 57
Ilustración 23: Compilación y ejecución del código 7
Búsquedas en cadenas de caracteres
Existen dos métodos que permiten realizar búsquedas de caracteres 
específicos dentro de la cadena. charAt(int posicion) que nos devuelve 
el carácter que se encuentra en la posición enviada por parámetro a la 
función.
Luego tenemos el método indexOf(char caracter) que nos devuelve un 
entero indicando la posición en donde se encuentra el carácter enviado 
como parámetro a la función.
Cabe indicar que los dos métodos mencionados manejan el carácter 
como tipo char y se lo debe colocar entre comillas simples.
Código 8: Búsquedas en cadenas
Ilustración 24: Compilación y ejecución del código 8
Estructuras de control
Las estructuras de control selectivas y repetitivas son las mismas que 
podemos encontrar en Lenguaje C++ y por lo general en la mayoría de 
los lenguajes de programación.
No se profundizará en el estudio del comportamiento de las estructuras 
de control por cuanto suponemos que el lector las debería conocer. Sin 
embargo, puede buscar información de dichas estructuras en Internet 
si así lo desea.
Código 9: Estructuras de control selectivas
58 59
 Ilustración 25: Compilación y ejecución del código 9
El comando break que es utilizado en los case de la estructura switch 
tiene la misma funcionalidad que en Lenguaje C++, es decir, este 
comando sirve para sacarnos de una estructura, colocando el flujo del 
programa en la línea inmediatamente posterior al final de la estructura.
Así también en la línea 26 podemos observar que utilizamos el operador 
+ de una forma distinta a lo visto hasta el momento ya que uno de 
sus términos es una cadena de caracteres y el otro término un entero, 
la operación resultante es una nueva cadena construida de la unión 
de los dos términos del operador. A este proceso se le conoce con el 
nombre de CONCATENACIÓN, con lo que podemos darnos cuenta 
que en Java el operador + está sobrecargado y a más de sumar valores 
numéricos también construye cadenas cuando uno de sus términos es 
una cadena.
Código 10: Estructuras repetitivas
Ilustración 26: Compilación y ejecución del código 10
60 61
Código 11: Estructuras repetitivas
Código 12: Estructuras repetitivas
Ilustración 27: Compilación y ejecución de los códigos 10, 11 y 12
Los ejemplos 10, 11 y 12 resuelven el mismo problema, pero cadauno 
con una estructura de control repetitiva distinta.
Existe un comando muy utilizado dentro de las estructuras de control, 
al igual que el comando break que vimos en párrafos anteriores, 
este comando es el comando continue cuya funcionalidad consiste 
en colocar el flujo del programa al inicio de la estructura donde 
se encuentre el comando, es decir este comando no nos saca de la 
estructura, sino que nos coloca al inicio de la misma.
Tipo de datos complejos en Java. Manejo de arreglos.
El manejo de tipos de datos complejos como lo son los arreglos, difieren 
un poco a como se lo hace en Lenguaje C++. En Java la declaración de 
un arreglo es de la siguiente forma:
int[] x = new int[10];
Note que en la declaración de la variable arreglo, el tipo de dato no 
está dimensionado, sin embargo, al momento de inicializarlo con la 
palabra reservada new volvemos a escribir el arreglo pero ahora si con 
dimensión.
62 63
Ámbito de las variables.
El campo de acción de una variable en Java está determinado por las 
llaves de la estructura donde fue declarada dicha variable, es decir 
los límites de la variable son los límites de la estructura donde fue 
declarada.
Por ejemplo en la estructura repetitiva for, declaramos una variable 
que representa el índice del bucle, por lo tanto el campo de acción de 
esta variable índice son las llaves de la estructura for, esto quiere decir 
que la variable sólo existe dentro del for, fuera de esta estructura ya 
no existe.
Podemos deducir entonces que para declarar variables globales en Java, 
estas deberían tener como campo de acción las llaves de la clase y esto 
se lograría si son declaradas fuera de todo método o estructura interna 
anidada en la clase. Las variables que se declaran como parámetros de 
una función o método; su ámbito son las llaves de dicha función, es 
decir estas variables son reconocidas únicamente dentro de la función.
Ilustración 28: Ámbito de las variables en Java
Vamos poniendo en práctica lo aprendido hasta el momento con dos 
problemas:
1. Nos piden encontrar el resultado de esta operación:
Código 13: Ejercicio de aplicación de conocimientos adquiridos
Ilustración 29: Compilación y ejecución del código 13
Note en la línea 5 el uso del operado += que es una forma resumida de 
crear un acumulador, por ejemplo: escribir y+=z es equivalente a y = 
y + z. En la línea 11 tenemos un caso similar, pero con otro operador 
matemático.
Recuerde que, si se manda una expresión como parámetro en el llamado 
64 65
a una función, Java primero resuelve la expresión y el resultado 
obtenido es que el finalmente es enviado como parámetro a la función.
Bien, ahora veamos el segundo problema:
2. Supongamos que alguien nos pide que desarrollemos un 
programa que descubra si el promedio de los 10 primeros 
números enteros positivos primos es mayor a la sumatoria de 
los 10 primeros términos de la serie de Fibonacci.
Código 14: Ejercicio de aplicación de conocimientos adquiridos
Ilustración 30: Compilación y ejecución del código 14
Hagamos un análisis de lo que sucede en las líneas 3 y 4, primero 
aclarar que se trata de una sola línea de código ya que la línea 3 no 
termina con punto y coma, por tanto, el compilador de Java asume que 
continua en la siguiente línea.
Vemos que estamos frente a una concatenación, pero lo interesante es 
analizar lo que se aprecia en el término de la derecha del operador +, 
se está haciendo uso del operador condicional simple (?:), que es una 
versión resumida de la estructura de control selectiva simple (if).
Este operador condicional simple tiene la siguiente sintaxis:
(expresión booleana) ? (se ejecuta por V) : (se ejecuta por F)
Esto significa que la concatenación se hará con una de las dos 
expresiones ubicadas después del signo ?, dependiendo del resultado 
de la expresión booleana.
Este operador es muy útil, sin embargo, sólo se lo puede usar en 
expresiones donde existe sólo una acción por verdadero y una por 
falso, si existen más acciones ya no es posible su uso, en ese caso se 
recurre a la estructura if.
Así también, cuando una estructura if sólo tiene una acción asociada, 
es posible que no se utilicen las llaves del if, como podemos apreciar 
66
en las líneas 12 y 13, si hay más de una línea dentro del if en ese caso 
si se debe colocar las llaves.
En la línea 20 note que Java primero resolverá la operación y el 
resultado es el valor que el return devolverá.
PILARES DE LA 
PROGRAMACIÓN 
ORIENTADA A OBJETOS: 
ABSTRACCIÓN
Capítulo 2
68 69
Pilares de la Programación Orientada a Objetos: 
ABSTRACCIÓN
La POO tiene varios pilares sobre los que se soporta el paradigma 
para garantizar dos objetivos fundamentales que son: la simplicidad u 
optimización del código; y, la reusabilidad del mismo. Sin embargo, son 
cuatro los pilares de mayor difusión: Abstracción, Encapsulamiento, 
Herencia y Polimorfismo.
En este capítulo veremos las técnicas más básicas que ofrece Java para 
realizar aplicaciones que cumplan con este primer pilar de la POO, el 
cual está orientado a la simplicidad de la programación. Por supuesto 
se recomienda al lector profundizar y complementar el aprendizaje de 
este pilar.
Concepto de Abstracción
Recordemos un poco las ventajas de la Programación Orientada a 
Objetos sobre la Programación Estructurada.
Ilustración 31: Comparación entre la PE y la POO
Para obtener la simplicidad y optimización del código a la hora de 
programar nuestras soluciones; la Orientación a Objetos nos propone 
la Abstracción como una de las técnicas claves para conseguir estos 
objetivos. 
Esta técnica consiste en identificar las características y 
comportamientos de un ente para construir luego una clase o plantilla 
que modelará a este ente. En síntesis, este pilar o fundamento nos 
plantea la posibilidad de reconocer los atributos y métodos de un 
objeto.
Java nos ofrece dos alternativas para modelar objetos: la clase y la 
interface. Primero nos centraremos en el estudio de la clase y luego en 
el de la interface.
Ya hemos visto que la clase es considerada un tipo de dato definido por 
el usuario y como cualquier tipo de dato se puede crear variables de 
ella. Pero esto es una visión muy básica y genérica que se despega del 
paradigma para dar un concepto de lo que es una clase.
Si nos centramos en el paradigma de POO veremos que el concepto 
de clase es más complejo y completo, por eso a partir de esta parte del 
libro, ya no nos referiremos a la clase como tipo de dato, sino como 
clase y a lo que se mencionó como variables del tipo de dato se le dirá 
objetos o instancias de la clase.
Clase y Objeto: Definición
Clase.- Es una plantilla construida con el propósito de modelar un ente 
o elemento cualquiera. En síntesis, es el molde de algo. 
70 71
Está construida a partir de la abstracción que se hace de las características 
y comportamientos previamente analizados sobre el ente a modelar.
Las características identificadas se transforman en variables internas 
de la clase, que pueden ser primitivas, complejas u otras clases.
El comportamiento identificado se transforma en los métodos o 
funciones internas de la clase, por lo que podemos notar que las clases 
tienen la facultad de almacenar internamente cualquier tipo de dato y 
adicionalmente métodos y funciones.
Las variables internas reciben el nombre de atributos de la clase, 
mientras que las funciones internas reciben el nombre de métodos de 
la clase.
La clase tiene 2 propósitos fundamentales:
1) Modelar algo.
2) Dar funcionalidad al modelo.
Objeto.- Son todos los elementos que nacen o se crean a partir de una 
clase. En síntesis, son todos los ejemplares que salen del molde.
Todos estos ejemplares tendrán la misma estructura, es decir los 
mismos atributos y métodos, sin embargo, lo que los diferenciará entre 
sí, será el valor que almacenen o contengan sus atributos.
En párrafos anteriores vimos una estructura muybásica de la clase, a 
continuación, veamos la estructura promedio de una clase.
Ilustración 32: Estructura promedio de una clase
Análisis de la estructura.
Como vimos al inicio de la obra sobre la evolución de Java, sabemos 
que el lenguaje permite el trabajo en un ambiente o esquema de 
paquetería.
Si se va a trabajar en este ambiente la primera línea de nuestras clases 
deberán indicar dentro de que paquete van a estar y si no se trabaja 
en este esquema no se coloca la línea del package. En el capítulo 4 se 
profundiza este tema.
El import es un caso similar al del package, si vamos a necesitar de 
clases que estén fuera de nuestro paquete o carpeta de trabajo habrá 
que importarlas indicando la ruta del paquete donde se encuentran las 
clases que se desea utilizar.
72 73
La tercera sección representa a la cabecera de la clase, por efectos de 
espacio se la dividió en 3 líneas. Identificando las partes de la cabecera 
notaremos que lo primero que se coloca son los modificadores de la 
clase, que en el siguiente capítulo del libro se analizarán con detalle. 
Luego vemos la palabra reservada class y luego el nombre de la clase.
Si nuestra clase es hija de otra clase superior, es decir, estamos 
haciendo herencia, se utilizaría entonces la palabra reservada extends 
para indicar el nombre de la clase padre. La herencia es un tema que 
se tratará en el capítulo 4.
Si se va a hacer uso de interfaces se deberá entonces utilizar la palabra 
reservada implements para indicar el nombre de la interface que se va 
a utilizar. Este tema será tratado con más detalle, más adelante.
Dentro de la clase tenemos ya la declaración de las variables globales 
y la codificación de los métodos internos de la clase, de los cuales hay 
dos que merecen un estudio a parte: el main y el constructor.
Del main ya hemos hablado en gran parte del libro, su cabecera está 
conformada por los modificadores, el valor void de retorno, el nombre 
main y que recibe como argumento un arreglo de objetos String que 
contienen cadenas de texto que son enviadas desde la consola del OS 
por parte del usuario al momento de ejecutar la aplicación.
Cabe indicar que dentro de un paquete pueden existir múltiples clases, 
pero sólo una puede llevar main, a esta clase se le denomina la clase 
principal y como resultado un paquete puede tener solo una clase 
principal.
Al ser el main el método que va a buscar la JVM para arrancar la 
ejecución del programa, por esta situación a las clases principales se 
les suele llamar también clases ejecutables.
Ahora estudiemos el método llamado constructor.
Método Constructor.
Si bien se considera al main como el método principal de la clase, el 
constructor tiene la importancia por sus características y funcionalidad 
que a continuación se indica:
1. Inicializa el objeto.- Cuando se crea un objeto en Java, la 
forma correcta de hacerlo obedece a la siguiente sintaxis:
String x = new String(“Hola”);
En donde el String de la izquierda es la clase y el String() de la 
derecha es el método constructor. Como se aprecia es una instrucción 
de asignación en donde el objeto x recibirá el valor de retorno que le 
entrega el llamado al constructor. Pero qué tareas realiza el constructor 
cuando es invocado en la creación del objeto. La más básica es la 
inicialización o enceramiento de las variables internas de la clase, 
que es el mismo proceso que se realiza en la PE cuando arranca un 
programa, se pone en cero todas las variables del mismo.
2. Realiza todas las actividades previas que se requieren antes 
de que el objeto esté disponible para el programador.- En 
ocasiones cuando se crea un objeto no sólo basta con que se 
inicialice las variables internas de la clase, sino que también 
se requiere una serie de actividades que si no se ejecutan 
74 75
previamente es probable que el objeto creado no tengo un buen 
comportamiento o funcionalidad. Estas actividades dependerán 
exclusivamente de la naturaleza de la clase o de la aplicación 
que se esté construyendo, analicemos el siguiente escenario:
Supongamos que tenemos acceso a una clase llamada ClaseSql que se 
especializa en hacer consultas de tipo Sql a un motor de base de datos. 
Esta clase tiene un método llamado consultar() que recibe la sentencia 
Select que se quiera ejecutar. Después de crear un objeto, queremos 
realizar una consulta a una tabla, supongamos de la siguiente forma:
ClaseSql x = new ClaseSql();
x.consultar(“Select * from tabla”);
En este escenario, entre la creación del objeto y la consulta que se trata 
de realizar, deben haber sucedido muchas acciones que garanticen el 
éxito de la consulta que se trata de realizar, enumerando algunas serían:
• Confirmar si hay conexión con el equipo DBServer.
• Confirmar que se trata del motor SGBD que se desea acceder.
• Confirmar si existe la base de datos a consultar.
• Confirmar si se tiene los privilegios necesarios para gestionar la 
base.
• Confirmar si existe la tabla a consultar.
En el escenario planteado, estas serían las actividades que se deberían 
realizar antes de que el objeto esté disponible para ser usado en una 
consulta. En síntesis, estas tareas deberían estar programadas en el 
constructor de la clase ClaseSql del ejemplo planteado, para que en 
el llamado que se hace al constructor al momento de la creación del 
objeto se ejecuten todas estas actividades.
A pesar de la importancia del constructor no todas las clases lo tienen, 
como por ejemplo de una biblioteca normalmente no es necesario 
realizar instancias u objeto, se podría concluir que no necesita un 
constructor, en teoría ya que finalmente el desarrollador determinará 
la necesidad o no de realizar este método.
Ilustración 33: Mapa conceptual
Pongamos en práctica lo aprendido mediante el siguiente ejercicio:
En Ecuador se suele festejar el fin de año y la llegada del nuevo año, 
creando un monigote que simboliza al año que está finalizando. En los 
días previos múltiples personas se dedican a construir estos monigotes 
para ponerlos a la venta.
76 77
Ilustración 34: Monigotes de fin de año
Ilustración 35: Monigotes de fin de año
|
Ilustración 36: Monigotes de fin de año
A pesar de que existen una infinidad de diversos personajes a los 
que representan estos monigotes, es fácil notar que todos parten de 
un mismo molde, dado que tienen las mismas características como 
colores, representan un personaje, tienen accesorios, etc. Pero lo que 
los diferencia entre ellos son los valores que toma cada característica 
en cada monigote. En la ilustración 36 se aprecia claramente esta 
situación.
Vamos a llevar esta situación de la vida real al mundo virtual a través 
de la POO empleando los conceptos de abstracción.
Se necesita construir el molde de donde salen todos los monigotes, para 
el ejemplo vamos a tomar sólo 3 características que tienen en común: 
todos tienen color, representan algún personaje y llevan accesorios.
Es válido aclarar que este molde no será una clase ejecutable, por tanto 
no llevará main, sólo servirá para crear modelos de monigotes. La 
creación de los objetos se hará en otra clase, la cual si será ejecutable.
Como no será una clase ejecutable, sólo se debe compilar mas no 
ejecutar.
78 79
Código 15: Clase molde para monigotes
Ahora desarrollamos la clase principal que utilizará el modelo para 
crear objetos que representen personajes.
En esta clase podremos entender y apreciar la creación y referencia 
a objetos que es un tema que enseña a cómo generar objetos a partir 
de una clase ya establecida y cómo acceder a los recursos de dichos 
objetos (sus atributos y métodos). Es lo que se podrá apreciar con la 
creación de objetos del tipo molde y su posterior manipulación.
Esta clase después de compilarla es la que se debe ejecutar.
 
Código 16: Creación y referencia a objetos de la clase molde
80 81
Ilustración 37: Compilación y ejecución de los códigos 15 y 16
Noteque primero debe ser compilado la clase molde y luego la clase 
monigote, esto es debido a que dentro de la clase monigote se crean 
objetos de molde y por lo tanto en ese momento la clase molde ya 
debería estar compilada. En síntesis, debe existir una jerarquía de 
compilación. Finalmente, la única clase que debe ser ejecutada es la 
clase principal, en este caso monigote.
Con este ejemplo hemos modelado el escenario real visto en la 
ilustración 36.
Interface
Este es otro de los recursos que ofrece Java para realizar abstracción. 
Su estructura y funcionamiento tiene algo de similitud, pero sin llegar 
a ser parecidas, a las de una clase. haciendo una analogía se podría 
decir que las interfaces son las primas hermanas de las clases. Sus 
diferencias se resumen en el siguiente cuadro.
Ilustración 38: Relación clase interface
El uso de las interfaces es un tema muy extenso que no será tratado en 
este libro, por eso se recomienda al lector profundizar en el estudio de 
esta temática.
Tanto la clase como la interfaces son archivos con autonomía, para 
crear una clase utilizamos la palabra reservada class y para crear una 
interface la palabra reservada interface.
Mientras que la clase tiene 2 propósitos, la interface sólo tiene el 
propósito de modelar, esto significa que se crea el modelo pero con 
las funciones no se codifican, sólo se declaran, es decir, quedan sólo 
como prototipo de función dejando a la clase que la va a implementar 
el trabajo de ponerle el código a los métodos según su necesidad.
82
Ilustración 39: Ejemplo básico y sencillo del uso de interfaces
PILARES DE LA 
PROGRAMACIÓN 
ORIENTADA 
A OBJETOS: 
ENCAPSULAMIENTO 
Capítulo 3
84 85
Pilares de la Programación Orientada a Objetos: 
ENCAPSULAMIENTO 
En este capítulo veremos una de las técnicas pilares de la POO 
mediante la cual a más de conseguir optimización y simplicidad de 
código es muy utilizada para otorgar seguridad a las clases y sus 
recursos, permitiendo obtener aplicaciones robustas y estables.
Concepto de encapsulamiento
La POO sostiene que los atributos de una clase no deberían ser 
accedidos externamente de forma directa a través de las instancias de 
la clase, sino internamente a través de los métodos de la clase.
Esto quiere decir que los atributos de la clase sólo deberían ser 
manipulados única y exclusivamente por los métodos de la clase 
con el propósito de proteger los atributos de factores externos 
encapsulándolos dentro de la clase.
Este concepto de protección no sólo se aplica a los atributos sino 
también a los métodos e incluso a las clases, con lo cual el proceso de 
encapsulamiento oculta y protege el código más sensible de nuestra 
aplicación.
Java ofrece múltiples recursos para realizar un eficiente 
encapsulamiento y protección de nuestros elementos 
programacionales como lo son los atributos, los métodos y las clases.
Modificadores
Este es un tema muy extenso, en este libro lo hemos resumido 
a sus aspectos más destacados, sin embargo, sugerimos al 
lector profundizar sobre este tema por cuanto es una de las 
herramientas más poderosas que tiene Java.
Los modificadores son palabras reservadas de Java que tienen 
como propósito fundamental determinar el nivel de accesibilidad 
y el alcance de acción de los tres elementos programacionales más 
importantes en la POO que son: la clase, los atributos y los métodos.
Ilustración 40: Tabla de resumen de Modificadores
86 87
Cuando a una clase o a una variable o a un método le ponemos un 
modificador public estamos permitiendo que ese recurso pueda ser 
accedido y manipulado por cualquier otra clase que esté en nuestro 
paquete o carpeta de trabajo o incluso fuera de ella. Se les suele llamar 
recursos promiscuos.
Lo opuesto a public es el modificador private que, por supuesto, 
genera el efecto contrario, es decir si una variable o un método son 
privados sólo podrán ser gestionados dentro de la misma clase. Esto 
es lo más hermético y seguro que se puede hacer a estos elementos de 
programación. Este modificador no se aplica en clases por la sencilla 
razón de que no tiene sentido tener una clase que nadie pueda utilizar.
Que pasa cuando “no utilizamos” modificadores ,Java les asigna un 
modificador default que transforma a los elementos en friendly o 
amistosos, cuyo accesibilidad está permitida sólo para las clases que 
se encuentren en el mismo paquete del elemento friendly.
Los elementos amistosos tienen un problema cuando son heredados 
por clases que ya no van a estar en el mismo paquete. Las clases hijas 
o derivadas no podrán utilizar estos recursos sino están en el mismo 
paquete, así los hayan heredados.
Para resolver este tema existe el modificador protected, el cual sólo 
se puede aplicar a variables y métodos, permitiendo que estos puedan 
ser accedidos por las demás clases del paquete y las clases derivadas 
aunque éstas no estén en el mismo paquete donde se encuentran estos 
elementos protegidos.
Es importante aclarar que aunque se ha mencionado que los 
modificadores private y protected no se aplican a clases; no obstante, 
SI es posible hacerlo sobre clases de tipo inner que son clases internas 
es decir diseñadas dentro de otra clase. El mismo caso se aplica para 
el modificador static.
El modificador static hace que los métodos puedan ser invocados 
directamente desde la clase sin necesidad de tener que instanciarla 
para llegar a ellos, por ejemplo Math.sin().
En las variables static la transforma en una variable común entre todas 
las instancias de la clase, es decir la misma variable para todos los 
objetos, de tal forma que si se altera su valor se reflejará en todos los 
objetos.
El modificador abstract evita que una clase pueda ser instanciada, es 
decir no se puede crear objetos de ella.
El modificador final evita que una clase pueda ser derivada, es decir 
que no pueda tener clases hijas o lo que es decir evita la herencia. En 
los métodos final no permite su sobreescritura, concepto que veremos 
más adelante, mientras que en las variables final las transforma en 
constantes.
Métodos get y set
Ya hemos visto que el encapsulamiento de un atributo nos indica que 
sólo deba ser accedido desde un método interno de la clase. Pero qué 
pasa si se desea que este atributo reciba o entregue valores desde o 
hacia fuera de la clase.
88 89
Para este escenario existen los métodos get y set que consiste en que 
todo atributo que necesite interactuar con elementos externos a la 
clase deberá tener dos métodos asociados al atributo uno para entregar 
información (get) y otro para recibir información (set).
El estándar de la escritura de estos métodos en Java nos indica que se 
debe empezar por get o set según sea el caso y seguir con el nombre 
del atributo con su primera letra en mayúscula. Para el caso del set la 
función deberá recibir como parámetro el nuevo valor que almacenará 
el atributo y para el caso del get la función deberá devolver el valor 
actual del atributo. Por ejemplo supongamos que tenemos la variable 
edad encapsulada, para cambiar su valor el método se debería llamar 
setEdad(nuevoValor) y para devolver el valor actual de la variable 
el método se debería llamar getEdad(). Finalmente es claro que el 
modificador que debería tener la variable edad es private.
Comando this
Este comando es muy útil cuando se tiene conflictos de nombres de 
variables, aunque su uso también aplica a los métodos.
El comando this hace referencia a los atributos y métodos propios de 
la clase.
Suponga que el nombre de un atributo de la clase es el mismo nombre 
que tiene la variable parámetro del constructor de dicha clase, al 
momento de hacer la asignación de valor se tendría el mismo nombre 
en ambos lados del operador igual, el dilema para Java sería identificar 
cual variable es el parámetro y cuál el atributo. Para eso existe this, al 
momento de utilizarlo Java sabe que la variable que utilizamos