Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
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 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
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 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 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................................................................................................61
Ilustració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 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 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
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
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 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
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 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
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Ó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
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
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