TECNOLOGÍAS DE LA INFORMACIÓN

EN LINEA
PROGRAMACIÓN ORIENTADA A OBJETOS (POO)
4 créditos
33

Titulaciones Semestre

• PROGRAMACIÓN ORIENTADA A OBJETOS Segundo

Tutorías: El profesor asignado se publicará en el entorno virtual de aprendizaje online.utm.edu.ec), y sus

horarios de conferencias se indicarán en la sección

CAFETERÍA VIRTUAL.

PERÍODO MAYO / SEPTIEMBRE 2023

Índice

Tabla de contenido

Unidad 1 Fundamentos de la programación orientada a objetos .................................................................... 2

Tema 1: Introducción al paradigma orientado a objeto............................................................................. 2
Propiedades del paradigma orientado a objeto ........................................................................................ 3
Principales Paradigmas de la programación ............................................................................................. 4
Utilización de una interfaz de programación de aplicaciones................................................................... 6
Tema 2: Fundamentos de la programación orientada a objetos .............................................................. 11
Lenguaje de Programación Java ............................................................................................................. 13
Características del Lenguaje ................................................................................................................... 13
Sintaxis del Lenguaje ............................................................................................................................. 14
Estructura de un programa .................................................................................................................... 16
Variables y tipos de datos ....................................................................................................................... 17
Expresiones y estructuras de control ...................................................................................................... 20
Arreglos de una y dos dimensiones ........................................................................................................ 23
Objetos y variables de referencia ............................................................................................................ 26
Definición de una clase.......................................................................................................................... 26
Métodos ................................................................................................................................................. 28
Constructores y sobrecarga de métodos ................................................................................................. 36
Encapsulamiento ................................................................................................................................... 41
Tema 3: UML ........................................................................................................................................... 46
Introducción a UML ............................................................................................................................. 46
Interacción de clases .............................................................................................................................. 47

1
 Organización de la lectura para el estudiante por semana del compendio
Semanas Paginas
Semana 1 Página 1 – 10
Semana 2 Página 11 – 45
Semana 3 Página 46 – 58

Resultado de aprendizaje de la asignatura

Aprender los conceptos básicos y desarrollar habilidades de programación bajo el enfoque orientada
a objetos, comportamiento, relaciones y operaciones, para que el estudiante resuelva problemas a
través del entendimiento de objetos reales o imaginarios del mundo.

Programación Orientada a
Objeto

Unidad 1 Fundamentos de la programación orientada a objetos

Resultado de aprendizaje de la unidad: Conocer los conceptos fundamentales de la programación

orientada a objetos (POO) para el desarrollo de soluciones computacionales de complejidad media.

Tema 1: Introducción al paradigma orientado a objeto

La programación orientada a objetos o POO es un paradigma de programación que usa objetos y

sus interacciones, para diseñar aplicaciones y programas de computadoras. Está basado en varias
técnicas, incluyendo herencia, abstracción, polimorfismo y encapsulamiento.

Un paradigma de programación representa un enfoque particular o filosofía para la construcción

del software. No es mejor uno que otro, sino que cada uno tiene ventajas y desventajas.

En la POO las entidades centrales son los objetos, que son tipos de datos que encapsulan con el
mismo nombre estructuras de datos, operaciones o algoritmos que manipulan esos datos.

2
Objeto: Entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o
funcionalidad (métodos) los mismos que consecuentemente reaccionan a eventos. Se corresponde
con los objetos reales del mundo que nos rodea, o a objetos internos del sistema (del programa). Es
una instancia a una clase.

Recuerda que: Un paradigma de programación es un estilo de

desarrollo de programas. Es decir, un modelo para resolver problemas
computacionales.

Propiedades del paradigma orientado a objeto

Abstracción

Jerarquia PPOO Encapsulamiento

Modularidad

3
Abstracción. - Representa las características esenciales de un objeto sin preocuparse de las restantes
características. Se centra en la vista externa de un objeto de modo que sirve para separar el
comportamiento esencial de un objeto, de su implementación.

Encapsulamiento. - Es la que asegura que el contenido de la información de un objeto esta oculta al

mundo exterior, es decir el objeto A no conoce lo que hace el objeto B y viceversa.

Modularidad. - Permite subdividir una aplicación en partes más pequeñas llamadas módulos, cada
una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las partes
restantes.

Jerarquía. - Es la propiedad que permite una ordenación de las abstracciones, las dos jerarquías más
importantes de un sistema complejo son:

− Estructuras de clases (jerarquía Es-Un: Generalización/Especificación)

− Estructuras de objetos (jerarquía Parte-De: Agregación)

Principales Paradigmas de la programación

En la evolución de la programación han surgido diversas técnicas de programación que se han ido
adaptando a las necesidades tecnológicas e informáticas del momento. Aunque la forma de enfocar
la elaboración de los programas es diferente en cada una de ellas, el objetivo es el mismo: facilitar la
creación y el mantenimiento de programas informáticos. Estas técnicas se han traducido en
diferentes filosofías de creación de programas que son los denominados paradigmas de
programación.

Sabías que: Las bases de la programación orientada a objetos son:

abstracción, encapsulación, modularidad y jerarquización.

En la actualidad existe una gran cantidad de Lenguajes de Programación, y estos han evolucionado
de acuerdo a las necesidades presentadas en cada proceso del desarrollo, A continuación, se detallan
algunos paradigmas de programación:

4
Propiedades del paradigma orientado a objeto

Imperativo

Lógico Paradigmas Funcional

Orientado
a objeto

Paradigma Imperativo. - Contienen instrucciones que dicen al ordenador cómo realizar una tarea.
Los primeros lenguajes imperativos fueron los códigos máquina de los ordenadores, que utilizaban
instrucciones sencillas y permitían implementar el hardware fácilmente, pero no servían para
desarrollar programas complejos. El primer lenguaje imperativo que posibilitó la creación de
programas con un nivel de complejidad elevado fue FORTRAN. Hoy en día está representado por
los lenguajes de programación BASIC, C ó PASCAL, entre otros.

Paradigma Funcional. - Los programas funcionales se basan en el uso de una o más funciones
dentro de las cuales se pueden utilizar funciones creadas anteriormente. Su objetivo es dividir el
programa en módulos de forma que cada uno de éstos realice una única función. El primer lenguaje
de programación funcional fue LISP. Existen dos tipos de lenguajes funcionales: los puros (como
HASKELL) y los híbridos (SAP, ML, Scheme)

5
Paradigma Lógico. - La programación lógica comprende la programación declarativa y la funcional.
El proceso de elaboración de programas está basado en la lógica de primer orden y, a diferencia de
los demás paradigmas, especifica qué debe hacer el programa y no cómo hacerlo. Se emplea en
aplicaciones de inteligencia artificial. El lenguaje de programación lógica por excelencia es
PROLOG.

Paradigma Orientado a Objeto (POO). - La programación orientada a objetos expresa un programa

como un conjunto de objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los
programas y módulos más fáciles de escribir, mantener, reutilizar y volver a utilizar. Su uso se
popularizó a principios de los 90 y actualmente son muchos los lenguajes de programación
asociados a este paradigma. Las características del paradigma orientado a objetos son:
encapsulamiento, abstracción, polimorfismo y herencia. Muchos lenguajes utilizados en la
actualidad están orientados a objetos, como Java, C++, Python o Delphi. Un lenguaje
completamente orientado a objetos es Smalltalk.

Utilización de una interfaz de programación de aplicaciones

La API define la forma correcta para que un desarrollador escriba un programa que solicite servicios
de un sistema operativo (SO) u otra aplicación. Las API se implementan mediante llamadas a
funciones compuestas de verbos y sustantivos. La sintaxis requerida se describe en la documentación
de la aplicación a la que se llama.

Sabías que: Una interfaz de programación de aplicaciones (API) es un

código que permite que dos programas de software se comuniquen
entre sí.

Cómo funcionan las API

Azpitarte et al (2009) expresa que las API se componen de dos elementos relacionados; la primera es
una especificación que describe cómo se intercambia la información entre programas, hecha en
forma de una solicitud de procesamiento y una devolución de los datos necesarios. El segundo es
una interfaz de software escrita según esa especificación y publicada de alguna manera para su uso.

En la Figura 1, se muestra el rol que juegan las API, lo que hace posible conectar fácilmente
diferentes fuentes de datos y habilitar la cadena de valor digital.

6
 Figura 1. Diagrama API de conexión de datos (Azpitarte et al., 2009)

Comprueba tu aprendizaje

1. Son aquellos cuyas sentencias están formadas por códigos nemotécnicos (abreviaturas de
palabras en inglés).

Lenguaje maquina

Lenguaje de programación

Lenguaje de bajo nivel

Lenguaje Ensamblador

2. Definición de reglas, Unificación como elemento de computación, Programación

declarativa, Lenguajes: Prolog, Mercury, Oz.

