Paradigma 6

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 20

PARADIGMA ORIENTADO A OBJETOS

UNIDAD Nº III
Estructuras de Control

1 www.iplacex.cl
SEMANA 6

Consideraciones previas

El contenido que se expone a continuación está ligado a los siguientes


objetivos:

- Relaciona la reutilización de código como la capacidad de poder encontrar


comportamiento y características comunes entre objetos que puedan ser
definidas globalmente mediante clases de tipo interface.

- Distingue el proceso de sobreescritura como la capacidad de un método


de poder tener más de un comportamiento en base a sus parámetros de
entrada.

- Distingue el uso del contador para el desarrollo de aplicaciones.

- Distingue el estado de un objeto y el manejo de la referencia “this” para


llamar a los métodos y atributos de acuerdo con la instancia concreta de la
clase y su uso.

- Distingue los distintos tipos de comentarios para facilitar la comprensión


de acciones y descripciones de los métodos.

Sobre las fuentes utilizadas en el material


El presente Material de Estudio constituye un ejercicio de recopilación de
distintas fuentes, cuyas referencias bibliográficas estarán debidamente
señaladas al final del documento. Este material, en ningún caso pretende asumir
como propia la autoría de las ideas planteadas. La información que se incorpora
tiene como única finalidad el apoyo para el desarrollo de los contenidos de la
unidad correspondiente, respetando los derechos de autor ligados a las ideas e
información seleccionada para los fines específicos de cada asignatura.

2 www.iplacex.cl
Introducción

Estamos en la semana seis de la asignatura, y es la última en la que veremos


conceptos teóricos. En esta ocasión corresponde hablar de reutilización de código,
concepto muy importante en la eficiencia en el desarrollo de sistemas. Se indicará
igualmente el concepto de sobreescritura, y se analizará como usar variables
contadores.

Otros conceptos importantes que se abordarán en esta semana es el prefijo this,


que permite hacer referencia a un elemento existente dentro de una clase, y los
comentarios al código fuente, tema que es muy relevante para que terceros
entiendan mejor las soluciones desarrolladas.

3 www.iplacex.cl
Ideas fuerza
1. Reutilización de código: capacidad de poder encontrar comportamiento y
características comunes entre objetos que puedan ser definidas globalmente.

2. Sobreescritura: capacidad de un método de poder tener más de un


comportamiento en base a sus parámetros de entrada.

3. Contador: variable que se declara e inicializa con un valor especifico, y que


permite registrar la cantidad de iteraciones que se realiza durante un proceso.

4. Comentario: anotación agregada a un código fuente, que permite a otros


desarrolladores o al programador mismo indicar ciertas observaciones que
ayudan a entender la naturaleza de la solución propuesta o datos que sea
necesario indicar.

4 www.iplacex.cl
Índice

1.- Reutilización de código ......................................................................................6


2.- Sobreescritura de métodos ..............................................................................10
3.- Contadores ......................................................................................................12
4.- Directiva this ....................................................................................................13
5.- Comentarios ....................................................................................................15

5 www.iplacex.cl
Desarrollo

1.- Reutilización de código

El uso de la reutilización de código en el trabajo diario es muy habitual. Cuando un


estudiante comienza a programar, a veces considera que la herencia es la
característica de un lenguaje de programación orientado a objeto que aportar mayor
reutilización. Sin embargo, esto no es cierto ya que la herencia se usa normalmente
para categorizar.

Fuera de este tipo de opciones el uso de herencia no suele encajar y se opta por un
enfoque de composición, donde una clase usa otras clases. Un ejemplo cotidiano
podría ser el diseñar las clases Persona, Empresa y Direccion. En el siguiente
ejemplo, la Persona como la Empresa contienen la información de la Direccion como
propiedades individuales.

Ilustración 1: Clases Persona y Empresa. Fuente: Arquitectura Java [1]

Este enfoque no favorece la reutilización ya que ambas clases comparten las


propiedades. Para solventar este problema se debe apostar por un enfoque de
composición. En este enfoque tanto Persona como Empresa se apoyan en la clase
Dirección para gestionar el concepto de calle y numero.

