Universidad Técnica Estatal de Quevedo
Facultad de Ciencias De La Ingeniería
Informe acerca de la programación orientada a objetos
en Java
Realizado por:
JOSÉ MARIO SOLÓRZANO CABRERA
Carrera:
INGENIERÍA EN SISTEMAS
Materia y semestre:
PROGRAMACIÓN DE BASE DE DATOS (TERCER SEMESTRE)
Docente encargado:
ING. EFRAIN EVARISTO DÍAZ MACÍAS
Ecuador, Los Ríos, Quevedo – 2018
Tabla de contenidos
Introducción ............................................................................................................................ 3
Objetivos ................................................................................................................................. 4
Objetivo general .................................................................................................................. 4
Objetivos específicos .......................................................................................................... 4
La programación orientada a objetos (POO) .......................................................................... 5
Elementos de la programación orientada a objetos (POO) ................................................. 5
Objetos ............................................................................................................................ 5
Clases .............................................................................................................................. 6
Encapsulamiento ............................................................................................................. 7
Herencia .......................................................................................................................... 8
Polimorfismo ................................................................................................................. 10
Abstracción.................................................................................................................... 11
Sobrecarga de métodos ..................................................................................................... 12
Sobrecarga de operadores ................................................................................................. 12
Bibliografía ........................................................................................................................... 14
Tabla de ilustraciones
Ilustración 1: Instancias de una clase "Perro" (Objetos) ........................................................ 6
Ilustración 2: Clase "Perro" con sus atributos y operaciones. ................................................ 7
Ilustración 3: Clase "Perro" y sus diferentes tipos de encapsulamiento. ................................ 7
Ilustración 4: Ejemplo de herencia, entre la superclase Mamífero y las subclases Perro y
Gato. ....................................................................................................................................... 8
Ilustración 5: Clase Gato, la cual también hereda atributos de la clase Mamífero................. 9
Ilustración 6: Clase Perro1, la cual hereda atributos de la clase Mamífero............................ 9
Ilustración 7: Clase Mamífero ................................................................................................ 9
Ilustración 8: Método comunicarse en la superclase Mamífero. .......................................... 10
Ilustración 9: La subclase Perro interpreta el método Comunicarse de una manera, y
comunica que es un perro. .................................................................................................... 11
Ilustración 10: La subclase Gato interpreta el método Comunicarse de una manera, y
comunica que es un gato. ...................................................................................................... 11
2
Introducción
Como cualquier lenguaje de programación, el lenguaje Java tiene su propia estructura,
reglas de sintaxis y paradigma de programación. El lenguaje paradigma de programación
del lenguaje Java se basa en el concepto de programación orientada a objetos (POO).
Este informe está enfocado a presentar de manera precisa y detallada las características e
implementación de los diferentes conceptos que se detallan en la POO, como pueden ser el
encapsulamiento, la herencia, el polimorfismo y la abstracción. A su vez estos conceptos
deben ser implementados en alguna “base”, es por esto que se mencionara la definición de
los objetos y las clases, su estructura e inicialización.
Cabe mencionar que la POO mejora notablemente el código de nuestro software, ya que su
funcionalidad mayormente enfocada a la resolución de grandes problemas, hace que exista
la reutilización de código y así mantener nuestro código limpio y entendible, previniendo
así problemas de búsqueda en futuros mantenimientos.
En cuando a la parte académica de este informe, el docente se encuentra comprometido con
la orientación y evaluación de esta actividad, con la cual se lograría entender e implementar
la POO en futuros proyectos, implementando el lenguaje de programación Java. El
compromiso de este informe es vital para favorecer el aprendizaje autónomo y la aplicación
correcta de los conocimientos adquiridos durante la formación académica.
Se espera dominar los conceptos de la POO, mediante la implementación de diagramas
UML para la planificación y diagramación de nuestras clases y objetos, además de la
implementación de pequeñas prácticas en el lenguaje de programación Java.
3
Objetivos
Objetivo general
Analizar los conceptos, funcionalidades y características de la programación
orientada a objetos en Java.
Objetivos específicos
Entender cómo funcionan las clases y objetos en Java.
Comprender el uso de atributos y sus diferentes niveles de protección.
Interpretar los diferentes conceptos de POO mediante el uso de los mismos.
Hacer uso de diagramas UML para facilitar la comprensión de la POO.
4
La programación orientada a objetos (POO)
En si la POO es bastante amplia y muy necesaria para el desarrollo de software; según
(Largo, 2016), Java es un lenguaje orientado a objetos y para programar aplicaciones
robustas, eficientes y escalables en él es necesario entender cómo funcionan los objetos.
La POO permite relacionar objetos del mundo real y de alguna manera llevar estos a la
programación, por lo que es conocida como un paradigma de programación, según
(Rodríguez, 2011), “un paradigma de programación indica un método de realizar cómputos
y la manera en que se deben estructurar y organizar las tareas que debe llevar a cabo un
programa”, en pocas palabras los paradigmas de programación determinan los métodos y
las herramientas que un programador usara en la construcción de un software.
Regresando a la POO y la manera en que como se podría relacionar objetos del mundo real
con la programación, pues lo que se quiere lograr mediante la implementación de la misma
es crear sistemas basados en “objetos” que se comunican entre sí, heredando características
y adaptándose a las mismas, logrando así la reutilización del código y mejorando el
rendimiento del mismo.
Este “paradigma de programación” está pensado para la resolución de problemas
complicados, no está pensado para tareas sencillas. Para la planificación o diagramación de
nuestro software orientado a objetos se usan los diagramas UML (Unified Modeling
Language).
Elementos de la programación orientada a objetos (POO)
Como principales elementos de la POO tenemos a las clases y a los objetos, pero también
se basa en otros conceptos como la herencia, polimorfismo, encapsulamiento, etc., los
cuales se detallarán más adelante.
Objetos
Como menciona (Perry, 2012), “un objeto es una entidad independiente que contiene
atributos y comportamientos y nada más”, los lenguajes orientados a objetos, como el
lenguaje Java, combinan datos e instrucciones del programa en objetos.
En programación, un objeto, evita tener una estructura de datos con atributos y pasar toda
esa estructura a toda la lógica del programa que actúa sobre la misma, combinando los
datos y la lógica del programa.
5
Ilustración 1: Instancias de una clase "Perro" (Objetos)
Como se puede apreciar en la Ilustración 1, tenemos tres objetos “Perro”: Perro, Perro2 y
Perro3, todos tienen los mismos atributos, esto sucede porque previamente se ha creado una
clase “Perro” la cual puede recibir diferentes instanciaciones de la misma. En este ejemplo
se han creado solo tres, pero se pueden crear las que uno quiera.
Objetos padre e hijo
Un objeto padre es aquel que sirve como la base estructural para derivar objetos hijos más
complejos (Perry, 2012). Se podría definir como objeto hijo a aquel que se parece a su
padre, pero más detallado y especifico. Tomando en cuenta el ejemplo de la Ilustración 1,
se podría pensar que cada uno de los objetos “Perro” detallados en la imagen son objetos,
pero no la manera correcta de decir seria que “Perro” podría ser un objeto hijo de una clase
padre “Mamífero” previamente creada, y a su vez “Mamífero” podría ser hija del objeto
padre “Animal”.
Clases
Para poder definir un objeto en Java, se debe declarar una clase. Llamamos clase a nuestra
plantilla para un objeto, tomemos como ejemplo un molde para pan. Según (Perry, 2012) la
clase define la estructura básica del objeto y, al momento de la ejecución, nuestra
aplicación crea una instancia de dicho objeto. En pocas palabras una clase es la estructura
de algo que definimos como objeto, y como ya se mencionó anteriormente un objeto es la
instancia de una clase.
6
Ilustración 2: Clase "Perro" con sus atributos y operaciones.
Como se puede apreciar en la Ilustracion 2, la clase “Perro” cuenta con distintos
atributos/caracteristicas, los cuales pueden ser distintos en cada instanciacion de la clase.
Esta clase fue la que se uso como referencia para la instanciacion de los objetos: Perro,
Perro2 y Perro3 detallados en la Ilustracion 1.
Encapsulamiento
Hay que recordar que un objeto es, sobre todo, diferenciado o independiente. Este es el
principio de encapsulamiento en funcionamiento. Ocultación es otro término que a veces se
usa para expresar la naturaleza independiente y protegida de los objetos. (Perry, 2012)
En Java, se pueden usar distintas especificaciones de acceso para variar la naturaleza de
nuestros objetos por ejemplo se pueden declarar como públicos, privados, protegidos.
public: se puede acceder desde cualquier lugar.
private: sólo se puede acceder desde la propia clase.
protected: sólo se puede acceder desde la propia clase o desde una clase que herede
de ella.
Ilustración 3: Clase "Perro" y sus diferentes tipos de encapsulamiento.
De esta forma se controla qué cosas son modificables y cómo se pueden modificar. El
estado suele ser privado, y se suele modificar a través del comportamiento.
7
El límite entre lo público y lo privado hace cumplir el principio orientado a objetos de
encapsulamiento. En la plataforma Java, podemos variar la fortaleza de ese límite sobre una
base de objeto a objeto, al depender de un sistema de confianza. El encapsulamiento es una
potente función del lenguaje Java. (Perry, 2012)
Herencia
La herencia es un mecanismo que sirve para reutilizar clases, generalmente se utiliza
cuando existen clases que comparten muchas de sus características. Dentro de herencia se
introducen los conceptos de superclase y subclase.
En la programación estructurada, es común copiar una estructura definida, darle un nombre,
atributos y operaciones nuevos o simplemente adaptar los mismos para lo que necesitemos.
Con el tiempo esto resultara como una gran cantidad de código redundante, lo que puede
crear problemas de rendimiento y mantenimiento.
Es por eso que la POO presenta el concepto de herencia, sin necesidad de implementar
algún condigo adicional, se pueden “copiar” los atributos y el comportamiento de los
objetos de origen, y si necesitamos que algún comportamiento tenga otra utilidad,
simplemente habrá que modificarlos temporalmente.
Ilustración 4: Ejemplo de herencia, entre la superclase Mamífero y las subclases Perro y Gato.
8
Ilustración 7: Clase Mamífero
Ilustración 6: Clase Perro1, la cual hereda atributos de la clase
Mamífero.
Ilustración 5: Clase Gato, la cual también hereda atributos de
la clase Mamífero.
9
Como se aprecia en las anteriores figuras la manera en que se hereda en Java es public class
subclase extends superclase. En el ejemplo anterior “Mamífero” es la superclase y “Perro1”
y “Gato” son las subclases. Los objetos de las subclases pueden poseer atributos y métodos
propios, los cuales no existen en la superclase y como ya se mencionó, heredan los
atributos y métodos de la superclase. Cabe mencionar que Java no permite herencia
múltiple.
Polimorfismo
El polimorfismo es un concepto más difícil de entender que el encapsulamiento o la
herencia. Básicamente, significa que los objetos que pertenecen a la misma ramificación de
una jerarquía, cuando se envía el mismo mensaje (es decir, cuando se le indica que realice
lo mismo), pueden manifestar ese comportamiento de modo diferente. (Perry, 2012)
Para entender esto un poco mejor, nos podemos hacer la siguiente pregunta ¿se mueve igual
un pez, un pájaro o una rana?, pues esto no es así, se mueven de diferente forma, pero nos
podemos dar cuenta que todos son animales, así que todos podrían heredar el método
mover de dicha clase, y adaptarlo a su tipo de movimiento. Gracias al polimorfismo, cada
objeto concreto realizara la operación mover como corresponda. No hay que confundir
polimorfismo con sobrecarga, más adelante se explicara acerca de la sobrecarga.
Ilustración 8: Método comunicarse en la superclase
Mamífero.
10
Ilustración 9: La subclase Perro interpreta el método Comunicarse
de una manera, y comunica que es un perro.
Ilustración 10: La subclase Gato interpreta el método
Comunicarse de una manera, y comunica que es un gato.
Abstracción
El termino abstracción consiste en ver algo como un todo sin saber cómo está formado
internamente. (Largo, 2016)
Según (Largo, 2016), “las personas gestionan la complejidad a través de la abstracción, que
quiere decir esto, por ejemplo para alguien es difícil entender todos los componentes,
circuitos de un televisor y como trabajan, sin embargo es más fácil conocerlo como un
todo, como un televisor, sin pensar en sus detalles o partes internas”.
11
Para entender esto mejor se puede definir a la abstracción como la descomposición de
sistemas complejos en partes sencillas, las cuales se pueden describir de una manera muy
sencilla. Un ejemplo de abstracción en Java es una clase, ya que se define como un todo, el
objetivo de la abstracción es que el usuario pueda crear objetos de una determinada clase,
que utilice sus métodos, y que no se preocupe por como esta implementada y diseñada
nuestra clase.
Sobrecarga de métodos
Un método sobrecargado se utiliza para reutilizar el nombre de un método, pero con
diferentes argumentos, se sabe confundir la sobrecarga con el polimorfismo, pero son
completamente diferentes. Según (Navarro, 2008) las reglas para sobrecargar un método
son las siguientes:
Los métodos sobrecargados deben cambiar su lista de argumentos.
Pueden cambiar el tipo de retorno.
Pueden cambiar el modificador de acceso.
Pueden declarar nuevas o más amplias excepciones.
Un método puede ser sobrecargado en la misma clase o en una subclase.
Tenemos el siguiente método y lo queremos sobrecargar:
public void mostrarInfo(string nPerro, string rPerro) { }
Los siguientes métodos son sobrecargas legales del método mostrarInfo():
public void mostrarInfo(string nPerro, string rPerro,string pPerro) { }
public void mostrarInfo(string nPerro, string rPerro, string pPerro, string aPerro) { }
public string mostarInfo(string nPerro) { }
Esta misma lógica se aplica a los Constructores, cuando en una clase existen constructores
múltiples se dice que hay sobrecarga de constructores.
Sobrecarga de operadores
La sobrecarga de operadores es la capacidad para transformar los operadores de un lenguaje
como por ejemplo el +, -, etc, cuando se dice transformar se refiere a que los operandos que
entran en juego no tienen que ser los que admite el lenguaje por defecto. Mediante esta
técnica podemos sumar dos objetos creados por nosotros o un objeto y un entero, en vez de
limitarnos a sumar números enteros o reales, por ejemplo. La sobrecarga de operadores ya
era posible en c++ y en otros lenguajes, pero sorprendentemente Java no lo incorpora, así
12
que podemos decir que esta característica es una ventaja de c# respecto a java, aunque
mucha gente, esta posibilidad, no lo considera una ventaja porque complica el código.
(Perez, 2012)
Que Java no incorpore la sobrecarga de operadores por defecto no significa que no se pueda
implementar. Esto se puede hacer mediante el uso de métodos “complejos”, creados por
nosotros mismos y que se adaptan a nuestras necesidades, esto como ya se mencionó
anteriormente, puede llegar a complicar el código.
13
Bibliografía
Largo, E. (4 de 10 de 2016). ECODEUP. Obtenido de Programacion Web Full Stack :
[Link]
orientada-objetos-en-java/
Navarro, L. (25 de 1 de 2008). Los apuntes del Mono. Obtenido de
[Link]
[Link]
Perez, D. P. (24 de 5 de 2012). Programación Orientado a Objetos - ITSAV Lerdo.
Obtenido de [Link]
[Link]
Perry, J. S. (03 de 12 de 2012). IBM. Obtenido de International Business Machines
Corporation: [Link]
introtojava1/[Link]#N10341
Rodríguez, C. V. (11 de 2 de 2011). Departamento de informática. Obtenido de
Universidad de Valladolid: [Link]
14