1

TEORÍA BÁSICA DE PROGRAMACIÓN

SARAH VALERIA HERNÁNDEZ LEÓN

UNIVERSIDAD PEDAGÓGICA Y TECNOLÓGICA DE COLOMBIA

INGENIERÍA DE SISTEMAS Y COMPUTACIÓN

PROGRAMACIÓN I

TUNJA

2023
 2

TABLA DE CONTENIDO

1. Introducción..................................................................................................................................................
2. Figuras...........................................................................................................................................................
3. Marco Teórico...............................................................................................................................................
3.1 Herencia.................................................................................................................................................
3.2 Polimorfismo...........................................................................................................................................
3.3 Interfaces................................................................................................................................................
3.4 Clases Abstractas...................................................................................................................................
3.5 Sobreescritura de Métodos....................................................................................................................
3.6 Modelo Vista Presentador......................................................................................................................
3.7 Código....................................................................................................................................................
3.7.1 Ejercicio 1......................................................................................................................................
3.7.2 Ejercicio 2......................................................................................................................................
3.7.3 Ejercicio 3......................................................................................................................................
3.8 Video Tutorial.........................................................................................................................................
4. Conclusiones................................................................................................................................................
5. Referencias...................................................................................................................................................
 3

1. Introducción

El trabajo expuesto tiene como fin explicar la lógica de cada uno de los códigos
desarrollados mediante el uso de algunos conceptos básicos de la programación
dentro de los cuales están: herencia, polimorfismo, interfaces, clases abstractas,
sobreescritura de métodos, y el patrón de diseño arquitectónico (Modelo - vista -
presentador) , a partir de los cuales se hará uso de condicionales, ciclos y métodos.

En total se realizaron 3 ejercicios en los que se implementaron cada uno de estos

conceptos distribuidamente, de manera que el código resultante es más práctico y
mucho más sencillo de entender.

A lo largo de este informe se examinarán y se describirán detalladamente los

procesos lógicos de cada ejercicio de inicio a fin y cada elemento empleado en la
ejecución del código, teniendo en cuenta los mecanismos ya mencionados.
 4

2. Figuras

Tabla 1

Variable (tipo) Función

int Guarda números enteros y positivos

String Almacena texto y números

boolean Guarda caracteres con el significado de

verdadero o falso

Char Almacena símbolos o caracteres

Tabla 2

Elemento Función

import Importar un paquete o un scanner

Scanner sc = new Scanner(System.in) Crear un objeto de Scanner

System.out.println() Imprime el texto especificado dentro de los

paréntesis

sc.nextInt() Scanner accede al buffer de entrada para

obtener un dato de tipo int y asignarlo a la
variable

protected Modificador de acceso

for Permite repetir varias instrucciones (pasos)

un cierto número de ocasiones

while Se utiliza para ejecutar un bloque de código

repetidamente hasta que se cumple una
condición determinada.

switch - case Recibe un caso y lo evalúa hasta encontrar

el caso que corresponda.
 5

3. Marco Teórico

3.1 Herencia

Es el mecanismo por el cual una clase permite heredar las características (atributos
y métodos) de otra clase.

La herencia permite que se puedan definir nuevas clases basadas de unas ya

existentes a fin de reutilizar el código, generando así una jerarquía de clases dentro
de una aplicación. Si una clase deriva de otra, esta hereda sus atributos y métodos
y puede añadir nuevos atributos, métodos o redefinir los heredados.

3.2 Polimorfismo

El polimorfismo hace referencia a la cualidad por la que un objeto adquiere o puede

tener diferentes formas. En Java, el polimorfismo alude al modo en que se pueden
crear y utilizar dos o más métodos con el mismo nombre para ejecutar funciones
diferentes.

En programación orientada a objetos, el polimorfismo es la capacidad que

tienen los objetos de una clase en ofrecer respuesta distinta e independiente
en función de los parámetros (diferentes implementaciones) utilizados durante
su invocación. Dicho de otro modo el objeto como entidad puede contener
valores de diferentes tipos durante la ejecución del programa.

Por lo general diremos que existen 3 tipos de polimorfismo:

Sobrecarga: El más conocido y se aplica cuando existen funciones con el

mismo nombre en clases que son completamente independientes una de la
otra.
Paramétrico: Existen funciones con el mismo nombre pero se usan diferentes
parámetros (nombre o tipo). Se selecciona el método dependiendo del tipo de
datos que se envíe.
 6