Programación Lineal

Paradigma Orientado a objetos

7
 Paradigma imperativo

Paradigma lógico

3. Tienen origen en Simula 67, un lenguaje diseñado para hacer simulaciones, creado por
Ole-Johan Dahl y Kristen Nygaard del Centro de Cómputo Noruego en Oslo.

Programación Lineal

Programación Lógica

POO

Programación imperativa

4. Es una forma de escribir programación de computadora de forma clara, para ello se

utilizan únicamente tres estructuras: secuencial, selectiva e iterativa; siendo innecesario y
no permitiéndose el uso de la instrucción o instrucciones de transferencia incondicional
(GOTO).

Programación orientada a objetos

Programación Lógica

Programación estructurada

Programación Lineal

5. Las instrucciones en este tipo de lenguaje se componen de la unidad de memoria más

pequeña que existe dentro de una computadora, que se llama bit.

Lenguaje maquina

Lenguaje de programación

Lenguaje de bajo nivel

Lenguaje Ensamblador

6. El principal inconveniente de este método de programación, es que se obtiene un único

bloque de programa, que cuando se hace demasiado grande puede resultar problemático
su manejo, esto se resuelve empleando la programación modular, definiendo módulos

8
 interdependientes programados y compilados por separado. Un método un poco más
sofisticado es la programación por capas, en la que los módulos tienen una estructura
jerárquica muy definida y se denominan capas.

Desventaja de la programación

Desventaja de la programación estructurada

Desventaja de la programación orientada a objetos

Desventaja de la programación lineal

Desventaja de la programación imperativa

7. Definición de procedimientos, Definición de tipos de datos, Chequeo de tipos en tiempo

de compilación, Cambio de estado de variables, Pasos de ejecución de un proceso

Paradigma Funcional

Paradigma orientado a objetos

Paradigma imperativo

Paradigma lógico

8. Representa un enfoque particular o filosofía para la construcción del software. No es

mejor uno que otro, sino que cada uno tiene ventajas y desventajas.

Paradigma de programación

Paradigma orientado a objetos

Paradigma lógico

Paradigma imperativo

9. La computación se realiza mediante la evaluación de expresiones, Definición de

funciones, Funciones como datos primitivos, Valores sin efectos laterales, no existe la
asignación, Programación declarativa, Lenguajes: LISP, Scheme, Haskell, Scala

Paradigma Funcional

9
 Paradigma Orientado a objetos

Paradigma imperativo

Paradigma lógico

10. Son aquellos que poseen sentencias formadas por palabras similares a las de los lenguajes
humanos.

Lenguaje maquina

Lenguaje de programación

Lenguaje de bajo nivel

Lenguaje de alto nivel

11. Son un conjunto de reglas, herramientas y condiciones que admiten crear programas o
aplicaciones dentro de una computadora.

Lenguaje maquina

Lenguaje de programación

Lenguaje de bajo nivel

Lenguaje Ensamblador

10
Tema 2: Fundamentos de la programación orientada a objetos
Antes de empezar a desarrollar las características propias de la programación orientada a objeto,
conviene hacer una revisión de alto nivel de la programación, sus fases y sus diferentes métodos.

En el proceso de desarrollo de un sistema de información (un programa, software, en general) hay

una serie de etapas o fases en las que la programación como tal es una de ellas, ni tan siquiera la
más importante. Hay diferentes modelos de desarrollo en los que se definen esas fases o etapas antes
comentadas; uno de ellos es el método en cascada (waterfall) que nos servirá como guía en el
desarrollo de estas ideas.

Según este modelo, a grandes rasgos, el desarrollo software consta de las siguientes fases:

Análisis. - Esta es una de las fases más importantes puesto que se trata de definir y analizar el
problema en su totalidad.

Diseño. – Junto con el análisis anterior, diseña una solución del problema. Se trataría de definir los
módulos, patrones, algoritmos, entre otros, que ayudaran a una solución. Entre esta fase y la
anterior, se debería consumir un 70-80 % del tiempo del proyecto.

Desarrollo. - Sería un equivalente a la programación. En este caso, el diseño anterior se traducirá a

un lenguaje de programación concreto; en esta fase es donde realmente se programa (codifica).

Pruebas. - Periodo en el que el producto se somete a diferentes tipos de pruebas: de sistema, de

integración, entre otros.

Implantación. - Proceso de puesta en producción del producto.

Mantenimiento. - Realizar mejoras varias sobre el producto desde el punto de vista tecnológico,
funcional, entre otros.

En la vida real podremos apreciar que casi todo se compone de objetos (coche, lapicero, casa y,
porque no, personas). Todos entendemos que tanto un BMW verde como un SEAT rojo son
coches, pero son distintos en su aspecto físico. Pero a pesar de esa diferencia de aspecto entendemos

11
que ambos tienen unas características comunes como son poseer ruedas, un volante, asientos, Esas
características comunes son las que hacen pensar en el concepto coche en ambos casos. A partir de
ahora podemos interpretar que el BMW y el SEAT son objetos, y el tipo o clase, de esos objetos es
coche.

Además, se puede suponer que la clase de un objeto describe como es dicho objeto.

Por ejemplo:

clase Coche:
4 ruedas
1 volante
5 asientos
acelerar
frenar
girar

Como se puede observar en esta clase no sólo describe que cosas posee un coche, sino que también
describe que acciones puede realizar un coche (acelerar, frenar y girar). Es decir, una clase define los
atributos y las acciones (o métodos) que puede realizar un objeto de la clase.

Además, se comprueba que un objeto puede estar formado por otros objetos, por ejemplo, el coche
posee 4 objetos de la clase Rueda.

En el mundo real los objetos se relacionan entre sí, un objeto puede pedir a otro que realice alguna
acción por él. En la vida real una persona acelera, pero lo hace pidiéndoselo al coche, que es quien
realmente sabe acelerar, no la persona. El hecho de que un objeto llame a un método de otro objeto
se indica diciendo que el primer objeto ha enviado un mensaje al segundo objeto, el nombre del
mensaje es el nombre de la función llamada.

Recuerda que: Una interpretación de una clase es el plano que describe como
es un objeto de la clase, por tanto, podemos entender que a partir de la clase
podemos fabricar objetos. Ese objeto construido se le denomina instancia, y al
proceso de construir un objeto se le llama instanciación.

Cuando se construye un objeto es necesario dar un valor inicial a sus atributos, es por ello que
existe un método especial en cada clase llamado constructor, el cual es ejecutado de forma
automática cada vez que es instanciada una variable. Generalmente el constructor se llama igual que

12
la clase y no devuelve ningún valor. Análogamente destructor es un método perteneciente a una
clase que es ejecutado de forma automática cuando un objeto es destruido. Java no soporta los
destructores. Es posible que exista más de un constructor en una clase, diferenciados sólo en los
parámetros que recibe, pero en la instanciación sólo será utilizado uno de los constructores.

Lenguaje de Programación Java

El lenguaje de programación Java, fue diseñado por la compañía Sun Microsystems Inc, con el
propósito de crear un lenguaje que pudiera funcionar en sistemas de ordenadores heterogéneos
(redes de computadoras formadas por más de un tipo de ordenador, ya sean PC compatibles,
Macintosh o estaciones de trabajo que empleen diferentes sistemas operativos como Windows,
OS/2 o Unix), y que fuera independiente de la plataforma en la que se vaya a ejecutar. Esto
significa que un programa de Java puede ejecutarse en cualquier máquina o plataforma.

Su origen se remonta a la creación de un lenguaje de programación para el desarrollo de

aplicaciones para electrodomésticos y otros aparatos electrónicos de consumo por parte de una
empresa filial de Sun, llamada FirstPerson en 1991. Su creador, James Gosling, lo bautizó como
Oak. Al abandonarse este proyecto, el lenguaje se modificó, al igual que su nombre y se orientó al
desarrollo de aplicaciones para la red. En septiembre de 1995 aparece el primer Kit de Desarrollo de
Java (JDK). A principios de 1997 se presenta la primera revisión de Java (la versión 1.1) y a finales de
1998 surge la versión 1.2 (Java 2) que introdujo modificaciones bastante significativas. En octubre
de 2004 se hace pública la versión Java 1.5 (Java 5) incluyendo innovaciones muy importantes en la
plataforma.

Características del Lenguaje

Según la propia Sun Microsystems, el lenguaje Java muestra las siguientes características generales:

Sencillo. - Elimina la complejidad de los lenguajes como C y da paso al contexto de los lenguajes
modernos orientados a objetos. Aunque la sintaxis de Java es muy similar a C y C++, que son
lenguajes a los que una gran mayoría de programadores están acostumbrados a emplear.

Orientado a Objetos. - La filosofía de programación orientada a objetos es diferente a la

programación convencional (imperativa o procedural). Su nivel de abstracción facilita la creación y
mantenimiento de programas. Existen muchas referencias que dan una introducción a esta forma
de programar.

