III - CIDEPROIII 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

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 JAVAGUÍA PRÁCTICA PARA PROGRAMAR EN 10 DÍAS.

Editado por:Centro de Investigación y Desarrollo ProfesionalCIDEPROBabahoyo, EcuadorMóvil - (Whatsapp): (+593) 9 8 52-92-824E-mail: [email protected]: 978-9942-792-02-01° Edición, Mayo 2018Libro sometido a revisión de pares académicos.

www.cidepro.org

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


ENCAPSULAMIENTO....................................................................84

Concepto de encapsulamiento...........................................................84

Modificadores....................................................................................84

Métodos get y set...............................................................................87

Comando this.....................................................................................88

CAPÍTULO 4


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 ILUSTRACIONESIlustració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 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................................................................................................61

Ilustración 28: Ámbito de las variables en Java.................................62



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 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 EJEMPLOSCó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 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 23: Aplicación de polimorfismo sobre ejercicio de

monigotes........................................................................................103


monigotes........................................................................................104


monigotes........................................................................................105


monigotes........................................................................................105

XVI XVII

PREFACIOJava 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

INTRODUCCIÓN Y CONOCIMIENTOS BÁSICOSToda 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 Capítulo 1

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 construido

utilizando 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 el paquete 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ón transportable 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/

http://www.oracle.com/technetwork/es/java/javase/downloads/index.htmlhttp://www.oracle.com/technetwork/es/java/javase/downloads/index.htmlhttps://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


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


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 adquirir los 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


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


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.


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


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


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


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


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 cada uno

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


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


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ÓNLa 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 muy bá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


|


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

Note que 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 con

this se trata del atributo de la clase.

Desarrollemos el ejercicio de los monigotes aplicando lo aprendido,

existirán algunas variaciones producto del encapsulamiento. Recuerde

que este ejercicio sólo tenía abstracción, ahora tiene 2 de los 4 pilares

de la POO.

Código 17: Aplicando encapsulamiento

90

Código 18: Aplicando encapsulamiento

Documents

III - CIDEPROIII 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