Compendio-Modelo Poo U I

TECNOLOGÍAS DE LA INFORMACIÓN
EN LINEA
PROGRAMACIÓN ORIENTADA A OBJETO (POO)
4 créditos
Profesor:
Ingeniero. Carlos Alfredo Silva Villafuerte,
Titulaciones Semestre
• PROGRAMACIÓN ORIENTADA AOBJETO 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 ................................................................. 5
Lenguaje de Programación Java .............................................................................................................. 9
Características del Lenguaje ................................................................................................................... 9
Sintaxis del Lenguaje ........................................................................................................................... 10
Estructura de un programa .................................................................................................................. 12
Variables y tipos de datos ..................................................................................................................... 13
Expresiones y estructuras de control .................................................................................................... 16
Arreglos de una y dos dimensiones ...................................................................................................... 19
Objetos y variables de referencia .......................................................................................................... 22
Definición de una clase........................................................................................................................ 22
Métodos .............................................................................................................................................. 24
Constructores y sobrecarga de métodos ............................................................................................... 32
Encapsulamiento ................................................................................................................................. 36
Tema 3: UML ...................................................................................................................................... 39
Introducción a UML ........................................................................................................................... 39
Interacción de clases ............................................................................................................................ 40
Organización de la lectura para el estudiante por semana del compendio
CARLOS SILVA VILLAFUERTE 1

Semanas Paginas
Semana 1 Página 1 – 10
Semana 2 Página 11 – 55
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.
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
Encapsulam
Jerarquia PPOO
iento
Modularida
d
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:
Imperat
ivo
Funcio
Lógico Paradigmas
nal
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)
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.
Figura 1. Diagrama API de conexión de datos (Azpitarte et al., 2009)

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

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.

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:

{
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 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;

}
}
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

{
{
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

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

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.

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;

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.

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

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.

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

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

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

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.

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];

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

de arreglos bidimensionales.
https://www.youtube.com/watch?v=9W1DegmmNZs.
Objetos y variables de referencia

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
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:

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
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
{
{
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
}
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
{
{
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);
}
}
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
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
(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
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();
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 IDE de Netbeans correctamente en un equipo.

Link de descarga: https://netbeans.apache.org/download/nb123/nb123.html.
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()
{
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
{
{
//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"
}
}

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)
{
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
*/
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
{
{
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
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);
}
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);
}
}

de constructores y sobrecarga de métodos.
https://www.youtube.com/watch?v=_DUSaU58GDk
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;}
}
//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
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.

de encapsulamiento.
https://www.youtube.com/watch?v=zK73q1VNOms.
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)
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
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.
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 lí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 }
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 sí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.

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
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.
Así́, el diagrama tendría la siguiente estructura en el proceso de análisis.

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.
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;
}
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”);
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.
-
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.

- Netbeans.
- EasyUML.
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.
Videos: En el siguiente enlace se muestra una explicación sobre la instalación

de JDK.
- https://www.youtube.com/watch?v=kPWezAZGPks.
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.

de Apache Netbeans.
- https://www.youtube.com/watch?v=h4xn1vSc5f0.
Por último, se tendrá que instalar EasyUML en java, para ello revisar el siguiente enlace del video:

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
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. (1395). Programacion Orienta a Objetos.

Compendio-Modelo Poo U I

Cargado por

Información del documento

Título original

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

Compendio-Modelo Poo U I

Cargado por

Copyright:

Formatos disponibles

TECNOLOGÍAS DE LA INFORMACIÓN

• PROGRAMACIÓN ORIENTADA AOBJETO Segundo

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

PERÍODO MAYO / SEPTIEMBRE 2023

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

Organización de la lectura para el estudiante por semana del compendio

CARLOS SILVA VILLAFUERTE 1

Resultado de aprendizaje de la asignatura

Unidad 1 Fundamentos de la programación orientada a objetos

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

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

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

Objeto: Entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o

CARLOS SILVA VILLAFUERTE 2

Propiedades del paradigma orientado a objeto

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

CARLOS SILVA VILLAFUERTE 3

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

Principales Paradigmas de la programación

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

CARLOS SILVA VILLAFUERTE 4

Paradigma Lógico. - La programación lógica comprende la programación declarativa y la funcional.

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

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

CARLOS SILVA VILLAFUERTE 5

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

Cómo funcionan las API

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

CARLOS SILVA VILLAFUERTE 6

Antes de empezar a desarrollar las características propias de la programación orientada a objeto,

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

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

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

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

CARLOS SILVA VILLAFUERTE 7

CARLOS SILVA VILLAFUERTE 8

Lenguaje de Programación Java

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

Características del Lenguaje

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

CARLOS SILVA VILLAFUERTE 9

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

Sintaxis del Lenguaje

CARLOS SILVA VILLAFUERTE 10

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.

CARLOS SILVA VILLAFUERTE 11

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

public class TablaMultiplicar

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

public class ClasePrincipal

CARLOS SILVA VILLAFUERTE 12

/***** Inicio de comentarios

* La clase hola construye un programa que

* muestra un mensaje en pantalla

public class Hola

Variables y tipos de datos

Tipo Descripción Tamaño/Formato

byte Entero byte 8-bit 2’s

short Entero corto 16-bit 2’s

int Entero 32-bit 2’s