13
Independiente a la arquitectura y portable. - Al compilar un programa en Java, el código resultante
es un tipo de código binario conocido como Java bytecodes. Este código es interpretado por
diferentes computadoras de igual manera, por lo que únicamente hay que implementar un
intérprete para cada plataforma. De esa manera Java logra ser un lenguaje que no depende de una
arquitectura de ordenador específica. Como el código compilado de Java es interpretado, un
programa compilado de Java puede ser utilizado por cualquier computadora que tenga
implementado el intérprete de Java.

Robusto. - Java simplifica la gestión de la memoria dinámica. Por ejemplo, ya no es necesaria la

liberación explícita, el intérprete de Java lo lleva a cabo automáticamente cuando detecta que una
variable dinámica ya no es usada por el programa. Finalmente, el acceso a la memoria es supervisado
por el intérprete de tal manera que no es posible acceder a zonas de memoria no autorizadas sin
provocar un error. Por ejemplo, no es posible escribir fuera de los límites de un vector.

Seguro. - El sistema de Java tiene ciertas políticas que evitan que se puedan codificar virus con este
lenguaje. Existen muchas restricciones, especialmente para los denominados applets, que limitan lo
que se puede y no puede hacer con los recursos críticos de una computadora.

Multitarea. - Un lenguaje que soporta múltiples threads, hilos o tareas, es un lenguaje que puede
ejecutar diferentes líneas de código al mismo tiempo. El soporte y la programación de hilos en Java
está integrado en la propia sintaxis del lenguaje.

Dinámico. - En Java no es necesario cargar completamente el programa en memoria, sino que las
clases compiladas pueden ser cargadas bajo demanda en tiempo de ejecución (dynamic binding).
Esto proceso permite la carga de código bajo demanda.

Sintaxis del Lenguaje

Java es un lenguaje orientado a objetos, eso implica que su concepción es muy próxima a la forma
de pensar humana. También posee otras características muy importantes:

Es un lenguaje que es compilado, generando ficheros de clases compilados, pero estas clases
compiladas son en realidad interpretadas por la máquina virtual java. Siendo la máquina
virtual de java la que mantiene el control sobre las clases que se estén ejecutando.
Es un lenguaje multiplataforma: El mismo código java que funciona en un sistema operativo
funcionará en cualquier otro sistema operativo que tenga instalada la máquina virtual java.

14
 Es un lenguaje seguro: La máquina virtual al ejecutar el código java realiza comprobaciones
de seguridad, además el propio lenguaje carece de características inseguras, como por
ejemplo los punteros.
Gracias al API de java podemos ampliar el lenguaje para que sea capaz de, por ejemplo,
comunicarse con equipos mediante red, acceder a bases de datos, crear páginas HTML
dinámicas, crear aplicaciones visuales al estilo windows,

Para poder trabajar con java es necesario emplear un software que permita desarrollar en java,
existen varias alternativas comerciales en el mercado: JBuilder, Visual Age, Visual Café, y un
conjunto de herramientas shareware e incluso freeware que permiten trabajar con java. Pero todas
estas herramientas en realidad se basan en el uso de una herramienta proporcionada por Sun, el
creador de java, que es el Java Development Kit (JDK). Nosotros nos centraremos en el uso de dicha
herramienta.

El lenguaje se basa en pensar que hay en el mundo real objetos y esos objetos tienen un tipo, o
clase. Por ello el lenguaje se basa en clases, que describen como son los objetos.

Recuerda que: El lenguaje tiene una clase que describe ficheros, una que
describe cadenas de texto, o bien se puede crear clases, por ejemplo, la clase
Persona que describe los datos que interesan de una persona.

Por ello siempre para comenzar a trabajar con un programa java hay que crear una clase:

public class TablaMultiplicar

{

Además, se deben de cumplir las siguientes características:

La clase se debe de llamar exactamente igual que el fichero que la contiene.

La clase que se llama igual que el fichero debe de estar precedida de la palabra public.

Cuando se intenta ejecutar una clase java la máquina virtual lo que hace es llamar a un método
especial llamado main que debe de estar dentro de la clase a ejecutar:

15
public class TablaMultiplicar
{
public static void main (String arg[])
{

}
}

Y es dentro de la función main es donde se escribe el código que se va a ejecutar:

public class TablaMultiplicar

{
public static void main(String arg[])
{
int numero = Integer.parseInt(arg[0]);
for (int i = 1; i<=10; i++)
{
System.out.println(""+numero+" * "+i+" = "+(i*numero));
}
}
}

Estructura de un programa
La estructura de un programa de Java es similar a la de un programa de C/C++. Por su diseño,
permite a los programadores de cualquier otro lenguaje leer código en Java sin mucha dificultad.
Java emplea siempre la Programación Orientada a Objetos por lo que todo el código se incluye
dentro de las clases. Aunque ya se explicarán detenidamente más adelante, las clases son
combinaciones de datos (constantes y variables) y rutinas (métodos).

La estructura de un programa simple en Java es la siguiente:

public class ClasePrincipal

{
public static void main(String[] args)
{
sentencia_1;
sentencia_2;
// ...
sentencia_N;

16
 }
}

Como primer ejemplo sencillo de programa escrito en Java se va a utilizar uno que muestra un
mensaje por la pantalla del ordenador. Por ejemplo, el programa Hola.java:

/***** Inicio de comentarios

* La clase hola construye un programa que

* muestra un mensaje en pantalla

*/ Fin de comentarios

public class Hola

{
public static void main(String[] args)
{
System.out.println("Hola, ");
System.out.println("me llamo Angel");
System.out.println("Hasta luego");
}
}

Variables y tipos de datos

Las variables en Java pueden ser uno de los siguientes tipos:

Tipo primitivo. - Una variable de tipo primitivo contiene un solo valor del tamaño y formato
apropiado de su tipo: un número, un carácter, o un valor booleano.

La tabla siguiente lista los tipos de datos primitivos soportados por Java.

Tipo Descripción Tamaño/Formato

Números enteros

byte Entero byte 8-bit 2’s

short Entero corto 16-bit 2’s

int Entero 32-bit 2’s

long Entero largo 64-bit 2’s

Números reales

17
 float Punto flotante 32-bit IEEE 754

double Punto flotante de doble precisión 64-bit IEEE 754

Otros tipos

char Un solo carácter 16-bit caracteres Unicode

boolean Un valor booleano true o false

Tabla 1: tipos de datos primitivos soportados por Java

Recuerda que: En Java, cualquier numérico con punto flotante

automáticamente se considera double. Para que sea considerado float se agrega
una letra "f" o "F" al final del valor.
double d = 10.50;
float f = 10.50F;

Referencia. - Los arreglos, las clases y las interfaces son del tipo referencia. El valor de una variable
del tipo referencia es una dirección de un conjunto de valores representados por una variable.

Las referencias en Java no son como en C++, éstas son identificadores de instancias de alguna clase
en particular.

Ejemplo:

String cad; //referencia a un objeto de la clase String

Punto p; //referencia a un objeto de la clase Punto

int[] var_arreglo; //referencia a un arreglo de enteros

Sentencia. - Una instrucción o sentencia representa la tarea más sencilla que se puede realizar en un
programa.

Sentencias de expresión. - Los siguientes tipos de expresiones pueden ser hechas dentro de una
sentencia terminando la expresión con punto y coma (;):

Expresiones de asignación
Cualquier uso de los operadores ++ y --
Llamada de métodos

18
 Expresiones de creación de objetos

Esta clase de sentencias son llamadas sentencias de expresión.

Ejemplo:

valorA = 8933.234; // asignación

valorA++; // incremento

System.out.println(valorA); // llamada a un método

Integer objInt = new Integer(4); // creación de objetos

Sentencias de declaración de variables. - Las sentencias de declaración de variables se utilizan para

declarar variables.

Ejemplo:

int bValue;

double aValue = 8933.234;

String varCad;

Sentencias de control de flujo. - Las sentencias de control de flujo determinan el orden en el cual
serán ejecutadas otro grupo de sentencias. Las sentencias if y for son ejemplos de sentencias de
control de flujo.

Bloque de sentencias. - Un bloque es un grupo de cero o más sentencias encerradas entre llaves ( { y
} ). Se puede poner un bloque de sentencias en cualquier lugar en donde se pueda poner una
sentencia individual.

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de tipos de datos, variables y operadores.
https://www.youtube.com/watch?v=OyBibRaS1Bk.

19
Expresiones y estructuras de control
JAVA al igual que C y C++ utiliza las estructuras de control if-else, while, do-whiel y como selector
de opciones la estructura switch. Las estructuras de control rigen en su ejecución a partir de una
condición del tipo boolean, es decir, el resultado de operadores lógicos o el resultado de un método
que retorne un valor de verdad, verdadero o falso

Bifurcacion if-else
La bifurcación if-else es la más simple de las estructuras:

if (expresionBooleana)
{
sentencias1;
}
else
{
sentencias2;
}

Bifurcacion if-else-if-else
if (expresionBooleana)
{
sentencias1;
}
else if (exprecionBooleana2)
{
sentencias2;
}
else
{
sentencias3;
}

Bifurcacion switchs

El switch es clasificado como selector de sentencias de ejecución evaluando una expresión integral
(valor numérico entero o carácter).

switch (expresionIntegral)
{
case valor1: sentencias1; break;
case valor2: sentencias2; break;
case valor3: sentencias3; break;

20
 default: setencias4; break;
}

La ejecución se resuelve evaluando la expresión integral y se busca desde la primera expresión hacia
la expresión por defecto, cual etiqueta de evaluación de caso resuelve ser igual en valor, al valor de la
expresión integral. En caso de no ser ninguna de las etiquetas (case) igual al valor de la expresión se
ejecutan las sentencias de la opción default.

En caso de no agregar las sentencias break, se ejecutará de continuo una etiqueta tras otra hasta
encontrar un break o salir del alcance definido por el switch.

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de estructuras de control if – else y switch.
https://www.youtube.com/watch?v=CJol15sy4oM.

Bucle while

Las sentencias de bucles, son clasificadas como sentencias de iteración. Las sentencias serán
ejecutadas a la medida en que sea verdadera la expresión booleana, solo dejarán de ejecutarse
cuando esta expresión sea falsa. La expresión puede nunca ser verdadera, en ese caso se ejecutarán
las sentencias que están dentro del ciclo.

while (expresionBooleana)
{
sentencias;
}

Bucle do-while

La única diferencia con el bucle while es que el bucle do-while ejecuta al menos una vez las
sentencias, aunque desde el principio la expresión booleana sea falsa.

do
{
sentencias;
} while(expresionBooleana);

Bucle for

21
El bucle for permite en un principio una inicialización, luego itera comenzando con una evaluación
de la expresión booleana y por último realiza algún tipo de paso a próximo, o reducción de la
complejidad del algoritmo, en camino hacia convertir la expresión booleana en falso. Se ejecutan las
sentencias, mientras la expresión booleana se mantenga en un estado de verdadero por cada paso.

for (inicialización; expresionBooleana; postAccion)

{
sentencias;
}

Sentencia break

La sentencia break puede encontrarse dentro del alcance de un ciclo. Generalmente se encuentra
dentro de una bifurcación, tal que si una condición booleana se cumple si ejecutará el break y saldrá
del alcance del ciclo.

Si bien se escribe de la misma forma que el break del switch, su funcionamiento es distinto dado
que no salta al siguiente paso, sino que corta la ejecución del ciclo, sin importar el estado de verdad
o falsedad de la expresión booleana, y lo deja sin efecto.

Sentencia continue

La sentencia continue puede utilizarse en ciclos, y permite la omisión de la ejecución de las

sentencias definidas justo luego de la sentencia, dado que salta la ejecución hasta la próxima
iteración. Generalmente se encuentra dentro de una bifurcación, de forma tal que una expresión
booleana permita saltar las sentencias siguientes, hasta la próxima iteración del ciclo.

Moreno (2000) indica que debe tomarse muy en cuenta que antes de la ejecución de un continue
debe haberse logrado reducir la complejidad del algoritmo, ya que, al saltar a la próxima iteración, si
la expresión booleana sigue en la misma condición y no se ha reducido la complejidad, puede
generarse un ciclo infinito de ejecución.

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de estructuras de control while, do while y for.
https://www.youtube.com/watch?v=qZLXT832VlM.

22
Arreglos de una y dos dimensiones
Arreglos unidimensionales

La sintaxis para declarar e inicializar un array será:

Tipo_de_variable[ ] Nombre_del_array = new Tipo_de_variable[dimensión];

También se puede usar esta declaración:

Tipo_de_variable[ ] Nombre_del_array;

Nombre_del_array = new Tipo_de_variable[dimensión];

El tipo de variable puede ser cualquiera de los admitidos por Java y que ya hemos explicado.
Ejemplos de declaración e inicialización con valores por defecto de arrays usando todos los tipos de
variables Java, serían:

byte[ ] edad = new byte[4];

short[ ] edad = new short[4];
int[ ] edad = new int[4];
long[ ] edad = new long[4];
float[ ] estatura = new float[3];
double[ ] estatura = new double[3];
boolean[ ] estado = new boolean[5];
char[ ] sexo = new char[2];
String[ ] nombre = new String[2];

Aclarar que los valores por defecto son los siguientes:

a) Para números el valor cero “0”.