6 www.iplacex.cl
Ilustración 2: Clases Persona, Empresa y Direccion. Fuente: Arquitectura Java [1]

La idea anterior en lenguaje Java se vería de la siguiente manera:

public class Persona {


private String nombre;
private int edad;

private Direccion dirección;

public Persona(String nombre, int edad) {


super();
this.nombre = nombre;
this.edad = edad;
}
public Direccion getDirección() {
return dirección;
}
public void setDirección(Direccion dirección) {
this.dirección = dirección;
}
public String getNombre() {
return nombre;

7 www.iplacex.cl
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}

public class Empresa {


private String rut;
private Direccion direccion;

public Direccion getDirección() {


return dirección;
}
public void setDireccion(Direccion dirección) {
this.direccion = direccion;
}
public String getRut() {
return rut;
}
public void setRut(String rut) {
this.rut = rut;
}

public class Direccion {


private String calle;
private int numero;

public String getCalle() {


return calle;
}
public void setCalle(String calle) {

8 www.iplacex.cl
this.calle = calle;
}
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
this.numero = numero;
}
public Direccion(String calle, int numero) {
super();
this.calle = calle;
this.numero = numero;
}

De esta manera es muy sencillo compartir a través de la composición el concepto


de Dirección entre ambas clases sin la necesidad de utilizar herencia.

En el ejemplo a continuación se muestra un programa main que se encarga de


construir un objeto Empresa y otro objeto Persona, cada uno de ellos asociado a
una Direccion diferente.

public class Principal {


public static void main(String[] args) {

Direccion d1= new Direccion("calle A",3);


Direccion d2= new Direccion("calle B",7);
Persona p= new Persona("pepe",20);
p.setDirección(d1);
Empresa e= new Empresa();
e.setRut("1A");
e.setDirección(d2);

System.out.println(p.getDirección().getCalle());
System.out.println(e.getDirección().getCalle());
}
}

9 www.iplacex.cl
ANTES DE CONTINUAR CON LA
LECTURA…REFLEXIONEMOS

¿Existe una relación entre la complejidad de un código fuente y su nivel de


reutilización?

¿En qué otro caso ejemplo pudiese ser útil la reutilización?

2.- Sobreescritura de métodos

La sobreescritura de métodos es una característica que se presenta en el concepto


de la herencia, que consiste en implementar un método en la clase superior e inferior
en la jerarquía de herencia.

Por ejemplo, considerando las clases cuadrado y cubo de la jerarquía de figuras


geométricas que se presenta en la siguiente figura, es posible crear un método
getArea, tanto para la clase cuadrado como para la clase cubo. Entonces, si se crea
una referencia de la clase cuadrado, dependiendo de la instancia del objeto que se
crea que puede ser de cuadrado o cubo, se accede al método implementado en
cuadrado o en cubo, respectivamente.

10 www.iplacex.cl
Ilustración 3: Jerarquía de herencia de Cuadrado y Cubo

La implementación de la jerarquía es la siguiente:

public class Cuadrado {

protected int valor1;

public Cuadrado(double valor1) {


this.valor1 = valor1;
}

public double getArea() {


return Math.pow(this.valor1, 2);
}
}

public class Cubo extends Cuadrado {

public Cubo(double valor1) {


super(valor1);
}

public double getArea() {


return Math.pow(this.valor1, 3);
}
}

11 www.iplacex.cl
En la implementación anterior, sobre escribe el método getArea debido a que el
área del cuadrado es diferente al área del cubo. Java identifica a cual método
sobrescrito debe acceder en tiempo de ejecución.

ANTES DE CONTINUAR CON LA


LECTURA…REFLEXIONEMOS

¿Qué otra clase se puede generar a partir de Cuadrado?

3.- Contadores

Cuando se trabaja con bucles repetitivos, muchas veces interesa saber en qué
repetición se está. Para contar las repeticiones, se suele usar una variable que es
llamada contador [3].

En teoría un contador puede llevar cualquier nombre. Sin embargo, la idea es que
tenga un nombre que permita identificarlo bien y reconocerlo en el proceso. En el
caso de los ciclos, es común usar contadores llamados solo una letra, usando los
caracteres i, j, k, l, entre otros.

Para hacer uso de un contador es necesario realizar los siguientes pasos:

• Inicializar una variable a cero o uno antes del ciclo repetitivo.


12 www.iplacex.cl
• Dentro del ciclo repetitivo, incrementar en uno la variable.

Considérese el siguiente código:

public class ContadorWhile {


public static void main(String[] args) {
int contador = 0;
while (contador < 5) {
contador = contador + 1;
System.out.println(contador);
}
}
}

El ejemplo anterior usa una variable contador para contar las repeticiones y se
imprime por la consola el número de cada repetición: 1,2,3,4,5.

ANTES DE CONTINUAR CON LA LECTURA…REFLEXIONEMOS

¿Qué sucedería si no se aumenta el valor del contador dentro de un ciclo?

¿Qué podría ocurrir si no se asigna un valor correcto inicial a un contador?

4.- Directiva this

13 www.iplacex.cl
El apuntador o prefijo "this" [2] permite acceder a los atributos y métodos de la clase.
Hace referencia al objeto actual de la clase, es decir, a una instancia concreta de la
misma y nos sirve para usar los métodos y atributos de esa clase desde alguno de
sus métodos, para llamar a otro de sus constructores o simplemente para pasarle
el objeto completo a algún otro método u objeto.

El uso del prefijo no es obligatorio, pero se recomienda usarlo como buena práctica.
Es posible que el parámetro de un método tenga el mismo nombre que un atributo,
en este caso el uso del apuntador this es obligatorio para que el compilador
identifique si está haciendo referencia al atributo o al parámetro del método.

Por eso normalmente siempre se verá el “this.” delante de los atributos en los
constructores y en los setters ya que lo normal es que los parámetros tengan los
mismos nombres que los atributos de la clase, mientras que en los getters no se
suele poner porque no hay ninguna duda de a que es a lo que se está accediendo.

public class Archivo {


private String nombre;
private String extension;
private String ruta;

public Archivo(String nombre, String extension) {


this.nombre = nombre;
this.extension = extension;
this.ruta = "";
}

public Archivo(String nombre, String extension, String ruta) {


this(nombre, extension);
this.ruta = ruta;
}

public String getNombre() {


return nombre;
}

public void setNombre(String nombre) {


this.nombre = nombre;
}

14 www.iplacex.cl
public String getExtension() {
return extension;
}

public void setExtension(String extension) {


this.extension = extension;
}

public String getRuta() {


return ruta;
}

public void setRuta(String ruta) {


this.ruta = ruta;
}

@Override
public String toString() {
return this.getRuta() + this.getNombre() + "." +
this.getExtension();
}

En el código anterior también se puede ver como “this” se puede usar al mismo
tiempo para llamar a otro de los constructores de la clase.

5.- Comentarios

Los comentarios son líneas de texto que aparecen en el código fuente y que son
obviadas por el compilador. Su principal utilidad consiste en ayudar a entender el
código fuente adyacente.

Dentro de un programa Java hay dos formas de escribir un comentario. La primera,


que se denomina comentario en bloque, se hereda del lenguaje de programación C
y utiliza una combinación del carácter barra inclinada hacia la derecha seguido del
carácter asterisco para abrir el comentario, y la combinación asterisco barra
inclinada para cerrarlo.

15 www.iplacex.cl
La otra forma se hereda de C ++ y simplifica la tarea de hacer comentarios de una
sola línea. Para ello utiliza dos veces el carácter de la barra inclinada a la derecha
para indicar el comienzo del comentario y el retorno de carro para terminarlo.

Puede observarse que, por definición no es posible anidar comentarios de tipo C,


aunque sí es posible que un comentario de tipo C incluya comentarios de línea.

/*
Esto es un comentario que
Puede ocupar varias líneas
*/

// Esto es un comentario de línea

Además, Java aconseja un modo estándar de escritura de comentarios que, de


seguirse, permite al programa Javadoc del JDK generar de manera automática la
documentación del código. El programa Javadoc produce un archivo HTML por cada
archivo que analiza, el cual puede visualizarse con cualquier navegador web. Los
comentarios de documentación son comentarios de bloque que repiten el asterisco
Los comentarios de documentación se deben colocar antes del bloque de definición
al que hacen referencia, porque Java asocia el comentario de documentación a la
primera sentencia que se encuentra después del propio comentario.

En los comentarios de documentación se utilizan ciertas palabras clave precedidas


del carácter arroba para etiquetar los elementos que se describen. La siguiente tabla
recoge las diferentes posibilidades.

@param Parámetros de entrada para un método


@return Valor devuelto por un método
@throws Excepciones lanzadas por un método
@version Versión del código
@author Autor del código
@deprecated El método ya no se debe usar, pero se mantiene por
compatibilidad
@see Referencias a otras clases
@since Nueva funcionalidad añadida en la versión que marque
este tag

16 www.iplacex.cl
El siguiente fragmento de código muestra un ejemplo de comentarios de
documentación. Además, en todos los fragmentos de código que se utilicen en este
libro se incluirá el Javadoc correspondiente como parte del ejemplo.

/** Ejemplo de documentación


automática con Javadoc
@author Iplacex
@version 1.0
*/

/**
* Descripción del comportamiento del método
* @param nombreParametro_1 descripción
* @param nombreParametro_N descripción
* @return descripción del valor de retorno
* @throws nombre_clase descripción
* @since 0.6
* @deprecated explicación
*/

17 www.iplacex.cl
Conclusión
Tal como se indicó antes, con este texto se finalizan los conceptos teóricos
asociados a la asignatura Paradigma Orientado a objetos. Durante todas estas
semanas, se ha podido abarcar conceptos simples como la definición de clases y
de atributos, hasta temas como la reutilización del código.

En esta ocasión correspondió aplicar la reutilización del código en un ejemplo


sencillo; en este punto es complejo revisar casos más complejos dado que la
experiencia en desarrollo permitirá tener un panorama aún más amplio. Otro
concepto analizado es el de sobreescritura de métodos, junto al concepto de los
contadores, incluyendo ejemplos en cada caso. Igualmente se revisó la función del
prefijo “this” y su relevancia en la definición de una clase.

Por último, se revisaron los diferentes tipos de comentarios. Estos permiten registrar
anotaciones al código fuente, tanto en modo multilínea como en una sola. Se indicó
también que otro tipo de comentario es el existente en Javadoc, que da la opción
de establecer documentación estándar a una clase en base a comentarios.

Lo que se ha visto durante estas semanas es solo parte de lo que permite la


programación orientada a objetos en Java, y se revisó más bien desde una
perspectiva teórica desde su naturaleza como paradigma. El siguiente paso debe
ser desarrollar aplicaciones de escritorio, móviles o web con este lenguaje, usando
alguno de los marcos de trabajo y editores de código creados para estos efectos.
Como reflexión final, se plantean las siguientes preguntas:

- ¿Qué diferencias se pueden apreciar entre Java y algún lenguaje de


programación multipropósito como Python?

- ¿Existe un lenguaje de programación mejor que otro? De ser así, ¿qué


factores se debería considerar?

18 www.iplacex.cl
Bibliografía
[1] Arquitectura Java, “Java Composicion y la reutilización del código”. Referencia:
https://www.arquitecturajava.com/java-composicion-y-la-reutilizacion-del-codigo/

[2] Flórez Fernández, H. A. (2012). Programación orientada a objetos usando java.


Bogotá, Colombia: Ecoe Ediciones.

[3] Dudas de programación, “Crear un contador en Java”. Referencia:


https://www.dudasprogramacion.com/277/crear-un-contador-en-java

[4] Vélez Serrano, J. (2011). Diseñar y programar, todo es empezar: una


introducción a la Programación Orientada a Objetos usando UML y Java.

19 www.iplacex.cl
20 www.iplacex.cl

También podría gustarte