Inclusión: Es cuando se puede llamar a un método sin tener que conocer su

tipo, así no se toma en cuenta los detalles de las clases especializadas,
utilizando una interfaz común.

3.3 Interfaces

Una interfaz es una especie de plantilla para la construcción de clases.

Normalmente una interfaz se compone de un conjunto de declaraciones de
cabeceras de métodos (sin implementar) que especifican un protocolo de
comportamiento para una o varias clases. Además, una clase puede implementar
una o varias interfaces, que se deben ejecutar con la palabra implements: en ese
caso, la clase debe proporcionar la declaración y definición de todos los métodos de
cada una de las interfaces o bien declararse como clase abstract. Por otro lado, una
interfaz puede emplearse también para declarar constantes que luego puedan ser
utilizadas por otras clases.

3.4 Clases Abstractas

En Java se dice que son clases abstractas aquellas clases base (superclases) de
las que no se permite la creación de objetos. Para ello, se utiliza la palabra clave
abstract.

En una clase abstracta es posible definir métodos abstractos, los cuales se

caracterizan por el hecho de que no pueden ser implementados en la clase base.

3.5 Sobreescritura de Métodos

Una subclase hereda todos los métodos de su superclase que son accesibles a
dicha subclase a menos que la subclase sobreescriba los métodos.

Una subclase sobreescribe un método de su superclase cuando define un método

con las mismas características ( nombre, número y tipo de argumentos) que el
método de la superclase.
 7

Las subclases emplean la sobreescritura de métodos la mayoría de las veces para

agregar o modificar la funcionalidad del método heredado de la clase padre.

Se debe usar «@Override» antes de implementar el método.

3.6 Modelo Vista Presentador

MVP es otro patrón de diseño que tiene como objetivo separar la interfaz de usuario
de la lógica de las aplicaciones.

Básicamente este patrón consiste en 3 componentes:

La vista. Compuesta de las ventanas y controles que forman la interfaz de usuario

de la aplicación.

El modelo. Que es donde se lleva a cabo toda la lógica de negocio.

El presentador. Escucha los eventos que se producen en la vista y ejecuta las

acciones necesarias a través del modelo. Además puede tener acceso a las vistas a
través de las interfaces que la vista debe implementar.

3.7 Código

3.7.1 Ejercicio 1

En este ejercicio se hará uso de 4 de los recursos explicados anteriormente: modelo

vista presentador, herencia, interfaces y sobreescritura de métodos.
Además, tiene como fin realizar las cuatro operaciones básicas (suma, resta,
multiplicación y división) entre dos matrices llenadas por el usuario.

3.7.1.1 MVP. En primer lugar, se crea el nuevo proyecto de java, seguido a

esto creamos los 3 paquetes respectivos, que son: modelo, vista y
presentador. En modelo, creamos 2 clases: “Matriz” y “Rta” y una interfaz
“Operacion”, en presentador creamos una clase llamada presentador, en la
 8

cual toda la lógica y el contenido del paquete modelo se comunica con Vista
por medio de esta; y en vista creamos una clase denominada Vista en la cual
usamos Scanner y System.out.println() para comunicarnos con el usuario y
mostrar/pedir los datos necesarios.

3.7.1.2 Herencia. Después, definimos la lógica de la clase Rta, en la cual

inicializamos una matriz de 3 posiciones.

3.7.1.3 Interfaces. y luego pasamos a la interfaz Operacion, en la cual

declaramos los 4 métodos que implementaremos luego.

Por último, pasamos a la clase “Matriz”, escribimos sus atributos y

heredamos la variable de la clase Rta.
 9

3.7.1.4 Sobreescritura de Métodos. En esta clase también reescribimos los

métodos de la interfaz y definimos su lógica utilizando ciclos for.

3.7.2 Ejercicio 2

En este ejercicio se hará uso de 2 de los recursos explicados anteriormente:

polimorfismo y se empleará nuevamente la técnica de sobreescritura de métodos.
Además, este ejercicio tiene como objetivo mostrar los datos de diferentes tipos de
vehículos por medio del polimorfismo.

3.7.2.1 Polimorfismo. En primera instancia, establecemos las clases que son:

el main, que contiene la interfaz de usuario, “Vehiculo” que es la clase padre,
y “Bus”, “Camion”, “Carro” que son las clases que heredan o las clases hijas.
 10