b) Para cadenas y letras el valor vacío.
c) Para booleanos el valor false.

En caso de que queramos inicializarlos con valores propios, haremos esto:

Para números enteros

int[ ] edad = {45, 23, 11, 9}; //Array de 4 elementos

23
De la misma forma procederíamos para los otros tipos de enteros: byte, short, long.

Para números reales

double[ ] estatura = {1.73, 1.67, 1.56}; //Array de 3 elementos

De la misma forma procederíamos para el tipo float, pero teniendo en cuenta que los números
deberán llevar al final la letra “f” o “F”. Por ejemplo 1.73f o 1.73F.

Para cadenas

String[ ] nombre = {"María", "Gerson"}; //Array de 2 elementos

Para caracteres

char[ ] sexo = {'m', 'f'}; //Array de 2 elementos

Para booleanos

boolean[ ] = {true,false}; //Array de 2 elementos

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de arreglos unidimensionales.
https://www.youtube.com/watch?v=O3ke7e-pC3o.

Arreglos Bidimensional

Es muy común llamarles arreglos bidimensionales, arreglos 2d, o matrices, pero en realidad, se
tratan de un arreglo de arreglos. Sólo que, para su manipulación lógica, ha sido más conveniente
pensar en ellos como una tabla de valores.

24
 Figura 2: Declaración de un arreglo bidimensional

Como puedes observar ahora tenemos dos dimensiones: el número de renglones y el número de
filas del arreglo.

Al igual que los arreglos unidimensionales, el proceso de declaración y construcción puede realizarse
en una sola sentencia o en dos. En la figura 3 puedes ver la instrucción que crea una matriz.

Figura 3. Construcción de una matriz o arreglo bidimensional

Al igual que los arreglos unidimensionales, las dimensiones de una matriz deben:

Ser un valor entero.

Pueden expresarse como constantes numéricas (10, 100, 1000, etc)

arreglo = new int[10][5];

También pueden expresarse como una constante simbólica, ya sea las dos dimensiones o
sólo una de ellas.

public static final R = 10;

public static final C = 6;
...
matriz = new boolean[R][C];

Y también pueden usarse variables enteras previamente inicializadas.

int renglones = 12;

int columnas = 8;
matriz = new double[renglones][columnas];

25
 La primera dimensión se refiere al total de renglones de la matriz, y la segunda se refiere al
total de columnas.

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de arreglos bidimensionales.
Objetos y variables de referencia
https://www.youtube.com/watch?v=9W1DegmmNZs.
El elemento fundamental de la POO es, como su nombre indica, el objeto. Se define a un objeto
como un conjunto complejo de datos y programas que poseen estructura y forman parte de una
organización. En este caso las estructuras de datos y los algoritmos usados para manipularlas están
encapsulados en una idea común llamada objeto.

Esta definición específica dos propiedades características de los objetos:

En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto
número de componentes bien estructurados.
En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una
organización jerárquica o de otro tipo.

