Temas Completo Poo

2/7/2020 Tema 1: Conceptos generales de la POO
Conceptos generales de la POO
Obra publicada con Licencia Creative Commons Reconocimiento No comercial Compartir igual 4.0
Unidad de Educación a Distancia
https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=16725&id_unidad=178299&id_pkg=11559&wAccion=ver_scos 1/1
2/7/2020 1.1. Sistema de control de versionamiento (VCS) | Tema 1: Conceptos generales de la POO
1.1. Sistema de control de versionamiento (VCS)
1.1. Sistema de control de versionamiento (VCS)
El control de versiones es un sistema que registra los cambios realizados sobre un archivo
o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones
específicas más adelante. El control de versiones es útil para guardar cualquier documento
que cambie con frecuencia, como código fuente, documentación o ficheros de configuración.
Sistemas de control de versiones locales
Un método de control de versiones usado por muchas personas es copiar los archivos a
otro directorio (quizás indicando la fecha y hora en que lo hicieron, si son ingeniosas). Este
método es muy común porque es muy sencillo, pero también es tremendamente propenso a
errores. Es fácil olvidar en qué directorio te encuentras y guardar accidentalmente en el
archivo equivocado o sobrescribir archivos que no querías. Para hacer frente a este
problema, los programadores desarrollaron hace tiempo VCSs locales, que contenían una
simple base de datos en la que se llevaba el registro de todos los cambios realizados sobre
los archivos, como muestra la figura 1.
Figura 1. Diagrama de control de versionamiento local.
Fuente: https://git-scm.com/book/es/v1/Empezando-Acerca-del-control-de-versiones
Sistemas de control de versiones centralizados
El siguiente gran problema que se encuentra la gente es que necesita colaborar con
desarrolladores en otros sistemas. Para solventar este problema, se ejecutaron los sistemas
de control de versiones centralizados (Centralized Version Control Systems o CVCSs en
inglés). Estos sistemas, como CVS, Subversion y Perforce, tienen un único servidor que
contiene todos los archivos versionados y varios clientes que descargan los archivos de ese
lugar central. Durante muchos años, este ha sido el estándar para el control de versiones
(figura 2).
Figura 2. Diagrama de control de versionamiento centralizado.
Esta configuración ofrece muchas ventajas, especialmente frente a VCSs locales. Por
ejemplo, todo el mundo sabe hasta cierto punto en qué está trabajando el resto de gente en
el proyecto. Los administradores tienen control detallado de qué puede hacer cada uno; es
mucho más fácil administrar un CVCS que tener que lidiar con bases de datos locales en
cada cliente. Sin embargo, esta configuración también tiene serias desventajas. La más obvia
es el punto único de fallo que representa el servidor centralizado. Si ese servidor se cae
durante una hora, entonces durante esa hora nadie puede colaborar o guardar cambios
versionados de aquello en que están trabajando. Si el disco duro en el que se encuentra la
base de datos central se corrompe y no se han llevado copias de seguridad adecuadamente
pierdes absolutamente todo, toda la historia del proyecto, salvo aquellas instantáneas que la
gente pueda tener en sus máquinas locales. Los VCSs locales sufren de este mismo
problema cuando tienes toda la historia del proyecto en un único lugar, te arriesgas a perderlo
todo.
Sistemas de control de versiones distribuidos
Es aquí donde entran los sistemas de control de versiones distribuidos (Distributed Version
Control Systems o DVCSs en inglés). En un DVCS (como Git, Mercurial, Bazaar o Darcs), los
clientes no solo descargan la última instantánea de los archivos, replican completamente el
repositorio. Así, si un servidor muere y estos sistemas estaban colaborando a través de él,
cualquiera de los repositorios de los clientes puede copiarse en el servidor para restaurarlo.
Cada vez que se descarga una instantánea, en realidad se hace una copia de seguridad
completa de todos los datos como indica la figura 3.
Figura 3. Diagrama de control de versionamiento distribuido.
Es más, muchos de estos sistemas se las arreglan bastante bien teniendo varios
repositorios con los que trabajar, por lo que puedes colaborar con distintos grupos de gente
de maneras distintas simultáneamente dentro del mismo proyecto. Esto te permite establecer
varios tipos de flujos de trabajo que no son posibles en sistemas centralizados, como pueden
ser los modelos jerárquicos.
2/7/2020 1.1.1. Software VCS: Git, GitHub | Tema 1: Conceptos generales de la POO
1.1.1. Software VCS: Git, GitHub
1.1.1. Software VCS: Git, GitHub
Git es un software de control de versiones diseñado por Linus Torvalds. La pregunta es:
¿qué es control de versiones? Pues bien, se define como control de versiones a la gestión de
los diversos cambios que se realizan sobre los elementos de algún producto o una
configuración de este, y para los que aún no les queda claro del todo, control de versiones es
lo que se hace al momento de estar desarrollando un software o una página web.
Exactamente es eso que haces cuando subes y actualizas tu código en la nube o le añades
alguna parte o simplemente le editas cosas que no funcionan como deberían o al menos no
como tú esperarías.
Git fue creado pensando en la eficiencia y la confiabilidad del mantenimiento de versiones

de aplicaciones cuando estas tienen un gran número de archivos de código fuente, es decir,
Git nos proporciona las herramientas para desarrollar un trabajo en equipo de manera
inteligente y rápida. Por trabajo nos referimos a algún software o página que implique código,
el cual necesitemos hacerlo con un grupo de personas.
Algunas de las características más importantes de Git son:
Rapidez en la gestión de ramas, debido a que Git nos dice que un cambio será
fusionado mucho más frecuentemente de lo que se escribe originalmente.
Gestión distribuida. Los cambios se importan como ramas adicionales y pueden ser
fusionados de la misma manera como se hace en la rama local.
Gestión eficiente de proyectos grandes.
Realmacenamiento periódico en paquetes.
GitHub es un sistema de gestión de proyectos y control de versiones de código, así como