Luego creamos los atributos de la clase Vehiculo que son: placa, marca y modelo
empleando el modificador de acceso «protected», con su respectivo constructor,
getters y setters

y creamos un método de tipo String para mostrar cada uno de esos datos.

Luego de esto definimos el atributo específico para cada clase; en el caso de

la clase Bus el número de asientos, en Camión el número de trailers y en
Carro el número de puertas, todas de tipo int.
 11

3.7.2.2 Sobreescritura de Métodos. En estas clases reescribimos el método

declarado en la superclase Vehiculo, y lo implementamos haciendo uso de
las variables de la clase padre y de cada atributo específico de las clases
hijas.

Por último, en el main creamos un objeto de Vehiculo haciendo uso de un

arreglo de 4 posiciones, mediante el cual podemos crear objetos de cada una
de las clases para mostrar los datos.
 12

3.7.3 Ejercicio 3

En este ejercicio se hará uso de 2 de los recursos explicados anteriormente: clases

abstractas y para efectos del correcto funcionamiento del código reforzaremos la
sobreescritura de métodos. Además, el ejercicio tiene como fin mostrar de qué
manera se alimentan algunos seres vivos utilizando clases y métodos abstractos.

3.7.3.1 Clases Abstractas. Inicialmente creamos el main y las clases

necesarias que son: “SerVivo” que será una clase abstracta y además una
clase padre y declaramos el método abstracto alimentarse() , “Planta” que
heredará de ser vivo , “Animal” que será también una clase padre y abstracta,
“AnimalCarnivoro” que hereda de Animal y “AnimalHerbivoro” que también
hereda de la clase Animal.

3.7.3.2 Sobreescritura de métodos. En las clases Planta, AnimalCarnivoro y

AnimalHerbivoro, heredamos de SerVivo y reescribimos el método que se encuentra
allí; en Animal no lo reescribimos pues es también una clase abstracta, por lo tanto
no hay necesidad de la sobreescritura.
 13

Finalmente, en el main creamos objetos de las clases que no son abstractas

es decir, las mencionadas anteriormente y se llama al método en cada una,
para mostrar el mensaje propio de cada una.

3.8 Video Tutorial

https://drive.google.com/drive/folders/1CGXpWDOlYw3NMWvPkFLM52EbESy65YjQ
 14

4. Conclusiones
 15

Estos ejercicios abordan una variedad de conceptos, desde operaciones básicas

hasta algoritmos más avanzados, lo que permite explorar y ahondar ejes más
específicos de la programación.

Además, al desarrollar y ejecutar el código de cada uno de los ejercicios expuestos,

adquirí experiencia práctica y de manera general me ayudaron a fomentar la
capacidad de pensar de forma lógica y desarrollar programas eficientes aplicando
cada uno de los conceptos mencionados.

En conclusión, la implementación de estos conceptos sienta las bases para

comprender aspectos más avanzados en programación, aprender a resolver
problemas de formas alternas que pueden llegar a ser más prácticas y forman parte
fundamental en el proceso de aprendizaje y desarrollo de habilidades en esta área.

5. Referencias
 16

Clases abstractas en Java | Tutorial de Java. (n.d.). Abrirllave.com.

https://www.abrirllave.com/java/clases-abstractas.php

Equipo Geek. (2019, Junio 5). ¿Qué es la Herencia en programación

orientada a objetos? IfgeekthenNTTdata | El blog tecnológico más geek.

https://ifgeekthen.nttdata.com/es/herencia-en-programacion-orientada-objetos

Equipo Geek. (2020, Febrero 3). Polimorfismo en Java: Programación

orientada a objetos. IfgeekthenNTTdata | El blog tecnológico más geek.

https://ifgeekthen.nttdata.com/es/polimorfismo-en-java-programaci%C3%B3n-

orientada-objetos

Interfaces | Java. (n.d.). Arkaitz Garro.

https://www.arkaitzgarro.com/java/capitulo-18.html

Medina Serrano, J. (2023, 09 26). El patrón Modelo-Vista-Presentador (MVP)

a examen. La Güeb de Joaquin , PaLa Güeb de Joaquin , Página de

presentación.

http://joaquin.medina.name/web2008/documentos/informatica/documentacion

/logica/patrones/patronMVP/2012_06_09_PatronMVP.html

UNAM & Carlos. (n.d.). Sobreescritura de métodos. IV - Sobreescritura de

métodos. http://profesores.fi-b.unam.mx/carlos/java/java_basico4_7.html