Definición de una clase

Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es una clase o describe
cómo funciona una clase. El conocimiento de las clases es fundamental para poder entender los
programas Java.

Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto.
Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables
globales. Esto puede despistar a los programadores de C++, que pueden definir métodos fuera del
bloque de la clase, pero esta posibilidad es más un intento de no separarse mucho y ser compatible
con C, que un buen diseño orientado a objetos. Así pues, el esqueleto de cualquier aplicación Java
se basa en la definición de una clase.

Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos.
En C la unidad fundamental son los ficheros con código fuente, en Java son las clases. De hecho,
son pocas las sentencias que se pueden colocar fuera del bloque de una clase. La palabra clave
import (equivalente al #include) puede colocarse al principio de un fichero, fuera del bloque de la

26
clase. Sin embargo, el compilador reemplazará esa sentencia con el contenido del fichero que se
indique, que consistirá, como es de suponer, en más clases.

Tipos de Clases

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que
hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son:

Abstract

Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que
se utiliza como clase base para la herencia.

Final

Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar
de una clase final. Por ejemplo, la clase Math es una clase final.

Public

Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son
accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes,
primero tienen que ser importadas.

Synchronizable

Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir,
que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de
colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se
puedan modificar las mismas variables sin que haya problemas de que se sobrescriban.

Variables y método de instancia

Una clase en Java puede contener variables y métodos. Las variables pueden ser tipos primitivos
como int, char, etc. Los métodos son funciones.

Por ejemplo:

27
La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el constructor de la clase y
Suma_a_i( int j ).

Métodos
Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases. El
constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que
realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase.

Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de MiClase, se crean
(instancian) todos los métodos y variables, y se llama al constructor de la clase:

MiClase mc;
mc = new MiClase();

La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada con new no
consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo
objeto mc, el valor de i en el objeto mc será igual a 10. Se puede referenciar la variable (de instancia)
i con el nombre del objeto:

mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar
al método Suma_a_i() utilizando el nuevo nombre de clase mc:

mc.Suma_a_i( 10 );

y ahora la variable mc.i vale 21.

Finalizadores

Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger
automáticamente todos los objetos que se salen del alcance. No obstante, proporciona un método

28
que, cuando se especifique en el código de la clase, el reciclador de memoria (garbage collector)
llamará:

// Cierra el canal cuando este objeto es reciclado

protected void finalize() { close(); }

Ejemplo de Método:

/*** Demostración del método cubo

*/
public class PruebaCubo
{
public static void main (String [] args)
{
System.out.println("El cubo de 7.5 es: " + cubo(7.5)); // llamada
}
public static double cubo (double x)
{
// declaracion
return x*x*x;
}
}

En el siguiente código se incluye un ejemplo de método que no devuelve un valor (de tipo void):

/**
* Demostración del método tabla
*/
public class PruebaTabla
{
public static void main (String [] args)
{
tabla(4);
tabla(7);
}
public static void tabla (int n)
{
// ejemplo de llamada
// de tipo void
System.out.println("Tabla de multiplicar del número " + n);
for (int i=0; i<=10; i++)
System.out.println(n + " x " + i + " = " + producto(n, i));
return; // No devuelve ningún valor
}

29
 public static int producto (int a, int b)
{
return a*b;
}
}

Recursión de Métodos

Java permite la recursión o recurrencia en la programación de métodos. La recursión consiste en

que un método se llame a sí mismo. Un ejemplo muy típico de empleo de la recursión puede verse
en la construcción de un método que devuelva la factorial de un entero. ¡Se basa en el hecho de que
n! es igual a n·(n-1)! si n es mayor que 1. Por ejemplo:

/**
* Demostración de la función recursiva factorial
*/
public class PruebaFactorialR
{
public static void main (String [] args)
{
for (int i=1; i<=20; i++)
System.out.println("Factorial de " + i + " = " + factorialR(i));
}
public static long factorialR (int n)
{
if (n==0)
return 1;
else
return n * factorialR(n-1);
}
}

30
En la construcción de métodos recursivos es importante evitar el problema de la recursión infinita.
Es decir, que, en algún caso, la ejecución del método definido de forma recursiva no implique una
nueva llamada al propio método.

Métodos de Instancias

Los métodos de instancia, como su nombre lo indica, son aplicables a una instancia de la clase en
particular. Es decir, que un método de instancia trabaja sobre el estado actual de la instancia, y para
cada instancia tendrán un resultado distinto, por ejemplo, el hecho de comer permitirá a la
instancia mario estar satisfecho, mientras que la instancia maria estará insatisfecha hasta que
también se le aplique el método comer.

Ejemplo:

public class Persona

{
public void comer (int cantidadDeAlimento)
{
// Esto es un comentario. Acá va la definición del método.
}
}

Métodos de Clase

Los métodos de clase son un comportamiento común a todas las instancias que pertenecen a la
misma clase. Al ser un método de clase, no hace falta instanciar un objeto de la clase para utilizarlo.
Estos métodos no hablan del estado actual de la clase, sino solo de un comportamiento genérico de
la clase, de un procedimiento que solo utiliza los parámetros de entrada o las variables estáticas. Son
para un uso particular y es bien visible cuando un método debe ser estático.

Ejemplo:

public class Persona

{
public static int obtenerAlturaMaxima()
{
// Esto es un comentario. Acá va la definición del método.
}
}

Ejemplos de creación de objeto, clases y métodos

31
Un objeto en Java cumple las funciones que realizan un record en Pascal o una estructura en C. En
Java las variables sólo pueden contener referencias a objetos, es decir punteros a objetos.

Todos los objetos se crean con new: A a1= new A();

A es el tipo del objeto creado. También se dice que A es la clase del objeto o que el objeto es una
instancia de la clase A. La variable a1 también es de tipo A, o análogamente a1 es de la clase A,
porque a1 debe contener siempre referencias a objetos que pertenecen a la clase A.

Un objeto posee variables de instancia o campos que se pueden consultar o asignar. Los campos que
posee un objeto se definen al momento de declarar la clase a la cual pertenece:

class A { int x, y; }
A a= new A();
a.x= 1;
a.y= 2;
System.out.println(a.x+" "+a.y); // 1 2

Un objeto también puede poseer métodos. Un método es un procedimiento cuya invocación

siempre va asociada a un objeto. Los métodos se definen en la declaración de la clase:

class A
{
int x, y; // variables de instancia
// Métodos
void Set(int vx, int vy) { x= vx; y= vy; }
void Incx() { x++; }
void Print() { System.out.println(x+" "+y); }
}
A a= new A();
a.Set(10, 20);
a.Print(); // 10 20
a.Incx();
a.Print(); // 11 20
Incx(); // error, falta indicar el objeto
A a2= new A();
a2.Set(5, 6);
a2.Print(); // 5 6
a.Print(); // 11 20

La definición de un método tiene la siguiente sintaxis:

tipo-retorno nombre-método

32
(tipo-parámetro nombre, ...)

{instrucciones}

Si el procedimiento no retorna nada se coloca void. En las instrucciones las variables que se acceden
que no sean parámetros o variables locales del procedimiento deben ser variables de instancia del
objeto.

Una variable de tipo objeto es una referencia (puntero) a un objeto:

A a1= new A();

A a2= new A();
A a3= a2;
a1.Set(1,2);
a2.Set(5,6);
a3.Set(8,9);
a1.Print(); // 1 2
a2.Print(); // 8 9
a3.Print(); // 8 9

En este caso las variables a2 y a3 referencian el mismo objeto, mientras que a1 y a2 referencian
objetos distintos.

Una referencia puede ser pasada como argumento y puede ser retornada por un método.

class A
{
...
void CopyFrom(A from) { x= from.x; y= from.y }
A MakeCopy()
{
A acopy= new A();
acopy.Set(x, y);
return acopy;
}
}
A a1= new A();
a1.Set(1,2);
A a2= new A();
a2.CopyFrom(a1);
a2.IncX();
a2.Print(); // 2 2
a1.Print(); // 1 2
A a3=a1.MakeCopy();
a3.Print(); // 1 2

33
Dentro de un método, el identificador this contiene una referencia al objeto con que se invocó este
método.

class A
{
...
void CopyTo(A to)
{ to.CopyFrom(this); }
}

En Java no existe enlace directo entre identificador y objeto como en C o Pascal. Las variables se
pueden inicializar con la referencia nula:

A a;
a= null;
a.x= 0; // error, a es la ref. nula

Un objeto puede referenciar otros objetos:

class Eslabon
{
Eslabon next;
A a;
void Encadenar(Eslabon anext) { next= anext; }
}
...
for (Eslabon e= prim; e!=null; e= e.next)
e.a.Print();

Los arreglos y strings son objetos predefinidos.

String s= null;
s.substring(1,2); // error
int[] a= null;
a[0]=0; // error

Se pueden crear arreglos de referencias a objetos. No se pueden crear arreglos de objetos.

A[] aArr= new A[10];

aArr[0].x=1; // error, aArr[0] es nulo
for (int i=0; i<aArr.length; i++)
aArr[i]= new A();

34
Ningún objeto se destruye explícitamente: No hay free ni delete

A a= new A();
a= new A();

Azpitarte (2015) demuestra que el objeto que se creó primero ya no es alcanzable y por lo tanto el
recolector de basura recuperará el espacio que ocupa.

Ejemplos de clase y objeto:

Prerrequisitos

• Instalar y configurar Java en conjunto con el Visual Studio Code correctamente en un

equipo. Link de descarga: https://code.visualstudio.com/.

Descripción del ejemplo:

Crear una clase en Java de nombre "Animal", dentro del paquete "misClases" con los atributos raza,
nombre y edad, adicionalmente un constructor que reciba el nombre y lo asigna al animal y tres
métodos encargados de obtener y establecer la edad del animal y el restante para obtener el nombre.

package misClases; //Se le declara un paquete

public class Animal
{
private String raza;
private String nombre;
private int edad;
public Animal(String nuevoNombre)
{
nombre = nuevoNombre; //Se le da un nombre al animal
}
//Método para obtener la edad del animal
public int getEdad()
{
return edad;
}
//Método para establecer la edad del animal
public void setEdad(int nuevaEdad)
{
edad = nuevaEdad;
}
//Método para obtener el nombre del animal
public String getNombre()
{

35
 return nombre;
}
}

Ahora se procede a crear un objeto o instancia en Java para la clase “Animal”:

import misClases.Animal; //Importamos la clase Animal para poder usarla
public class Ejemplo
{
public static void main(String[] args)
{
//Creamos un animal cuyo nombré será Falco
Animal miAnimal = new Animal("Falco");
//Le establecemos 3 años de edad a Falco.
miAnimal.setEdad(3);
//Mostraremos el nombre del animal por pantalla
System.out.println("El nombre es: " + miAnimal.getNombre());
//Mostramos la edad del animal por pantalla
System.out.println(" y tiene " + miAnimal.getEdad() + " años");
//Este código debería imprimir "El nombre es: Falco y tiene 3 años"
}
}

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de clases, métodos y objetos.
https://www.youtube.com/watch?v=Z6ispQvMy8s.

Constructores y sobrecarga de métodos

Por defecto toda clase tiene un constructor sin parámetros cuyo identificador coincide con el de la
clase y que, al ejecutarse, inicializa el valor de cada atributo de la nueva instancia: los atributos de
tipo primitivo se inicializan a 0 o false, mientras que los atributos de tipo objeto (referencia) se
inicializan a null.

En el ejemplo de la clase PruebaPrecio, que utiliza una instancia de la clase Precio, la llamada al
constructor se produce en la sentencia p = new Precio();. Mientras que la ejecución de new genera
una nueva instancia y devuelve su dirección de memoria, la ejecución del constructor Precio()
inicializa los valores de los atributos.

public class PruebaPrecio

{
public static void main(String [] args)

36
 {
Precio p; // Crea una referencia de la clase Precio
p = new Precio(); // Crea el objeto de la clase Precio y realiza
// una llamada al método constructor
}
}

Declaración de un constructor

La declaración de un constructor diferente del constructor por defecto, obliga a que se le asigne el
mismo identificador que la clase y que no se indique de forma explícita un tipo de valor de retorno.
La existencia o no de parámetros es opcional. Por otro lado, la sobrecarga permite que puedan
declararse varios constructores (con el mismo identificador que el de la clase), siempre y cuando
tengan un tipo y/o número de parámetros distinto. Por ejemplo, para la clase Fecha se declaran dos
constructores, el primero sin parámetros (por lo tanto, se redefine el constructor por defecto) y el
segundo con tres parámetros:

/**
* Declaración de la clase Fecha
*/
public class Fecha
{
// Atributos o variables miembro
private int dia;
private int mes;
private int anho;
/**
* Constructor 1
* Asigna los valores 1, 1 y 2000 a los atributos
* día, mes y año respectivamente
*/
public Fecha()
{
this.dia = 1;
this.mes = 1;
this.anho = 2000;
}
/**
* Constructor 2
* @param ndia el día del mes a almacenar
* @param nmes el mes del anho a almacenar
* @param nanho el anho a almacenar
*/

37
 public Fecha(int dia, int mes, int anho)
{
this.dia = dia;
this.mes = mes;
this.anho = anho;
}
public String toString()
{
return this.dia + "/" + this.mes + "/" + this.anho;
}
}

La sobrecarga permite que puedan declararse varios constructores (con el mismo identificador que
el de la clase), siempre y cuando tengan un tipo y/o número de parámetros distinto. Para probar el
código anterior, se construye el siguiente programa:

/**
* Ejemplo de uso de la clase Fecha
*/
public class PruebaFecha
{
public static void main (String [] args)
{
Fecha origen = new Fecha();
Fecha actual = new Fecha(16,2,2009);
System.out.println("Primera fecha: " + origen.toString());
System.out.println("Segunda fecha: " + actual.toString());
}
}

Recuerda que: Una vez construido un constructor ya no se puede

emplear el constructor por defecto sin parámetros. Si se desea trabajar
con él, es necesario declararlo explícitamente.

Sobrecarga de métodos

Java permite asignar el mismo identificador a distintos métodos, cuya diferencia reside en el tipo o
número de parámetros que utilicen. Esto resulta especialmente conveniente cuando se desea llevar a
cabo la misma tarea en diferente número o tipos de variables. La sobrecarga (overloading) de los
métodos puede resultar muy útil al efectuar llamadas a un método, ya que en lugar de tener que

38
recordar identificadores de métodos distintos, basta con recordar uno sólo. El compilador se
encarga de averiguar cuál de los métodos que comparten identificador debe ejecutar. Por ejemplo:

/**
* Demostración de métodos sobrecargados * A. Garcia-Beltran - marzo, 2002
*/

public class PruebaSobrecarga

{
public static void main (String[] args)
{
int a=34;
int b=12;
int c=56;

System.out.println("a = " + a + "; b = " + b + "; c = " + c);

// El primer método
System.out.println("El mayor de a y b es: " + mayor(a,b));
// El segundo método
System.out.println("El mayor de a, b y c es: " + mayor(a,b,c));
}

// Definición de mayor de dos números enteros

public static int mayor (int x, int y)
{
return x>y ? x : y;
}
// Definicion de mayor de tres numeros enteros
public static int mayor (int x, int y, int z)
{
return mayor(mayor(x,y),z);
}
}

Ejemplo de Constructor: Arboles.java

public class Arboles

{
public Arboles()
{
System.out.println("Un árbol genérico");
}
public Arboles(String tipo)
{
System.out.println("Un árbol tipo " + tipo);

39
 }
public Arboles(int altura)
{
System.out.println("Un árbol de " + altura + " metros");
}

public Arboles(int altura,String tipo)

{
System.out.println("Un " + tipo + " de " + altura + " metros");
}
public static void main(String args[])
{
Arboles arbol1 = new Arboles(4);
Arboles arbol2 = new Arboles("Roble");
Arboles arbol3 = new Arboles();
Arboles arbol4 = new Arboles(5,"Pino");
}
}

Ejemplo de sobrecarga

En este ejemplo, se ha creado dos métodos sobrecargados, primero método de la suma realiza una
suma de dos números y segundo método de la suma se realiza la adición de tres números:

class Calculation
{
void sum(int a,int b){System.out.println(a+b);}
void sum(int a,int b,int c){System.out.println(a+b+c);}
public static void main(String args[])
{
Calculation obj=new Calculation();
obj.sum(10,10,10);
obj.sum(20,20);
}
}

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de constructores y sobrecarga de métodos.
https://www.youtube.com/watch?v=_DUSaU58GDk

40
Encapsulamiento
En encapsulamiento es un principio del lenguaje Java cuya filosofía es hacer que los atributos de las
clases se puedan editar sólo a través de métodos. De manera general, se hace teniendo las
propiedades como privadas y métodos que la controlan públicos. Comúnmente, se crean un grupo
de métodos llamados getters (se encargan de obtener el valor de la propiedad) y setters (se encargan
de setearla).

Moreno (2000) explica que mantener las clases con el principio de encapsulamiento nos permite
controlar el cambio de valor que pueda producirse en ellas añadiendo validaciones. De cualquier
manera, es una convención dentro de la programación orientada a objetos, aunque no se esté
realizando una operación adicional al cambio de valor.

Ejemplo:

public class Gato

{
public String nombre;
public int patas;
}
//Mi método main...
Gato g = new Gato();
g.nombre = "Nemo";
g.patas = 4;
System.out.println("Mi gato se llama: " + g.nombre);
System.out.println("El número de patas de mi gato es: " + g.patas);

En este caso, no se ha aplicado el principio de encapsulamiento, por lo que cualquier otro

desarrollador con visibilidad de nuestra clase, puede cambiar las propiedades del mismo tan sólo
con acceder a ellas, de manera muy simple.

Se mostrará la misma clase, con el principio de encapsulamiento:

public class Gato

{
private String nombre;
private int patas;
public getNombre(){ return nombre;}
public getPatas(){ return patas;}
public setNombre(String nuevoNombre){ nombre = nuevoNombre;}
public setPatas(int numeroPatas){ patas = numeroPatas;}
}

41
//Mi método main...
Gato g = new Gato();
g.setNombre("Nemo");
g.setPatas(3);
System.out.println("Mi gato se llama: " + g.getNombre());
System.out.println("El número de patas de mi gato es: " + g.getPatas());

Tras aplicar el principio de encapsulamiento, ya no tenemos acceso a las propiedades directamente,

por lo que tenemos que usar los métodos (que son públicos y sí tenemos acceso a ellos) para poder
acceder a las variables, tanto para modificarlas como para obtenerlas. El comportamiento es el
mismo, aunque lleve un código adicional.

¿Por qué debemos aplicar el principio de encapsulamiento?

Por mantenibilidad, estabilidad y seguridad principalmente. Un segundo equipo va a usar nuestra

aplicación y por tanto nuestras clases, se conoce perfectamente la funcionalidad, y entre todas las
cosas que sabemos y asumimos, una de ellas es que los gatos no tienen más de 4 patas (o menos de
0). Pero, sin embargo, según la estructura del lenguaje Java, no hay nada que no impida a un
desarrollador hacer esto (No con nuestra clase actual):

g.setPatas(10);
g.setPatas(-50);

Por lo tanto, se da la idea de actualizar el método «setPatas» de nuestra clase Gato para que quede
así:

public void setPatas(int numeroPatas)

{
if(numeroPatas>=0 && numeroPatas<5)
{
patas = numeroPatas;
}
else
{
throw new IllegalArgumentException("Número de patas no válido");
}
}

Con esta actualización del método, el segundo (tercer, cuarto, quinto...) equipo que use nuestra
clase gato, no va a variar su código (estabilidad), seguirá llamando al método setPatas
(mantenibilidad), y nosotros controlaremos que el número sea entre 0 y 4 (seguridad). Si volvemos a

42
la primera versión de la clase, no nos permitiría añadir este tipo de controles a posteriori sin hacer
cambiar todos los usos de nuestra clase.

Canchala (2012) expresa que, aunque parezca un ejemplo tonto (y un poco cruel para los gatos) no
es raro en Java encontrarte que tienes que trabajar con librerías que no conoces, que respetan el
principio de encapsulamiento y que gracias a él puedes hacer un correcto funcionamiento de la
misma, ya que controlará que no te salgas del tiesto, con valores inválidos, errores o incluso
validando los datos con los que se crea.

Videos: En el siguiente enlace se muestra una explicación sobre el uso

de encapsulamiento.
https://www.youtube.com/watch?v=zK73q1VNOms.

Comprueba tu aprendizaje

1. Desde el punto de vista del comportamiento, es lo que el objeto puede hacer.

Clase

Objeto

Polimorfismo

Método

2. Definiciones de las propiedades y comportamiento de un tipo de objeto concreto.

Objeto

Método

Clase

Polimorfismo

3. Entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento

o funcionalidad (métodos). Corresponden a los objetos reales del mundo, o a objetos
internos del sistema (del programa).

Método

43
 Objeto

Clase

Herencia

4. Contenedor de un tipo de datos asociados a un objeto (o a una clase de objetos), que hace
los datos visibles desde fuera del objeto, y cuyo valor puede ser alterado por la ejecución
de algún método.

Atributo

Estado

Comportamiento

Evento

5. Práctica 1: Variables y tipos de Datos

Verificar cuáles son los valores que se pueden almacenar en las variables de tipo: int, byte,
short, long doublé, etc. En la siguiente tabla cite un ejemplo de un valor que se pueda
almacenar y otro que no en una variable declarada.

Tipo de dato Nombre de la variable Valor permitido Valor no permitido

Int
Byte
Short
Long
Double
Float
Char
boolean

6. Empleando la estructura de control if-else, realizar un programa en java utilizando la

herramienta Visual Studio Code que permita mostrar la estación del año de un mes
ingresado, a continuación, se muestra la tabla de estación del año según el mes.

Numero de mes Mes Estación del año

1 Enero Invierno

44
 2 Febrero Invierno
3 Marzo Primavera
4 Abril Primavera
5 Mayo Primavera
6 Junio Verano
7 Julio Verano
8 Agosto Verano
9 Septiembre Otoño
10 Octubre Otoño
11 Noviembre Otoño
12 Diciembre Invierno

7. Del ejercicio anterior resolver con la estructura de control switch.

8. Crea una clase con un método main que pida una entrada de teclado y usando un bucle
while, el método length de la clase String y el método substring de la clase String, muestre
cada una de las letras que componen la entrada. Por ejemplo, si se introduce “ave” debe
mostrar:
Letra 1: a
Letra 2: v
Letra 3: e
9. Ingresar un número por teclado e imprimir por la consola su decena superior: Ejemplo
sin ingreso el número 5, su decena superior es 10, si ingreso el 25, su decena superior es
30.
10. Crea una clase llamada Cuenta que tendrá los siguientes atributos: titular y cantidad
(puede tener decimales). El titular será obligatorio y la cantidad es opcional. Crea dos
constructores que cumpla lo anterior. Crea sus métodos get, set y toString. Tendrá dos
métodos especiales:
- ingresar(double cantidad): se ingresa una cantidad a la cuenta, si la cantidad
introducida es negativa, no se hará nada.
- retirar(double cantidad): se retira una cantidad a la cuenta, si restando la cantidad
actual a la que nos pasan es negativa, la cantidad de la cuenta pasa a ser 0.
11. Diseñe e implemente en Java una clase para trabajar con triángulos isósceles. Para ello,
defina las variables de ejemplar mínimas que requiera, proporcione métodos de consulta,
un método constructor e implemente otros métodos para calcular el perímetro y el área
de un triángulo.

45
Tema 3: UML
Introducción a UML
El Lenguaje Unificado de Modelado (Unifield Modeling Lenguaje UML), es un lenguaje estándar
para escribir planos de software, UML se puede utilizar para visualizar, especificar, construir y
documentar los artefactos de un sistema que involucra una gran cantidad de software. UML
prescribe un conjunto de notaciones y diagramas estándar para modelar sistemas orientados a
objetos, y describe la semántica esencial de lo que estos diagramas y símbolos significan.

UML se puede usar para modelar distintos tipos de sistemas como, por ejemplo: sistemas de
software, sistemas de hardware, y organizaciones del mundo real. UML ofrece nueve diagramas en
los cuales modelar sistemas. Es un lenguaje muy expresivo, que cubre todas las vistas necesarias para
desarrollar y luego desplegar tales sistemas.

UML es sólo un lenguaje y por tanto es tan solo una parte de un método de desarrollo de software,
además, es independiente del proceso, aunque para utilizar óptimamente se debería usar en
procesos que fuesen dirigidos por los casos de uso, centrados en la arquitectura, lo interactivo e
incremental. (Qué Es UML? | LENGUAJE DE MODELADO UNIFICADO UML, n.d.)

Diagrama de Clases

UML está compuesto por diversos elementos gráficos que se combinan para conformar diagramas.
Al ser UML un lenguaje, existen reglas para combinar dichos elementos. En conjunto, los
diagramas UML brindan diversas perspectivas de un sistema, por ende, el modelo. Ahora bien, el
modelo UML describe lo que hará el sistema y no como será implementado. (Programación, 2012)

46
Si se observa alrededor, se visualizan una serie de cosas (objetos), los cuales tienen atributos
(propiedades) y nos damos cuenta que algunos realizan acciones (métodos). Esas cosas,
naturalmente se agrupan en categorías (automóviles, viviendas, entre otros). Una clase es una
categoría de cosas u objetos que poseen atributos y acciones similares.

Por ejemplo: la clase lavadora tiene las propiedades fabricante, número de serie y realiza las acciones
de remojo, lavado, enjuague y centrifugado.

Las clases las representamos en un rectángulo compuesto por tres:

Sección 1) nombre de la clase