una plataforma de red social diseñada para desarrolladores. Pero, ¿para qué se usa GitHub?
Bueno, en general, permite trabajar en colaboración con otras personas de todo el mundo,
planificar proyectos y realizar un seguimiento del trabajo.
GitHub es una compañía sin fines de lucro que ofrece un servicio de hosting de
repositorios almacenados en la nube. Esencialmente, hace que sea más fácil para individuos
y equipos usar Git como la versión de control y colaboración.
La interfaz de GitHub es bastante fácil de usar para el desarrollador novato que quiera
aprovechar las ventajas del Git. Sin GitHub, usar un Git generalmente requiere de un poco
más de conocimientos de tecnología y uso de una línea de comando.
GitHub es tan fácil de usar, que incluso algunas personas lo usan para administrar otro
tipo de proyectos, como escribir libros.
Además de esto, cualquier persona puede inscribirse y alojar un repositorio de código público
completamente gratuito, el cual hace que GitHub sea especialmente popular con proyectos
de fuente abierta.
Como compañía, GitHub obtiene dinero vendiendo alojamiento para repositorios de código
privado, al igual que otros planes enfocados para negocios, lo que hace más fácil que las
organizaciones administren a los miembros de su equipo y su seguridad. Utilizamos GitHub
de forma extensiva aquí en Kinsta para administrar y desarrollar proyectos internos.
Ejemplo de uso de GitHub
Tenemos que tener instalado Git en nuestro ordenador que estará en la página oficial
(https://git-scm.com/).
Figura 4. Descarga.
Fuente: Pablo Pärra
Figura 5. Descarga.
Fuente: Pablo Parra
Luego procederás a instalar. El siguiente paso es tener una cuenta en GitHub. En la

página oficial podemos crear una cuenta (https://github.com/), creamos un repositorio para
nuestros códigos.
Figura 6. Repositorio.
Fuente: Pablo Parra
Figura 7. Crear repositorio.
Fuente: Pablo Parra
El siguiente paso es tener un código fuente listo para subir, que es un programa que sume
dos números enteros, como se muestra en la figura 8.
Figura 8. Ejemplo de código.
Fuente: Pablo Parra
Nos dirigimos a la barra de herramientas y seguimos estos pasos:
Figura 9. Ejemplo.
Fuente: Pablo Parra
Buscamos donde está nuestro proyecto y damos clic en OK.
Figura 10. Guardar proyecto.
Fuente: Pablo Parra
El siguiente paso es dar clic derecho en nuestro proyecto.
Figura 11. Ejemplo.
Fuente: Pablo Parra
Buscamos la opción Git y le damos clic en Add.
Figura 12. Add.
Fuente: Pablo Parra
Hacemos el mismo paso pero esta vez damos clic en Commint.
Figura 13. Commint.
Fuente: Pablo Parra
Esta opción nos agrega todos los archivos del proyecto, todo lo que utiliza el paquete de
Java para poderlo subir. Le damos clic en Commint.
Figura 14. Commint.
Fuente: Pablo Parra
Después le volvemos a dar clic derecho al proyecto con lo siguiente:
Figura 15. Push.
Fuente: Pablo Parra
Damos clic en Push. En esta opción necesitamos la url del repositorio en el que vamos a
subir el archivo. Inicialmente al crear un repositorio nos da un enlace, tenemos que copiar el
enlace y pegarlo, nos pedirá nuestro usuario y contraseña. Una vez que hemos llenado esos
campos le damos clic en siguiente.
Figura 16. Copiar URL.
Fuente: Pablo Parra
Figura 17. Añadir URL.
Fuente: Pablo Parra
Seleccionamos el combo box y damos clic en siguiente y finalizar.
Figura 18. Siguiente.
Fuente: Pablo Parra
Actualizamos nuestro repositorio y ya está el proyecto creado en el repositorio.
Figura 19. Repositorio.
Fuente: Pablo Parra
Le damos clic en nuestro proyecto.
Figura 20. Código en Git.
Fuente: Pablo Parra
2/7/2020 1.2. Paradigmas de programación | Tema 1: Conceptos generales de la POO
1.2. Paradigmas de programación
1.2. Paradigmas de programación
Es un estilo de desarrollo de programas, es decir, un modelo para resolver problemas

computacionales. Los lenguajes de programación necesariamente se encuadran en uno o
varios paradigmas a la vez, a partir del tipo de órdenes que permiten implementar algo que
tiene una relación directa con su sintaxis.
Principales paradigmas de programación
Imperativo. Los programas se componen de un conjunto de sentencias que cambian

su estado. Son secuencias de comandos que ordenan acciones a la computadora.
Declarativo. Opuesto al imperativo. Los programas describen los resultados esperados
sin listar explícitamente los pasos a llevar a cabo para alcanzarlos.
Lógico. El problema se modela con enunciados de lógica de primer orden.
Funcional. Los programas se componen de funciones, es decir, implementaciones
de comportamiento que reciben un conjunto de datos de entrada y devuelven un
valor de salida.
Orientado a objetos. El comportamiento del programa es llevado a cabo por objetos,
entidades que representan elementos del problema a resolver y tienen atributos y
comportamiento.
Transición de paradigmas
Es el paso de un paradigma de programación a otro a partir de las características que

presentan cada uno de estos
2/7/2020 1.2. Paradigmas de programación | Tema 1: Conceptos generales de la POO
Figura 21. Transición de paradigmas.
Fuente: https://culturacion.com/wp-content/uploads/2011/05/Image1.jpg
2/7/2020 1.2.1. Transición de paradigma | Tema 1: Conceptos generales de la POO
1.2.1. Transición de paradigma
1.2.1. Transición de paradigma
Un paradigma de programación indica un método de realizar cómputos y la manera en

que se deben estructurar y organizar las tareas que debe llevar a cabo un programa.
Los paradigmas fundamentales están asociados a determinados modelos de cómputo.

También se asocian a un determinado estilo de programación; los lenguajes de programación
suelen implementar a menudo, de forma parcial, varios paradigmas.
2/7/2020 1.3. Revisión de conceptos generales del paradigma orientado a objetos | Tema 1: Conceptos generales de la POO
1.3. Revisión de conceptos generales del paradigma

orientado a objetos
1.3. Revisión de conceptos generales del paradigma orientado a objetos
Es una forma de construir, pensar, diseñar e implementar programas basados en objetos

que combinan estados, comportamientos e identidades. El estado está compuesto por datos,
el comportamiento es una serie de acciones que se realizan y son llamados métodos, y la
identidad es una identidad del objeto que lo diferencia del resto de los objetos. Las tareas se
realizan con estos objetos, basadas en su colaboración y relación entre ellos. El objetivo de
esto es mantener diversas partes del código separadas entre sí, llegando de esta forma a
tener una unidad de código fácil de mantener y de reutilizar en otros proyectos. La
comunicación entre los diversos objetos se realiza mediante mensajes entre ellos. Estos
mensajes son llevados a cabo mediante el llamado método de un cierto objeto.
La programación orientada a objetos (POO) nace en los años 60 en el Norwegian

Computing Center con la implementación de dos lenguajes de programación de simulación
(Simula 1 y Simula 67), desarrollados por Kristen Nygaard y Ole Johan Dahl.
Simula 67 introdujo por primera vez los conceptos de clases, objetos, herencia, subclases,
corrutinas y funciones virtuales. Es por esta razón que Simula es considerado el primer
lenguaje orientado a objetos.
A continuación, se modelará el consumo de agua de un usuario al momento de abrir el

grifo de su hogar.
Usuario abre el grifo.

El grifo libera la presión y el agua fluye desde la cisterna hasta el grifo.
Como el usuario abrió el grifo, este deja fluir el agua, lo que bajó el nivel del agua que
mantiene la cisterna. Está activa la bomba de alimentación, que deja ingresar agua
hasta completar el nivel máximo.
Se detendrá el ingreso de agua a la cisterna.
Como se puede ver, los objetos interactúan entre ellos, ha habido un análisis funcional
que ha conducido a la creación de los diferentes objetos, su realización y su puesta en
relación.
2/7/2020 1.3. Revisión de conceptos generales del paradigma orientado a objetos | Tema 1: Conceptos generales de la POO
Figura 22. Interacción de objetos.
Fuente: Pablo Parra
El código del programa al modelar los objetos va a seguir esta realidad, proponiendo
tantos objetos como se han descrito con anterioridad, pero definiendo entre estos objetos los
métodos de intercambio adecuados, que conducirán al funcionamiento esperado.
2/7/2020 1.3.1. Principios generales de la POO | Tema 1: Conceptos generales de la POO
1.3.1. Principios generales de la POO
1.3.1. Principios generales de la POO
La programación orientada a objetos (POO) es un paradigma de programación que, como

su nombre indica, usa objetos, basado en un ambiente real (todo lo que nos rodea, como son
útiles escolares, cuadernos, personas, entre otros, como muestra la figura 23), para diseñar
aplicaciones y programas de computadoras.
Figura 23. Niño con útiles escolares.
Fuente https://previews.123rf.com/images/dualororua/dualororua1706/dualororua170600527/80388651-
ni%C3%B1o-de-dibujos-animados-corriendo-y-llevando-un-material-escolar.jpg
Con la POO tenemos que aprender a pensar las cosas de una manera distinta, para
escribir nuestros programas en términos de objetos, propiedades, métodos y otras cosas que
veremos rápidamente para aclarar conceptos y dar una pequeña base que permita soltarnos
un poco. Con este tipo de programación, cada objeto tiene una responsabilidad y el resultado
es el producto de la colaboración de todos los objetos en la solución del problema. Las
acciones en programación orientada a objetos se producen como respuesta a las peticiones
de acciones, que se llaman mensajes. Un objeto puede aceptar un mensaje y como
respuesta puede realizar una acción y devolver un valor. Está basado en varias técnicas,
incluyendo herencia, abstracción, polimorfismo y encapsulamiento, que sirven como pilares
de la POO (figura 24).
Figura 24. Pilares de la programación orientada a objetos.
Fuente https://elvex.ugr.es/decsai/builder/intro/oop/pilares.gif
Abstracción. Captar las características principales de un objeto, así como su

comportamiento. En la figura 25 se muestra un ejemplo de abstracción en la cual
sacamos características principales de un objeto llamado bus. Todo bus tiene un
número de placa, un color y número de llantas. Son características propias que
caracterizan al objeto.
Figura 25. Programación orientada a objetos.
Fuente: http://1.bp.blogspot.com/-
l3aZgFckxJY/VOEUXEtWVQI/AAAAAAAAAHA/Jb3TzvMPAEI/s1600/image008.png
Encapsulamiento. Un principio fundamental de la POO es la ocultación de la

información que es el proceso de ocultar dentro de sí mismo todos los secretos de un
objeto que no contribuyan a sus características esenciales. Se maximiza la
reutilizabilidad, se reduce la dependencia de los datos y se minimiza el tiempo de
depuración.
Figura 26. Encapsulamiento.
Fuente: http://ygalicia.cs.buap.mx/POO.pdf
En otras palabras, es la capacidad de esconder los detalles de cómo funciona algo, detrás
de una interfaz. Solo se necesita conocer la interfaz para poder usar alguna cosa. El usuario
no se ve afectado si se cambia o se mejora al funcionamiento interno de algo, mientras se
mantenga la interfaz.
Ejemplo de encapsulamiento
Consiste en restringir el acceso y ocultar el proceso de cada uno de los datos miembro de
una clase y solo podrán cambiar mediante las operaciones definidas para ese espacio. El
aislamiento protege contra la modificación y garantiza el flujo del programa. Una clase y un
método funcionan como cápsula. En una pantalla, nosotros solo vemos la imagen y no
conocemos lo que se procese dentro (figura 27).
Figura 27. Ejemplo de encapsulamiento.
Fuente http://paginawebleon.mx/wp/programacion-orientada-a-objetos-poo/
Polimorfismo. Es la habilidad que adquieren los objetos de responder en forma

diferente al mismo mensaje, es decir, el mismo mensaje se envía a muchos tipos de
objetos, toma muchas formas.
Es la habilidad de esconder diferentes implementaciones tras una sola interfaz.
Figura 28. Polimorfismo.
Fuente: http://agrega.juntadeandalucia.es/repositorio/02122016/da/es-
an_2016120212_9103251/Polimorfismo.jpg
Herencia. Las clases no se encuentran aisladas, sino que se relacionan entre sí,
formando una jerarquía de clasificación. Es el proceso mediante el cual un objeto
hereda las propiedades a una subclase, la cual contiene las características de la clase
primaria, nos ayudan a reutilizar el código existente. En la figura 29 se muestra un
ejemplo.
Figura 29. Introducción al paradigma orientado a objetos.
Fuente http://www.itnuevolaredo.edu.mx/takeyas/Apuntes/POO/Apuntes/01.-
%20Introduccion%20a%20la%20POO.pdf
Semánticamente, la herencia denota una relación “es un”, por ejemplo, un oso es un
mamífero, una casa es un bien inmueble. Los objetos en sí disponen de una clase, atributo y
método.
El enfoque orientado a objetos dispone de sus respectivas diferencias con el enfoque

estructurado que se pueden observar en el siguiente cuadro:
Figura 30. Cuadro comparativo: enfoque estructurado y enfoque orientado a objetos.
Fuente: https://image.slidesharecdn.com/cuadrocomparativodeenfoqueestructuradoyenfoqueorientado-
131123193238-phpapp01/95/cuadro-comparativo-de-enfoque-estructurado-y-enfoque-orientado-2-638.jpg?
cb=1385235348
A partir de las diferencias previamente establecidas para los dos paradigmas, se puede
determinar las ventajas y desventajas de que dispone la POO.
Tabla 1
Ventajas y desventajas de la Programación orientada a objetos.
Ventajas Desventajas
La implementación es detallada, puntual

Curva de aprendizaje
y coherente.
Se puede reutilizar el código en

La ejecución es más lenta.
distintas fases del programa.
La clase hija puede heredar código que

Es fácil de modificar.
no se usará.
Los datos son fáciles de proteger. La fase de diseño requiere tiempo.
Permite hallar fácilmente los errores al

dividir el problema en partes.
Las clases son independientes entre sí.
El tamaño del programa

Beneficios en diseño
Mantenimiento de software
Amplia documentación
Fuente https://ferestrepoca.github.io/paradigmas-de-programacion/poo/poo_teoria/index.html
2/7/2020 1.3.2. Definición de objeto, clase, atributo y método | Tema 1: Conceptos generales de la POO
1.3.2. Definición de objeto, clase, atributo y método
1.3.2. Definición de objeto, clase, atributo y método
Objeto
Un objeto es el elemento básico de la POO. Todo objeto contiene un conjunto de

propiedades o atributos (datos que se almacenarán del mismo) y de comportamientos que se
conocen como métodos que representan las acciones que se pueden hacer con el objeto.
En el mundo de la programación orientada a objetos (POO), un objeto es el resultado de

la instanciación de una clase.
Los objetos poseen características propias que los distinguen entre sí.
Todos los objetos tienen acciones denominadas métodos asociados a ellos.
Ejemplo de objeto
En la siguiente imagen podemos observar que hay cuatro perros, a estos perros podemos
ver como un objeto, ya que tienen características y acciones propias:
Características Acciones
- Raza - Ladrar
- Nombre - Comer
- color - Ladrar
Figura 31. Conjunto de perros.
Fuente: https://previews.123rf.com/images/ghenadie/ghenadie1704/ghenadie170400037/76873629-conjunto-de-
perros-de-perrito-de-dibujos-animados-simple-ilustraci%C3%B3n-vectorial.jpg
Características
- Nombre
- Edad
- Genero
- Estatura
- Peso
Acciones
- Saludar
- Hablar
- Comer
Figura 32. Objeto.
Fuente: http://micanalsamuelc.blogspot.com/
Clase
Es un modelo que permite la creación de un objeto, formado a partir de un conjunto de

variables y métodos. Puede ser utilizado en cualquier punto del programa, basado en un
nombre que las identifica, sus atributos y los métodos que disponen. Las clases son la base
del diseño orientado a objetos.
Una clase no es un objeto, es solo una planilla, plano o definición para crear objetos.
A partir de una clase se pueden crear muchos objetos independientes con las mismas
características.
Figura 33. Paradigmas de programación.
Fuente: http://ferestrepoca.github.io/paradigmas-de-programacion/poo/poo_teoria/images/philosophy.png
Un objeto es declarado a partir de una clase, los datos y funciones son encapsulados, un
objeto es una instancia de una clase.
Figura 34. Curso de programación POO
Fuente: http://cdn.simplesite.com/i/5e/50/285415631240056926/i285415639416338167._szw480h1280_.jpg
Cada clase tendrá atributos y métodos propios específicos que darán funcionalidad a los
objetos creados. Tomemos como ejemplo un objeto vehículo el cual será representado con el
siguiente molde:
Figura 35. Programación orientada a objetos, POO.
Fuente: http://paginawebleon.mx/wp/programacion-orientada-a-objetos-poo/
En un segundo ejemplo vamos a modelar a un profesor:
Figura 36. Ejemplo de clase.
Fuente: https://www.google.com/url?
sa=i&source=images&cd=&cad=rja&uact=8&ved=2ahUKEwjO7M_j6J3nAhWrslkKHYXTA90QjB16BAgBEAM&url
Instanciar
Es la creación o manifestación concreta de un objeto a partir de su clase.
Atributo
Se trata de las propiedades que tiene un objeto, consideradas como tal las características
de las que dispone la clase como el nombre, el color, el modelo, entre otras.
Son controlados a través de la declaración de variables. Es muy importante identificar el

tipo de dato. Se debe seleccionar solo aquellos atributos necesarios para el modelo
planteado (abstracción).
Los atributos son los datos que se van a almacenar de los objetos. Se declaran de la
siguiente manera:
tipo nombreAtributo;
int numero;
float valorResultado;
Dependiendo del lenguaje de programación se debe indicar el nivel de accesibilidad de

cada atributo, por concepto de encapsulamiento de la POO todo atributo es privado. Más
adelante se verán los niveles de accesibilidad.
Figura 37. introducción a la POO.
Método
Son mecanismos que permiten acceder a los atributos de un objeto. Son las operaciones
que es capaz de hacer un objeto, como en el caso de un automóvil se puede acelerar, frenar,
prender, moverse, abrirse, entre otros. En los métodos se implementan los algoritmos, así
mismo de cada método debe indicarse su nivel de accesibilidad.
Figura 38. introducción a la POO.
Ejemplos
Se pide abstraer las características y métodos de los objetos presentados en la siguiente

imagen y representarlas en un molde.
Figura 39. Ejemplos de mesas.
Fuente: Pablo Parra
Figura 40. Modelado de mesa.
Fuente: Pablo Parra
Los atributos son representados con un signo – esto quiere decir que son privados, solo la
clase los conoce.
Los métodos son representados con un signo + que significa que son públicos.
Se puede observar que son objetos mesas de los cuales podemos abstraer las
características que tienen: atributos: material, forma/modelo, color, entre otros.
Métodos: moverla, ubicarObjetosSobre, ubicarObjetosBajo, crearMesa, entre otros.
Figura 41. Ejemplo de vasos.
Fuente: https://www.google.com/url?sa=i&source=images&cd=&cad=rja&uact=8&ved=2ahUKEwjU--
ac7p3nAhVCj1kKHZe5CeQQjB16BAgBEAM&url=https%3A%2F%2Fwww.degaplast.com.ar%2Fvaso-facetado-
plastico-simil-vidrio-nair-320-color-x-72-unidades--det-
-06010118&psig=AOvVaw1GPg4tfUVNGNxoUZmLMKu2&ust=1580011108608155
Figura 42. Modelado de vaso.
Fuente: Pablo Parra
2/7/2020 Tema 2: Modelamiento de clases y objetos
Modelamiento de clases y objetos
2/7/2020 2.1. Modelamiento de clases y objetos | Tema 2: Modelamiento de clases y objetos
2.1. Modelamiento de clases y objetos
2.1. Modelamiento de clases y objetos
UML son las siglas de “Unified Modeling Language” o “Lenguaje Unificado de

Modelado”. Se trata de un estándar que han adoptado a nivel internacional numerosos
organismos y empresas para crear esquemas, diagramas y documentación relativa a los
desarrollos de software.
UML no es un lenguaje propiamente dicho, sino una serie de normas y estándares gráficos
respecto a cómo se deben representar los esquemas relativos al software.
UML es una especificación de notación orientada a objetos. Se basa en las anteriores

especificaciones BOOCH, RUMBAUGH y COAD-YOURDON. Divide cada proyecto en un
número de diagramas que representan las diferentes vistas del proyecto. Estos diagramas
juntos son los que representan la arquitectura del proyecto.
UML permite describir un sistema en diferentes niveles de abstracción, simplificando la

complejidad sin perder información, para que tanto usuarios, líderes y desarrolladores
puedan comprender claramente las características de la aplicación.
UML se quiere convertir en un lenguaje estándar con el que sea posible modelar todos los
componentes del proceso de desarrollo de aplicaciones. Sin embargo, hay que tener en
cuenta un aspecto importante del modelo: no pretende definir un modelo estándar de
desarrollo, sino únicamente un lenguaje de modelado. Otros métodos de modelaje como
OMT (Object Modeling Technique) o Booch sí definen procesos concretos. En UML los
procesos de desarrollo son diferentes según los distintos dominios de trabajo; no puede ser el
mismo el proceso para crear una aplicación en tiempo real, que el proceso de desarrollo de
una aplicación orientada a gestión, por poner un ejemplo.
Bloques básicos de construcción UML
Elementos. Abstracciones básicas e importantes del modelo.
Elementos estructurales
Elementos de comportamiento
Elementos de agrupación
Elementos de anotación
Relaciones que ligan elementos entre sí.
Dependencia
Asociación
Generalización
Realización
Diagramas. Agrupan colecciones interesantes de elementos.
Clases Estados
Objetos Actividades
Casos de uso Componentes
Secuencia Despliegue
Colaboración
Clasificación de diagramas
Se dispone de dos tipos diferentes de diagramas: los que dan una vista estática del
sistema y los que dan una visión dinámica.
Figura 1. Clasificación de diagramas UML.
Fuente: Pablo Parra
2/7/2020 2.1.1. UML Diagrama de casos de uso | Tema 2: Modelamiento de clases y objetos
2.1.1. UML Diagrama de casos de uso
2.1.1. UML Diagrama de casos de uso
Un caso de uso es una descripción de las acciones de un sistema desde el punto de vista
del usuario. Es una herramienta valiosa dado que es una técnica de aciertos y errores para
obtener los requerimientos del sistema, justamente desde el punto de vista del usuario.
Los diagramas de caso de uso modelan la funcionalidad del sistema usando actores y
casos de uso. Los casos de uso son servicios o funciones provistas por el sistema para sus
usuarios.
Permiten facilitar la comprensión de la estructura y funcionamiento a cualquier medio de

manera gráfica.
Figura 2. Simbología de casos de uso.
Fuente: http://www.antonionavas.info/blog/wp-content/uploads/2016/01/requerimientos6-simbologia.jpg
Sistema
El rectángulo representa los límites del sistema que contiene los casos de uso. Los actores
se ubican fuera de los límites del Sistema.
A continuación, se analiza el caso de uso de un cliente en un restaurante de comida.

Como se aprecia, el crítico de comida (cliente) no prepara su comida.
Figura 3. Sistema de casos de uso.
Fuente: https://ingsotfwarekarlacevallos.files.wordpress.com/2015/07/3.png
Caso de uso
Se representa con óvalos. La etiqueta en el óvalo indica la función del sistema.
Figura 4. Casos de uso.
Actor
Un diagrama de caso de uso contiene los símbolos del actor y del caso de uso, junto con
líneas conectoras. Los actores son similares a las entidades externas; existen fuera del
sistema. El término actor se refiere a un rol específico de un usuario del sistema.
Figura 5. Actor que inicia el caso de uso.
Relaciones
Las relaciones entre un actor y un caso de uso se dibujan con una línea simple. Para
relaciones entre casos de uso, se utilizan flechas etiquetadas “incluir” o “extender”. Una
relación “incluir” indica que un caso de uso es necesitado por otro para poder cumplir una
tarea. Una relación “extender” indica opciones alternativas para un cierto caso de uso.
Figura 6. Ejemplo de casos de uso.
Fuente: https://ingsotfwarekarlacevallos.files.wordpress.com/2015/07/esta.png
Relaciones de los casos de uso
Las relaciones activas se conocen como relaciones de comportamiento y se utilizan

principalmente en los diagramas de casos de uso. Hay cuatro tipos básicos de relaciones de
comportamiento: comunica, incluye, extiende y generaliza.
Figura 7. Relaciones entre los casos de uso.
Documentación de los casos de uso
Existen dos formas principales de documentar un caso de uso:
Un diagrama en UML
Un documento detallado
Documentar casos de uso no es una tarea fácil que se pueda dominar de un día para
otro, requiere de tiempo, disciplina y experiencia, sin embargo, podemos definir una serie de
pasos identificables para escribir los casos de uso.
Figura 8. Pasos para la documentación de los casos de uso.
Formato de la documentación de caso de uso para los actores que participen
Figura 9. Documentación de los actores dentro de los casos de uso.
Fuente: https://ingsotfwarekarlacevallos.files.wordpress.com/2015/07/10.png?w=646&h=373
Documentación de un caso de uso
Figura 10. Documentación de los casos de uso.
2/7/2020 2.1.2. UML Diagrama de clases | Tema 2: Modelamiento de clases y objetos
2.1.2. UML Diagrama de clases
2.1.2. UML Diagrama de clases
En UML, una clase se representa con un rectángulo que posee tres divisiones: nombre de
la clase, atributos que tiene y métodos.
En el primero de los cuadros se anota el nombre de la clase. Si es abstracta, se

escribe en letra cursiva o también se utiliza un estereotipo como < > arriba del nombre
de la clase.
En la segunda parte van los atributos o variables de instancia; las variables de clase
van subrayados.
En el último cuadro se escriben los métodos, es decir, las operaciones que puede
realizar.
Debemos tener en cuenta que una clase que no tiene comportamiento no está
comunicando qué tipo de rol cumple en la solución, así que o está faltando definir qué es lo
que le puedo pedir, o entonces esa clase no debería estar en el diagrama.
Figura 11. Ejemplo de clases y objetos.
Fuente: https://2.bp.blogspot.com/-
GNHmDKzeqcI/WJj8EFzPbxI/AAAAAAAABZ8/iH9R4gmpdMUsYaOGLU3TYW_oB9nTyECXwCK4B/s640/elemen
Relaciones
Los tipos más importantes de relaciones entre clases son los siguientes:
Asociación
Las relaciones de asociación, representan un conjunto de enlaces entre objetos o

instancias de clases. Es el tipo de relación más general y denota básicamente una
dependencia semántica. Por ejemplo, una persona trabaja para una empresa.
Cada asociación puede presentar elementos adicionales que doten de mayor detalle al
tipo de relación:
Rol o nombre de la asociación, que describe la semántica de la relación en el sentido

indicado. Por ejemplo, la asociación entre persona y empresa recibe el nombre
de trabaja para, como rol en ese sentido.
Multiplicidad, que describe la cardinalidad de la relación, es decir, especifica cuántas
instancias de una clase están asociadas a una instancia de la otra clase. Los tipos de
multiplicidad son: uno a uno, uno a muchos y muchos a muchos.
Herencia
Las jerarquías de generalización/especialización se conocen como herencia. Herencia es

el mecanismo que permite a una clase de objetos incorporar atributos y métodos de otra
clase, añadiéndolos a los que ya posee.
Agregación
La agregación es un tipo de relación jerárquica entre un objeto que representa la totalidad

de ese objeto y las partes que lo componen. Permite el agrupamiento físico de estructuras
relacionadas lógicamente. Los objetos “son-parte-de” otro objeto completo. Por
ejemplo, motor, ruedas, carrocería son parte de automóvil.
Composición
La composición es una forma de agregación donde la relación de propiedad es más fuerte,

e incluso coinciden los tiempos de vida del objeto completo y las partes que lo componen.
Por ejemplo, en un sistema de máquina de café́ , las relaciones entre la
clase máquina y producto o entre máquina y depósito de monedas son de composición.
Dependencia
Una relación de dependencia se utiliza entre dos clases o entre una clase y una interfaz e
indica que una clase requiere de otra para proporcionar alguno de sus servicios.
Interfaces
Una interfaz es una especificación de la semántica de un conjunto de operaciones de una

clase o paquete que son visibles desde otras clases o paquetes. Normalmente, se
corresponde con una parte del comportamiento del elemento que la proporciona.
Paquetes
Los paquetes se usan para dividir el modelo de clases del sistema de información,
agrupando clases u otros paquetes según los criterios que sean oportunos. Las
dependencias entre ellos se definen a partir de las relaciones establecidas entre los distintos
elementos que se agrupan en estos paquetes.
Notación general
Las diferentes propiedades de la relación se pueden representar con la siguiente notación:
Multiplicidad. La multiplicidad puede ser un número concreto, un rango o una colección

de números. La letra ‘n’ y el símbolo ‘*’ representan cualquier número.
Orden. Se puede especificar si las instancias guardan un orden con la palabra clave
‘{ordered}’. Si el modelo es suficientemente detallado, se puede incluir una restricción
que indique el criterio de ordenación.
Navegabilidad. La navegación desde una clase a la otra se representa poniendo una
flecha sin relleno en el extremo de la línea, indicando el sentido de la navegación.
Rol o nombre de la asociación. Este nombre se coloca junto al extremo de la línea
que está unida a una clase, para expresar cómo esa clase hace uso de la otra clase
con la que mantiene la asociación.
Figura 12. Notación general.
Fuente: https://manuel.cillero.es/wp-content/uploads/2013/11/asociacion.png
Notaciones específicas
Agregación. Se representa con un rombo hueco en la clase cuya instancia es una

agregación de las instancias de la otra.
Composición. Se representa con un rombo lleno en la clase cuya instancia contiene
las instancias de la otra clase.
Dependencia. Una línea discontinua con una flecha apuntando a la clase cliente. La
relación puede tener un estereotipo que se coloca junto a la línea y entre el símbolo: <<
... >>.
Herencia. Esta relación se representa como una línea continua con una flecha hueca
en el extremo que apunta a la superclase.
Figura 13. Notaciones de clases.
Fuente: https://manuel.cillero.es/wp-content/uploads/2013/11/tipos-asociacion.png
Interfaces
Una interfaz se representa como una caja con compartimentos, igual que las clases. En la
zona superior se incluye el nombre y el estereotipo <>. La lista de operaciones se coloca en
la zona inferior, igual que en las representaciones de clases. La zona en la que se listan los
atributos estará vacía o puede omitirse.
Existe una representación más simple para la interfaz: un círculo pequeño asociado a una
clase con el nombre de la interfaz debajo. Las operaciones de la interfaz no aparecen en esta
representación; si se quiere que aparezcan, debe usarse la primera notación.
Entre una clase que implementa las operaciones que una interfaz ofrece y esa interfaz se
establece una relación de realización que, dependiendo de la notación elegida, se
representará con una línea continua entre ellas cuando la interfaz se representa como un
círculo y con una flecha hueca discontinua apuntando a la interfaz cuando se represente
como una clase.
Figura 14. Interfaces.
Fuente: https://manuel.cillero.es/wp-content/uploads/2013/11/clase-interfaz.png
Paquetes
Los paquetes se representan mediante un icono con forma de carpeta y las dependencias
con flechas discontinuas entre los paquetes dependientes.
Ejemplo
Juanito necesita realizar un diagrama de clases que modele la reproducción de un CD

musical, si se conoce que el CD tiene un título y fecha de edición, y que contiene canciones
de las que se conoce el título y la duración de estas, así como se puede obtener la duración
total en un reproductor de CD que permite detener, reproducir, adelantar y retroceder.
Solución
1. Extraer todos los sustantivos que aparecen en el enunciado, escríbelos en singular, y

que pueden ser, por lo tanto, una clase, es lo siguiente:
CD Reproductor CD Canción Juanito
2. Tras identificar todas las posibles clases que se extraen de forma directa del enunciado
pasamos a eliminar aquella que no aporta nada para modelar el problema.
a. En este caso se eliminaría a Juanito por no aportar ninguna característica al problema.

b. Tras quedarnos con las clases candidatas se debe identificar los atributos de la clase,
para lo cual se debe observar los posibles valores.
c. El CD tiene atributos que son el título y fecha de edición para lo cual está representada
con el símbolo (-) que significa privado y el tipo de dato que va a almacenar.
3. A continuación, recogemos las operaciones de una clase en nuestro enunciado.
a. En la clase reproducción vemos que tenemos reproducir (), detener (), adelantar (),
retroceder.
b. A diferencia de los atributos, se ubica el símbolo + que significa público y el tipo de
método va a hacer y en el CD obtener duración total ().
c. A continuación, ubicamos las diferentes relaciones entre las clases modeladas
dependiendo de cada enunciado y comportamiento del mundo real.
d. Luego, vemos cómo queda el respectivo diagrama de clases.
Figura 15. Ejemplo de paquete.
Fuente: Pablo Parra
2/7/2020 2.1.3. Identificar clases de un sistema. Uso correcto de identificadores | Tema 2: Modelamiento de clases y objetos
2.1.3. Identificar clases de un sistema. Uso correcto de

identificadores
2.1.3. Identificar clases de un sistema. Uso correcto de identificadores
Identificadores
Son los nombres que pueden tener las clases, los métodos y las variables y no pueden
contener espacios ni caracteres especiales.
Tabla 1
Tipos de identificadores
Tipo de identificador Convención Ejemplo
Comienza con
Clase HolaMundoOO
mayúscula.
Método Comienza con minúscula. mostrarSaludo ()
Variable Comienza con minúscula. Saludo
Fuente: http://www.cursodejava.com.mx/cursodejava105.html
Si el identificador está formado por más de un vocablo, a partir del segundo las iniciales
deben ser mayúsculas. Además, se recomienda que los nombres de las clases sean
sustantivos, los de los métodos verbos y que las variables expresen con claridad su
contenido.
2/7/2020 2.1.3. Identificar clases de un sistema. Uso correcto de identificadores | Tema 2: Modelamiento de clases y objetos
2/7/2020 2.1.4. Modificadores de acceso | Tema 2: Modelamiento de clases y objetos
2.1.4. Modificadores de acceso
2.1.4. Modificadores de acceso
Los modificadores de acceso nos permiten determinar desde qué clase o desde qué parte
de nuestro programa cierto elemento podrá ser accedido o utilizado como, por ejemplo, una
variable, un método o una clase.
1. Private. Es el más restrictivo de todos. Los elementos que hagan uso de él solo podrán
ser accedidos dentro de la misma clase. (Se aplica a los atributos o miembros de una
clase, interfaces y clases internas).
2. Protected. Los elementos podrán ser accedidos desde el mismo paquete y desde
cualquier clase que extienda o herede de la clase padre, independientemente si se
encuentran en el mismo paquete o no. (Se aplica a los miembros de una clase como
atributos, métodos, etc.).
3. Public. Es el menos restrictivo de todos ya que se puede acceder desde cualquier

parte, es decir, está abierto o disponible para todos. (Se aplica a clases, métodos,
atributos, interfaces, etc.).
4. Default. Es el nivel de acceso por defecto, cuando no declaramos de forma explícita un

modificador (no especificado), los elementos solo podrán ser accedidos dentro del
mismo paquete.
Tabla 2
Modificadores de acceso
Modificador Clase Paquete Subclase Todos (otras clases)
Private Sí No No No
Protected Sí Sí Sí No
2/7/2020 2.1.4. Modificadores de acceso | Tema 2: Modelamiento de clases y objetos
Public Sí Sí Sí Sí
Default Sí Sí No No
Fuente: http://unaprendizprogramacion.blogspot.com/2015/06/modificadores-de-acceso.html
2/7/2020 2.1.5. Implementación de clases | Tema 2: Modelamiento de clases y objetos
2.1.5. Implementación de clases
2.1.5. Implementación de clases
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear
un objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente
dicho.
La implementación se compone de la declaración de la clase y el cuerpo de la clase.
La estructura de una clase es:
Figura 16. Estructura de clase.
Fuente: Pablo Parra
Ejercicio 1
Se desea crear una aplicación que permita jugar a dos jugadores, en la cual los usuarios
ingresan por teclado su userName, y cada jugador tiene un puntaje inicial de 100 puntos.
Su trabajo es acertar la raíz cuadrada de un número, en caso de que el usuario digite

incorrectamente la raíz del número a encontrar, el programa indica si el número es menor o
mayor y le resta 10 puntos de puntaje de cada jugador.
El programa termina cuando uno de los dos jugadores ingresa la raíz correcta o se queda
sin puntaje.
2/7/2020 2.1.5. Implementación de clases | Tema 2: Modelamiento de clases y objetos
Figura 17. Ejemplo de estructura de clase.
Fuente: Pablo Parra
Ejercicio 2
Se necesita realizar el modelado de una aplicación para los Cevichochos del Sur que
solicita realizar una aplicación que le permita conocer cuántos cevichochos puede preparar si
se conoce la cantidad de materia prima que dispone. Para preparar se conoce lo siguiente:
Que por cada tres platos de cevichochos necesita: 0,250 gramos de chochos, 0,100
gramos de especies (curtido, jugo tomates, chifles, cueros).
Se considera que solo ocupan dos ingredientes.
Figura 18. Ejemplo de estructura de clase.
Fuente: Pablo Parra
2/7/2020 Anexos | Tema 2: Modelamiento de clases y objetos
Anexos
Anexos
Instalación de plugin PlantUML para la generación de diagramas en
Apache NetBeans
Debemos instalar en nuestro IDE el plugin "PlantUML-NB" que lo podrás descargar en

esta dirección:
https://sourceforge.net/projects/plantumlnb/
Al dar clic en "Download" se obtiene el archivo PlantUML-NB-XX.nbm (donde XX es la

versión del plugin).
Luego, en nuestro IDE se dirige a la opción "Tools > Plugins", como se observa en la
figura 19.
Figura 19. Anexos. Localización de la opción Plugins en NetBeans.
Diego SIlva, 2015
Selecciona la ficha "Downloaded" y haz clic en el botón "Add plugins...", como se

observa en la figura 20.
Figura 20. Anexos. Opción añadir Plugins.
Diego SIlva, 2015
Selecciona el archivo nbm que se descargó, como se observa en la figura 21.
Figura 21. Anexos. Archivo .nbm PlantUML.
Diego SIlva, 2015
Haz clic en "Install". Confirma todas las ventanas que vienen después y se reinicia.
Instalación de graphviz
Este plugin necesita del graficador para que muestre lo procesado en nuestro IDE. Este
graficador se lo puede descargar desde http://www.graphviz.org/Download..php y en el
margen izquierdo está el listado del instalador para el respectivo sistema operativo.
Se descarga, se instala como cualquier otro aplicativo, y listo. Ahora, debes buscar dónde
está el ejecutable dot.exe. En Windows es posible que se encuentre aquí: c:\Program Files
(x86)\GraphvizX.X\bin
Ahora, teniendo la ubicación del dot.exe en claro, regresa al IDE, y ve a la opción: Tools >
Options > Miscellaneous > PlantUML, e indica la ubicación de dot.exe, como se observa en
la figura 22.
Figura 22. Anexos. Instalación de Graphviz
Diego SIlva, 2015
Diagramando en UML
Bien, todo listo para crear nuestro primer diagrama. Para comenzar, se debe tener
cualquier proyecto creado. Luego, seleccionar File > New File (o Ctrl+N) y en "Categorías"
seleccionar "PlantUML" y a la derecha "New PlantUML Diagram", como se observa en la
figura 23.
Figura 23. Anexos. Creación de un nuevo diagrama UML mediante PlantUML
Diego SIlva, 2015
Clic en "Next", indica un nombre de archivo... el que sea... y clic en "Finish".
Listo, ya tienes el IDE listo para poder crear nuestro diagrama, como se observa en la
figura 24.
Figura 24. Anexos. Creación de un diagrama UML, casos de uso en Netbeans.
Diego SIlva, 2015
Páginas web con más información sobre la creación de diagramas uml con PlantUML
Diagramas de clase UML
Figura 25. Anexos. Creación de un diagrama de clase UML.
Diego SIlva, 2015
Diagrama de actividades UML
Figura 26. Anexos. Creación de un diagrama de actividades UML.
Diego SIlva, 2015
Figura 27. Anexos. Creación de un diagrama de secuencias UML.
Diego SIlva, 2015
2/7/2020 Tema 3: Estructura de un programa
Estructura de un programa
2/7/2020 3.1. Introducción | Tema 3: Estructura de un programa
3.1. Introducción
3.1. Introducción
Cuando hablamos de un programa en Informática, estamos haciendo referencia a un

software. Un programa es un conjunto de aplicaciones y recursos que permite desarrollar
diferentes tareas en una computadora (ordenador), un teléfono u otros equipos tecnológicos.
Para desarrollar un programa informático, se necesita usar un lenguaje de programación

que posibilita el control de las máquinas. A través de diversas reglas semánticas y sintácticas,
estos lenguajes especifican los datos que transmite el software y que tendrá que operar la
computadora.
Un programa (sea informático o no) está compuesto por cuatro partes bien diferenciadas:
Código. Es el conjunto de instrucciones en sí. Normalmente, el código está escrito de forma

que sea fácil de entender y manipular por una persona.
Memoria. Ofrece un espacio al programa para almacenar datos y recuperarlos más tarde.
Entrada. Es el conjunto de datos que el programa recibe mientras se ejecuta y que

condicionan las acciones que este realiza y, en consecuencia, los resultados que genera.
Normalmente, los datos proceden del usuario (pulsaciones del teclado, movimientos y
pulsaciones del ratón, etc.), pero también pueden venir de otros programas. En este último
caso tenemos, por ejemplo, los datos enviados por un servidor web a nuestro navegador.
Salida. Es el conjunto de datos generados en forma de resultado durante la ejecución del

programa. Estos datos pueden percibirse como acciones desde el punto de vista del usuario.
Los resultados pueden ser variopintos: un número, una hoja de papel impresa, una imagen
en la pantalla, etc.
Ejemplo
Para entender mejor los conceptos anteriormente mencionados tomemos de referencia a

una lavadora:
2/7/2020 3.1. Introducción | Tema 3: Estructura de un programa
Figura 1. Lavadora.
Fuente: https://es.123rf.com/photo_95127144_lavadora-de-dibujos-animados-y-lavander%C3%ADa.html
El código son las distintas acciones que la lavadora lleva a cabo, que dependen, ni más ni
menos, del programa elegido y de las entradas (la cantidad de detergente, suavizante, lejía y
la ropa sucia). La salida, en este caso, está clara: la ropa lavada. Que esté más o menos
limpia dependerá del tipo de ropa, de cómo estaba de sucia, del programa que hayamos
escogido y de la cantidad de producto que hayamos usado, en fin, de las entradas. Por otro
lado, la lavadora también usa la memoria para saber en qué punto está dentro del programa
seleccionado, el tiempo que le queda para pasar al siguiente estadio de lavado, etc.
Para entender mejor el tema es necesario conocer una definición básica sobre Java.
Según el portal Definición, “Java es un lenguaje de programación orientado a objetos que se
incorporó al ámbito de la Informática en los años noventa. La idea de Java es que pueda
realizarse programas con la posibilidad de ejecutarse en cualquier contexto, en cualquier
ambiente, siendo así su portabilidad uno de sus principales logros…”.
2/7/2020 3.1.1. Lenguajes de programación más utilizados | Tema 3: Estructura de un programa
3.1.1. Lenguajes de programación más utilizados
3.1.1. Lenguajes de programación más utilizados
Existen tres tipos de lenguajes claramente diferenciados: el lenguaje máquina, los lenguajes
de bajo nivel y los de alto nivel.
El lenguaje máquina. Es el lenguaje de programación que entiende directamente la

máquina (computadora). Este lenguaje de programación utiliza el alfabeto binario, es
decir, el 0 y el 1.
Lenguajes de programación de bajo nivel. Son mucho más fáciles de utilizar que el
lenguaje máquina, pero dependen de la máquina o computadora como sucedía con el
lenguaje máquina.
Lenguajes de programación de alto nivel. Son más fáciles de aprender porque se
usan palabras o comandos del lenguaje natural, generalmente del inglés.
Figura 2. Lenguajes de programación.
Fuente: https://codigoonclick.com/mejores-lenguajes-programacion-para-2018/
C++
Es un lenguaje orientado a objetos, aunque también tiene las mismas características que
C, como por ejemplo, su eficiencia y el uso de punteros.
Como es lógico, y debido a que se creó a partir de C, C++ cuenta con diversas mejoras y
avances respecto de C, lo que le hace un lenguaje más completo y es por ello que los
programadores tienden a programar más en este lenguaje. Un programa en C++ soporta

instrucciones escritas en C, pero un programa escrito en C no nos permite ejecutar
instrucciones de C++, por lo que viéndolo de esta forma resulta más cómodo programar en
C++.
Es un lenguaje muy popular debido a la eficiencia y robustez de sus programas. También

nos permite realizar programas estructurados, lo cual nos da libertad a la hora de programar.
Es un lenguaje compilado, es decir, compila directamente al código que entienden los

ordenadores por lo que es uno de los lenguajes más rápidos. Es portable al gran número de
compiladores que permiten utilizar los programas en diversos ordenadores con diferentes
sistemas operativos.
Soporta varios paradigmas de programación. Un paradigma de programación es una forma

de pensar a la hora de programar, el más utilizado es el paradigma de programación
orientada a objetos.
Java
Java nace en 1991 con el nombre "OAK", posteriormente cambiado por Green por
problemas legales y finalmente con la denominación actual JAVA.
Es un lenguaje orientado a objetos. Un objeto se compone de atributos (estado del objeto)

y métodos (comportamiento) que actúan sobre esos atributos. Para comprender lo que es un
objeto, relacionemos a este con una analogía del mundo real. Al igual que en el mundo
virtual, en el mundo real los objetos tienen un estado y un comportamiento. Por ejemplo, un
coche es un objeto que tiene una serie de estados o atributos (matrícula, marca, modelo,
color, marchas) y una serie de comportamientos o métodos (corriendo, parado, aparcando,
cambio de marcha). Todos los objetos tienen un identificador único que los diferencia del
resto de objetos. En el ejemplo anterior el identificador del coche es la matrícula.
Posee modularidad que permite dividir los programas en pequeños módulos denominados
clases, para reducir la complejidad del problema y, en caso de producirse un fallo, este
solamente afecta al módulo donde se produjo y no a todo el programa.
Es robusto, es decir, es un lenguaje de programación fiable que reacciona adecuadamente

ante situaciones excepcionales.
Es un lenguaje de programación portable que nos permite utilizar los programas

desarrollados en Java en cualquier ordenador con cualquier sistema operativo.
Es dinámico, podemos compilar y ejecutar los programas en tiempo real, y seguro, ya que
elimina los accesos ilegales a memoria que realizan los punteros en C.
En definitiva, Java es uno de los lenguajes más utilizados actualmente ya que podemos
reutilizar el código de los programas y su arquitectura neutral nos permite utilizarlo en
cualquier arquitectura y sistema operativo independientemente de la máquina en que se
realizó el programa. Es un lenguaje fácil de aprender lo que reduce los tiempos de formación
y aprendizaje de las personas que lo vayan a utilizar.
Python
Python fue creado a finales de los ochenta por Guido van Rossum en CWI en los Países
Bajos como un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e
interactuar con el sistema operativo Amoeba. Van Rossum es el principal autor de Python, y
su continuo rol central en decidir la dirección de Python es reconocido, refiriéndose a él como
Benevolente dictador vitalicio o Benevolent Dictator for Life (BDFL).
Se dice que Python es un lenguaje multiparadigma ya que soporta diversos tipos de

paradigmas de programación como son la orientación a objetos, la programación imperativa
o, en menor medida, la programación funcional.
En cuanto al código, es un lenguaje simple y sencillo con instrucciones claras y fáciles de

leer. Se utilizan clases y sentencias de control, sin embargo, no presenta encapsulación. Se
pueden escribir instrucciones en código C para poder ejecutar el código de una manera más
rápida, por lo que Python es compatible con instrucciones de C. También cabe destacar que
es un lenguaje interpretado por lo que no es necesario compilar el código antes de ejecutarlo,
lo cual reduce los tiempos de espera.
Es un lenguaje tipificado que cuenta con un gran número de librerías, tipos de datos y
funciones que sirven de mucha ayuda al programador y simplifican su trabajo.
Uno de los aspectos más importantes es que se trata de un lenguaje libre y gratuito por lo
que se pueden realizar copias del software y modificarlo como se quiera con tal de mejorarlo.
Como consecuencia de ello existen diversas versiones de Python.
Se utiliza con mucha frecuencia gracias a que es un lenguaje de propósito general que nos
permite realizar desde cualquier tipo de programa hasta desarrollar páginas web.
2/7/2020 3.2. Estructura de un programa | Tema 3: Estructura de un programa
3.2. Estructura de un programa
3.2. Estructura de un programa
En el mundo de la programación, la estructura del programa consiste en un conjunto de

sentencias con su respectiva sintaxis que se aplica de manera general al momento de la
creación de un programa en cualquier lenguaje de programación.
Una sentencia es una unidad ejecutable más pequeña de un programa. En otras palabras,
una línea de código escrita es una sentencia. Especifica y controla el flujo y orden de
ejecución del programa. Una sentencia consta de palabras clave o reservadas como cout,
cin, for, while, if ... else, etc., expresiones, declaraciones o llamadas a funciones. Si no existen
sentencias específicas de selección o salto, el programa se ejecuta de forma secuencial en el
mismo orden en que se ha escrito el código fuente (es el que podríamos considerar orden
"natural" de ejecución).
Las sentencias se ejecutan evaluando la expresión. Todos los efectos colaterales de la

evaluación son tenidos en cuenta antes de ejecutar la próxima sentencia. La mayoría de
sentencias son asignaciones o llamadas a funciones. Un caso especial es la sentencia nula;
consiste en un punto y coma (;) aislado. Una sentencia nula no hace nada, pero puede ser
necesaria en situaciones en que la sintaxis del lenguaje espere una sentencia pero nuestro
programa no necesita hacer nada.
Pueden existir infinitas sentencias distintas e innumerables criterios para su clasificación.

Las clases de sentencia son:
De etiqueta
De expresión
Compuestas
De selección
De iteración
De salto
De declaración
Bloques de intento
Sentencias de pre proceso
Sentencias ensamblador
Sentencias de etiqueta
Existen tres clases de sentencias etiquetadas: las etiquetas directas, las sentencias case y
las default, estas últimas se utilizan en conjunción con las sentencias switch.
Sentencias de expresión
Podríamos decir que son las que no pertenecen a ninguno de los otros grupos y que, en la
práctica, son las más abundantes. Generalmente son asignaciones o invocaciones de
funciones. Ejemplo:
Figura 3. Sentencias.
Fuente: https://www.ecured.cu/Sentencias_(Programaci%C3%B3n)
Sentencias compuestas
Las sentencias compuestas, también denominadas bloques, se utilizan en aquellas

situaciones en que la sintaxis espera una sentencia pero se necesita usar varias. Ejemplo:
En caso de cumplirse la condición hay que incrementar x, lo que puede hacerse en una
sola sentencia, pero si la condición resulta falsa, se precisan dos computaciones. Para que
se comporten como una sola frente a else, se recurre a englobarlas en un bloque entre llaves
{ ... }. Las sentencias dentro del bloque se comportan como una sola y constituyen un ámbito
léxico. Los identificadores definidos en su interior eclipsan a los exteriores y las variables
automáticas creadas en él son destruidas al salir del ámbito.
Sentencias de iteración
Las sentencias de iteración permiten repetir un conjunto de sentencias ejecutando un

bucle. En C++ existen tres formas de iteraciones: los bucles while, do…while y for. Ejemplo:
Sentencias de salto
Las sentencias de salto permiten transferir el control del programa de forma incondicional.
Existen cuatro de estas sentencias: break, goto start, continue y return. Ejemplo:
Sentencias de declaración
Este tipo de sentencias introducen uno o más identificadores en un bloque. Ejemplo:
Bloques de intento
Estas sentencias deben estar seguidas de una sentencia catch y tienen la forma:
3/7/2020 3.2.1. El lenguaje de programación Java | Tema 3: Estructura de un programa
3.2.1. El lenguaje de programación Java
3.2.1. El lenguaje de programación Java
El lenguaje Java, como la mayoría de lenguajes de programación, requiere una estructura

mínima que acoja el programa y sus componentes. En el caso concreto de Java, a esta
estructura mínima se le llama clase (estructura donde ocurren los procesos lógicos del
programa). A continuación, se muestra la estructura mínima de una clase ejecutable.
Figura 9. Introducción a la programación.
Fuente:
http://downloads.gvsig.org/download/documents/learning/collaborations/ce_1104_01/Programacion_personalizac
En la figura 9, el código define una clase (class) llamada “Programa” con una función
“main”, que será la que se ejecutará al iniciar el programa. El nombre de la clase ha sido
escogido arbitrariamente (es decir, puede cambiarse); no así el nombre de la función, que
siempre deberá llamarse “main”. Las funciones son simples agrupaciones (funcionales) de
código. Este programa deberá guardarse en un fichero que se llame como la clase más el
sufijo .java; en este caso, “Programa.java”. El código del programa deberá ir entre las llaves
de la función “main”.
En el siguiente programa:
3/7/2020 3.2.1. El lenguaje de programación Java | Tema 3: Estructura de un programa
Figura 10. Introducción a la programación.
Fuente:
http://downloads.gvsig.org/download/documents/learning/collaborations/ce_1104_01/Programacion_personalizac
El código de la figura 10 calcula la distancia recorrida por un vehículo a partir de su

velocidad y el tiempo que ha estado circulando. El texto precedido por doble barra (//) son
comentarios. Los comentarios son simples anotaciones que el programador hace en el
código del programa para facilitar su comprensión. Los comentarios no se ejecutan. La última
línea usa la función “System.out.println” para escribir el resultado en la pantalla. Como puede
apreciarse, todas las variables se han declarado al inicio del código. A diferencia de otros
lenguajes, en Java las variables pueden declararse en cualquier parte del código, siempre y
cuando la declaración preceda a su uso. Sin embargo, es una práctica habitual declararlas al
principio del código para mejorar su legibilidad.
3/7/2020 3.2.2.Sintaxis de Java | Tema 3: Estructura de un programa
3.2.2.Sintaxis de Java
3.2.2. Sintaxis de Java
Java cumple con la sintaxis general que fue mencionada anteriormente, sin embargo,
posee una cierta estructura que no veremos en otro lenguaje de programación.
Declaración de variables
Las variables son unidades básicas de almacenamiento en Java. Una variable se define
por la combinación de un identificador, un tipo y un inicializador opcional. Además, las
variables tienen un ámbito que define su visibilidad y una duración.
Una variable debe ser declarada antes de poder ser utilizada.
Sintaxis nombretipo identificador
nombretipo identificador =expresión
Es posible declarar dos o más variables a la vez.
Existen dos categorías de variables:
Variables de tipo primitivo. Contienen directamente una representación de un valor de un

tipo primitivo.
Variables de tipo referencia. Contienen una referencia a un objeto cuando un tipo de

referencia toma el valor null, significa que no se refiere a un objeto real (referencia nula).
Modificaciones de variables
Las variables se pueden modificar mediante indicadores.
Public. La clase o variable de instancia es accesible desde todos los ámbitos.
Protected. La clase o variable de instancia es accesible solo en el ámbito actual de la clase,

el ámbito del paquete actual y todas las subclases de la clase actual.
Private. La clase o variable de instancia es accesible solo en el ámbito actual de la clase.
Final. La variable es una constante, de modo que su valor no se puede modificar.
Static. La variable es una variable de clase, compartida entre todos los objetos instancia de
una clase.
Transfert. Se declara que no es parte de un estado persistente del objeto.
Volatile. Se necesita a veces cuando se utiliza una variable instancia por ¿¿ para prevenir al
compilador de su optimización.
Expresiones
Las expresiones se utilizan para buscar, calcular y asignar valores. Excepto para una
llamada a un método con un tipo de retorno void, todas las expresiones devuelvan un valor,
permitiendo a las expresiones combinarse en más expresiones complejas. Las expresiones
principales traen o crean valores y son las siguientes:
Las palabras reservadas this, super y null.
Un valor literal.
Una expresión con paréntesis.
(expresión)
Una expresión de campo, utilizando ́. ́
Identificador
Expresión principal. Identificador
Paquete. Identificador
Una expresión de índices de array, utilizando ́[] ́
Término [expresionValorentero]
Una expresión de llamada a métodos.
Una expresión de asignación.
New numbetipo (listaArgumentos)
New numbetipo [expresionEntera]
Impresión básica
El flujo de salida estándar permite acceder a los métodos básicos de impresión; print () y
println(), de la clase PrintStream. Proporciona una referencia a un objeto de printStream que
puede acceder a esos métodos. La variable out es un miembro de la clase System. La

sintaxis es la siguiente:
System.out // uno de la variable out
Existe un método llamado print ( ) el cual imprime el argumento parado a la salida

estándar (normalmente la consola), sin un carácter fin de línea. Su sintaxis es la siguiente:
public void print(String s)
public void print(Boolean b)
public void print(Char c)
public void print(double d)
public void print(float f)
public void print(int i)
public void print(long l)
public void print(object ob)
Otro método es el printIn( ) el cual es similar al método print( ) excepto un carácter fin de
línea o secuencia se añade al final. Su sintaxis es la siguiente:
public void print(String s)
public void print(Boolean b)
public void print(Char c)
public void print(double d)
public void print(float f)
public void print(int i)
public void print(long l)
public void print(object ob)
Tablas resumen de la sintaxis de Java
Figura 11. Sintaxis del lenguaje Java.
Fuente: https://www.studocu.com/es/document/universidad-rey-juan-carlos/programacion-orientada-a-
objetos/resumenes/sintaxis-del-lenguaje-java/411416/view
3/7/2020 3.3. Entorno de desarrollo | Tema 3: Estructura de un programa
3.3. Entorno de desarrollo
3.3. Entorno de desarrollo
Los entornos de desarrollo son aplicaciones que permiten al programador implementar las
abstracciones del mundo real en un aplicación concreta mediante la introducción de
secuencias de código con sus estructuras de programación.
Actualmente existen dos entornos de desarrollo Java de amplio uso en el sector profesional.
Estos entornos de desarrollo Java: son NetBeans y Eclipse.
Para poder programar en Java, antes que nada, es imprescindible que el Java Development
Kit o JDK que, entre otras muchas cosas, incluye el compilador de Java, el depurador, las
bibliotecas de servicios y la JVM (Java Virtual Machine), permita convertir el código fuente en
bytecode y ejecutarlo.
El procedimiento a seguir para instalarlo es prácticamente el mismo con independencia del

sistema operativo en que estemos trabajando, si bien hay métodos alternativos en algunos
casos como ocurre con GNU/Linux.
Descarga del JDK
Para poder instalar el JDK lo primero que debemos hacer es, lógicamente, descargar el
correspondiente paquete. Ya sabemos que podemos elegir entre distintos orígenes: Oracle,
OpenJDK, IBM, etc., así como entre múltiples versiones. Lo habitual es que obtengamos un
ejecutable (.exe para Windows), una imagen (.dmg para OS X) o un paquete (tar.gz para
GNU/Linux) comprimido. Almacenaremos dicho archivo temporalmente en el sistema donde
se quiere realizar la instalación.
Figura 15. Campos MVP.
Fuente: https://www.campusmvp.es/recursos/post/Paso-a-paso-como-instalar-el-JDK-de-Java-para-empezar-a-
programar.aspx
Proceso de instalación JDK
En el siguiente link, el tutor Francisco Charte muestra paso a paso cómo instalar y
configurar la versión 9 del JDK en Windows, Mac y Linux:
https://youtu.be/Ja6PvoTw_oQ
Verificación
A fin de verificar que el JDK está instalado correctamente, y conocer la versión exacta de
que se dispone, podemos usar los comandos java -versión y/o javac -versión.
Figura 16. Campos MVP.
Fuente: https://www.campusmvp.es/recursos/post/Paso-a-paso-como-instalar-el-JDK-de-Java-para-empezar-a-
programar.aspx
El primero invoca a la JVM de Java y el segundo al compilador.
IDE de programación
Un IDE es un entorno de programación que ha sido empaquetado como un programa de

aplicación, o sea, consiste en un editor de código, un compilador, un depurador y un
constructor de interfaz gráfica. Los IDE pueden ser aplicaciones por sí solas o pueden ser
parte de aplicaciones existentes. Algunos ejemplos que se pueden mencionar son:
Eclipse. Entorno de desarrollo integrado de código abierto multiplataforma para

desarrollar proyectos. Esta plataforma ha sido usada para desarrollar entornos de
desarrollo integrados, como el IDE de Java llamado Java Development Toolkit (JDT) y el
compilador (ECJ) que se entrega como parte de Eclipse (y que son usados también
para desarrollar el mismo Eclipse). También se puede usar para otros tipos de
aplicaciones cliente, como BitTorrent o Azureus. En Eclipse se pueden usar diferentes
lenguajes de programación como: Java, ANCI C, C++, JSP, sh, perl, php, sed.
NetBeans. Programa que sirve como IDE que permite programar en distintos lenguajes,
es ideal para trabajar con el lenguaje de desarrollo JAVA (y todos sus derivados),
además ofrece un excelente entorno para programar en PHP. También se puede
descargar una vez instalado NetBeans, los complementos para programar en C++. La
IDE de NetBeans es perfecta y muy cómoda para los programadores. Tiene un
excelente balance entre una interfaz con múltiples opciones y un aceptable
completamiento de código.
Geany. Es un IDE que hasta hace poco solo estaba disponible para sistemas Linux,
Mac OS X y BSD, pero ya está disponible para Windows. Este entorno es muy sencillo,
pero proporciona las funcionalidades necesarias para desarrollar aplicaciones sin
problemas. Su interfaz está dividida en tres zonas: panel lateral con el árbol de carpetas
y documentos abiertos, sección principal para el código y panel inferior para los
mensajes de la aplicación, compilación, etc. Este IDE permite programar en diferentes
lenguajes como: C, C++, Java, Python, Pascal, SQL o HTML.
CodeRun. Es un IDE que permitirá programar en línea varios lenguajes, entre ellos
PHP, Ajax, C#, CSS, JavaScript y HTML. Funciona perfectamente, aunque está en
inglés, es útil para quien no disponga de un buen editor a mano.
Proceso de instalación de NetBeans
Para poder utilizar el NetBeans primero debemos instalar el JDK (proceso anteriormente
detallado).
En la página oficial de Java damos clic en Java Platform y en la pantalla que aparezca
debemos dar clic en “Accept License Agreement” y seleccionar la descarga de acuerdo con el
tipo de computadora que se tenga (32 o 64 bits y el tipo de sistema operativo):
Figura 17. Aceptar licencia.
Fuente: Pablo Parra
Se abre una nueva pestaña donde debemos crear una cuenta.
Figura 18. Crear una cuenta.
Fuente: Pablo Parra
Se abre una nueva pestaña donde debemos crear una cuenta: Llenamos los datos que
soliciten. Se recomienda escribir en “Cargo: Estudiante” y en “Nombre de empresa: ESPE”:
Figura 19. Datos.
Fuente: Pablo Parra
Damos clic en “Crear una cuenta” y debemos ingresar al correo electrónico que dimos
como referencia para la verificación del correo, damos clic en la pestaña de “Verificación” y
deberá aparecer este mensaje:
Figura 20. Verificación.
Fuente: Pablo Parra
Damos clic en la opción “Sign in” y elegimos “Sig in to my Account”.
Figura 21. Sig in to my Account
Fuente: Pablo Parra
Y nos aparece la pantalla para ingresar a nuestra cuenta, ingresamos y regresamos a la

pestaña de descargas y le damos en descargar:
Figura 22. Descarga.
Fuente: Pablo Parra
Después de que el archivo se haya descargado realizamos el proceso de instalación y

deberá aparecer esta pantalla:
Figura 23. Instalación.
Fuente: Pablo Parra
Luego de haber instalado el JDK procederemos a instalar el NetBeans y para ello nos
dirigimos a la siguiente página: https://netbeans.org/downloads/8.0.2/
Fuente: Pablo Parra
Damos clic en la columna de “All” en la opción “Downloand” y nos aparecerá la siguiente

pantalla, esperamos unos segundos y empezará la descarga con este mensaje:
Figura 25. Descxarga.
Fuente: Pablo Parra
Damos clic en el archivo para instalarlo, aceptamos las condiciones y lo instalamos:
Fuente: Pablo Parra
Fuente: Pablo Parra
Damos clic en “Finish” y listo, NeatBeans estaría instalado con éxito para ya poder ser
utilizado:
Figura 28. Instalación exitosa.
Fuente: Pablo Parra
Configuración de nuestro JDK
Para que el kit de desarrollo (Java Development Kit) funcione correctamente se procede a
realizar la configuración de las variables de ambiente y a probar la versión instalada.
Lo primero que se debe hacer es copiar la ruta donde se instaló el JDK. Ejemplo:
“C:JavaCursojdk1.8.0_151”.
Figura 29. Copiar la ruta.
Fuente: Pablo Parra
Después se abren las variables de ambiente del computador, en este caso es

Windows.
Se abre el explorador de archivos / Clic derecho en Este equipo / Configuración

avanzada del sistema / En Opciones avanzadas clic en el botón Variables de entorno.
Con esta navegación muestra las variables de entorno que existen en el PC.
Figura 30. Variables de entorno.
Fuente: Pablo Parra
Ahora se crea dos variables y a modificar una.
Tabla 1
Variables de ambiente Java
No Nombre Valor
1 JAVA_HOME (Nueva) C:JavaCursojdk1.8.0_151
2 CLASSPATH (Nueva) .
3 PATH (Modificación) %JAVA_HOME%/bin;
Fuente: Pablo Parra
Variable JAVA_HOME. Esta variable contiene la ruta donde se instaló nuestro JDK.
Figura 31. Variable.
Fuente: Pablo Parra
Variable CLASSPATH
Esta variable va a contener un punto “.”, esto para poder compilar programas Java desde
cualquier directorio en nuestro sistema operativo.
El punto significa “Directorio actual”.
Fuente: Pablo Parra
Variable PATH
Esta es una variable del sistema muy importante, esta variable solo se va a modificar
porque ya se encuentra creada y con valor. Es una variable muy delicada, así que se hace la
modificación con mucho cuidado, ya que si se borra algún carácter se dejará inhabilitado
algún programa.
Ahora se posiciona al inicio de todo el contenido del campo Valor, después se escribe
“%JAVA_HOME%bin;”.
Lo que se está realizando con esto es decirle al sistema operativo que reconozca todos
los programas que se encuentran en nuestro directorio de instalación de Java en la carpeta
BIN.
Fuente: Pablo Parra
3/7/2020 3.3.1. Probando la instalación | Tema 3: Estructura de un programa
3.3.1. Probando la instalación
3.3.1. Probando la instalación
Con esto ya se encuentra configurado el kit de desarrollo (no es necesario reiniciar la

computadora), ahora solo falta verificar la instalación.
Para esto se debe abrir una terminal de MS-DOS y se ejecuta el siguiente comando:
java -versión.
Figura 34. Verificación.
Fuente: Pablo Parra
La ejecución del comando regresa la versión instalada del JDK, esto quiere decir que la
instalación y configuración fue correcta.
Instalación de un IDE desarrollo para Java
En este punto se instala un programa para que se pueda realizar los programas que se
desea en Java.
Para este fin hay muchos editores de código Java como son: JDdeveloper, NetBeans,
Eclipse, entre otros.
3/7/2020 3.4. Creación de un programa básico O.O. | Tema 3: Estructura de un programa
3.4. Creación de un programa básico O.O.
3.4. Creación de un programa básico O.O.
Para iniciar con la creación de un programa basado en la programación orientada a objetos

es necesario tener un software para poder hacerlo y para ello vamos a utilizar Java con varias
opciones para ejecutarlo, como el JDK y el IDE de programación.
Ejemplo
Empezaremos con el ejemplo de sumar dos números con Java pidiendo dichos números
por consola. Nos apoyaremos en la clase Scanner para realizar esta tarea. Es por ello que
instanciaremos el Scanner sobre la consola, la cual es representada mediante la clase
System.in
Figura 35. Sumar dos números con Java.
Fuente: Pablo Parra
Para leer cada uno de los números nos apoyamos en el método .nextInt(). Ejecutaremos
este método dos veces (una por cada número) y almacenaremos el resultado en sendas
variables de tipo int.
Fuente: http://lineadecodigo.com/java/sumar-dos-numeros-con-java/
Ya solo nos quedará la parte más sencilla del código, la suma de los números. El
resultado de la suma lo almacenaremos en otra variable.
Solo nos quedará mostrar el resultado por pantalla. En este caso nos apoyamos en
System.out
Se procederá a realizar ejercicios en el IDE de programación NetBeans. Para esto primero

se ejecuta NetBeans en el ordenador a usar, una vez ejecutado el programa ahora sí
procederemos a dar clic en la parte superior izquierda en File, luego clic en New Project como
indica la figura 39.
Figura 39. Creación de un nuevo proyecto NetBeans.
Fuente: Pablo Parra
Luego aparecerá una pantalla en la cual en la sección de categoría ponemos en Java y

Project de igual manera, aunque estos dos aparecerán seleccionados por defecto como se
indica en la figura 40 y clic en Next.
Figura 40. Creación de un nuevo proyecto NetBeans.
Fuente: Pablo Parra
De igual manera que la anterior se desplegará otra ventana y en la sección que dice
Project name se pondrá el nombre con el cual irá nuestro nuevo programa. Cabe recalcar
que al iniciar un nuevo proyecto la primera letra debe ser mayúscula y la que continúa de
igual manera como en la figura 41. Ademas si da clic en Browse se puede seleccionar dónde
quiere que se guarde el proyecto que crea NetBeans.
Figura 41. Nombre del proyecto NetBeans.
Fuente: Pablo Parra
Una vez creado nuestro proyecto procedemos a realizar el hola mundo. En Java cuando
se compila el programa primero lee el main, es decir, el programa principal. Para hacer una
impresión en pantalla pondremos en el main System.out.println (“Hola mundo”).
También se puede poner sout y presionar la tecla tab y se pondrá automáticamente la

estructura para la impresión de pantalla, lo que se desea mandar a imprimir en pantalla lo
ponemos entre comillas, en este caso se puso un "Hola mundo", si desea puede poner lo que
quiere mandar a imprimir en pantalla.
Una vez puesto el Hola mundo se dará clic en el icono que se indica en la flecha, este
icono compilará y ejecutará el programa y en la parte inferior indicará nuestro Hola mundo
como se ve en la figura 42.
Figura 42. Impresión en pantalla en NetBeans.
Fuente: Pablo Parra
Otro ejemplo para un mejor entendimiento será el de sumar dos números con Java
pidiendo dichos números por consola. Se usará la clase Scanner para realizar esta tarea. Es
por ello que se instancia el Scanner sobre la consola, la cual es representada mediante la
clase System.in.
Para leer cada uno de los números también usaremos el método nextInt (). Ahora se
ejecuta este método dos veces, una por cada número y se almacena el resultado en las
variables de tipo int. Ya solo queda la parte más sencilla del código: la suma de los números.
El resultado de la suma será almacenado en otra variable. Para indicar el resultado por
pantalla en este caso nos apoyamos en System.out el cual nos ayudará a indicar el resultado
de la suma realizada.
Figura 43. Sumar dos números en NetBeans.
Fuente: Pablo Parra
A continuación, debe crear un programa el cual indicará si un número es par o impar, el

número será ingresado por teclado. De igual manera que el ejercicio anterior, instanciaremos
el Scanner para el ingreso de datos, luego se declarará la variable la cual asignará el valor de
ingreso.
Se hará el uso de la sentencia if-then-else para verificar si el número ingresado es par o

impar. El System.out.println mostrará si el número ingresado es par o impar. En la figura 44
se indica toda la ejecución y compilación del algoritmo anteriormente explicado.
Figura 44. Verificación de un número si es par o impar en NetBeans.
Fuente: Pablo Parra
3/7/2020 3.5. Tipos de datos, primitivos y referenciados | Tema 3: Estructura de un programa
3.5. Tipos de datos, primitivos y referenciados
3.5. Tipos de datos, primitivos y referenciados
Un tipo de dato representa un conjunto de valores que significan lo mismo, un atributo

el cual representa la clase de datos que se está utilizando, sin embargo, hay algunos
tipos que no representan valores en la aplicación que se ejecutan.
Cuando se utilizan tipos entre los objetos estos no pueden intercambiarse, bueno, o al
menos no totalmente ya que pueden lograrse intercambiar de formas muy limitadas.
Un tipo de dato es una característica de datos que especifica cómo debe trabajarse el
mismo dentro de un entorno, esto incluye si se deben aplicar restricciones o alguna
operación específica para este tipo de dato.
Se debe tener en cuenta que la buena comprobación de tipos impide que se mezclen
abstracciones.
La manera de comprobar los tipos es agrupar en tres clases: estático, dinámico y

estricto, este último suele tratarse como un tipo estático.
Tipo estático
Los datos de tipo estático son expresados en tiempo de compilación con esto se dice
que mediante un análisis de compilación puede determinarse el tipo de dato.
El tipo de dato estático puede llegar a ser muy restrictivo, pero detecta anomalías en
tiempo de compilación.
Los lenguajes que utilizan un tipado estático son C++, Java, C#.
Figura 45. Tipos de datos.
Fuente: https://laraveles.com/series/poo/tipos-datos-programacion-orientada-objetos/
El tipo estático permite que los errores sean detectados antes de la ejecución,
haciendo así la aplicación más eficiente.
Tipo estricto
Todas las expresiones son consistentes en tiempo de compilación, es decir, asegura

que no se asigne accidentalmente un tipo de valor incorrecto a una variable, por esta
razón es que suele tratarse como un tipo de dato estático. El tipo de dato estricto
también se encarga de que no se accedan a propiedades o métodos que no pertenezcan
al tipo de objeto.
Consistencia
La consistencia es una cualidad que tiene un objeto que resiste sin corromperse
fácilmente.
La consistencia se define a través de tres restricciones fundamentales:
Restricción de declaración. Indica que todas las entidades deben tener un tipo
declarado.
Restricción de compatibilidad: El tipo fuente debe ser compatible con el tipo de
destino.
Restricción de llamada a característica. Para poder llamar a un atributo o método X
desde la clase Y, X tiene que estar definida en la clase Y o en sus antecesores.
Pesimismo
Se llama así cuando se tienen operaciones con tipos las cuales creemos estar seguros
que funcionaran o serán válidas siempre, pero si no se está seguro es preferible que no
se permita.
Tipo dinámico
En este tipo de dato las comprobaciones se realizan en tiempo real, es decir, en

tiempo de ejecución. Esto permite que una variable tome valores de tipos diferentes en
diferentes momentos. Los lenguajes que podemos mencionar que utilizan este tipado
son Phyton y PHP.
Fuente: https://laraveles.com/series/poo/tipos-datos-programacion-orientada-objetos/
En la siguiente tabla se resumen los tipos de datos en Java.
Figura 47. Tipos de datos Java.
Fuente: https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=419:tipos-de-
datos-java-tipos-primitivos-int-boolean-y-objeto-string-array-o-arreglo-variables-cu00621b&catid=68&Itemid=188
Tipo referenciado
Los tipos de datos referencia o referenciados indican que vamos a trabajar con
instancias de clases, no con tipos primitivos. De esta manera, una variable de tipo
referencia establece una conexión hacia un objeto, y a través de esta conexión podemos
acceder a sus métodos y atributos.
Las variables de tipo primitivo nos permiten almacenar valores primitivos como
números o caracteres. Las variables de tipo referencia NO almacenan valores, sino que
nos permiten acceder a métodos y atributos de un objeto.
Además, algo importante a tener en cuenta es que el tipo de referencia debe ser
compatible al tipo de objeto al que se refiere.
Fuente: http://ayudasprogramacionweb.blogspot.com/2012/12/tipos-de-datos-referencia-y-ejemplos-java.html
3/7/2020 Tema 4: Constructores y métodos encapsulados
Constructores y métodos encapsulados
3/7/2020 4.1. Introducción | Tema 4: Constructores y métodos encapsulados
4.1. Introducción
4.1. Introducción
El presente capítulo se estudiará el paradigma de programación orientada a objetos

(POO). Lo primero que distingue a un lenguaje orientado a objetos de otros lenguajes no
orientados a objetos es el concepto de clase, definiéndola como un nuevo tipo de dato.
Cuando se define el dato o atributo de la clase, este se lo utilizará para crear o instanciar
objetos de dicho tipo de atributo. El objeto o instancia es el segundo concepto que se puede
distinguir a los lenguajes orientados a objetos del resto.
El programador por su habilidad debe utilizar el lenguaje que se centre en el paradigma

orientado a objetos, diseñando su trabajo en la abstracción y diseño de clases con la
utilización previamente de constructores, métodos de encapsulamiento, que se observaré en
el presente documento, como elementos primordiales en la creación o definición de una clase
que servirá para crear posteriormente objetos o instancias.
Mediante el correcto diseño de la clase, el programador describirá los atributos y el

comportamiento que tendrán todos los objetos pertenecientes a dicha clase, es decir, que
sean instancias de la misma.
3/7/2020 4.2. Constructores | Tema 4: Constructores y métodos encapsulados
4.2. Constructores
4.2. Constructores
Los constructores son métodos públicos especiales en Java que sirven para inicializar
valores en instancias de objetos que llevan el mismo nombre de la clase, se invocan
automáticamente al momento de crear o instanciar el objeto de la clase. Las principales
características de los constructores son:
• No devuelven nada, no siquiera void.

• Pueden existir uno o varios.
• Tienen el mismo nombre de la clase.
• De entre los que se hayan creado, tan solo uno se ejecutará al crear una instancia de un
objeto de la clase.
La función es de asignar memoria al objeto que se está creando e inicializar sus datos
como se muestra en la figura 1.
Figura 1. Constructores.
Fuente: Pablo Parra
Es conveniente que haya al menos un constructor, si no existen se crea por Default o por
defecto sin parámetros que inicializan los atributos por defecto.
Nota. Se puede usar para establecer valores iniciales para los atributos de objeto.
Pueden existir varios tipos de constructores en una clase, si tienen diferentes listas de
parámetros que se indicarán a continuación.
3/7/2020 4.2. Constructores | Tema 4: Constructores y métodos encapsulados
3/7/2020 4.3. Tipos de constructores | Tema 4: Constructores y métodos encapsulados
4.3. Tipos de constructores
4.3. Tipos de constructores
Una clase puede contener uno o varios constructores, es decir, definir algunos constructores
diferentes por el número o tipo de parámetros que reciben.
Los constructores pueden ser: vacío o por defecto, común o con parámetros y de copia.
3/7/2020 4.3.1. Constructor vacío o por defecto | Tema 4: Constructores y métodos encapsulados
4.3.1. Constructor vacío o por defecto
4.3.1. Constructor vacío o por defecto
El constructor sin parámetros es llamado constructor vacío. Sino se define ningún

constructor, el compilado crea un constructor por defecto, por lo que se debe proporcionar en
el código valores iniciales según los tipos de datos de la clase como se indica en la figura 2.
Figura 2. Constructor sin parámetros.
Fuente: Pablo Parra
Nota. La palabra reservada this hace referencia al objeto que realiza la operación cuya
implementación especifica el método.
3/7/2020 4.3.2. Constructor común o con parámetros | Tema 4: Constructores y métodos encapsulados
4.3.2. Constructor común o con parámetros
4.3.2. Constructor común o con parámetros
El constructor con parámetros se lo conoce como constructor parametrizado y es aquel

que recibe como datos primitivos y/o referencias de la clase sus propios valores.
Habitualmente se utilizan para iniciar los atributos como se muestra en la figura 3.
Figura 3. Constructor con parámetros.
Fuente: Pablo Parra
Cuando se utilizan constructores con parámetros surge la necesidad de inicializar algún

atributo o campo perteneciente a la clase. En el caso de la figura 3, dentro del constructor se
desea asignar valores a los campos de la clase. Para tener total acceso a los campos de la
clase se utiliza el vocablo this, al empezar la sintaxis con lo cual se está haciendo alusión a
los campos de la clase. (García Hernández, E., 2017).
3/7/2020 4.3.3. Constructor de copia | Tema 4: Constructores y métodos encapsulados
4.3.3. Constructor de copia
4.3.3. Constructor de copia
El constructor de copia es aquel que recibe como parámetros un objeto de la misma clase
del cual se realiza una copia exacta de sus datos. (Calva & Asanza, 2015).
El constructor de copia solo tiene un argumento o parámetro, que es una referencia a un

objeto de su misma clase. En general, los constructores copia tienen la siguiente forma para
sus prototipos:
Figura 4. Constructor de copia.
Fuente: Pablo Parra
Figura 5. Constructor de copia.
Fuente: Calva & Asanza, 2015
3/7/2020 4.3.4. Operador “this” | Tema 4: Constructores y métodos encapsulados
4.3.4. Operador “this”
4.3.4. Operador “this”
Un método miembro de un objeto está asociado al objeto. Cuando este se está ejecutando
se debe usar this, para conseguir una referencia al objeto asociado.
Dentro del método constructor, se usará this para acceder al nombre del objeto asociado.
La palabra clave this funciona igual dentro de un constructor como se presenta en el
siguiente ejemplo en la figura 6.
Figura 6. Constructor con parámetros. Ejemplo.
Fuente:http://www.edu4java.com/es/java/constructores-palabra-clave-this.html
En el método toString se usará this para acceder al campo nombre. En realidad, no es tan
necesario como se puede observar en la misma línea cuando se accede al campo. Por
defecto, el compilador entiende que es el campo del objeto asociado.
Figura 7. Constructor con parámetros.
Fuente: http://www.edu4java.com/es/java/constructores-palabra-clave-this.html
Donde sí es necesario usar this es en Persona (String nombres, String apellido, String
dirección), donde existe un parámetro llamado nombre. Si se escribe solo “nombre”, el
compilador entiende que se refiere al parámetro y no al campo. Por eso se utiliza this
nombre=nombre inicializando el atributo como se indica en figura 8.
Figura 8. Constructor un solo parámetro.
Otro caso interesante donde usar this es en el constructor Persona (String nombre). Aquí
se llama al constructor informando solo el nombre. Lo que se quiere obtener es que los
demás campos tengan el contenido por defecto dado por el constructor vacío "No informado".
Se usa this () para llamar al constructor vacío public Persona (), desde el constructor
Persona (String nombre). Esto rellena todos los campos con "No informado” y luego
actualiza el nombre con el parámetro (Edu4, 2017). En la figura 9, presentamos la
introducción a la instanciación o creación de un objeto con o sin parámetros.
Figura 9. Utilización de constructores con y sin parámetros.
En el método main (principal), se puede ver cómo se crean tres objetos personas, usando
los diferentes constructores y después se imprime cada uno de los objetos, usando el método
toString ().
3/7/2020 4.4. Instanciación | Tema 4: Constructores y métodos encapsulados
4.4. Instanciación
4.4. Instanciación
La instanciación de una clase tiene por objetivo la creación de un objeto. Crear un objeto
significa reservar espacio de memoria para el mismo y establecer una ligadura con una
variable referencia. por lo que se puede concluir que instancia es la estrecha relación entre el
objeto y la clase.
Figura 10. Instancia.
Fuente: http://profejavaoramas.blogspot.com/2010/04/instancia.html
Clase
La clase es la estructura de un objeto, es decir, la descripción de los elementos de los

cuales está formado o hecho un objeto. Una clase está compuesta por dos elementos:
- Atributos
Se los denomina por lo general datos miembros, esto es los datos que se refieren al
estado del objeto como se puede observar en el figura 11.
- Métodos
Se los denomina por lo general funciones miembros, aquellos que pueden aplicarse al
objeto, el comportamiento de estos objetos que pueden contener o no parámetros.
Figura 11. Elementos de una clase.
Fuente: Pablo Parra
Objeto
El objeto es una instancia (proceso de creación de un objeto de una clase) mencionado

anteriormente en la definición de una instancia de una clase. Por lo tanto, un objeto es el
resultado de una clase, en realidad es una instancia de una clase, por lo que se pueden
intercambiar los términos objeto o instancia. (Palmer, 2017)
Un objeto está compuesto y al igual que los objetos del mundo real comparte siempre
características que son: estado (atributos) y comportamiento (funciones o métodos).
Figura 12. Instanciación de objetos
Fuente: https://www.albertopalmer.com/2017/08/02/que-es-una-clase-que-es-un-objeto/
Nota. Una clase no es un objeto, pero se usa para construirla.
3/7/2020 4.4.1. Instanciar | Tema 4: Constructores y métodos encapsulados
4.4.1. Instanciar
4.4.1. Instanciar
Para instanciar(crear) objetos de una determinada clase se puede encontrar con distintas
formas que se deberá aplicar. Lo más habitual de ellas es utilizar la palabra reservada, la cual
nos proporciona la invocación de un constructor para crear objetos en Java siguiendo el
siguiente formato:
Figura 13. Palabra reservada new.
Fuente: https://javiergarciaescobedo.es/programacion-en-java/2-clases-y-objetos/218-instanciacion-de-objetos
Figura 14. Palabra reservada new
Fuente: Javier García Escobedo, 2011
Lo cual sería una llamada al método constructor (con o sin parámetros) de la clase. El
tipo de llamada nos devuelve una instancia u objeto de dicha clase. Una vez creado el objeto,
se podrá guardarlo en una variable dentro de cualquier expresión compatible con la clase del
objeto creado.
El proceso de declarar una variable que pueda contener el objeto de una determinada
clase se actúa de forma similar a la declaración de las variables habituales, es decir,
siguiendo la estructura como se muestra en la figura 15.
3/7/2020 4.4.1. Instanciar | Tema 4: Constructores y métodos encapsulados
Figura 15. Creación de un objeto.
Fuente: https://javiergarciaescobedo.es/programacion-en-java/2-clases-y-objetos/218-instanciacion-de-objetos
Figura 16. Variable contenedora del objeto
Es habitual que a la vez que se declara una variable, se cree el objeto de la misma clase y
se le asigne a dicha variable, formando una sentencia completa de la siguiente forma:
Figura 17. Ejemplo creación de la instancia (objeto).
3/7/2020 4.5. Métodos Getters y Setters | Tema 4: Constructores y métodos encapsulados
4.5. Métodos Getters y Setters
4.5. Métodos Getters y Setters
En estos métodos, todo atributo de una clase es privado por el principio de

encapsulamiento además son métodos que se usan en las clases para mostrar (get) o
modificar (set) el valor de un atributo. El nombre del método siempre será get o set y a
continuación el nombre del atributo. Su modificador siempre es public, ya que se quiere
mostrar o modificar desde fuera la clase. Son métodos de acceso lo que indica que son
siempre declarados públicos.
Los sets y gets son la forma de acceder a atributos de una clase. Generalmente, se usan
con los atributos privados, ya que a los públicos se puede acceder directamente sin tener que
acudir a ellos.
Figura 18. Inicializamos los atributos.
Fuente: Pablo Parra
Conceptos generales
Getters. Del inglés Get, que significa obtener, nos sirve para obtener (recuperar o acceder) el
valor ya asignado a un atributo y utilizarlo para cierto método. Un tipo de dato representa un
conjunto de valores que significa lo mismo, un atributo el cual representa la clase de datos
que se está utilizando, sin embargo, hay algunos tipos que no representan valores en la
aplicación que se ejecutan.
Figura 19. Formato de un getters.
Fuente: Pablo Parra
Setters. Del inglés set, que significa establecer, nos sirve para asignar un valor inicial a un
atributo, pero de forma explícita, además el setter nunca retorna nada (siempre es void) y
solo nos permite dar acceso público a ciertos atributos que se desee que el usuario pueda
modificar.
Figura 20. Formato de una setters con su parámetro.
Fuente: Pablo Parra
Ejemplo práctico
Aquí se realizará un ejemplo práctico de la vida real que nos ayuda a entender mejor los
conceptos getters y setters.
Programa
Realizar una aplicación que dado dos números enteros realice las cuatro operaciones
básicas:
Suma
Resta
Producto
División
En primera instancia se crearán tres clases que se detallan a continuación:
Clase 1: Número
En esta clase se colocará todos los atributos y métodos utilizados en ella.
Como se puede observar ahí, los métodos lo único que hacen es proporcionar un acceso a
unos atributos que son privados y que no serían accesibles desde otras clases si no es por
otros métodos.
Figura 21. Construcción de los atributos y generado sus getters y setters.
Fuente: Pablo Parra
Como se puede observar en la imagen, se creó atributos del objeto, que en este caso solo
tiene uno el cual es el atributo valor, además se colocó los getters y setters de dicho
atributo (clic Izq + insertarcodigo+getters y setters).
Clase 2: Operaciones
Figura 22. Metodoscon con getters y setters.
Fuente: Pablo Parra
En esta clase se realizará los métodos necesarios para la solución del problema, a
continuación se detallará un método para la mejor comprensión.
Figura 23. Implementación de getters y setters.
Fuente: Pablo Parra
En la figura 24 se crea el método Suma con sus dos parámetros de tipo Número; en la
siguiente línea se crea un objeto de tipo Número que a su vez llevará una variable del objeto;
en la línea siguiente se observa la utilización del setters ya que va a modificar el valor de la
variable con la operación suma de dos parámetros de tipo Número utilizando los getters para
cada parámetro, porque lo que se quiere es mostrar el valor de dichos parámetros y realizar
la operación.
Clase 3: Principal
Figura 24. Clase main() para ejecutar en programa. Fuente: Pablo Parra
Esta clase principal llevará a cabo el llamado de las otras clases ya creadas anteriormente
con todos sus atributos y métodos respectivos que le pedirán los datos al usuario.
En la figura 25 se observa la ejecución del programa con todos los datos de la solución del
problema.
Figura 25. Resultados del programa.
Fuente: Pablo Parra
3/7/2020 Tema 5: Lectura y escritura de datos por consola y arreglos primitivos
Lectura y escritura de datos por consola y arreglos

primitivos
3/7/2020 5.1. Lectura y escritura de datos por consola | Tema 5: Lectura y escritura de datos por consola y arreglos primitivos
5.1. Lectura y escritura de datos por consola
5.1. Lectura y escritura de datos por consola
La entrada o lectura de datos en Java es uno de los conceptos más importantes y

fundamentales al momento de interactuar con el usuario de nuestro programa. La entrada de
datos en Java, a diferencia de otros lenguajes, es un poco complicada (no demasiado) y
existen diferentes formas de hacerlo, unas más complejas que otras.
Lectura de entrada por teclado usando la clase Scanner
La clase Scanner de la librería java.util es también muy sencilla para obtener datos de
entrada del usuario, a diferencia de BufferedReader, Scanner sí posee un método para la
lectura de números y para la lectura de texto que nos ayudará a facilitar un poco las cosas.
Veamos:
import java.util.Scanner;
public class EntradaJava2
public static void main(String[] args)
int numero;
Scanner sc = new Scanner(System.in); //Se crea el lector
numero=sc.nextInt();//Se ingresa el número
if(numero%2==0)
System.out.println(“Numero Par“);
else
System.out.println(“Numero Impar“);
Con este código hemos podido realizar la lectura de datos del usuario muy fácil, pues ya
no nos tuvimos que preocupar por el tipo de dato, solo debemos usar el método adecuado
según sea entero, String, float, etc.
System.out.print
Para mostrar un mensaje en consola, escribimos System.out.println(“cadena”); dentro

del paréntesis, además de cadenas, podemos mostrar el valor de una variable, para ello, solo
escribimos el nombre de la variable sin comillas dobles, no importa el tipo de variable.
También se puede incluir una cadena de texto más el valor de una variable, para ello
escribimos la cadena con comillas dobles, un signo + y el nombre de la variable, recuerda
poner un espacio entre una variable y una cadena de texto. Por
ejemplo, System.out.println(“El valor de la variable num es
“+num); o System.out.println(“El precio final es “+precio+” euros”);
Figura 1. Fuente: https://www.discoduroderoer.es/entrada-y-salida-de-datos-en-java/
Figura 2. Fuente: https://es.slideshare.net/cpavella/12-curso-de-poo-en-java-entrada-y-salida-de-datos
Streams de bytes
A través de un stream, podemos enviar y recibir todo tipo de datos. Desde bytes hasta
objetos.
Streams bufferizados
Java provee clases que permiten almacenar temporalmente en memoria los datos que
quieres enviar o leer a través de un stream. El uso de estas clases incrementa el rendimiento
de nuestro programa porque ayuda a minimizar el overhead generado por el uso de recursos
como accesos a disco, actividad de red, etc.
El área de memoria temporal en el que se almacena la información que llega o que se

envía se llama buffer. Un programa puede escribir en un buffer pero físicamente se leerá el
stream cuando el buffer esté vacío.
Las clases que permiten bufferizar son BufferReader, BufferWriter, BufferInputStream y

BufferedOutputStream.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public static void main(String[] args) throws Exception
BufferedReader br=new BufferedReader(new FileReader(arg[0]));
BufferedWriter bw=new BufferedWriter(new FileWriter(arg[1]));
int c=br.read();
while{
bw.write(c);
c=br.read();
bw.close();
br.close();
Cuadro de diálogo
Se podrá ver en cualquier sitio que lo ejecutemos. Antes de escribir la linea de código,
debemos importar el paquete necesario para poder utilizar la clase necesaria para el cuadro
de diálogo.
Antes de la linea public class “nombre_clase”, escribimos import

javax.swing.JOptionPane; después dentro del
main JOptionPane.showMessageDialog(null, “cadena”); por lo de null, no debes
preocuparte, lo entenderás más adelante y en la cadena podemos hacer lo mismo que
hemos mostrado antes.
Resultado
3/7/2020 5.2. Arreglos | Tema 5: Lectura y escritura de datos por consola y arreglos primitivos
5.2. Arreglos
5.2. Arreglos
Un arreglo es un conjunto finito e indexado de elementos, que se referencian por un

identificador común (nombre). La propiedad indexada significa que el elemento primero,
segundo, hasta el n-ésimo de un arreglo pueden ser identificados por su posición ordinal.
De manera formal se define un arreglo de tamaño n de los elementos de tipo A, es un

elemento del espacio n-dimensional del conjunto A, es decir, X es arreglo de tamaño n del
tipo A si y solo si XeAn.
Figura 5. Fuente: https://rogersorianos.files.wordpress.com/2012/11/arreglos_java.png
Ambas definiciones reconocen los siguientes conceptos:
Finita. Todo arreglo tiene un límite, es decir, debe determinarse cuál será el número
máximo de elementos que podrá formar parte del arreglo.
Homogénea. Todos los elementos de un arreglo son del mismo tipo o naturaleza (todos
enteros, todos booleanos, etc.), pero nunca una combinación de distintos tipos.
Ordenada. Se debe determinar cuál es el primer elemento, el segundo, el tercero… y el
n-ésimo elemento.
Características
Los arreglos pueden contener un mínimo de un elemento hasta un máximo de n. Por

tanto, si un arreglo tiene n elementos, la última localidad está dada por n-1.
Tienen un único nombre de variable, que representa todos los elementos.
Contienen un índice, el cual diferencia a cada elemento del arreglo.
Se pueden realizar ciertas operaciones como son: recorridos, ordenaciones y

búsquedas de elementos.
El número total de elementos del arreglo (NTE) es igual al límite superior (LS), menos
límite inferior NTE = LS - LI + 1.
El tipo de índice puede ser cualquier tipo ordinal.
El tipo de los componentes puede ser cualquiera.
Se utilizan [ ] para indicar el índice de un arreglo. Entre los [ ] se debe escribir un valor
ordinal (puede ser una variable, una constante o una expresión que dé como resultado
un valor ordinal).
Si un arreglo tiene n componentes, la última localidad está dada por n-1.
Figura 6. Representación Arreglo en Java. https://www.incanatoit.com/2016/01/arrays-arreglos-vectores-

programacion-csharp-net.html
Los arreglos se clasifican en:
Unidimensionales (Vectores): un solo índice

Bidimensionales (Tablas o Matrices): dos índices
Multidimensionales: más de dos índices
Concepto de multidimensionales
En Java es posible crear arrays con más de una dimensión, pasando de la idea de lista,
vector o matriz de una sola fila a la idea de matriz de m x n elementos, estructuras
tridimensionales, tetradimensionales, etc. La sintaxis será:
Tipo_de_variable[][]…[] Nombre_del_array=new Tipo_de_variable[dimensión1][dimensión2]…

[dimensiónN];
Figura 7. https://i2.wp.com/dcodingames.com/wp-content/uploads/2017/02/matrices1.fw_.png?
resize=1005%2C485
Arreglos primitivos
Los primeros lenguajes de programación no usaban objetos, solo variables. Una variable
podríamos decir que es un espacio de la memoria del ordenador a la que asignamos un
contenido que puede ser un valor numérico (solo números, con su valor de cálculo) o de tipo
carácter o cadena de caracteres (valor alfanumérico que constará solo de texto o de texto
mezclado con números).
Consideraremos que las variables son entidades elementales: un número, un carácter, un

valor verdadero o falso… mientras que los objetos son entidades complejas que pueden estar
formadas por la agrupación de muchas variables y métodos. Pero ambas cosas ocupan lo
mismo: un espacio de memoria (que puede ser más o menos grande).
Tabla 1
Tipos primitivos de datos
RANGO
NOMBRE TIPO OCUPA
APROXIMADO
Tipos primitivos byte Entero 1 byte -128 a 127
(Sin métodos; no son

objetos; no necesitan una
short Entero 2 bytes -32768 a 32767
invocación para ser
creados)
int Entero 4 bytes 2*109
long Entero 8 bytes Muy grande
Decimal
oat 4 bytes Muy grande
simple
Decimal
double 8 bytes Muy grande
doble
Carácter
char 2 bytes ---
simple
Valor true
boolean 1 byte ---
o false
Fuente.https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=419:tipos-de-
Ejemplo
private TipoPrimitivoUObjeto [ ] nombreDelArray; //Declaración: reserva espacio de

memoria
nombreDelArray = new TipoPrimitivoUObjeto [numero]; //Creación del arreglo
private int [ ] miArrayDeNumeros = { 2, -3, 4, 7, -10 }; //Sintaxis ejemplo declarar y crear un

arreglo en una línea
Ejemplo de uso con tipos
private int [ ] cochesHorasDelDia;
cochesHorasDelDia = new int [24]; // Creamos un arreglo de enteros con índices entre el 0 y
el 23
cochesHorasDelDia [9] = 4521; //Ejemplo de asignación
cochesHorasDelDia [23]++ ; //Ejemplo de asignación que equivale a cochesHorasDelDia[23]

+=1;
Declarar el array y crear el objeto en una misma línea
Tipo [ ] nombreDelArray = new Tipo [número];
Ejemplo con ingreso y entrada de salida de datos empleando un bucle for para saber
cu{antos datos ingresados son pares y cuantos impares.
import java.util.Scanner;
public static void main(String[] args)
int numero,contadorPares=0,contadorImpares=0;
int [] numero=new int[5];
Scanner sc = new Scanner(System.in);
System.out.println (“Ingrese 5 números”);
for(int i=0;i<5;i++){
numero[i]=sc.nextInt();
if(numero[i]%2==0)
contadorPares++;
else
contadorImpares++;
System.out.println (“Existen ”+contadorPares+” números pares y ”+contadorImpares+”

números impares ”);
}
Ejemplo de ordenamiento de un arreglo
Figura 8. https://www.discoduroderoer.es/formas-de-ordenar-un-array-en-java/
3/7/2020 Tema 6: Manejo de excepciones
Manejo de excepciones
3/7/2020 6.1. Definición | Tema 6: Manejo de excepciones
6.1. Definición
6.1. Definición
Una excepción es cualquier incidente que no permite la terminación correcta de un

programa. En la mayoría de los casos se tratará de impedir la terminación de los programas
manejando las excepciones o lanzándolas hacia algún punto del programa que pueda
manejar dicha excepción.
La excepción también es una forma de hacer que la aplicación continúe la ejecución si se

produce un error.
Figura 1. Manejo de excepciones.
Fuente: https://magicplsql.blogspot.com/2016/10/manejo-de-excepciones.html
Un ejemplo es cuando se realiza un programa que permita dividir dos números. Tengamos
en cuenta que la división para cero nos genera un error y es ahí donde se utiliza el manejo de
errores. Vamos a restringir que cuando se realice la división para cero se genere un mensaje
diciendo “Error: No se puede dividir para cero”.
Fuente: http://www.buscaminegocio.com/cursos-de-java/capturar-excepciones-java.html
Ventajas de usar una excepción
Se usa para detectar situaciones inusuales en la ejecución.

Se separa el código que controla los errores.
Las utilidades de las excepciones ayudan a que el programa sea muy concreto y
preciso.
Fuente: https://www.redeszone.net/2018/06/15/anadir-excepciones-windows-defender-windows-10/
Ejemplos
No hay memoria disponible para asignar.

Acceso a un elemento de un array fuera de rango.
Leer por teclado un dato de un tipo distinto al esperado.
Error al abrir un fichero.
División por cero.
Problemas de hardware.
Si la excepción no se trata, el manejador de excepciones realiza lo siguiente:
Muestra la descripción de la excepción.

Muestra la traza de la pila de llamadas.
Provoca el final del programa.
Fuente: http://www.elguille.info/colabora/ NET2005/Percynet_ControlExceptionsNet.html
Jerarquía de clases
Fuente: Pablo Parra
Jerarquía de clases
La clase java.lang. Throwable describe cualquier clase que pueda ser lanzada como
excepción.
Existen dos tipos de clases Throwable que son:
lang.Error. Representa errores de compilación y errores del sistema.

lang.Exception. Representa las excepciones generadas por la aplicación.
Existe un tipo especial de clases Exception que es:
lang.RuntimeException. Representa excepciones generadas por la aplicación cuya

gestión no es obligatoria.
Fuente: Pablo Parra
3/7/2020 6.2. Excepciones y errores | Tema 6: Manejo de excepciones
6.2. Excepciones y errores
6.2. Excepciones y errores
Según la página progra.usm.cl:
No siempre los programas que escribiremos están correctos. Existen muchos tipos de
errores que pueden estar presentes en un programa.
No todos los errores pueden ser detectados por el computador. Los errores más comunes
son:
Error de sintaxis
Un error de sintaxis ocurre cuando el programa no cumple las reglas del lenguaje. Cuando
ocurre este error, significa que el programa está mal escrito. El nombre del error es
SyntaxError.
Los errores de sintaxis siempre ocurren antes de que el programa sea ejecutado. Es decir,
un programa mal escrito no logra ejecutar ninguna instrucción. Por lo mismo, el error de
sintaxis no es una excepción.
Figura 7. Manejo de errores y excepciones.
Fuente: https://slideplayer.es/slide/166428/
Error de nombre
Un error de nombre ocurre al usar una variable que no ha sido creada con anterioridad.
Figura 8. Mensajes de error.
Fuente: Pablo Parra
Error de tipo
En general, todas las operaciones en un programa pueden ser aplicadas sobre valores de
tipos bien específicos. Un error de tipo ocurre al aplicar una operación sobre operandos de
tipo incorrecto.
Figura 9. Excel por módulos: Mensajes de error en cálculos.
Fuente: http://minubeinformatica.com/cursos/excel-por-modulos/mensajes-de-error-en-calculos
Error de valor
El error de valor ocurre cuando los operandos son del tipo correcto, pero la operación no
tiene sentido para ese valor.
Figura 10. Tipos de errores en Excel.
Fuente: https://www.gerencie.com/tipos-de-errores-en-excel.html
Error de división por cero
El error de división por cero ocurre al intentar dividir por cero.
Figura 11. Evitar errores de división entre cero en Excel.
Fuente: https://exceltotal.com/evitar-errores-de-division-entre-cero-en-excel/
Error de desborde
El error de desborde ocurre cuando el resultado de una operación es tan grande que el
computador no puede representarlo internamente.
Figura 12. Error 6 desbordamiento en visual basic.
Fuente: http://www.forosdelweb.com/f69/error-6-desbordamiento-visual-basic-954306/
3/7/2020 6.3. Clases de excepciones | Tema 6: Manejo de excepciones
6.3. Clases de excepciones
6.3. Clases de excepciones
Existen varios tipos fundamentales de excepciones que son los siguientes:
1. Error
Excepciones que indican problemas muy graves, que suelen ser no recuperables y no
deben casi nunca ser capturadas. Este tipo de error tiene sus propias derivadas que son:
OutOfMemoryError. El lector ha agotado la memoria.

InternalError. Error interno en tiempo de ejecución.
UnknownError. Grave error desconocido.
VerifyError. Se ha producido un error de verificación al cargar una clase.
2. IOException
Excepciones no definitivas, pero que se detectan fuera del tiempo de ejecución. Este tipo
de error tiene sus propias derivadas que son:
FileNotFoundException. Excepción cuando no se encuentra un archivo seleccionado.

MalFormedURLException. Excepción que se genera cuando una ubicación de un
archivo /página URL es incorrecta o está mal redactada.
3. RuntimeException
Excepciones que se dan durante la ejecución del programa. Este tipo de error tiene sus
propias derivadas que son:
NullPointerException. Se ha usado una referencia null para acceder a un campo.

ArithmeticException. Error de cálculo (como división por cero...).
ClassCastException. Intento de conversión inválida.
NegativeArraySizeException. Intento de creación de un vector de tamaño negativo.
Excepciones verificadas y no verificadas
- Excepciones verificadas
Su tratamiento es obligatorio y el compilador así lo chequea.
3/7/2020 6.3. Clases de excepciones | Tema 6: Manejo de excepciones
Todas aquellas clases hijas de lang.Exception que no lo sean de

java.lang.RuntimeException.
Excepciones no verificadas
Su tratamiento no es obligatorio y el compilador no lo chequea.

Todas aquellas clases hijas de lang.Error o de java.lang.RuntimeException.
3/7/2020 6.4. Lanzamiento de excepciones | Tema 6: Manejo de excepciones
6.4. Lanzamiento de excepciones
6.4. Lanzamiento de excepciones
La cláusula Throws
Barnes, D. dice: El primer requerimiento del compilador es que un método que lanza una
excepción comprobada debe declarar que lo hace mediante una cláusula throws que se
agrega en su encabezado. Por ejemplo, un método que lanza una IOException comprobada
del paquete java.io debe tener el siguiente encabezado:
Fuente: Barnes, D (2007): Programación orientada a objetos con Java. Madrid: Pearson Educación, S. A.
Si bien se permite el uso de la cláusula throws para las excepciones no comprobadas, el

compilador no lo requiere. Recomendamos que se use una cláusula throws solamente para
enumerar las excepciones comprobadas que lanza un método.
Parte del tratamiento de una excepción puede incluir la propagación de la misma para que
también la traten los métodos llamantes. También puede suceder que queramos que nuestro
código lance una excepción en una situación determinada. En ambos casos es necesario
decir que el método puede lanzar una excepción.
Una función miembro que lanza una excepción tiene la declaración habitual que cualquier
otro método, pero se le añade a continuación la palabra reservada throws seguida de la
excepción o excepciones que pueden lanzar.
Throw
La sentencia throw se utiliza para lanzar explícitamente una excepción. En primer lugar, se
debe obtener un descriptor de un objeto Throwable, bien mediante un parámetro en una
cláusula catch o se puede crear utilizando el operador new. La forma general de la
sentencia throw es:
throw ObjetoThrowable;
El flujo de la ejecución se detiene inmediatamente después de la sentencia throw y nunca

se llega a la sentencia siguiente. Se inspecciona el bloque try que la engloba más cercano,
para ver si tiene la cláusula catch cuyo tipo coincide con el del objeto o instancia Thorwable.
Si se encuentra, el control se transfiere a esa sentencia, si no se inspecciona el siguiente
bloque try que la engloba, y así sucesivamente, hasta que el gestor de excepciones más
externo detiene el programa y saca por pantalla el trazado de lo que hay en la pila hasta que
se alcanzó la sentencia throw.
En el programa siguiente, java905.java, se demuestra cómo se hace el lanzamiento de una

nueva instancia de una excepción y también cómo dentro del gestor se vuelve a lanzar la
misma excepción al gestor más externo.
Fuente: http://dis.um.es/~bmoros/Tutorial/parte9/cap9-3.html
La sentencia Try
El try viene del inglés ‘Tratar’ y es donde se encapsula el código donde posiblemente puede
llamarse una excepción por ejecuciones fuera del flujo esperado. Si una cierta cantidad de
código está fuera de un TRY, este código está libre de que llame una excepción.
Según Barnes, D., el segundo requerimiento es que el invocador de un método que lanza
una excepción comprobada debe proveer un tratamiento para dicha excepción. Esto
generalmente implica escribir un manejador de excepción bajo la forma de una sentencia try.
Sintaxis de la sentencia Try
La sentencia Catch
El Catch es el lugar donde se listan las excepciones que se van a ‘tratar’ (try) junto con las
órdenes de cada excepción. Las excepciones se listan de la más específica a las más
generales.
Sintaxis de la sentencia Catch
Bloque Try – Catch
Fuente: https://www.fdi.ucm.es/profesor/jpavon/poo/2.12.Excepciones.pdf
Fuente: Pablo Parra
En esencia, un bloque try es el contexto para decir cuáles son los manejadores que se
invocan cuando se levanta una excepción. El orden en que se definen los manejadores
determina el orden en que se prueban los mismos para una excepción levantada coincidente
en tipos. De un modo más detallado, el bloque try se asocia siempre con catch.
Múltiples catch
Se pueden utilizar múltiples bloques de sentencias catch en el mismo bloque de sentencias

try. Cada bloque gestionará un tipo de excepción. El orden en el que se colocan las
sentencias catch es relevante.
Los bloques catch de excepciones genéricas deberían situarse después de los de

excepciones más particulares. La JVM busca en orden descendente un bloque catch que sea
capaz de controlar la excepción producida, una vez que lo encuentra no sigue buscando.
Por ejemplo, si se incluyen dos bloques catch, uno que capture Exception y otro que
capture NullPointerException, este último deberá colocarse el primero porque de lo contrario
nunca podría llegar a ejecutarse.
La sentencia Finally:
El Finally viene del inglés ‘Finalmente’, es cuando un código fue tratado (try) y captado las
excepciones (catch), con FINALLY va a hacer una serie de instrucciones independientes si se
llama una excepción o no. Usualmente se usa esta cláusula para finalizar conexiones o cerrar
archivos.
Según Barnes, D., una sentencia try puede incluir un tercer componente que es
opcional. La cláusula finally se proporciona para sentencias que se deben ejecutar
cuando se lanza una excepción desde sentencias protegidas o desde sentencias no
protegidas. Si el control alcanza el final del bloque try entonces se saltea el bloque catch
y se ejecuta la cláusula finally. Recíprocamente, si se lanza una excepción a partir del
bloque try, entonces se ejecuta el bloque catch apropiado y luego se sigue con la
ejecución de la cláusula finally.
3/7/2020 6.5. Métodos para el control de excepciones | Tema 6: Manejo de excepciones
6.5. Métodos para el control de excepciones
6.5. Métodos para el control de excepciones
Fuente: Pablo Parra
Public void printStackTrace();
Imprime por la salida la pila (stack) de llamadas incluyendo los números de línea y ficheros
donde se ha producido la excepción.
Public String getMessage();
Devuelve una cadena de caracteres con la descripción de la excepción.
Public String toString();
Devuelve la representación en cadena de caracteres de la excepción.
3/7/2020 6.6. Creación de excepciones personalizadas | Tema 6: Manejo de excepciones
6.6. Creación de excepciones personalizadas
6.6. Creación de excepciones personalizadas
Antes de empezar a crear excepciones tenemos que saber los términos aprendidos
anteriormente.
Palabras
Descripción
clave
Clase de Java que contiene información sobre una

Exception
excepción o un error.
Mecanismo para emitir y recoger excepciones para

Thows
así poder tratar un problema.
Try Bloque que puede causar una excepción.
Bloque que permite recuperarse de una excepción o

Catch
capturarla.
Bloque que será ejecutado siempre, exista o no una

finally excepción. Asegura que se ejecuten instrucciones
aunque ocurra o no un problema.
Siempre es posible lanzar alguna excepción de las ya definidas en Java (IOException, por
ejemplo). También se pueden definir nuevas excepciones creando clases derivadas de las
clases Error o Exception.
Para la creación de las excepciones utilizamos cualquier software que permita realizar la
programación orientada a objetos.
Veamos un ejemplo.
La sentencia throw (lanzar) se usa en los métodos para lanzar una excepción que será
revisada por el compilador
throw new NombreClasedeExcepcion()
Un método que llama a otro que lanza una excepción, se debe declarar de la siguiente
forma:
Modificador tipodatoretorno nombreMetodo (..) throws NombreClasedeExcepcion
El método que lanza una excepción tiene la declaración habitual que cualquier otro
método, pero se le añade a continuación la palabra reservada throws seguido de la
excepción o excepciones que puede lanzar.
Fuente: Pablo Parra
Ejemplo
Realizar un programa que permita adivinar la raíz cuadrada de un número, ingresado por
consola donde el usuario digite el número de la raíz que él considere que es el resultado de
la misma, el programa le devolverá más o menos el valor que debe volver a ingresar, el
ejercicio debe manejar excepciones al momento de ingresar números negativos e ingreso de
caracteres al momento de ingresar los valores.
Solución
Creamos la clase que maneje las excepciones de número negativo, y también para
controlar que no se ingrese caracteres.
Creamos la clase para instanciar el número que necesitamos encontrar la raíz cuadrada.
Figura 22. Clase manejo excepciones.
Fuente: Pablo Parra
Comenzamos a crear una clase “número”.
Figura 23. Clase número.
Fuente: Pablo Parra
Luego comenzamos a crear la clase “juego", donde va todo lo que queremos hacer.
28
Figura 24. Clase Juego.
Fuente: Pablo Pärra
Finalmente realizamos la clase “Raíz” donde va a ir el procedimiento de la raíz cuadrada
Fuente: Pablo Parra
3/7/2020 Tema 7: Arreglos estáticos y dinámicos
Arreglos estáticos y dinámicos
3/7/2020 7.1. Introducción | Tema 7: Arreglos estáticos y dinámicos
7.1. Introducción
7.1. Introducción
Algunas clases que hemos citado, como ArrayList o LinkedList, se denominan colecciones
de tamaño flexible porque permiten modificar dinámicamente el número de ítems que
contienen, es decir, ampliarlo o reducirlo. A veces nos referiremos a estas colecciones como
arrays dinámicos porque son similares a los arrays dinámicos que se emplean en otros
lenguajes de programación.
Los arrays dinámicos son muy potentes porque permiten crear colecciones de tamaño
variable que podemos agrandar o empequeñecer en función de nuestras necesidades.
Sin embargo, cuando se conoce el número de elementos en una colección y este va a
ser invariable (por ejemplo, los doce meses del año), será más eficiente utilizar una
colección de tamaño fijo a la que denominamos array estático, arreglo estático,
formación o vector. Si utilizamos el término array o arreglo, a secas, entenderemos que
hacemos alusión a un array estático.
El uso de arrays estáticos tiene ventajas e inconvenientes.
Tabla 1
Tipos de arrays de objetos
Ventajas Inconvenientes
- Acceso y operación con elementos más

eficientes. - Rigidez. No se pueden redimensionar
(aunque sí copiar a otros arrays
- Permiten almacenar tanto objetos como estáticos de mayor tamaño).
tipos primitivos directamente.
Fuente. https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=635:arrays-o-
arreglos-java-ejemplos-de-objetos-y-tipos-primitivos-length-tipos-de-colecciones-
cu00669b&catid=68&Itemid=188
3/7/2020 7.1. Introducción | Tema 7: Arreglos estáticos y dinámicos
3/7/2020 7.2. Arreglos estáticos | Tema 7: Arreglos estáticos y dinámicos
7.2. Arreglos estáticos
7.2. Arreglos estáticos
Un arreglo estático es un conjunto de datos homogéneos agrupados, pero con una

cantidad fija de elementos en su composición que dependiendo de la necesidad del
programador será fijado.
¿Cómo utilizar un arreglo estático?
Se sigue la siguiente sintaxis:
Paso 1
Figura 1. http://www.cs.umss.edu.bo/doc/material/mat_gral_33/ArreglosEstaticos.pdf
Ejemplo: int [] numeros;
Creación de arreglos
Los arreglos ocupan espacio en memoria. En Java se usa el operador new para asignar
espacio de almacenamiento al número de elementos requerido por cada arreglo.
Paso 2
Figura 2. http://www.cs.umss.edu.bo/doc/material/mat_gral_33/ArreglosEstaticos.pdf
Ejemplo: numeros = new int [50];
Inicialización de arreglos
Una vez creado el arreglo, se puede proceder a llenar con elementos dispuestos en cada
posición. Ejemplo:
for(int j =0; j<50; j++){
numeros[j] = j++;
El arreglo en Java empieza en la posición 0, es decir, el primer elemento del arreglo ocupa
la posición de 0, de ahí que el for comienza en 0.
Arreglos de objetos
Figura 3. https://jagonzalez.org/wp-content/uploads/2013/04/Diferencia-Arreglo-de-Objetos-y-Arreglo-de-datos-
Primitivos.png
Tabla 2
Tipos de arrays de objetos
Tipos objeto String (cadenas de texto)

Tipos de la biblioteca
(Con métodos, estándar de Java Muchos otros (p.ej. Scanner,
necesitan una TreeSet, ArrayList…)
invocación para
ser creados).
Tipos definidos por el Cualquiera que se nos ocurra, por
programador / usuario ejemplo Taxi, Autobus, Tranvia
arrays Serie de elementos o formación

tipo vector o matriz. Lo

consideraremos un objeto especial
que carece de métodos.
Byte
Short
Integer
Tipos envoltorio o Long

wrapper (Equivalentes a
los tipos primitivos pero
como objetos). Float
Double
Character
Boolean
Fuente. https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=419:tipos-de-
Ejemplo de uso con tipos objeto
private Persona [ ] Grupo3A;
Grupo3A = new Persona [50]; //Creamos un arreglo de objetos Persona con índices entre el
0 y el 49
private String [ ] nombre;
nombre = new String [200];

nombre [37] = “Juan Antonio”;
3/7/2020 7.3. Arreglos dinámicos | Tema 7: Arreglos estáticos y dinámicos
7.3. Arreglos dinámicos
7.3. Arreglos dinámicos
Listas
Hay varias implementaciones de List, siendo ArrayList la que debería ser la elección por
defecto, en caso de no tener que utilizar las características que proporcionan las demás
implementaciones.
List (interfaz). La ordenación es la característica más importante de una lista,

asegurando que los elementos siempre se mantendrán en una secuencia concreta. La
lista incorpora una serie de métodos a la colección que permiten la inserción y borrar de
elementos en medio de la lista. Además, en la lista enlazada se puede generar un
listIterator para moverse a través de las listas en ambas direcciones.
ArrayList. Es una lista volcada en un Array. Se debe utilizar en lugar de vector como
almacenamiento de objetos de propósito general. Permite un acceso aleatorio muy
rápido a los elementos, pero realiza con bastante lentitud las operaciones de insertado
y borrado de elementos en medio de la lista. Se puede utilizar un listIterator para
moverse hacia atrás y hacia delante en la lista, pero no para insertar y eliminar
elementos.
LinkedList. Proporciona un óptimo acceso secuencial, permitiendo inserciones y
borrado de elementos de en medio de la lista muy rápidas. Sin embargo, es bastante
lento el acceso aleatorio, en comparación con la ArrayList. Dispone, además, de los
métodos addLast(), getFirst(), getLast(), removeFirst() y removeLast(), que no están
definidos en ningún interfaz o clase base y que permiten utilizar la lista enlazada como
una pila, una cola o una cola doble.
Map
La interface Map (java.io.Map) en Java nos permite representar una estructura de datos
para almacenar pares "clave/valor"; de tal manera que para una clave solamente tenemos un
valor.
HashMap. Los elementos que inserta en el map no tendrán un orden específico. No

aceptan claves duplicadas ni valores nulos.
TreeMap. El mapa lo ordena de forma "natural". Por ejemplo, si la clave son valores
enteros (como luego veremos), los ordena de menos a mayor.
3/7/2020 7.3. Arreglos dinámicos | Tema 7: Arreglos estáticos y dinámicos
LinkedHashMap. Inserta en el Map los elementos en el orden en el que se van

insertando; es decir, que no tiene una ordenación de los elementos como tal, por lo que
esta clase realiza las búsquedas de los elementos de forma más lenta que las demás
clases.
Iterator
La interface Iterator también pertenece como las anteriores al framework Collections de

Java. Esta interface nos permite iterar sobre una colección de elementos. Para ello
hemos de implementar sus métodos, que son los siguientes: boolean hasNext(), E
next(), void remove().
La interface iterable está incluida en el api de Java, en concreto en el paquete java.lang.
Es una interfaz de uso habitual al igual que el caso de las interfaces Cloneable y
Comparable que ya hemos explicado. Implementar Iterable tan solo obliga a
sobreescribir un método que es iterator(). Este método debe devolver un objeto de tipo
Iterator.
3/7/2020 7.3.1. Arraylist | Tema 7: Arreglos estáticos y dinámicos
7.3.1. Arraylist
7.3.1. Arraylist
De forma general, un ArrayList en Java se crea de la siguiente manera:
ArrayList nombreArray = new ArrayList(); à Esta instrucción crea el

ArrayList nombreArray vacío. Un arrayList declarado así puede contener objetos de cualquier
tipo.
Por ejemplo:
ArrayList a = new ArrayList();
a.add("Lenguaje");
a.add(3);
a.add('a');
a.add(23.5);
Los elementos del arrayList a son:
“Lenguaje” 2 ‘a’ 23.5
Es decir, un ArrayList puede contener objetos de tipos distintos. En este ejemplo, el primer
objeto que se añade es el String “Lenguaje”. El resto no son objetos. Son datos de tipos
básicos pero el compilador los convierte automáticamente en objetos de su clase
envolvente (clase contenedora o wrapper) antes de añadirlos al array.
Un array al que se le pueden asignar elementos distintos puede tener alguna complicación
a la hora de trabajar con él. Por eso, una alternativa a esta declaración es indicar el tipo de
objetos que contiene. En este caso, el array solo podrá contener objetos de ese tipo.
De forma general:
ArrayList nombreArray = new ArrayList();
Tipo debe ser una clase. Indica el tipo de objetos que contendrá el array.
No se pueden usar tipos primitivos. Para un tipo primitivo se debe utilizar su clase
envolvente.
Características propias
Similar a un arreglo.
Provee métodos para manejar los datos.
Su tamaño crece dinámicamente.
Más lento en ejecución que un arreglo, dado el proceso dinámico de administración de
la memoria del compilador.
Se debe declarar una librería especializada para poder utilizarlo: java.util.ArrayList
Por ejemplo:
ArrayList numeros = new ArrayList(); à Crea el array números de enteros.
Métodos de Arraylist
Algunos métodos que proporciona ArrayList son:
Tabla 3
Métodos del Arraylist
Método Descripción
size() Devuelve el número de elementos (int).
add(X) Añade el objeto X al final. Devuelve true.
add(posición, X) Inserta el objeto X en la posición indicada.
get(posicion) Devuelve el elemento que está en la posición indicada.
Elimina el elemento que se encuentra en la posición

remove(posicion)
indicada. Devuelve el elemento eliminado.
remove(X) Elimina la primera ocurrencia del objeto X. Devuelve true si el

elemento está en la lista.
clear() Elimina todos los elementos.
Sustituye el elemento que se encuentra en la posición

set(posición, X)
indicada por el objeto X. Devuelve el elemento sustituido.
Comprueba si la colección contiene al objeto X. Devuelve

contains(X)
true o false.
indexOf(X) Devuelve la posición del objeto X. Si no existe devuelve -1.
Fuente: http://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html
Figura 4. https://medium.com/@Emmanuel.A/data-structures-arraylist-239a5b39cd7e
Recorrer un Arraylist
Podemos recorrerlo de forma clásica con un bucle for:
for(int i = 0;i<array.size();i++){< strong=""></array.size();i++){<>
System.out.println(array.get(i));
Con un bucle foreach:
Si suponemos el array de enteros llamado numeros:
for(Integer i: numeros){
System.out.println(i);
Si el array contiene objetos de tipos distintos o desconocemos el tipo:
for(Object o: nombreArray){
System.out.println(o);
Utilizando un objeto Iterator.

(http://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html)
La ventaja de utilizar un Iterador es que no necesitamos indicar el tipo de objetos que

contiene el array.
Iterator tiene como métodos:
hasNext. Devuelve true si hay más elementos en el array.
next. Devuelve el siguiente objeto contenido en el array.
Ejemplo
ArrayList numeros = new ArrayList();
…..
//se insertan elementos
.....
Iterator it = numeros.iterator(); //se crea el iterador it para el array numeros
while(it.hasNext()) //mientras queden elementos
System.out.println(it.next()); //se obtienen y se muestran
Copiar un Arraylist
El nombre de un ArrayList contiene la referencia al ArrayList, es decir, la dirección de

memoria donde se encuentra el ArrayList, igual que sucede con los arrays estáticos.
Si disponemos de un ArrayList de enteros llamado ventas:
Figura 5. http://puntocomnoesunlenguaje.blogspot.com/2012/12/arraylist-en-java.html
La instrucción:
ArrayList ventas1 = ventas;
No copia el array ventas en el nuevo array ventas1 sino que crea un alias:
De esta forma tenemos dos maneras de acceder al mismo ArrayList:
- mediante la referencia ventas
- mediante la referencia ventas1.
Para hacer una copia podemos hacerlo de forma manual, elemento a elemento, o se
puede pasar la referencia del ArrayList original al constructor del nuevo:
ArrayList ventas1 = new ArrayList(ventas);
3/7/2020 7.3.2. Hashmaps | Tema 7: Arreglos estáticos y dinámicos
7.3.2. Hashmaps
7.3.2. Hashmaps
Un HashMap es una colección de objetos, (como los Arrays), pero estos no tienen orden.
¿De qué se trata?
Cada objeto se identifica mediante algún identificador apropiado, por ejemplo un "uuid”.
El nombre HASH, hace referencia a una técnica de organización de archivos llamada

hashing o "dispersion" en la cual se almacenan registro en una dirección del archivo que es
generada por una función que se aplica sobre la llave del registro.
El concepto para Java es parecido, el Hashmap posee un espacio de memoria y cuando

se guarda un objeto allí, se determina su dirección aplicándole una función a la llave que le
indicamos.
Por ejemplo:
HashMap contenedor = new HashMap();

Object objeto = new Object();
String llave = new String("identificador de objeto"); contendor.add(llave,objeto);
La biblioteca estándar de Java tiene dos tipos diferentes de objetos Map (que es una
interfaz con cierta funcionalidad): HashMap y TreeMap. Ambos tienen la misma interfaz (dado
que implementan Map), pero difieren claramente en la eficiencia.
Si se observa lo que hace un get(), parecerá bastante lento hacerlo buscando a través de
la clave, por ejemplo de un ArrayList. Es aquí donde un HashMap acelera considerablemente
las cosas. En vez de hacer una búsqueda lenta de la clave, usa un valor especial
denominado "código de tipo hash". Esta es una manera de tomar cierta información del objeto
en cuestión y convertirlo en un entero "relativamente único" para ese objeto.
Todos los objetos de Java pueden producir un código de tipo hash y HashCode() es un
método de la clase raíz Object. Un HashMap toma un hashCode() del objeto y lo utiliza para
localizar rápidamente la clave. Esto redunda en una mejora dramática de rendimiento.
Figura 8. https://guru99.es/working-with-hashmaps/
Ejemplo
Figura 9. Ejemplo HashMap
¿Cuándo usar ArrayList y cuando usar HashMap?
Ambas estructuras de datos almacenan Objects y por defecto en Java todas las clases
heredan de Object. Es decir, puedes guardar cualquier objeto en cada una de ellas.
El asunto es ¿cuándo emplear una u otra?
Por ejemplo, usas un ArrayList cuando necesitas acceder al n-avo elemento. Haz cuenta
de que un ArrayList es una columna de objetos en línea y que un HashMap es algo así como
una sala llena de objetos dispersos a los que llamas por su nombre (clave-valor).
En lo personal suelo usar más un TreeMap para almacenar miles de objetos, pues el
tiempo de recorrido es mucho menor al de un ArrayList, las listas las utilizo para manejar no
más de 500 elementos.
De más está decir que esas no son las únicas estructuras de datos que existen en Java.
Tienes además Vector, LinkedList, TreeSet, TreeMap... etc, y cada una de ellas tiene
características que las diferencian del resto y que por ende son más óptimas que cualquier
otra en cada caso.
20/8/2020 Tema 8: Relaciones entre clases
Obra publicada con Licencia Creative Commons Reconocimiento No comercial Compartir

igual 4.0
20/8/2020 8.1. Asociación | Tema 8: Relaciones entre clases
8.1. Asociación
Es una conexión entre clases, que implica la existencia de una relación estructural
entre objetos de esas clases.
Diremos que dos o más clases tienen una relación de asociación cuando una de
ellas tenga que requerir o utilizar alguno de los otros atributos o métodos de las otras
clases.
La asociación expresa una relación (unidireccional o bidireccional) entre las

instancias, a partir de las clases conectadas.
No requieren que creemos un objeto nuevo a partir de otros objetos, sino únicamente
que los objetos interactúen entre sí. La creación o desaparición de uno de ellos
implica únicamente la creación o destrucción de la relación entre ellos y nunca la
creación o destrucción del otro.
Un ejemplo de relación de asociación es la relación “perfil – foto”. Podemos definir

una clase “Perfil” y una clase “Foto” que nos permitan representar esta relación.
Figura 1. Asociación entre clases.
Fuente: Pablo Parra
Implementación del ejemplo anterior en Java
Creación de la clase Foto
Figura 2. Implementación de la clase. Foto en Java.
Fuente: Pablo Parra
Creación de la clase Perfil
Figura 3. Implementación de la clase Perfil en Java.
Fuente: Pablo Parra
Creación de la clase principal
Figura 4. Implementación de la asociación en la clase principal.
Fuente: Pablo Parra
El gráfico anterior UML representa una relación de asociación. Las relaciones de

asociación se representan en UML como una línea que une las dos clases siendo
relacionadas.
En el ejemplo, además vemos que esta relación se ha declarado de multiplicidad

indefinida en ambos extremos, lo que quiere decir que una persona puede tener en su
perfil una o más fotos.
Figura 5. Multiplicidad de una asociación.
Fuente: http://www.ciberaula.com/articulo/uml

igual 4.0
20/8/2020 8.2. Agregación | Tema 8: Relaciones entre clases
8.2. Agregación
Es una relación que se derivó de la asociación, por ser igualmente estructural, es

decir, que contiene un atributo que en todos los casos será una colección, es decir, un
Array, Vector, entre otros, además indica que una clase es parte de otra clase.
Los componentes pueden ser compartidos por varios compuestos (de la misma
asociación de agregación o de varias asociaciones de agregación distintas). La
destrucción del compuesto no conlleva la destrucción de los componentes.
La agregación se representa en UML mediante un diamante de color blanco colocado

en el extremo en el que está la clase que representa el “todo”.
Veamos un ejemplo de agregación.
Figura 6. Ejemplo de agregación.
Fuente: Pablo Parra
Tenemos una clase Aula.

Tenemos una clase Alumnos.
Tenemos una clase Escritorios.
Un aula agrupa a varios.
Creación de la clase DatosP, que almacenará los datos personales de cada persona.
Figura 7. Implementación de la clase DatosP en Java.
Fuente: Pablo Parra
Creación de la clase Alumno
Figura 8. Implementación de la clase Cliente en Java.
Fuente: Pablo Parra
Creación de la clase Escritorio
Figura 9. Implementación de la clase Escritorio en Java.
Fuente: Pablo Parra
Creación de la clase Aula
Figura 10. Implementación de la clase Aula en Java.
Fuente: Pablo Parra
Figura 11. Implementación de la clase en la clase principal en Java.
Fuente: Pablo Parra

igual 4.0
20/8/2020 8.3. Composición | Tema 8: Relaciones entre clases
8.3. Composición
Es una relación estructural, pero se le suma un método de destrucción de los objetos.
Composición es una forma fuerte de composición donde la vida de la clase contenida

debe coincidir con la vida de la clase contenedor. Los componentes constituyen una
parte del objeto compuesto. De esta forma, los componentes no pueden ser
compartidos por varios objetos compuestos. La supresión del objeto compuesto
conlleva la supresión de los componentes.
La programación es la misma para las composiciones y las agregaciones, la

diferencia es meramente conceptual entre una y otras.
El símbolo de composición es un diamante de color negro colocado en el extremo en

el que está la clase que representa el “todo” (Compuesto).
Veamos un ejemplo de composición.
Figura 12. Ejemplo de Composición en representación UML.
Fuente: Pablo Parra
Tenemos una clase Equipo.

Un objeto Equipo está a su vez compuesto por uno o varios objetos del tipo
Jugador.
El tiempo de vida de los objetos Jugador depende del tiempo de vida de Equipo,
ya que si no existe un Equipo no pueden existir sus jugadores.
Creación de la clase Carrera
Figura 13. Implementación de la clase Carrera en Java.
Fuente: Pablo Parra
Creación de la clase Universidad
Figura 14. Implementación de la clase Universidad en Java.
Fuente: Pablo Parra
Figura 15. Implementación de la clase Universidad en Java.
Fuente: Pablo Parra
Tabla 4
Diferencias entre agregación y composición
Características Agregación Composición
Varias asociaciones comparten

Sí No
los componentes.
Destrucción de los componentes

No Sí
al destruir el compuesto.
Cardinalidad a nivel compuesto Cualquiera 0..1 o 1
Rombo
Representación Rombo negro
transparente
Fuente:https://www.seas.es/blog/informatica/agregacion-vs-composicion-en-diagramas-de-clases-uml/

igual 4.0
20/8/2020 8.4. Modelado e implementación | Tema 8: Relaciones entre clases
8.4. Modelado e implementación
Asociación
Para entender la implementación en la agregación, como se ha dicho antes, hay que

tomar en cuenta que esta relación no es de contención. Tomando el ejemplo antes
mencionado, un aula no contiene a estudiantes.
Para comprender de una mejor manera cómo se comporta o trabaja esta clase, es
necesario darle sentido a la frase que va a contener a la agregación “Usa un”.
Un cliente usa tarjeta de crédito.

Un estudiante usa libros.
Código
Figura 16. Ejemplo Implementación de Asociación.
Fuente: Pablo Parra
Composición
En caso contrario, la composición es un tipo de relación dependiente en donde un

objeto más complejo es conformado por objetos más pequeños. En esta situación, la
frase “Tiene un”, debe tener sentido.
Una biblioteca tiene libros.

La portátil tiene un teclado.
20/8/2020 8.4. Modelado e implementación | Tema 8: Relaciones entre clases
Representaremos la relación: La portátil tiene un teclado.
Código
Figura 17. Ejemplo implementación de Composición.
Fuente: Pablo Parra

igual 4.0
20/8/2020 8.5. Dependencia: implementación | Tema 8: Relaciones entre clases
8.5. Dependencia: implementación
Es la relación menos importante, debido a que simplemente refleja que la

implementación de una clase depende de otra.
Es una relación de uso entre dos clases (una usa a la otra). Esta relación es las más
básica entre clases y comparada con los demás tipos de relación, la más débil.
Representación UML
Se representa con una flecha discontinua que parte desde una clase y apunta a otra.
El sentido de la flecha nos indica quién usa a quién.
Una clase A usa una clase B cuando no contiene atributos de la clase B pero, o bien
utiliza alguna instancia de la clase B como parámetro en alguno de sus métodos para
realizar una operación, o bien accede a sus atributos (clases con métodos amigos).
Figura 18. Dependencia de clases.
Fuente: Pablo Parra
Del diagrama anterior podemos observar que:
La Persona usa una Cédula.

La Persona depende de la Cédula.
Dada la dependencia, todo cambio en la Cédula podrá afectar a la Persona.
En la práctica este tipo de relación se interpreta como que la Persona hace uso de
la Cédula ya sea instanciándola directamente, o bien, recibiéndola como parámetro de
entrada en uno de sus métodos.
Modelamiento e implementación
Supongamos lo siguiente:
1. Tenemos una clase.

2. Tenemos una clase Cédula con sus respectivos atributos.
3. La clase Persona necesita de su documento cédula.
Para esto generamos una relación de dependencia.
Traduciendo a código: (Java)
Clase Cedula
Figura 19. Implementación de la clase Cedula.
Fuente: Pablo Parra
Clase Persona
Figura 20. Implementación de la clase Persona.
Fuente: Pablo Parra
En funcionamiento
Figura 21. Implementación de la clase principal en java.
Fuente: Pablo Parra

igual 4.0
20/8/2020 Recursos complementarios | Tema 8: Relaciones entre clases
Recursos complementarios
* Video sobre los tipos de relaciones entre clases.
https://www.youtube.com/embed/6oXZSnaAxEg
https://www.youtube.com/watch?v=6oXZSnaAxEg
* Imagen para explicar la agregación frente a la composición
http://www.ciberaula.com/articulo/uml
* Video sobre las asociaciones entre clases
https://es.coursera.org/lecture/introduccion-programacion-java/asociaciones-
22Ub9
* Figura sobre una agregación de clases. Caso aula
* Figura sobre composición de clases

igual 4.0
20/8/2020 Tema 9 : Generalización/especialización y código limpio

igual 4.0
20/8/2020 9.1. Generalización/especialización | Tema 9 : Generalización/especialización y código limpio
9.1. Generalización/especialización
9.1.1. Herencia
9.1.2. Tipos de herencia
9.1.3. Constructores super () y this ()
9.1.4. Ventajas de la herencia
9.1.5. Modelado
9.1.6. Implementación

igual 4.0
20/8/2020 9.1.1. Herencia | Tema 9 : Generalización/especialización y código limpio
9.1.1. Herencia
La herencia es específica de la programación orientada a objetos, donde una clase

nueva se crea a partir de una clase existente. La herencia (a la que habitualmente se
denomina subclase) proviene del hecho de que la subclase (la nueva clase creada)
contiene los atributos y métodos de la clase primaria. La principal ventaja de la
herencia es la capacidad para definir atributos y métodos nuevos para la subclase,
que luego se aplican a los atributos y métodos heredados.
Figura 1. POO Herencia.
Fuente: https://www.google.com/url?
sa=i&source=images&cd=&ved=2ahUKEwi_3MHWq4DkAhUOxVkKHaoZBnsQjRx6BAgBEAQ
&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dz2Se29mcocw&psig=AOvVaw3CzwJVoD
Ventajas
Una vez que el método ha sido definido en la superclase, esto es heredado

automáticamente por las superclases.
De esta manera el método solo se escribe una vez y no una vez por cada
subclase.
Una clase y sus hijos comparten un conjunto común de propiedades.
Una subclase hereda todo lo public y lo protected (propiedades o métodos) de
su padre sin importar en qué paquete está la subclase.
Nomenclatura
Partiendo del siguiente ejemplo se procederá a explicar cómo funcionan las palabras
clave para reconocer cuando se habla de una herencia. Si definimos la clase Coche
20/8/2020 9.1.1. Herencia | Tema 9 : Generalización/especialización y código limpio
a partir de la clase Vehículo se dice que:
"Coche" hereda las variables y métodos de "Vehículo".

"Coche" extiende de "Vehículo".
"Coche" es subclase de "Vehículo".
clase derivada
clase hija
"Vehículo" es superclase de "Coche".
clase base.
clase padre.
La herencia realiza la relación es-un – Un coche es-un vehículo; un perro es-un
mamífero, etc.
Dentro de Java se indica usando la palabra reservada extends class.
Punto3D extends Punto2D
Visibilidad
Los miembros privados de la superclase no son visibles desde la subclase.

Los miembros públicos de la superclase son visibles y siguen siendo públicos en
la subclase.
- Se puede acceder a los miembros de la superclase usando la palabra

reservada super.
- Si una clase se declara como final no se puede heredar de ella.
- En Java, todas las clases heredan implícitamente de la clase Object.
Reglas
Una interfaz puede heredar de otra interfaz.

Una clase (abstracta o no) puede heredar de una interfaz.
Una interfaz NO puede heredar de una clase.

igual 4.0
20/8/2020 9.1.2. Tipos de Herencia | Tema 9 : Generalización/especialización y código limpio
9.1.2. Tipos de herencia
Herencia simple
La herencia simple consiste en que una clase hereda a una clase hijo, y a solo una le
hereda sus atributos. Es igual al concepto general de herencia, con la limitante de
solo poder heredar de una clase padre a una clase hijo, y solo a una clase hijo.
Figura 2. Herencia.
Fuente: https://rua.ua.es/dspace/bitstream/10045/15995/1/POO-3-Herencia-10-11.pdf
Clase Derivada Clase Derivada Clase Derivada

H. Pública H. Pública H. Pública
No direct. No direct. No direct.

PRIVATE
Accesible accesible accesible
PROTECTED Protected Protected Private
PUBLIC Public Protected Private
Ejemplo
Figura 3. Herencia.
Métodos en las clases derivadas
En la clase derivada se puede:
Añadir nuevos métodos/atributos propios de la clase derivada.

Modificar los métodos heredados de la clase base.
Refinamiento
Se añade comportamiento nuevo antes y/o después del comportamiento heredado.

(Simula, Beta) (se puede simular en C++, Java)
C++, Java: Constructores y destructores se refinan.
Reemplazo. El método heredado se redefine completamente, de forma que

sustituye al original de la clase base.
Constructor en herencia simple
Los constructores no se heredan.
Siempre son definidos para las clases derivadas.

Creación de un objeto de clase derivada: Se invoca a todos los constructores de
la jerarquía.
Orden de ejecución de constructores: Primero se ejecuta el constructor de la

clase base y luego el de la derivada.
Esto implica que la clase derivada aplica una política de refinamiento: añadir
comportamiento al constructor de la clase base.
Ejecución implícita del constructor por defecto de clase base al invocar a un

constructor de clase derivada.
Ejecución explícita de cualquier otro tipo de constructor en la zona de
inicialización (refinamiento explícito). En particular, el constructor de copia.
Figura 4. Herencia.
Herencia múltiple
Consiste en la utilización de las propiedades de una clase a varias clases más, lo que
significa que en esta propiedad una sola clase padre puede heredarle atributos u
objetos de esta a varias clases hijo sin ninguna limitación entre ellas.
Figura 5. Herencia.
Nota
Dentro de lenguajes como Java la herencia múltiple no puede ser implementada.
De implementación. La implementación de los métodos es heredada. Puede

sobrescribirse en las clases derivadas.
De interfaz. Solo se hereda la interfaz, no hay implementación a nivel de clase base

(interfaces en Java, clases abstractas en C++).

igual 4.0
20/8/2020 9.1.3. Constructores super () y this () | Tema 9 : Generalización/especialización y código limpio
9.1.3. Constructores super () y this ()
super ()
Las dudas con los constructores aparecen ligadas a las jerarquías de clases y a la
palabra super(). Supongamos que tenemos la siguiente jerarquía:
Figura 6. Java constructores y super().
Fuente: https://www.arquitecturajava.com/wp-content/uploads/herencia.png
En este caso podemos tener dos clases con el siguiente código por simplificar al
máximo:
Figuras 7 y 8. Java constructores y super().
Fuente: https://www.arquitecturajava.com/java-constructores-y-super/
Como podemos ver, todos los constructores llaman por defecto al constructor de la
clase superior a través de una llamada a super() (en este caso al constructor por
defecto). Esto es debido a que los constructores no se heredan entre jerarquías de
clases; por lo tanto, la palabra super() siempre es la primera línea de un constructor e
invoca al constructor de la clase superior que comparta el mismo tipo de
parametrización.
Figura 9. Java constructores y super().
Fuente: https://www.arquitecturajava.com/wp-content/uploads/super.png
Aunque nosotros no pongamos la palabra super() esta siempre será añadida salvo
que nosotros la añadamos. Por ejemplo, si nuestros constructores tienen parámetros,
las cláusulas super que deberemos construir serán las siguientes entre Persona y
Deportista para que el código compile:
Figuras 10 y 11. Java constructores y super().
Ya que sino el compilador añadirá super() por defecto y el código no compilará al

carecer la clase Persona de un constructor por defecto.
this ()
La otra posibilidad a super() es el uso de this() en la primera línea de un constructor.

Esto lo que hace es invocar a otro constructor que esté en la misma clase y que
soporte el conjunto de parámetros que le pasamos.
Figura 12. Java constructores y this ().

igual 4.0
20/8/2020 9.1.4. Ventajas de la herencia | Tema 9 : Generalización/especialización y código limpio
9.1.4. Ventajas de la herencia
1. Evitar duplicidad y favorecer la reutilización de código (las subclases utilizan el

código de superclases).
2. Facilitar el mantenimiento de aplicaciones. Podemos cambiar las clases que

usamos fácilmente.
3. Facilitar la extensión de las aplicaciones. Podemos crear nuevas clases a partir

de otras existentes.

igual 4.0
20/8/2020 9.1.5. Modelado | Tema 9 : Generalización/especialización y código limpio
9.1.5. Modelado
Dentro de UML se representa a la herencia con una flecha que va desde el hijo hacia
el padre, como se puede ver en el siguiente ejemplo:
Figura 13. Análisis y diseño orientado a objetos parte 2 de 2.
Fuente: https://maritzacondori.wordpress.com/2016/04/23/analisis-y-diseno-orientado-a-objetos-parte-
2-de-2/
Donde se puede ver que tanto CANINO como FELINO al ser hijos, su relación de
herencia (en este caso con el método rugir), se ve expresada con una flecha que sale
desde ellos y termina en el padre que es la clase Animal.

igual 4.0
20/8/2020 9.1.6. Implementación | Tema 9 : Generalización/especialización y código limpio
9.1.6. Implementación
Aquí se puede ver un ejemplo sobre la base del diagrama anterior.
Figura 14. Implementación del ejercicio anterior en Java.
Fuente: Pablo Parra
Figura 15. Implementación del ejercicio anterior en Java.
Fuente: Pablo Parra

igual 4.0
20/8/2020 9.2. Código limpio | Tema 9 : Generalización/especialización y código limpio
9.2. Código limpio
9.2.1. Estándares de implementación, buenas prácticas de programación
9.2.2. Atributos de calidad de código
9.2.3. Buenas prácticas de programación para tener un código limpio

igual 4.0
20/8/2020 9.2.1. Estándares de implementación, buenas prácticas de programación | Tema 9 : Generalización/especialización y código limpio
9.2.1. Estándares de implementación, buenas prácticas de

programación
Cuando hablamos de un código limpio, nos referimos al estilo de desarrollo centrado

en el lector, un software que sea fácil de leer, escribir y mantener. El código limpio es
uno fácil de entender y cambiar.
Para que un código sea fácil de cambiar, se debe tener en cuenta: que las clases y los
métodos sean pequeños y tengan una única responsabilidad, que las clases tengan
una API concisa y clara, que las clases y los métodos sean predecibles y trabajen
como lo esperado, un código fácil de testear y tenga pruebas unitarias, que los test
sean fáciles de entender y cambiar, etc.
Solid, cinco principios básicos de diseño de clases
Solid es un acrónimo inventado por Robert C. Martin para establecer los cinco
principios básicos de la programación orientada a objetos y diseño. Este acrónimo
tiene bastante relación con los patrones de diseño, en especial, con la alta cohesión y
el bajo acoplamiento.
El objetivo de tener un buen diseño de programación es abarcar la fase de

mantenimiento de una manera más legible y sencilla así como conseguir crear nuevas
funcionalidades sin tener que modificar en gran medida código antiguo. Los costes de
mantenimiento pueden abarcar el 80 % de un proyecto de software, por lo que hay
que valorar un buen diseño.
Figura 16. Solid.
Fuente: http://meridadesignblog.com/solid-principios-de-programacion-orientada-a-objetos-principio-de-
la-responsabilidad-unica/
S - Responsabilidad simple (Single responsibility)
Este principio trata de destinar cada clase a una finalidad sencilla y concreta. En
muchas ocasiones estamos tentados a poner un método reutilizable que no tiene
nada que ver con la clase, simplemente porque lo utiliza y nos pilla más a mano. El
problema surge cuando tenemos la necesidad de utilizar ese mismo método desde
otra clase. Si no se refactoriza en ese momento y se crea una clase destinada para
la finalidad del método, nos toparemos a largo plazo con que las clases realizan
tareas que no deberían ser de su responsabilidad.
Con la anterior mentalidad nos encontraremos, por ejemplo, con un algoritmo de

formateo de números en una clase destinada a leer de la base de datos porque fue el
primer sitio donde se empezó a utilizar. Esto conlleva a tener métodos difíciles de
detectar y encontrar, de manera que el código hay que tenerlo memorizado en la
cabeza.
Ejemplo
Modo incorrecto
Figura 17. Clase paciente implementada incorrectamente.
Fuente: Pablo Parra
Modo correcto
Figuras 18 y 19. Clase Paciente y Enfermedad implementadas correctamente.
Fuente: Pablo Parra
O - Abierto/Cerrado (Open/Closed)
Principio atribuido a Bertrand Meyer quien habla de crear clases extensibles sin
necesidad de entrar al código fuente a modificarlo. Es decir, el diseño debe ser abierto
para poderse extender pero cerrado para poderse modificar. Lo complicado es
predecir por dónde se debe extender y que no tengamos que modificarlo.
El uso más común de extensión es mediante la herencia y la reimplementación de

métodos. Existe otra alternativa que consiste en utilizar métodos que acepten
una interface de manera que podemos ejecutar cualquier clase que implemente esa
interface. En todos los casos, el comportamiento de la clase cambia sin que hayamos
tenido que tocar código interno.
Ejemplo
Modo incorrecto
Figuras 20 y 21. Clase Libro implementada incorrectamente, método calcularAlquiler.
Fuente: Pablo Parra
Modo correcto
Figuras 22,23 y 24. Clase Libro implementada correctamente, métodos sobrescritos.
Fuente: Pablo Parra
L - Sustitución Liskov (Liskov substitution)
Este principio fue creado por Barbara Liskov y habla de la importancia de crear todas
las clases derivadas para que también puedan ser tratadas como la propia clase
base. Cuando creamos clases derivadas debemos asegurarnos de no reimplementar
métodos que hagan que los métodos de la clase base no funcionasen si se tratasen
como un objeto de esa clase base.
Ejemplo
Modo incorrecto
Figuras 25 y 26. Clase Empleado y clase EmpleadoSalarioFijo implementadas incorrectamente.
Fuente: Pablo Parra
Modo correcto
Figuras 27, 28 y 29. Clase Empleado y clase EmpleadoSalarioFijo implementadas correctamente,

interface Salario.
Fuente: Pablo Parra
I - Segregacion de la interface (Interface segregation)
Este principio fue formulado por Robert C. Martin. Cuando se definen interfaces
estos deben ser específicos a una finalidad concreta. Por ello, si tenemos que definir
una serie de métodos abstractos que debe utilizar una clase a través de interfaces, es
preferible tener muchos interfaces que definan pocos métodos que tener una interface
con muchos métodos.
El objetivo de este principio es principalmente poder reaprovechar los interfaces en

otras clases. Si tenemos una interface que compara y clona en la misma interface,
de manera más complicada se podrá utilizar en una clase que solo debe comparar o
en otra que solo debe clonar.
Ejemplo
Modo incorrecto
Figuras 30, 31 y 32. Interface Producto, clase Zapatos y clase Chaqueta implementadas
incorrectamente.
Fuente: Pablo Parra
Modo correcto
Figuras 33 y 34. Implementación de interfaces, implementación de las clases Zapatos y Chaqueta.
Fuente: Pablo Parra
D - Inversión de dependencias (Dependency inversion)
También fue definido por Robert C. Martin. El objetivo de este principio es conseguir
desacoplar las clases. En todo diseño siempre debe existir un acoplamiento, pero hay
que evitarlo en la medida de lo posible. Un sistema no acoplado no hace nada, pero
un sistema altamente acoplado es muy difícil de mantener.
El objetivo de este principio es el uso de abstracciones para conseguir que una clase
interactúe con otras clases sin que las conozca directamente. Es decir, las clases de
nivel superior no deben conocer las clases de nivel inferior. Dicho de otro modo, no
debe conocer los detalles.
Un código limpio debería cumplir con la regla DRY (Don't Repeat Yourself, o No Te
Repitas). Cuando se aplica correctamente el principio DRY, la modificación de un
único elemento del sistema no requiere cambios en otros elementos que no tengan
relación lógica.
Ejemplo
Modo incorrecto
Figuras 35, 36 y 37. Clases CajaServicio, Sala y TarjetaCredito implementadas incorrectamente.
Fuente: Pablo Parra
Modo correcto
Figuras 38. , interface MetodoPago y clase TarjetaCredito.
Fuente: Pablo Parra

igual 4.0
20/8/2020 9.2.2. Atributos de calidad de código | Tema 9 : Generalización/especialización y código limpio
9.2.2. Atributos de calidad de código
1. Los nombres de paquetes deberían estar totalmente en minúsculas. Esto se

basa en la convención especificada por Sun para la nomenclatura de paquetes.
mypackage, com.company.application.ui
El nombre inicial de dominio del paquete debe estar totalmente en minúsculas.
2. Los nombres que representan tipos deben ser sustantivos y escribirse con
mayúsculas y minúsculas, iniciando con mayúscula.
Line, AudioSystem
Esta es una práctica común en la comunidad de desarrollo en Java e incluso la

convención de nomenclatura de tipos que utiliza Sun en los paquetes predefinidos de
Java.
3. Los nombres de variables deben utilizar mayúsculas y minúsculas iniciando con

minúscula.
line, audioSystem
Es una práctica común en la comunidad de desarrollo Java y también la convención

de nomenclatura de nombres de variables utilizada por Sun para los paquetes
predefinidos de Java. Esta hace que las variables sean fáciles de distinguir de los
tipos y resuelve de manera efectiva las posibles colisiones de nombre como en la
declaración Line line;
4. Los nombres que representan constantes (variables finales) deben estar totalmente
en mayúsculas utilizando subrayados (guion bajo) para separar las palabras.
MAX_ITERATIONS, COLOR_RED
5. Los nombres que representan métodos deben ser verbos y escribirse con
mayúsculas y minúsculas iniciando con minúscula.
getName(), computeTotalWidth()
Es una práctica común en la comunidad de desarrollo en Java y también la

convención de nomenclatura de nombres utilizada por Sun para los paquetes
predefinidos de Java. Es idéntico al caso de los nombres de variables, pero los
métodos en Java ya se distinguen de las variables por su forma particular.
20/8/2020 9.2.2. Atributos de calidad de código | Tema 9 : Generalización/especialización y código limpio
6. Las abreviaturas y acrónimos no deberían estar con mayúsculas cuando se usan

como nombre.
exportHtmlSource(); //NOT: exportHTMLSource();
openDvdPlayer(); //NOT: openDVDPlayer();
Utilizar todo en mayúsculas para el nombre base entraría en conflicto con las
convenciones anteriores. Una variable de este tipo debería nombrarse dVD, hTML,
etc., lo cual obviamente no es legible. Otro problema se ilustra en el ejemplo anterior.
Cuando el nombre se conecta a otro, se reduce seriamente la legibilidad. La palabra a
continuación del acrónimo no queda como debería.

igual 4.0
20/8/2020 9.2.3. Buenas prácticas de programación para tener un código limpio | Tema 9 : Generalización/especialización y código limpio
9.2.3. Buenas prácticas de programación para tener un código limpio
Evitar la creación innecesaria de objetos, Lazy Initialitation
La creación de objetos en Java es una de las operaciones más costosas en términos

de uso de memoria e impacto en el performance. Esto es evitable creando o
inicializando objetos solo en el momento en que serán requeridos en el código.
Figura 39. Lazy Initialitation.
Fuente: http://www.decodigo.com/2013/04/mejores-practicas.html
Nunca hacer variables de instancia públicas
Hacer una variable de instancia pública puede ocasionar problemas en un programa.

Por ejemplo, si se tiene una clase MiCalendario, esta clase contiene un arreglo de
cadenas diasDeLaSemana. Pero es un arreglo público y a este puede ser accedido
por cualquiera. Se debe asumir que este arreglo contiene siempre los siete nombres
de los días de la semana. Alguien por error puede cambiar el valor e insertar un error.
Figura 40. Clase MiCalendario.
Trata siempre de minimizar la mutabilidad de las clases
Hacer una clase inmutable es hacerla inmodificable. La información de la clase se

preservará durante el tiempo de vida de la clase. Las clases inmutables son simples y
fáciles de manejar.
No obstante, crear objetos inmutables puede golpear significativamente el rendimiento

de una aplicación. Así que se elige cuidadosamente si se quiere que una clase sea o
no inmutable.
Para hacer una clase inmutable se puede definir su constructor de forma privada y
luego crear un método estático para inicializar al objeto y devolverlo.
Figura 41. Clase Empleado.
Siempre que sea posible trata de usar tipos primitivos en lugar de las clases
Wrapper
Las clases Wrapper son buenas, pero también son lentas. Los tipos primitivos son
como clases, sin embargo, las clases wrapper almacenan la información completa
acerca de una clase. Algunas veces un programador puede agregar un error en el
código usando una wrapper por un descuido. Por ejemplo:
Figura 43. Uso de clases Wrapper.

igual 4.0
20/8/2020 Recursos complementarios | Tema 9 : Generalización/especialización y código limpio
* Imagen sobre cómo la herencia se presenta, en qué condiciones y qué ocasiona
http://www.it.uc3m.es/java/git-gisc/units/oo-herencia/slides/ProgramacionOrientadaAObjetos.pdf
* Video sobre la herencia, con ejemplos (código)
http://www.youtube.com/embed/LZPafq9Ve_Q
https://www.youtube.com/watch?v=LZPafq9Ve_Q
* Video sobre las características del principio SOLID para un código limpio
http://www.youtube.com/embed/lOg2IuQIp-s
https://www.youtube.com/watch?v=lOg2IuQIp-s
* Enlace sobre las diez mejores prácticas en Java para crear un código entendible
http://www.decodigo.com/2013/04/mejores-practicas.html
* Enlace sobre las nueve cualidades del código limpio
20/8/2020 Recursos complementarios | Tema 9 : Generalización/especialización y código limpio
https://dosideas.com/noticias/desarrollo-de-software/965-las-9-cualidades-del-
codigo-limpio

igual 4.0
20/8/2020 Tema 10: Gestion de defectos

igual 4.0
20/8/2020 10.1. Definición | Tema 10: Gestion de defectos
10.1. Definición
El testing es una actividad desarrollada para evaluar la calidad del producto y para
mejorarlo al identificar defectos y problemas.
El testing de software consiste en la verificación dinámica del comportamiento de un

programa sobre un conjunto finito de casos de prueba, apropiadamente seleccionados
a partir del dominio de ejecución que usualmente es infinito, en relación con el
comportamiento esperado.
Es una técnica dinámica en el sentido de que el programa se verifica poniéndolo en

ejecución de la forma más parecida posible a como se ejecutará cuando esté en
producción –esto se contrapone a las técnicas estáticas las cuales se basan en
analizar el código fuente.
Si uno de los casos de prueba detecta un error el programa es incorrecto, pero si

ninguno de los casos de prueba seleccionados encuentra un error no podemos decir
que el programa es correcto. Esos casos de prueba son elegidos siguiendo alguna
regla o criterio de selección. Se determina si un caso de prueba ha detectado un error
o no comparando la salida producida con la salida esperada para la entrada.
Figura 1. El proceso general de testing.
Fuente: Ian Sommerville. Software engineering (5th ed.). Addison Wesley Longman Publishing
Como sugiere la figura 1, un sistema complejo suele testearse en varias etapas que
por lo general se ejecutan siguiendo una estrategia bottom-up, aunque el proceso
20/8/2020 10.1. Definición | Tema 10: Gestion de defectos
general es iterativo. Se debe volver a las fases anteriores cada vez que se encuentra
un error en la fase que está siendo ejecutada.

igual 4.0
20/8/2020 10.2. Verificación y validación | Tema 10: Gestion de defectos
10.2. Verificación y validación
La verificación y validación es el nombre que se da a los procesos de comprobación y

análisis que aseguran que el software que se desarrolla está acorde a su
especificación y cumple las necesidades de los clientes.
Es un proceso de ciclo de vida completo. Inicia con las revisiones de los

requerimientos y continúa con las revisiones del diseño y las inspecciones del código
hasta la prueba del producto. Existen actividades en cada etapa del proceso de
desarrollo del software. Boehm (1979) expresó la diferencia entre ellas de forma
sucinta.

igual 4.0
20/8/2020 10.2.1. Verificación | Tema 10: Gestion de defectos
10.2.1. Verificación
¿Estamos construyendo el producto correctamente?
El papel de la verificación comprende comprobar que el software está de acuerdo con

su especificación. Se comprueba que el sistema cumple los requerimientos
funcionales y no funcionales que se le han especificado.

igual 4.0
20/8/2020 10.2.2. Validación | Tema 10: Gestion de defectos
10.2.2. Validación
¿Estamos construyendo el producto concreto?
La validación es un proceso más general. Se debe asegurar que el software cumple

las expectativas del cliente. Va más allá de comprobar si el sistema está acorde con
su especificación, para probar que el software hace lo que el usuario espera a
diferencia de lo que se ha especificado.
En la figura 1 se muestra el lugar que ocupan las inspecciones y las pruebas dentro
del proceso de desarrollo de software. Las flechas indican las fases del proceso en las
que se utilizan las técnicas. Las inspecciones de software se pueden utilizar en todas
las etapas del proceso, mientras que las técnicas de prueba solo cuando está
disponible un prototipo o código ejecutable.
Las técnicas de inspección incluyen inspección de programas, análisis automatizado

de código fuente y verificación formal. Sin embargo, las técnicas estáticas solo
pueden comprobar la correspondencia entre un programa y su especificación mas no
pueden probar que el software es de utilidad operacional y, mucho menos, que las
características no funcionales del software son las correctas. Por lo tanto, para validar
un sistema de software, siempre se requieren llevar a cabo ciertas pruebas. Aunque
en la actualidad las inspecciones se utilizan ampliamente, las pruebas de los
programas son aún la técnica de verificación y validación predominante.
Figura 2. Esquema de verificación y validación estática y dinámica.
Fuente:
https://www.ctr.unican.es/asignaturas/Ingenieria_Software_4_F/Doc/M7_09_VerificacionValidacion-
A2011.pdf
20/8/2020 10.2.2. Validación | Tema 10: Gestion de defectos

igual 4.0
20/8/2020 10.3. Pruebas vs. depuración | Tema 10: Gestion de defectos
10.3. Pruebas vs. depuración
10.3.1. Pruebas
10.3.2. Depuración

igual 4.0
20/8/2020 10.3.1. Pruebas | Tema 10: Gestion de defectos
10.3.1. Pruebas
Las pruebas que se aplican al programa son de diversa índole y generalmente

dependen del tipo de problema que se está resolviendo. Comúnmente se inicia la
prueba de un programa introduciendo datos válidos, inválidos e incongruentes y
observando cómo reacciona en cada ocasión.
Los resultados pueden ser los siguientes:
La lógica del programa está bien, pero hay errores sencillos, los cuales los
corregimos eliminando o modificando algunas instrucciones o incluyendo
nuevas.
Hay errores ocasionados por fallas en la lógica, lo que nos obliga a regresar a
las fases de Diseño y Codificación para revisión y modificación del diagrama.
Hay errores muy graves y lo más aconsejable es que regresemos a la fase 2
para analizar nuevamente el problema y repetir todo el proceso.
No hay errores y los resultados son los esperados. En este caso, guardamos el
programa permanentemente en un medio de almacenamiento.
Si se está automatizando alguna tarea manual, es común poner a funcionar por un

tiempo y de forma paralela ambas alternativas, a fin de comparar las salidas de las
dos y adquirir confianza en la solución automatizada.

igual 4.0
20/8/2020 10.3.2. Depuración | Tema 10: Gestion de defectos
10.3.2. Depuración
No existe un proceso sencillo para la depuración de programas. Los mejores

depuradores buscan patrones en los resultados de las pruebas donde el defecto se
detecta, y para localizar el defecto utilizan el conocimiento que tienen sobre el tipo de
defecto, el patrón de salida, así como el lenguaje y proceso de programación. El
conocimiento del proceso es importante. Los depuradores conocen los errores de los
programadores comunes (como olvidar incrementar un contador, errores de
direccionamiento de punteros en lenguaje C, etc.) y los comparan contra los patrones
observados.
En la figura 2 se explica que después de que se descubre el origen del fallo en el

programa, este debe corregirse y entonces reevaluar el sistema. Esto implica repetir
de nuevo las pruebas anteriores (pruebas de regresión). Estas pruebas se hacen para
comprobar que los cambios introducidos resuelven definitivamente el fallo y no
introducen nuevos fallos. La estadística muestra que la reparación de un fallo
frecuentemente es incompleta y además introduce nuevos fallos.
Figura 3. Proceso de depuración.
Fuente:
https://www.ctr.unican.es/asignaturas/Ingenieria_Software_4_F/Doc/M7_09_VerificacionValidacion-
2011.pdf

igual 4.0
20/8/2020 10.4. Pruebas de unidad | Tema 10: Gestion de defectos
10.4. Pruebas de unidad
Comprueban si el código funciona y cumple con las especificaciones necesarias para

su desempeño óptimo. Se focalizan en verificar cada módulo con lo que mejora el
manejo de la integración de lo más básico a los componentes mayores.
Las pruebas unitarias se enfocan en demostrar que la lógica existente en el código

está en buen estado y que funcionará en todos los casos en los que se los pueda
llegar a ejecutar, además aporta fiabilidad al código. Entre algunos de los beneficios
están:
Aumentan la legibilidad del código y ayudan a los desarrolladores a entender el

código base, lo que facilita hacer cambios más rápidamente.
Los test unitarios bien realizados sirven como documentación del proyecto.
Se realizan en pocos milisegundos, por lo que podrá realizar cientos de ellas en
muy poco tiempo.
Las unit testing le permiten al desarrollador refactorizar el código más adelante y
tener la garantía de que el módulo sigue funcionando correctamente. Para ello
se escriben casos de prueba para todas las funciones y métodos, para que cada
vez que un cambio provoque un error, sea posible identificarlo y repararlo
rápidamente. (¿Qué son las pruebas unitarias y cómo llevar una a cabo?, s. f.)
La calidad final del código mejorará ya que, al estar realizando pruebas de
manera continua al finalizar el código será limpio y de calidad.
Como las pruebas unitarias dividen el código en pequeños fragmentos, es
posible probar distintas partes del proyecto sin tener que esperar a que otras
estén completadas.
Para la elaboración de pruebas unitarias en Java, por ejemplo, se puede utilizar el

JUNIT y CACTUS.

igual 4.0
20/8/2020 10.4.1. Instalación de JUNIT | Tema 10: Gestion de defectos
10.4.1. Instalación de JUNIT
1. Se ingresa a la siguiente url a través de cualquier navegador

(http://search.maven.org/remotecontent?filepath=junit/junit/4.11/junit-4.11.jar).
Figura 4. Descarga del jUnit
Fuente: Pablo Parra
2. Posterior a esto se agrega el jar como un nuevo archivo.
Figura 5. Crear un jUnit test
Fuente: Pablo Parra
3. No se necesita hacer ninguna otra modificación, se hace clic a Finish para concluir
la agregación del jUnit.
20/8/2020 10.4.1. Instalación de JUNIT | Tema 10: Gestion de defectos
Figura 6. Instalación de jUnit test
Fuente: Pablo Parra
4. Finalmente se selecciona la versión que queramos instalar (se recomienda utilizar

la versión disponible).

igual 4.0
20/8/2020 10.4.2. El proyecto | Tema 10: Gestion de defectos
10.4.2. El proyecto
Creamos un proyecto que llamaremos «Prueba de Cobertura», agregamos un

paquete «example» y las librerías arriba mencionadas. Para finalizar, creamos una
clase «Miclase.java».
Figura 7. Clase Creada.
Fuente: https://www.jc-mouse.net/java/ejemplo-de-pruebas-unitarias-en-java

igual 4.0
20/8/2020 10.4.3. El código | Tema 10: Gestion de defectos
10.4.3. El código
El código que probaremos, lo estudiamos en un post anterior [LINK] donde realizamos

una prueba manual del algoritmo. El algoritmo corresponde al problema de detectar el
número mayor dados tres números.
Figura 8. Molde pseudocódigo.
Pasamos del algoritmo a código y tenemos:
20/8/2020 10.4.3. El código | Tema 10: Gestion de defectos
Figura 9. Código del programa.

igual 4.0
20/8/2020 10.4.4. Paquete de prueba | Tema 10: Gestion de defectos
10.4.4. Paquete de prueba
Ya que tenemos nuestra clase de prueba lista, procedemos a crear las clases de
prueba. Clic derecho sobre nuestro proyecto -> New -> Other… En Categoría
seleccionamos «Unit Tests» y en File Types, seleccionamos «Test for Existing Class»
y presionamos el botón siguiente.
A continuación, presionando el botón «browse…» buscamos y seleccionamos la clase

que testearemos («Miclase»), dejamos todas las opciones tal cuales están y
finalizamos presionando el botón «Terminar».
Figura 10. Existing Class to Test.
Se creará otra clase en la sección «Paquete de prueba» como se ve a continuación:
20/8/2020 10.4.4. Paquete de prueba | Tema 10: Gestion de defectos
Figura 11. Clase creada en Paquete.

igual 4.0
20/8/2020 10.4.5. JUnit | Tema 10: Gestion de defectos
10.4.5. JUnit
Antes de realizar la prueba con JUnit, debemos estudiar un poco el código generado.
En la parte inferior de la clase MiClaseTest encontramos el siguiente método:
Figura 12. Método de testeo.
Donde:
1) @Test: Los métodos marcados con esta anotación, le indican a JUnit que es
código que queremos que se ejecute. Son estos métodos donde se implementa el
código de pruebas.
2) Las variables del método que probaremos.
3) Instancia a muestra de prueba.
4) El resultado que esperamos obtener si la prueba tiene éxito.
5) La llamada al método de prueba, el resultado se almacena en otra variable.
6) assertEquals: Es uno de varios métodos con los que cuenta JUnit. Este método
en particular compara si dos objetos son iguales, de no ser así, lanzará una
excepción y la prueba se detiene.
7) fail: Este método hace que la prueba termine con fallo.
Como vimos en un post anterior [Caja blanca: Prueba del camino básico], este
algoritmo consta de cuatro caminos posibles, eso quiere decir que debemos
implementar cuatro métodos de prueba.
Figura 13. Explicación de algoritmo.
Tomando como base el método de prueba arriba mencionado, creamos cuatro

métodos con sus respectivos valores de entrada y valores esperados, es decir:
Figura 14. Métodos de testeos.
Figura 15. Métodos de testeos.
Para ejecutar el test con JUnit, damos clic derecho sobre la clase MiClaseTest.java
-> run file
Observamos que pasamos las cuatro pruebas con éxito.
Figura 16. Ejemplo de JUnit.
Fuente https://www.jc-mouse.net/java/ejemplo-de-pruebas-unitarias-en-java
Si tuviésemos algún error, este aparecería en color rojo.

igual 4.0
20/8/2020 Ejemplo | Tema 10: Gestion de defectos
Ejemplo
Realice una calculadora básica y haga todos los test de prueba necesarios para tener
una cobertura del 100 % del programa.
Creamos clases de los objetos que existan. En este caso creamos una clase (figura
17) del objeto principal, un número.
Figura 17. Clase Número.
Fuente: Pablo Parra
Al tener la clase Número, procedemos a la creación de la clase Operación (figura 18)

donde vamos a colocar las operaciones en cada método.
Figura 18. Clase Operación.
Fuente: Pablo Parra
Una vez creados los métodos, vamos a testearlos con ayuda de jUnit como se ve en
las figuras 19 y 20.
Figura 19. Test de Métodos
Fuente: Pablo Parra
Figura 20. Test de Métodos
Fuente: Pablo Parra
Compilaremos la clase OperacionTest para evaluar los métodos en la figura 21.
Figura 21. Testing de los Métodos.
Fuente: Pablo Parra

igual 4.0
20/8/2020 Tema 11: Encapsulamiento

igual 4.0
20/8/2020 11.1. Definición | Tema 11: Encapsulamiento
11.1. Definición
La encapsulación es un mecanismo que consiste en organizar datos y métodos de

una estructura, conciliando el modo en que el objeto se implementa, es decir, evitando
el acceso a datos por cualquier otro medio distinto a los especificados; por lo tanto, la
encapsulación garantiza la integridad de los datos que contiene un objeto.
Figura 1. Destilación y encapsulamiento.
Fuente: https://www.researchgate.net/figure/228773129_fig30_Figura-38-Destilacion-y-
encapsulamiento
Encapsulamiento significa que los datos y las acciones se combinan en una sola
entidad (es decir, un objeto de la clase) y se ocultan los detalles de la implementación.
La programación orientada a objetos (POO) encapsula datos (atributos) y métodos
(comportamientos) en objetos. Los objetos tienen la propiedad de ocultación de la
información. Esta propiedad significa que, aunque los objetos pueden conocer cómo
comunicarse unos con otros a través de interfaces bien definidas, no pueden conocer
cómo están implementados otros objetos (los detalles de la implementación están
ocultos dentro de los propios objetos).
Esta es una situación muy frecuente del mundo real. Es posible conducir con eficacia
un automóvil sin conocer los detalles internos de cómo funciona el motor, el tren de
engranajes o el sistema de frenos. En Java se tiene un gran control sobre el
encapsulamiento de una clase y un objeto. Se consigue aplicando modificadores a
clases, variables de instancia y de clases, y métodos. Algunos de estos modificadores
se refieren al concepto de paquete, que se puede considerar básicamente como un
grupo de clases asociadas.
Figura 2. Java Básico Encapsulamiento.
Fuente: https://juanjavierrg.com/java-basico-encapsulamiento/
Modificadores
Se pueden realizar modificaciones de:
Clases
Variables
Métodos
1. Modificadores de clase
Se puede cambiar la visibilidad de una clase utilizando una palabra reservada,

modificador, antes de la palabra reservada “class” en la definición de la clase. Por
ejemplo:
Figura 3. Modificadores de clase.
Fuente: Joyanes, Luis, (s.f), JAVA 2 MANUAL DE PROGRAMACIÓN, Madrid,España, Osborne

McGraw-Hill.
Una clase pública se define dentro de su propio archivo y es visible en cualquier parte.
Una clase que es local a un paquete específico no tiene modificador y se puede
definir dentro de un archivo que contiene otras clases. Como máximo, una de las
clases de un archivo puede ser una clase pública.
2. Modificadores de variables
La cantidad de encapsulamiento impuesta por una clase se establece a discreción del

programador. Puede permitirse el acceso completo a todo el interior dentro de la clase
o se pueden imponer diversos niveles de restricciones.
En particular, se puede controlar cuándo es el acceso a otra clase que tiene la

instancia y las variables de una clase. Se consigue esta acción utilizando un
modificador, palabra reservada, antes del tipo de la variable. Por ejemplo:
Figura 4. Modificadores de variables.

McGraw-Hill.
Normalmente es una buena idea imponer tanto encapsulamiento como sea posible.
En consecuencia, debe ocultarse todo lo que se pueda, excepto lo que se desea
hacer visible a otras clases, en cuyo caso se debe permitir la cantidad mínima de
visibilidad.
Lista de un modificador de variable o método
Figura 5. Modificadores de variables.

McGraw-Hill.
Nota
El modificador "Protected” es más débil que el uso de ningún modificador. No se debe

utilizar ningún modificador con preferencia a “protected”.
3. Modificadores de métodos
Se puede limitar también el acceso de otras clases a métodos. Esta acción se realiza
utilizando una palabra reservada (modificador), antes del tipo de retorno del método.
Los modificadores son los mismos que para las variables.

Figura 6. Modificadores de metodos.

McGraw-Hill.

igual 4.0
20/8/2020 11.2. Clases internas | Tema 11: Encapsulamiento
11.2. Clases internas
Java permite definir clases e interfaces dentro de otras clases e interfaces.
Una clase que no se anida dentro de otra se denomina clase de nivel superior. Esto
significa que prácticamente todas las clases utilizadas hasta ahora son clases de nivel
superior.
Las clases internas se definen dentro del ámbito de una clase externa (o de nivel
superior). Estas clases internas se pueden definir dentro de un bloque de sentencias o
(anónimamente) dentro de una expresión.
Figura 7. sambayredes.
Fuente:
http://sambayredes.pbworks.com/w/page/127511381/04_4%20Clases%20internas%20y%20herencia%2
Ejemplos
La clase Empleado tiene dos clases internas que representan una dirección y un
sueldo. El código fuente de la clase Empleado y sus dos clases internas Dirección y
Sueldo son:
Figura 8. Clases Internas.

McGraw-Hill
El resultado de la ejecución de esta aplicación es:

McGraw-Hill

McGraw-Hill
Las clases internas no se pueden utilizar fuera del ámbito. Por consiguiente, las
clases externas de la clase Empleado no pueden acceder a la clase interna (a menos
que sean subclases o estén en el mismo paquete, dependiendo de la visibilidad en la
definición de la clase).
En la práctica, la clase de nivel superior actúa como un paquete de objetos que

contiene cero o más clases internas. Esto es particularmente útil en desarrollo de
software orientado a objetos. Por otra parte, la capacidad para definir un código
determinado que se puede crear y pasar donde se necesite es muy importante.
Sintaxis: C posee punteros a funciones. El lenguaje Smalltalk utiliza objetos que

representan código (objetos bloque). Java posee clases internas.
Los tipos de clases internas son:
Estáticas Internas
Clase Interna Miembro
Clases Internas de Método
Clases Internas Anónimas
Estáticas Internas
Este tipo de clase interna tiene las siguientes normas:
Se declaran igual que una clase normal, con la diferencia de que le añadimos la
palabra reservada "static" a la clase.
static class NombreClase{}
Pueden acceder a métodos y variables de la clase "externa" directamente,

siempre que estos sean estáticos (incluidos privados).
En caso de que los atributos o métodos no sean estáticos, podemos seguir
accediendo a ellos, pero deberemos de instanciar su clase (crear un objeto de la
clase).
Para crear una instancia de la clase estática interna lo haremos de la siguiente
manera:
ClaseExterna.ClaseEstaticaInterna nombre=new
ClaseExterna.ClaseEstaticaInterna();
Clase Interna Miembro
La Clase Interna Miembro tiene las siguientes normas:
Este tipo de clase es considerada un elemento más de la clase externa, con lo

cual puede tener libre acceso a métodos y atributos de su clase externa (incluso
privados).
No podemos definir variables ni métodos estáticos dentro de este tipo de clase,
a no ser que sea alguna variable de tipo constante.
Se declara como una clase normal.
class ClaseInterna{};
Para acceder a métodos y atributos de esta clase interna desde la clase externa
deberemos de instanciar la clase Interna.
ClaseExterna.ClaseEstaticaInterna nombre=new
ClaseExterna.ClaseEstaticaInterna();
Clases Internas de Método
Para seguir el funcionamiento de este tipo de clase seguiremos las siguientes normas:
La clase solo podrá ser instanciada dentro del mismo método.

Una clase interna de método puede acceder a las variables locales del método
SOLO si son FINAL, pero puede acceder con normalidad al resto de variables
de la clase.
Los modificadores permitidos por este tipo de clase son "abstract" y "final".
Clases Internas Anónimas
Las reglas a seguir con este tipo de clases son:
Siempre debe ser una subclase de otra clase ya existente o bien implementar
alguna interfaz.
ClasePadre cp=new ClasePadre(){ //Definición de la clase anónima...};
La definición de la clase anónima se lleva en una linea de código; por lo tanto,

se debe añadir punto y coma ";" al final de la declaración.
Solamente podrá acceder a los métodos de la clase que se hayan heredado,
sobrescrito o implementado.
Es posible encontrarse una clase anónima como argumento de un método.

igual 4.0
20/8/2020 11.3. Paquetes | Tema 11: Encapsulamiento
11.3. Paquetes
Los paquetes son una forma de organizar grupos de clases. Un paquete contiene un
conjunto de clases relacionadas bien por finalidad, por ámbito o por herencia.
Los paquetes resuelven el problema del conflicto entre los nombres de las clases. Al
crecer el número de clases crece la probabilidad de designar con el mismo nombre a
dos clases diferentes.
Las clases tienen ciertos privilegios de acceso a los miembros dato y a las funciones
miembro de otras clases dentro de un mismo paquete. En el Entorno Integrado de
Desarrollo (IDE) JBuilder de Borland, un proyecto nuevo se crea en un subdirectorio
que tiene el nombre del proyecto. A continuación, se crea la aplicación, un archivo
.java que contiene el código de una clase cuyo nombre es el mismo que el del
archivo. Se pueden agregar nuevas clases al proyecto, todas ellas contenidas en
archivos .java situadas en el mismo subdirectorio. La primera sentencia que
encontramos en el código fuente de las distintas clases que forman el proyecto es
package o el nombre del paquete.
Figura 11. Paquetes.
Fuente: http://lenguajejava.com/producto/acceso-al-curso-de-fundamentos-de-programacion-orientada-
a-objetos-con-java/
La palabra reservada import
Para importar clases de un paquete se usa el comando import. Se puede importar una
clase individual import java.awt.Font; o bien, se puede importar las clases
declaradas públicas de un paquete completo, utilizando un asterisco (*) para
reemplazar los nombres de clase individuales import java.awt.*;
Para crear un objeto fuente de la clase Font podemos seguir dos alternativas
1. import java.awt.Font;
2. Font fuente=new Font("Monospaced", Font.BOLD, 36);
O bien, sin poner la sentencia import: java.awt.Font fuente=new

java.awt.Font("Monospaced", Font.BOLD, 36);
Normalmente, usaremos la primera alternativa, ya que es la más económica en

código, si tenemos que crear varias fuentes de texto.
Se pueden combinar ambas formas, por ejemplo, en la definición de la clase BarTexto
import java.awt.*;
public class BarTexto extends Panel implements java.io.Serializable{
//...
Panel es una clase que está en el paquete java.awt, y Serializable es una interface
que está en el paquete java.io (2).
Los paquetes estándar
Paquete Descripción
java.applet Contiene las clases

necesarias para crear
applets que se ejecutan
en la ventana del
navegador.
Contiene clases para

crear una aplicación
java.awt
GUI independiente de
la plataforma.
Entrada/Salida. Clases
java.io que definen distintos
flujos de datos.
Contiene clases
esenciales, se importa
java.lang implícitamente sin
necesidad de una
sentencia import.
Se usa en combinación
con las clases del
java.net paquete java.io para
leer y escribir datos en
la red.
Contiene otras clases

java. Útil útiles que ayudan al
programador.
Figura 12. Paquetes java.
Fuente: Pablo Parra
Declaración de un paquete
Cada clase de Java pertenece a un paquete. La clase se añade al paquete cuando se

compila. Un paquete explícito se define por la palabra reservada “package” en el
comienzo del archivo en el que se definen una o más clases o interfaces. Para poner
una clase en un paquete específico se necesita añadir la siguiente línea como la

primera sentencia no comentario:
Figura 13. Declaración de un paquete.

McGraw-Hill
Los nombres de los paquetes deben ser únicos para asegurar que no haya conflictos
de nombres. Java impone un convenio de nombres por el que un nombre de paquete
se construye por un número de componentes separados por un punto (separador).
Estos componentes corresponden a la posición de los archivos.
En el caso siguiente,

McGraw-Hill
Los archivos del paquete están en un directorio llamado dibujos dentro de un

directorio llamado pruebas.
Por otra parte, si los archivos de un paquete específico están en un directorio llamado
concurso, dentro de un directorio llamado pruebas, el nombre del paquete es:

McGraw-Hill
Observe que esto supone que todos los archivos asociados con un único paquete
están en el mismo directorio. Cualquier número de archivos se puede convertir en
parte de un paquete, sin embargo, un archivo solo se puede especificar en un único
paquete.
Nota
Un paquete es una colección de clases relacionadas e interfaces que proporcionan

protección de acceso y gestión de espacio de nombres.

igual 4.0
20/8/2020 Tema 12: Polimorfismo

igual 4.0
20/8/2020 12.1. Definición y ventajas | Tema 12: Polimorfismo
12.1. Definición y ventajas
Definición
Polimorfismo quiere decir "un objeto y muchas formas". Esta propiedad permite que
un objeto presente diferentes comportamientos en función del contexto en que se
encuentre. Por ejemplo, un método puede presentar diferentes implementaciones en
función de los argumentos que recibe, recibir diferentes números de parámetros para
realizar una misma operación y realizar diferentes acciones dependiendo del nivel de
abstracción en que sea llamado.
Figura 1. Tipos de polimorfismo.
Fuente: http://mapaches.itz.edu.mx/~mbarajas/pooisc/poo6.pdf
Ventajas
El polimorfismo permite a los programadores separar las cosas que cambian de

las que no cambian, y de esta manera hacer más fácil la ampliación, el
mantenimiento y la reutilización de los programas.
El polimorfismo puede hacerse con referencias de superclases abstract,
superclases normales e interfaces.
Por su mayor flexibilidad y por su independencia de la jerarquía de clases
estándar, las interfaces permiten ampliar muchísimo las posibilidades del
polimorfismo.
El polimorfismo está basado en utilizar referencias de un tipo más “amplio” que

los objetos a los que apuntan.
Las ventajas del polimorfismo son evidentes, pero hay una importante limitación: el
tipo de la referencia (clase abstracta, clase base o interface) limita los métodos que se
pueden utilizar y las variables miembro a las que se pueden acceder.
Tipos de polimorfismo
Fuente: https://img-
17.ccm2.net/5SQA8xe_1ML1o78keIH88ZCnf8I=/349x/24b04c1ad9174a11a882c852107a9a0b/ccm-
encyclopedia/poo-images-polymorphisme.gif
Polimorfismo de sobrecarga.
Ocurre cuando las funciones del mismo nombre existen, con función similar, en
clases que son completamente independientes unas de otras.
Polimorfismo paramétrico
Capacidad para definir varias funciones utilizando el mismo nombre, pero usando
parámetros diferentes (nombre y/o tipo). El polimorfismo paramétrico selecciona
automáticamente el método correcto a aplicar en función del tipo de datos
pasados en el parámetro.
Polimorfismo de subtipado
En realidad es el verdadero polimorfismo (o "polimorfismo puro"), donde las

clases derivadas redefinen los métodos y/o propiedades heredados mediante la
sobreescritura (override). Se resuelve en tiempo de ejecución.

igual 4.0
20/8/2020 12.2. Sobrecarga de métodos | Tema 12: Polimorfismo
12.2. Sobrecarga de métodos
Es una herramienta que nos ofrece la programación orientada a objetos, ya que nos
permite modelar y definir el comportamiento de los objetos como queramos, es decir,
de acuerdo con unos parámetros de entrada, ejecutar uno u otro método.
La sobrecarga de métodos consiste en poner varios métodos con el mismo nombre en

la misma clase, pero siempre que su lista de argumentos sea distinta, es decir, no
puede haber dos métodos que se llamen igual con la misma lista de
argumentos, aunque devuelvan datos de distinto tipo. El compilador sabría a cuál de
todas las sobrecargas nos referimos por los argumentos que se le pasen en la
llamada, pero no sería capaz de determinar cuál de ellas debe ejecutar si tienen la
misma lista de argumentos.
Un ejemplo de sobrecarga de métodos tenemos:
Figura 6. Ejemplo.
Fuente: Recuperado de: Vílchez, F. J. (2012). Programación en Java. Fundación Universitaria Andaluza
Inca Garcilaso para eumed.net
20/8/2020 12.2. Sobrecarga de métodos | Tema 12: Polimorfismo

igual 4.0
20/8/2020 12.3. Sobrecarga escritura de métodos | Tema 12: Polimorfismo
12.3. Sobrecarga escritura de métodos

La sobreescritura de métodos nos permite redefinir un método que heredamos para
que este funcione de acuerdo con nuestras necesidades y no a lo definido en la
superclase. Cuando en un objeto llamamos a un método, el compilador comprueba si
el método existe en nuestro objeto; si existe, lo usa y si no existe en nuestro objeto,
entonces lo busca en la superclase. Esto ocurre así hasta que el compilador
encuentra el método definido. El compilador busca el método de abajo a arriba.
20/8/2020 12.3. Sobrecarga escritura de métodos | Tema 12: Polimorfismo
Figura 7. Ejemplo de sobreescritura.
Fuente: http://aularagon.catedu.es/materialesaularagon2013/POO-Tecnologia/M3/Modul o3Herencia-

SobreescrituraMetodos.jpg

igual 4.0
20/8/2020 12.3.1. Conceptos relacionados | Tema 12: Polimorfismo
12.3.1. Conceptos relacionados
Sobrecarga
La sobrecarga representa diferentes maneras de realizar una misma acción.

En los programas se usa el mismo nombre en diferentes métodos con diferentes
firmas [número, orden y tipo de los parámetros].
El código de programación asociado a cada sobrecarga puede variar.
Ejemplo
Contratar(“Juan”, “Ventas”, 2500);

Contratar(“Juan”);
Contratar(“Juan”, 2500);
Herencia
La herencia es el mecanismo de implementación mediante el cual elementos más

específicos incorporan la estructura y comportamiento de elementos más generales
(Rumbaugh 99).
Una clase se dice que hereda o extiende a otra clase antecesora. La palabra
reservada extends sirve para indicar que una clase extiende a otra. La clase que
extiende a otra hereda todos los atributos y métodos de la clase antecesora que no
sean privados (private). La clase antecesora puede extender a su vez otra clase.
Figura 8. Clase padre.
Fuente: Pablo Parra
Figura 9. Clase padre.
Fuente: Pablo Parra
Sobreescritura
Los constructores son métodos invocados en el momento de la creación de

instancias. Como cualquier otro método, se puede sobrescribir en el momento de la
extensión. Si el constructor de una clase que extiende a otra necesita invocar a un
constructor de su clase antecesora, lo debe hacer antes de llamar a cualquier otro
método. Cuando se crea una instancia de una clase que extiende a otra, de alguna
manera se debe construir una instancia de la clase antecesora. Si no se especifica lo
contrario, al crear una instancia de una clase se invoca al constructor por defecto de
la clase antecesora, por lo que este constructor debe estar definido en la clase que se
extiende.
Ejemplo
Figura 10. Sobre Escritura.
Fuente: Pablo Parra

igual 4.0
20/8/2020 Recursos complementarios | Tema 12: Polimorfismo
* Video sobre el polimorfismo (conceptos)
https://www.youtube.com/embed/MD8QAyJpXhc
6 Polimorfismo | ¿Qué es POO? | @cursania
* Imagen sobre cómo el polimorfismo se presenta, en qué condiciones y que

ocasiona.
http://www.itnuevolaredo.edu.mx/takeyas/Apuntes/POO/Apuntes/04.-Polimorfismo.pdf?
fbclid=IwAR3Ck4Jc44plJizDf32VrITmdH34YaQRbuzsXfQytaM4fAUupicWffpWQdA
* Video acerca de la sobrecarga, con ejemplos (código)
https://www.youtube.com/embed/qHyw-9CxXVs
66. Programación en Java || POO || Sobrecarga de Métodos
* Video acerca de la sobreescritura, con ejemplos (código).
20/8/2020 Recursos complementarios | Tema 12: Polimorfismo
https://www.youtube.com/embed/vQZ4RY_4l-A
75. Programación en Java || POO || Sobre escritura de miembros

igual 4.0
20/8/2020 Tema 13: Abstracción, interfaces de programación

igual 4.0
20/8/2020 13.1. ¿Qué es abstracción? | Tema 13: Abstracción, interfaces de programación
13.1. ¿Qué es abstracción?
La abstracción radica en seleccionar una representación de datos de un conjunto

grande de los mismos, para mostrar solo los detalles relevantes del objeto. Esto
permite reducir el esfuerzo y la complejidad en la programación, lo cual se logra
usando clases e interfaces abstractas. Es uno de los conceptos más importantes de la
Programación Orientada Objetos (POO u OOP). (Guru99.com, 2019).
Entre los principales conceptos están:
Clase abstracta
Una clase abstracta es aquella que contiene métodos, pero al menos uno de
ellos debe ser abstracto, es decir, no tiene cuerpo y su implementación está en
otra clase. (Martin Sierra, 2008)
No puede instanciar objetos.
Se utiliza solo como superclases.
Sirve para proporcionar una superclase apropiada a partir de la cual heredan
otras clases.
Método abstracto
Es un método sin cuerpo. El método abstracto nunca será definitivo porque la clase
abstracta debe implementar todos los métodos abstractos. (SlideShare, 2012).
20/8/2020 13.1. ¿Qué es abstracción? | Tema 13: Abstracción, interfaces de programación
Figura 1. Método abstracto.
Fuente: (Líneas Abstractas—Clases Y Métodos Abstractos Java,s. f.)

igual 4.0
20/8/2020 13.1.1. Sintaxis de un método y una clase abstracta | Tema 13: Abstracción, interfaces de programación
13.1.1. Sintaxis de un método y una clase abstracta
Según Martin Sierra (2008), la sintaxis para la creación de un método y una clase
abstracta es la siguiente:
public abstract class nombreClase
public abstract tipo nombreMetodo (argumentos);
//otros método

igual 4.0
20/8/2020 13.1.2. Ventajas de la abstracción | Tema 13: Abstracción, interfaces de programación
13.1.2. Ventajas de la abstracción
Las ventajas que se tiene al utilizar la abstracción son:
El usar una clase abstracta permite agrupar varias clases relacionadas.

La abstracción ayuda a reducir la complejidad del diseño y del proceso de
implementación del software. (Guru99.com, 2019).

igual 4.0
20/8/2020 13.1.3. Modelado de la abstracción | Tema 13: Abstracción, interfaces de programación
13.1.3. Modelado de la abstracción
A continuación, se modelará un ejemplo generalizado de las clases abstractas como

se referencia en la figura 2.
Ejemplo
Se requiere modelar con clases y métodos abstractos un ser vivo y sus métodos
serán lo más generales posibles, en este caso se desea modelar la función de
alimentación de los seres vivos.
Figura 2. Modelado de la abstracción (UML).
Fuente: Pablo Parra
En el siguiente ejercicio se requiere modelar una clase abstracta para ser vivo y su
método alimentarse().
Diagrama de clases del ejemplo
Figura 3. Diagrama de clases.
Fuente: Pablo Parra
Se pude entender de mejor manera al traducirlo al lenguaje de Java con el IDE

NetBeans:
Para crear un nuevo proyecto:
Dar clic en la pestaña File, como se referencia en la figura 4.
Figura 4. Creación de un proyecto en NetBeans.
Fuente: Pablo Parra
Elegir New Project…
Figura 5.Creación de un proyecto en NetBeans.
Fuente: Pablo Parra
Dar clic en el icono semejante a una taza que lleva por etiqueta JavaApplication y
nombrar el proyecto, dar clic en“finish” y ya se puede trabajar en el código.
Figura 6. Creación de un proyecto en NetBeans.
Fuente: Pablo Parra
Para crear una clase del ejemplo 1:
Figura 7. Creación de una clase en NetBeans.
Fuente: Pablo Parra
Crear una clase llamada SerVivo
Figura 8. Creación de una clase en NetBeans.
Fuente: Pablo Parra
Si se declara un método abstracto en una clase que no está declarada como

abstracta, se lanzará un error.
Figura 9. Error típico al trabajar con clases y métodos abstractos.
Fuente: Pablo Parra
Al definir la clase como abstracta con la palabra reservada abstract se quitará el

error.
Figura 10. Corrección del Error típico al trabajar con clases y métodos abstractos.
Fuente: Pablo Parra
Crear una nueva clase que heredará el método abstracto de la superclase

SerVivo
Figura 11. Creación de clase Planta.
Fuente: Pablo Parra
La clase se llamará Planta.
Figura 12. Nombramiento de la clase Planta.
Fuente: Pablo Parra
Se implementa el método alimentarse() heredado de la superclase SerVivo.
Figura 13. Implementación del método abstracto.
Fuente: Pablo Parra
En el warning , que aparece en la línea 12 donde se encuentra la

implementación del método abstracto, dice que se debe añadir @Override para poder
sobrescribir en el método del padre.
Figura 14. Aviso por sobre escritura en el método de la superclase desde una clase hija. Autoría
Propia.
Figura 15. Corrección de aviso por sobreescritura en el método de la superclase desde una clase hija.
Fuente: Pablo Parra
De la misma forma se implementan los demás métodos abstractos de las clases que
hereden de la superclase.
Creamos una clase principal donde instanciaremos nuestros objetos:
Figura 16. Clase principal.
Fuente: Pablo Parra
Corrida
Figura 17. Salida de resultados.
Fuente: Pablo Parra

igual 4.0
20/8/2020 13.2. ¿Qué es la interfaz? | Tema 13: Abstracción, interfaces de programación
13.2. ¿Qué es la interfaz?
La palabra “interfaz” puede referirse a múltiples cosas, en muchos ámbitos, incluso en

programación puede tener varios significados.
En programación orientada a objetos (POO), interfaz o interfaces (también

llamada protocolo), podría hacer referencia al conjunto de métodos que tiene un
objeto para poder trabajar con este. Esos conjuntos de métodos constituyen la
interfaz del objeto en POO.
También, interfaz podría hacer referencia a un API. Un API es una interfaz de
programación de aplicaciones (del inglés Application Programming Interface -
API), es el conjunto de funciones y procedimientos (o métodos, en la
programación orientada a objetos), que ofrece cierta biblioteca para ser utilizado
por otro software como una capa de abstracción. Son usados generalmente en
las bibliotecas.
Interfaz podría hacer referencia también a la parte gráfica en la que se
programa. (Alegsa, 1998)
En nuestro caso, se considera el primer significado, el cual es un medio común para

que los objetos no relacionados se comuniquen entre sí. Estas son definiciones de
métodos y valores sobre los cuales los objetos están de acuerdo para cooperar.

igual 4.0
20/8/2020 13.2.1. Sintaxis de una interfaz | Tema 13: Abstracción, interfaces de programación
13.2.1. Sintaxis de una interfaz
Según Martin Sierra (2008), la sintaxis para una interfaz se define mediante la palabra
interface, utilizando la siguiente sintaxis:
public interface nombreInterfaz
tipo nombreMetodo (argumentos);
//otros métodos
Ejemplo
public interface Operaciones
void rotar ( );
String serializar();
//otros métodos
Al crear una interfaz se debe tener en cuenta las siguientes consideraciones:
Todos los métodos definidos en una interfaz, son públicos y abstractos.

En una interfaz es posible definir constantes.
Una interfaz no es una clase debido a que las interfaces tan solo pueden
contener constantes y métodos abstractos, no es posible crear objetos de una
interfaz.

igual 4.0
20/8/2020 13.2.2. Ventajas de la interfaz | Tema 13: Abstracción, interfaces de programación
13.2.2. Ventajas de la interfaz
Entre las principales ventajas de utilizar interfaz están:
El principal beneficio de usar una clase abstracta es que permite agrupar varias
clases relacionadas.
La abstracción ayuda a reducir la complejidad del diseño y el proceso de
implementación del software. (Guru99.com, 2019)
Obligar a que ciertas clases utilicen los mismos métodos (nombres y
parámetros).
Establecer relaciones entre clases que no estén relacionadas.
Al diseñar por interfaces se garantiza un mínimo de acoplamiento y un máximo
re-uso.
El principal uso de las interfaces es que puedes SIMULAR la herencia múltiple;
recuerda que Java solo soporta herencia simple.(Scribd, 2019)

igual 4.0
20/8/2020 13.2.3. Modelado de la interfaz | Tema 13: Abstracción, interfaces de programación
13.2.3. Modelado de la interfaz
Ejemplo del modelado de interfaces (figura 18)
Figura 18. Diagrama de clases de interfaz.
Fuente: Obtenido de Martin Sierra, 2008

igual 4.0
20/8/2020 13.2.4. Ejercicio con una interfaz | Tema 13: Abstracción, interfaces de programación
13.2.4. Ejercicio con una interfaz
Utilizando como IDE el Netbeans, realizar un programa en Java que permita imprimir
los datos del usuario para lo cual se utilizará una interface denominada Impresión,
como se muestra en el Diagrama de Clases UML, figura 19, además utilizar POO.
Figura 19. Diagrama de clases de Interfaz.
Fuente: Pablo Parra
Programación de la interface denominada Impresión
Figura 20. Implementación del Java Interface.
Fuente: Pablo Parra
Figura 21. Implementación del Java Interface.
Fuente: Pablo Parra
Figura 22. Creación de la clase Admin.
Fuente: Pablo Parra
Figura 23. Creación de la clase Cliente.
Para el método imprimir declarado en la interface Impresión, se crea otra clase que lo
contenga.
Figura 24. Implementación de la clase imprimir.
Fuente: Pablo Parra
Finalmente, en la clase principal, que se denominada “ProyectoInterfaz”, que permita

ejecutar cada una de las clases.
Figura 25. Clase principal.
Fuente: Pablo Parra
La Corrida del mencionado programa se referencia en la figura 26, en la cual se

puede ver los datos del cliente y del administrador.
Figura 26. Corrida del programa de interfaces.

igual 4.0
20/8/2020 13.2.5. Resumen de una interfaz | Tema 13: Abstracción, interfaces de programación
13.2.5. Resumen de una interfaz
La clase que implementa la interfaz necesita proporcionar funcionalidad para los

métodos declarados en la interfaz.
Todos los métodos en una interfaz son implícitamente públicos y abstractos.
Una interfaz no puede ser instanciada.
Una referencia de interfaz puede señalar objetos de sus clases de
implementación.
Una interfaz puede extenderse desde una o varias interfaces. Una clase puede
extender solo una clase, pero implementar cualquier cantidad de interfaces.
(Guru99.com, 2019)
Diferencias entre una interfaz y una clase abstracta
Tabla 1
Diferencias entre interfaz y clase abstracta
Interface Clase a
Las interfaces soportan herencia múltiple. Las clases abstractas no soporta
La interfaz no contiene atributos. La clase abstracta contiene atrib
La interfaz no contiene constructores. La clase abstracta contiene cons
Una interfaz contiene solo miembros incompletos. Una clase abstracta contiene mi
Una interfaz no puede tener modificadores de

Una clase abstracta puede conte
acceso por defecto, todo es asumido como público
para las funciones, propiedades
(public).
Los miembros de una interfaz no pueden ser Solo el miembro completo de la

estáticos (Static). estático.
20/8/2020 13.2.5. Resumen de una interfaz | Tema 13: Abstracción, interfaces de programación
Fuente: Difference-between-Abstract-Class-and-Interface-in-Java.png (500×277), s. f.

igual 4.0
20/8/2020 Tema 14: Componentes y objetos gráficos

igual 4.0
20/8/2020 14.1. Widgets (componentes gráficos) | Tema 14: Componentes y objetos gráficos
14.1. Widgets (componentes gráficos)
Un widget es una pequeña aplicación o programa, usualmente presentado en

archivos o ficheros pequeños, que es ejecutada por un motor de widgets o Widget
Engine. Entre sus objetivos están los de dar fácil acceso a funciones frecuentemente
usadas y proveer de información visual.
Figura 1. Objetos gráficos para Java en el IDE Netbeans.
Fuente: Pablo Parra
¿Qué es un Widget de Java?
Java es un lenguaje de programación orientado a objetos que utilizan los

programadores para desarrollar aplicaciones para entornos web y de escritorio. En el
desarrollo de aplicaciones de escritorio, el programador necesita a menudo para
proporcionar una interfaz gráfica de usuario (GUI) con la que puede interactuar el
usuario. Esto significa la creación de ventanas que contienen diferentes campos,
botones y funciones. Esto también significa que el programador tendrá que crear
"widgets" o un pequeño elemento funcional dentro de una ventana de la GUI de Java.
En la programación Java, un "widget" representa una pieza funcional de una interfaz

gráfica de usuario con la que puede interactuar un usuario. Esto puede tomar la forma
de un botón o un campo de texto.
Bibliotecas Widget
Dos bibliotecas comunes son la biblioteca Swing y la biblioteca SWT. La librería Swing
se origina a partir de Sun, el desarrollador que creó Java, como un constructor de
interfaz gráfica de usuario funcional completa con una biblioteca de widgets.
El Standard Widget Toolkit (SWT) se origina a partir de un toolkit, anteriormente

proporcionado con Java y permite los programas de acceso a las funciones de
programación de interfaz gráfica de usuario de bajo nivel. Esto significa que los
programadores pueden ampliar la funcionalidad de aspecto "natural" del sistema
operativo host para aplicaciones de aspecto más integradas.
Figura 2. Componentes y contenedores en Java.
Fuente: https://www.ntu.edu.sg/home/ehchua/programming/java/J4a_GUI.html
AWT y Swing: ¿Cuáles son sus características básicas?
Los componentes de Swing tienen nombres que comienzan con J. Ejemplo de

ello es Button en AWT y JButton en Swing.
Los componentes de AWT están en el paquete awt, mientras que los de Swing
los encontramos en javax.swing.
Figura 3. Diagrama de jerarquía de la clase Java Swing.
Fuente: https://guru99.es/java-swing-gui/
¿Qué es una clase de contenedor?
Las clases de contenedor son clases que pueden tener otros componentes. Entonces,
para crear una GUI, se necesita al menos un objeto contenedor. Hay tres tipos de
contenedores.
Panel. Es un contenedor puro y no es una ventana en sí misma. El único

propósito de un panel es organizar los componentes en una ventana.
Marco. Es una ventana en pleno funcionamiento con su título e iconos.
Diálogo. Se puede considerar como una ventana emergente que aparece

cuando se debe mostrar un mensaje. No es una ventana completamente
funcional como el marco.
Componentes gráficos principales en Java
JButton
La función de un JButton es crear un botón visible dentro de una aplicación de

interfaz gráfica de usuario en Java. Usando métodos adicionales dentro del
lenguaje Java, los programas también pueden proporcionar respuestas detalladas
a la interacción del usuario con un JButton.
Los programas de Java pueden crear JButtons y añadirlos a elementos visibles

de la interfaz de usuario como JFrames y JPanels. A menudo las declaraciones
de clase para GUIs de Java declaran elementos JButton como variables de
instancia antes del método constructor de la clase, como se muestra a
continuación.
private JButton pressButton;
A continuación, esta clase de Java puede instanciar la variable JButton dentro del
método constructor como se muestra a continuación:
pressButton = new JButton("Press Me");
Figura 4. Botón en una ventana en Java.
Fuente: https://www.javatpoint.com/java-jbutton
El parámetro constructor determina el texto que aparecerá en el botón visible, por lo

que debe ajustarse al propósito del botón dentro de la aplicación.
Métodos del JButton
void setText (String s); Se utiliza para configurar el texto especificado en el

botón.
String getText (); Se utiliza para devolver el texto del botón.
void setEnabled (boolean b); Se utiliza para habilitar o deshabilitar el botón.
void setIcon (Icon b); Se utiliza para establecer el icono especificado en el

botón.
JTextField
Un JTextField o campo de texto es un componente Java de la clase swing que crea

un input utilizado para la captura de datos. A continuación, se muestra cómo se crea
un JTextField:
JTextField campo=new JTextField ();
Esto crea un campo de texto vacío.
JTextField campo=new JTextField(String texto);
Esta instrucción crea un campo de texto con un texto especificado.
JTextField campo=new JTextField(String texto, int columnas);
Esto nos crea un campo de texto con un texto especificado y el número de columnas.
Figura 5. Campo de texto en una ventana en Java.
Fuente: https://www.javatpoint.com/java-jtextfield
Métodos del JTextField

campo de texto.
String getText (); Se utiliza para devolver el texto del campo de texto.
void setEnabled (boolean b); Se utiliza para habilitar o deshabilitar el campo

de texto.
Void setEditable (boolean b); Inicializar el campo de texto para no permitir

cambios por parte del usuario.
JLabel
Un Label o etiqueta puede mostrar texto plano, una imagen o una imagen con un
texto. A continuación, se muestra cómo se crea un JLabel.
JLabel etiqueta=new JLabel();
Esto crea una etiqueta vacía, sin texto y sin imagen.
JLabel etiqueta=new JLabel(Icon imagen);
Esto crea una etiqueta con una imagen especificada.
JLabel etiqueta=new JLabel(String texto);
Esto crea una etiqueta con un texto especificado.
JLabel etiqueta=new JLabel(String texto, Icon imagen, int alineacion);
Esto crea una etiqueta con imagen y texto especificado con una alineación horizontal.
Figura 6. Campo de texto en una ventana en Java.
Fuente: Pablo Parra
Métodos del JLabel

campo de texto.
String getText (); Se utiliza para devolver el texto del campo de texto.
void setEnabled (boolean b); Se utiliza para habilitar o deshabilitar el campo

de texto.
Void setIcon (Icon i); Define qué icono mostrará el componente.
JPanel
Entenderemos un JPanel como un contenedor en el cual podemos colocar y

acomodar elementos (dentro del panel) y así luego se nos facilitará mover todos esos
componentes relacionados de un lugar a otro solo moviendo el JPanel y no cada uno
de los elementos que este contiene.
JPanel panel=new JPanel();
Esto nos crea un panel vacío.
Figura 7. Paneles en una ventana en Java.
Fuente: https://jagonzalez.org/mostrar-y-ocultar-jpanel-en-java/
Métodos del JPanel
String paramString (); Devuelve una representación de cadena de este JPanel.
void updateUI (); Restablece la propiedad UI con un valor del aspecto actual.
add (Component c); Agrega un componente a un contenedor especificado.

igual 4.0
20/8/2020 14.2. Formularios | Tema 14: Componentes y objetos gráficos
14.2. Formularios
Para ejemplo, se creará un formulario en Java en el IDE NetBeans. Para crearlo, se

seleccionará un paquete creado anteriormente, y luego se dará clic derecho sobre
este; aparecerá un menú flotante en el cual se ubicará el puntero del mouse sobre
New, inmediatamente aparecerá una serie de elementos de los cuales se dará clic
sobre "JFrame Form":
Figura 8. Creación de un formulario en el IDE NetBeans.
Fuente: https://uh-tis.blogspot.com/2012/07/curso-de-java-como-hacer-un-proyecto-un.html
Aparecerá la ventana "New JFrame Form". En la parte de "Class Name" se colocará

el nombre para el formulario (aquí se tendrá en cuenta las mismas recomendaciones
que cuando le damos un nombre a un proyecto); en este caso se llamará Formulario1
y se dará clic en el botón "Finish".
Figura 9. Opciones de un formulario en el IDE NetBeans.
Ahora se podrá ver en la ventana "Projects" que el formulario fue creado; sin
embargo, se puede observar que automáticamente el IDE Netbeans abre
el formulario creado en la ventana central.
Figura 10. Ventana para modificar un formulario en el IDE NetBeans.
Al lado izquierdo de la ventana de Netbeans, hay una paleta de elementos (cajas de

texto, etiquetas, botones, etc.…), los cuales se usarán para darle forma al formulario.
Figura 11. Paleta de componentes gráficos en el IDE NetBeans.
Ahora se podrá dar clic sobre el elemento que se quiera colocar en el formulario, y
luego dirigir el puntero del mouse al JFrame o formulario, y dar clic en este en la
parte donde se desea colocar el elemento.
Figura 12. Cómo agregar un componente gráfico en el IDE NetBeans.
Luego de colocar todos los elementos que se dese al formulario, se tendrá algo como
lo siguiente:
Figura 13. Ejemplo de formulario en el IDE NetBeans.
Para poder cambiar el tamaño de un elemento, solo basta con seleccionarlo y

ubicarse en uno de sus extremos (superior, inferior, derecho, izquierdo o esquinas) y
se verá que el puntero del mouse toma una forma de flecha doble (bidireccional), en
ese momento, se dará clic sostenido y se arrastrará el mouse hacia la dirección
correcta y hasta la distancia requerida.
Figura 14. Cambiando el tamaño de un JTextField en el IDE NetBeans.
Ahora se cambiará el texto a los elementos; en este caso se seleccionará el elemento

y luego se dará clic derecho sobre este; se desplegará un menú flotante en el cual se
dará clic sobre "Edit Text", y luego se escribirá el texto que se desea.
Figura 15. Editando el nombre de un JTextField en el IDE NetBeans.
Luego de modificar cada uno de los elementos del formulario, se obtendrá el siguiente
resultado:
Figura 16. Formulario personalizado en el IDE NetBeans.
Ejemplo de aplicación
Para el siguiente ejemplo, se solicita crear tres formularios: el primer formulario tendrá
dos botones, cada botón permitirá moverse entre los distintos formularios que se
crearán; el segundo formulario permitirá ingresar un estudiante, en donde se pedirá el
número de cédula del estudiante, sus nombres, apellidos y en qué curso se
encuentra; en el tercer formulario, se deberá ingresar el número de cédula de un
estudiante y, por medio de un botón, se desplegará toda la información almacenada
de dicho estudiante.
El problema será resuelto en el IDE NetBeans para Java y se seguirán los siguientes
pasos:
1. Previa a la creación del nuevo proyecto, se creará un nuevo paquete con el nombre
“Ventanas”, y en este se crearán los formularios con los siguientes nombres:
Figura 17. Creación de los formularios.
Fuente: Pablo Parra
2. En el formulario “Principal”, colocaremos dos botones que nos servirán para

acceder a los otros formularios, se les asignará el nombre de Ingreso y Consulta.
Figura 18. Botones agregados en el formulario “Principal”.
Fuente: Pablo Parra
3. Ahora en el formulario “IngresoEstudiante”, colocaremos etiquetas (JLabel),

campos de texto (JTextField), una lista desplegable (JComboBox) y dos botones, y
luego los editaremos de la siguiente manera:
Figura 19. Formulario “IngresoEstudiante” personalizado.
Fuente: Pablo Parra
4. Para modificar el contenido de la lista desplegable, haremos clic derecho encima y

seleccionaremos propiedades, y en el campo “model” colocaremos el contenido que
deseemos que despliegue, como se muestra a continuación.
Figura 20. Modificando el contenido de un JComboBox.
Fuente: Pablo Parra
5. En el formulario “Consulta”, agregaremos etiquetas, campos de texto y tres botones

como se muestra a continuación:
Figura 21. Formulario “Consulta” personalizado.
Fuente: Pablo Parra
6. Una vez creados los formularios, crearemos una clase llamada Estudiante en el
paquete principal. En esta clase, crearemos el objeto de tipo Estudiante que quedará
de la siguiente manera (se recuerda al estudiante agregar los métodos getter y
setter).
Figura 22. Clase Estudiante.
Fuente: Pablo Parra
7. Para este ejemplo, se creará una clase llamada Alumnado que tendrá las
siguientes características:
Figura 23. Clase Alumnado.
Fuente: Pablo Parra
Figura 24. Métodos de la clase Alumnado.
Fuente: Pablo Parra
En la figura 23 se puede apreciar que se aplicó el patrón Singleton, este patrón de

diseño se encarga de que una clase determinada únicamente pueda tener un único
objeto. El objetivo de este patrón es el de garantizar que una clase solo tenga una
instancia (o ejemplar) y proporcionar un punto de acceso global a ella. En este

ejemplo se ha hecho uso de este patrón ya que el formulario IngresoEstudiante y el
formulario Consulta deben conocer a la clase Alumnado que contiene a los
estudiantes.
8. En el formulario principal, agregaremos las siguientes líneas de código:
Figura 25. Formulario principal.
Fuente: Pablo Parra
Figura 26. Métodos del formulario principal.
Fuente: Pablo Parra
9. En el formulario IngresoEstudiante, agregaremos las siguientes líneas de código:
Figura 27. Formulario IngresoEstudiante.
Fuente: Pablo Parra
Figura 28. Métodos del formulario IngresoEstudiante.
Fuente: Pablo Parra
10. En el formulario Consulta, agregaremos las siguientes líneas de código:
Figura 29. Formulario Consulta.
Fuente: Pablo Parra
Figura 30. Métodos del formulario Consulta.
Fuente: Pablo Parra
A continuación, se muestra la ejecución del programa con sus respectivos formularios:
Figura 31. Ejecución del programa.
Fuente: Pablo Parra

igual 4.0
20/8/2020 14.3. Menús y tablas | Tema 14: Componentes y objetos gráficos
14.3. Menús y tablas
Menús
Java ofrece varias clases para poner menús en una ventana.
JMenuBar
JMenu
JMenuItem
JCheckBoxMenuItem
JRadioButtonMenuItem
Un JFrame o JApplet puede guardar una barra de menú donde se cuelgan menús
desplegables.
Los menús tienen elementos de menú que puede seleccionar el usuario.
Las barras de menús se pueden contemplar como una estructura que soporta menús.
Una ventana (frame) solo puede tener una barra de menús (objeto MenuBar), que se
sitúa en la parte de arriba del mismo.
Los submenús son botones JMenu.
Los elementos de los menús son botones JMenuItem.
Cuando se activa un menú se despliegan automáticamente las opciones del menú.
Figura 32.Interfaces gráficas de usuario.
Fuente: https://www.fdi.ucm.es/profesor/jpavon/poo/Tema6resumido.pdf
Ejemplo
Figura 33. Ejemplo de menú.
Código
Figuras 34. Ejemplo de menú en código para Java.
Figuras 35. Ejemplo de menú en código para Java.
Tablas
Las tablas son uno de los elementos más utilizados dentro de cualquier lenguaje de
programación, se las puede utilizar para desplegar una lista de datos similares
ordenados de una forma específica. Su uso es amplio pues es bastante versátil.
Tablas en Java
Dentro de Java tenemos el componente gráfico conocido como jTable. Es una clase
que permite organizar una determinada información en tabla, esta difiere de una base
de datos normal porque al utilizar jTable se puede visualizar esta tabla, brindándole al
usuario organización de información, oportunidades de editar y cambiar el tamaño de
las columnas entre otras.
Inicios
En principio se creó la clase Jtable para constituir una interfaz ligada a bases de
datos a través de "Java Database Connectivity" (JDBC), y así evita la
complejidad que existía para el manejo de datos, dando así al programador
mucha más facilidad a la hora de trabajar con este tipo de información.
Edición
La tabla se puede manipular en modo diseño, se especifican los nombres y

cantidad de columnas haciendo clic derecho sobre la tabla y accediendo a
“Contenidos de tabla (Table Contents)”. Para el combo agregamos “Sí” y “No” en
modo diseño desde la propiedad del objeto y en el apartado “model”.
Figura 36. Panel de componentes en NetBeans.
Recuperado de: https://4.bp.blogspot.com/-SmpM_g9F9hg/VGISuyI-

PII/AAAAAAAADdU/sK1FxWrv3gQ/s1600/JTable001.png
Implementación
Una de las formas más fáciles de utilizar un jTable es la siguiente manera,

instanciar como modelo de datos un DefaultTableModel y luego un JTable,
pasándole el modelo en el constructor.
Figura 37. Ejemplos Java y C/Linux.
Recuperado de: http://www.chuidiang.org/java/tablas/tablamodelo/tablamodelo.php

igual 4.0
20/8/2020 14.4. Gestión de eventos | Tema 14: Componentes y objetos gráficos
14.4. Gestión de eventos
Cuando el usuario de un programa o applet mueve el ratón o hace un clic o usa el

teclado, genera un Evento. En Java los eventos, como cualquier otra cosa, se
representan como instancias u objetos de alguna clase. Para programar una interfaz
gráfica es necesario aprender a utilizar los eventos.
Cuando el usuario interactúa sobre los diversos componentes del awt, estos generan
eventos. La siguiente tabla muestra los eventos que cada tipo de componente puede
generar y cuándo los genera.
Tabla 1
Componentes de interacción
Tipo de componente Evento generado Hechos que lo genera
El usuario hace un clic sobre

Button ActionEvent
botón.
El usuario selecciona o desel

Checkbox ItemEvent
el interruptor (Checkbox).

CheckboxMenultem ItemEvent
el interruptor (Checkbox).

Choice ItemEvent
un elemento de la lista.
Component ComponentEvent El componente se mueve, ca

de tamaño, se esconde o se e
Focus Event El componente gana o pierde

foco.
KeyEvent
El usuario pulsa o suelta una
MouseEvent
El usuario pulsa o suelta un b
del ratón, el cursor del ratón e
sale o el usuario mueve o arra
ratón.
Se agrega o se quita un comp

Container ContainerEvent
al contenedor.
ActionEvent El usuario hace doble clic

elemento de la lista.
List

ItemEvent un elemento de la lista.
El usuario selecciona un el
Menultem ActionEvent
del menú.
El usuario mueve la ba
Scrollbar AdjustmentEvent
desplazamiento.
El usuario hace un cambio

TextComponent TextEvent
texto.
TextField ActionEvent El usuario termina de editar e

(hace un intro).
La ventana se abre, se cierra

Window WindowEvent
minimiza, se reestablece o se
Fuente: http://arquimedes.matem.unam.mx/pasados/java_profundizacion/index4.htm
Para facilitar la tarea del programador se ha creado una serie de interfaces que deben
implementarse cuando se quieren procesar algunos de estos eventos. La siguiente
tabla presenta estas interfaces con sus métodos.
Tabla 2
Interfaces
Interfaz Métodos
ActionListener actionPerformed(ActionEvent)
AdjustmentListener adjustmentValueChanged(AdjustementEvent)
componentHidden(ComponentEvent)
componentMoved(ComponentEvent)
ComponentListener
componentResized(ComponentEvent)
componentShown(ComponentEvent)
componentAdded(ContainerEvent)
ContainerListener
componentRemoved(ContainerEvent)
focusGained(FocusEvent)
FocusListener
focusLost(FocusEvent)
ItemListener itemStateChanged(ItemEvent)
keyPressed(KeyEvent)
KeyListener keyReleased(KeyEvent)
keyTyped(KeyEvent)
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
MouseListener mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
mouseDragged(MouseEvent)
MouseMotionListener
mouseMoved(MouseEvent)
TextListener textValueChanged(TextEvent)
windowActivated(WindowEvent)
windowClosed(WindowEvent)
windowClosing(WindowEvent)
WindowListener windowDeactivated(WindowEvent)
windowDeiconified(WindowEvent)
windowIconified(WindowEvent)
windowOpened(WindowEvent)
Fuente: http://arquimedes.matem.unam.mx/pasados/java_profundizacion/index4.htm

igual 4.0

Temas Completo Poo

Cargado por

Copyright:

Formatos disponibles

Temas Completo Poo

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Temas Completo Poo

Cargado por

Copyright:

Formatos disponibles

2/7/2020 Tema 1: Conceptos generales de la POO

Conceptos generales de la POO

Unidad de Educación a Distancia

1.1. Sistema de control de versionamiento (VCS)

1.1. Sistema de control de versionamiento (VCS)

Sistemas de control de versiones locales

Figura 1. Diagrama de control de versionamiento local.

Sistemas de control de versiones centralizados

Figura 2. Diagrama de control de versionamiento centralizado.

Sistemas de control de versiones distribuidos

Figura 3. Diagrama de control de versionamiento distribuido.

Unidad de Educación a Distancia

1.1.1. Software VCS: Git, GitHub

1.1.1. Software VCS: Git, GitHub

Git fue creado pensando en la eficiencia y la confiabilidad del mantenimiento de versiones

Algunas de las características más importantes de Git son:

GitHub es un sistema de gestión de proyectos y control de versiones de código, así como

más de conocimientos de tecnología y uso de una línea de comando.

Ejemplo de uso de GitHub

Fuente: Pablo Pärra

Fuente: Pablo Parra

Luego procederás a instalar. El siguiente paso es tener una cuenta en GitHub. En la

Fuente: Pablo Parra

Figura 7. Crear repositorio.

Fuente: Pablo Parra

Figura 8. Ejemplo de código.

Fuente: Pablo Parra

Nos dirigimos a la barra de herramientas y seguimos estos pasos:

Fuente: Pablo Parra

Buscamos donde está nuestro proyecto y damos clic en OK.

Figura 10. Guardar proyecto.

Fuente: Pablo Parra

El siguiente paso es dar clic derecho en nuestro proyecto.

Figura 11. Ejemplo.

Fuente: Pablo Parra

Buscamos la opción Git y le damos clic en Add.

Figura 12. Add.

Fuente: Pablo Parra

Hacemos el mismo paso pero esta vez damos clic en Commint.

Figura 13. Commint.

Fuente: Pablo Parra

Figura 14. Commint.

Fuente: Pablo Parra

Después le volvemos a dar clic derecho al proyecto con lo siguiente:

Figura 15. Push.

Fuente: Pablo Parra

Figura 16. Copiar URL.

Fuente: Pablo Parra

Figura 17. Añadir URL.

Fuente: Pablo Parra

Seleccionamos el combo box y damos clic en siguiente y finalizar.

Figura 18. Siguiente.

Fuente: Pablo Parra

Actualizamos nuestro repositorio y ya está el proyecto creado en el repositorio.

Figura 19. Repositorio.

Fuente: Pablo Parra

Le damos clic en nuestro proyecto.

Figura 20. Código en Git.

Fuente: Pablo Parra

Unidad de Educación a Distancia