Sección 2) propiedades y
Sección 3) acciones.

Los diagramas de clases representan las clases intervinientes en el sistema, destacando con que otras
clases se relacionan y como lo hacen.

Interacción de clases
Relaciones

47
Los tipos más importantes de relaciones estáticas 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. Con la herencia se refleja una relación “es_un” entre clases. La
clase de la cual se hereda se denomina superclase, y la que hereda subclase.

La generalización define una superclase a partir de otras. Por ejemplo, de las clases profesor y
estudiante se obtiene la superclase persona. La especialización o especificación es la operación
inversa, y en ella una clase se descompone en una o varias subclases. Por ejemplo, de la clase
empleado se pueden obtener las subclases secretaria, técnico e ingeniero.

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.

48
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
(ver Diagrama de paquetes).

Notación de Clases

Una clase se representa como una caja, separada en tres zonas por líneas horizontales.

En la zona superior se muestra el nombre de la clase y propiedades generales como el estereotipo. El

nombre de la clase aparece centrado y si la clase es abstracta se representa en cursiva. El estereotipo,
si se muestra, se sitúa sobre el nombre y entre el símbolo: << .... >>.

En La zona central contiene una lista de atributos, uno en cada línea. La notación utilizada para
representarlos incluye, dependiendo del detalle, el nombre del atributo, su tipo y su valor por
defecto, con el formato:

visibilidad nombre : tipo = valor-inicial { propiedades }

La visibilidad será́ en general publica (+), privada (-) o protegida (#), aunque puede haber otros tipos
de visibilidad dependiendo del lenguaje de programación empleado.

En la zona inferior se incluye una lista con las operaciones que proporciona la clase. Cada
operación aparece en una línea con formato:

visibilidad nombre (lista-de-parámetros): tipo-devuelto { propiedad }

49
La visibilidad será́ en general publica (+), privada (-) o protegida (#), aunque como con los atributos,
puede haber otros tipos de visibilidad dependiendo del lenguaje de programación. La lista de
parámetros es una lista con los parámetros recibidos en la operación separados por comas. El
formato de un parámetro es:

nombre : tipo = valor-por-defecto

La notación especificada se puede simplificar según el nivel de detalle con el que se quiera trabajar
en un momento dado.

Relaciones

Una relación de asociación se representa como una línea continua entre las clases asociadas. En una
relación de asociación, ambos extremos de la línea pueden conectar con la misma clase, indicando
que una instancia de una clase, está asociada a otras instancias de la misma clase, lo que se conoce
como asociación reflexiva.

La relación puede tener un nombre y un estereotipo, que se colocan junto a la línea. El nombre
suele corresponderse con expresiones verbales presentes en las especificaciones, y define la
semántica de la asociación. Los estereotipos permiten clasificar las relaciones en familias y se
escribirán entre el símbolo: << ... >>.

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.

50
 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.

Además, existen notaciones específicas para los otros tipos de relación, como son:

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.

Interfaces

51
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. (Diagrama de Clases - Manuel.Cillero.Es, n.d.)

Ejemplo: Estudio del sistema encargado de la gestión de préstamos y reservas de libros y revistas de
una biblioteca. Dependiendo del momento del desarrollo el diagrama estará́ más o menos detallado.
Así́, el diagrama tendría la siguiente estructura en el proceso de análisis.

52
Ejemplo de UML

Proyecto UML de Generalización: se ha

creado un diagrama de clases llamado
Personas que contiene como consecuencia
de lo trabajado, las clases: Persona,
Estudiante y Profesor y los tipos de datos
involucrados por las propiedades y retornos
de métodos int, String y void.

Se observa que se generalizó hacia la clase

Persona ya que las clases Estudiante y
Profesor poseen propiedades comunes
como lo son nombre y edad. Por lo que
Persona es la clase base y Estudiante y
Profesor son clases derivadas. ¿Qué significa esto? Que si instanciamos a las clases derivadas ellas
heredaran de la clase superior. ¿Entonces qué tipos de objetos podemos tener a partir de este
modelo? Objetos de tipo Estudiante y Profesor que heredan de Persona y objetos de tipo Persona
que pueden ser visitas en nuestra facultad.

53
Detalle del código generado automáticamente

Persona.java (contiene)
Public class Persona
{
Private String nombre; //propiedad
Private int edad; // propiedad
Public Persona() { //constructor}
Public int getEdad()
{ //asesor a edad
Return edad;
}
Public void setEdad (int val)
{ //mutador de edad
This.edad =val;
}

Public String getNombre ()

{ //asesor a nombre
Return nombre;
}
Public void setNombre (String val)
{ //mutador de nombre
This.nombre =val;
}
}

Estudiante.java (contiene)

Public class Estudiante extendes Persona

{
Private String carrera; //propiedad
Private int legajo; // propiedad
Public Estudiante() { //constructor}
Public String getCarrera()
{ //asesor a carrera
Return carrera;
}
Public void setCarrera (String val)
{ //mutador de carrera
This.carrera =val;
}
Public int getLegajo ()
{ //asesor a legajo
Return legajo;
}

54
 Public void setLegajo(int val)
{ //mutador de legajo
This.legajo=val;
}
}

Profesor.java (contiene)

Public class Profesor extendes Persona

{
Private String materia; //propiedad
Private String cargo; // propiedad
Public Profesor() { //constructor}
Public String getCargo()
{ //asesor a cargo
Return cargo;
}
Public void setCargo (String val)
{ //mutador de cargo
This.cargo =val;
}
Public String getMateria ()
{ //asesor materia
Return materia;
}
Public void setLegajo(String val)
{ //mutador de materia
This.materia=val;
}
}

El archivo Main.java quedaría con las siguientes líneas de código Java:

Package personas;
Import Clases.*;
Public class Main()
{
Public stactic void main (String[] args )
{
Persona p= new Persona();
p.setNombre(“Walter”);
p.setEdad(25);
Estudiante e = new Estudiante();
e.setNombre(“Javier López”);
e.setLegajo(223015);
e.setCarrera(“TI”);

55
 Profesor pro= new Profesor();
Pro.setNombre(“Wilson”);
Pro.setMateria(“POO”);
Pro.setCargo(“Tutor”);
System.out.println(“Objeto p de tipo persona”);
System.out.printf(“Nombre:%s, Edad: %d \n”, p.getNombre(), p.getEdad());
System.out.println(“Objeto e de tipo Estudiante”);
System.out.printf(“Nombre:%s, Carrera:%s, Legajo: %d \n”, e.getNombre(),
e.getCarrera(), e.getLegajo());
System.out.println(“Objeto pro de tipo Profersor”);
System.out.printf(“Nombre:%s, Materia: %s, Cargo=%s \n”,
pro.getNombre(), pro.getMateria(), pro.getCargo());
}
}

Videos: En el siguiente enlace se muestra una explicación sobre el uso de UML

en java.
- https://www.youtube.com/watch?v=CZcfhu8lrqg.
- https://www.youtube.com/watch?v=Z0yLerU0g-Q.
- https://www.youtube.com/watch?v=SrpX8xGtpv8.
- https://www.youtube.com/watch?v=zSaczWq7hVQ.
-

Comprueba tu aprendizaje

1. El siguiente diagrama de clases, incompleto, representa la estructura básica de un

programa para recopilar los encargos de productos de una compañía.

56
 Escriba una versión en Java de la clase Producto. Incluya métodos que permitan acceder a la
información del producto.

2. Una persona tiene un nombre, dos apellidos, una fecha de nacimiento, un sexo y un
número de identificación. Define las clases y los atributos correspondientes.
3. Escriba el código correspondiente al siguiente diagrama de clases.

4. Dibujar un posible diagrama de clases para el siguiente fragmento de código.

Compas unCompas = new Compas();
Circulo unCirculo = unCompas.dibujarCirculo(5);
Pincel unPincel = Cartuchera.getPinceles().getItem(2);
unPincel.setColor(new Color("#336677"));
unPincel.pintar(unCirculo);
int superficie = unCirculo.getSuperficie();

Herramientas & Software de la asignatura

Las herramientas y software a utilizar en el transcurso de esta unidad y la asignatura en general se
tienen:

- Lenguaje de Programación Java.

- Visual Studio Code
- Netbeans
- Diagrams.net (Draw.io) (solo Visual Studio Code)
- EasyUML (solo Netbeans)

Como primer paso se instalará el JDK, para ello les ubico el siguiente enlace de descarga:
https://www.oracle.com/java/technologies/javase-downloads.html.

57
Videos: En el siguiente enlace se muestra una explicación sobre la instalación
de JDK.
- https://www.youtube.com/watch?v=kPWezAZGPks.

58
Una vez instalado el JDK, se procede a instalar el Visual Studio Code o Netbeans, en el siguiente
enlace lo pueden descargar: https://code.visualstudio.com/. o
https://netbeans.apache.org/download/index.html.

Videos: En el siguiente enlace se muestra una explicación sobre la instalación

de VS Code.
- https://www.youtube.com/watch?v=3SVcbtiYVFk.

Videos: Una vez instalado el JDK, se procede a instalar el Apache Netbeans, en

el siguiente enlace lo pueden descargar:
https://netbeans.apache.org/download/index.html .

Por último, se tendrá que instalar el plugin de Diagramas.net en VS Code, para ello revisar el
siguiente enlace del video:

Videos: En el siguiente enlace se muestra una explicación sobre la instalación

del plugin Draw.io en VS Code.
- https://www.youtube.com/watch?v=Y47ZlxoDWNI.

Videos: Videos: En el siguiente enlace se muestra una explicación sobre la

instalación EasyUML.
- https://www.youtube.com/watch?v=mHDPLSs2d_w

Bibliografía
Azpitarte, R. L., Llinares, J. D., & Goterris, F. T. (2009). Introducción a la Programación Orientada a
Objetos con Java.

Canchala, A. (2012). Fundamentos de la POO. Msdn.Microsoft.Com, 1–7.

Diagrama de Clases - manuel.cillero.es. (n.d.). Retrieved May 3, 2020, from

https://manuel.cillero.es/doc/metrica-3/tecnicas/diagrama-de-clases/

Garro, A. (15 de Abril de 2014). JAVA. Obtenido de

https://www.arkaitzgarro.com/java/index.html

59
Morero, F. (2000). Desarrollo de software Introducción a la OOP. Eidos.

Programación, C. P. De. (2012). Proyectos UML Diagramas de clases y aplicaciones.

Qué es UML? | LENGUAJE DE MODELADO UNIFICADO UML. (n.d.). Retrieved May 3, 2020,
from http://stadium.unad.edu.co/ovas/10596_9839/qu_es_uml.html

Rodríguez, R. (1995). Programacion Orienta a Objetos.

60