Programación Orientada a Objetos

¡Buenas a todos!

Al fin comenzamos una nueva sección dentro del Curso de Desarrollo de Videojuegos Indie. En este ampliaremos lo visto en Fundamentos de la Programación, centrándonos en la Programación Orientada a Objetos y las Estructuras de Datos Avanzadas. ¡Vamos a por ello!

Paradigmas de Programación

Entendemos por paradigmas de programación a los diferentes enfoques que se pueden plantear a la hora de conceptualizar, estructurar y desarrollar un programa. Esto permite una mayor capacidad de resolver problemas, pues diferentes enfoques pueden reducir la complejidad del mismo.

Programación Imperativa

Este paradigma se centra en el cómo se resuelve el problema. Debido a ello, los programas consisten básicamente en una descripción precisa y detallada de los pasos a seguir para resolver el problema. Esto se logra mediante el uso de diversos condicionales, bucles y subrutinas. Básicamente, todo lo aprendido en el curso Fundamentos de la Programación se puede considerar este tipo de programación.

Programación Declarativa

Este paradigma se centra en describir qué se quiere conseguir, en lugar de como. Para ello el lenguaje consiste en una declaración de propiedades y reglas que deben cumplirse. Dentro de ella podemos encontrar diferentes enfoques, como la Programación Funcional (centrada en la evaluación de funciones matemáticas puras) o la Programación Lógica (centrada en reglas lógicas).

Programación Multiparadigma

Este enfoque consiste en el uso de más de un paradigma para resolver el problema. Para ello es necesario el uso de un lenguaje que permita dicha versatilidad.

Programación Orientada a Objetos

La Programación Orientada a Objetos (POO) se centra en el uso de diversos objetos que interactúan entre sí, y técnicamente pertenece a la familia de la Programación Imperativa. En la POO, los objetos sirven de encapsulado de las diversas propiedades y comportamientos del mismo, definiendo con ello un modelo que representa al objeto en cuestión.

Clases

Una clase es un modelo que sirve para determinar de que manera se representará un objeto. Dentro de la misma encontramos los distintos atributos y métodos que definirán el comportamiento del mismo. Por ejemplo, podemos tener una clase Persona() que nos servirá para definir objetos que representen a distintas personas dentro de, por ejemplo, una agenda.

Atributos

Los atributos son un conjunto de variables que sirven para almacenar la información relativa a la clase en cuestión. Estos atributos deben ser características o propiedades propias del objeto que se quiere representar. Siguiendo con el ejemplo anterior, podríamos tener los atributos nombre y edad, pues son características propias a todas las personas.

Métodos

Los métodos son las funciones propias de la clase. Estas representan las diferentes acciones que puede realizar un objeto. Para nuestra clase Persona(), un método podría ser mostrarNombre() para ver el nombre de la persona por pantalla.

Constructor

Se trata de un método especial. Este define los pasos a seguir a la hora de construir un nuevo objeto perteneciente a la clase en cuestión. Siguiendo con nuestro ejemplo, el constructor de Persona() podría ser una función que te solicitara el nombre y la edad y lo almacenara en los atributos correspondientes.

Getters y Setters

Muchos lenguajes, a la hora de definir una clase, separan sus elementos en privados y públicos. Esto nos impide poder acceder a los atributos desde fuera de la propia clase, y necesitamos una manera alternativa para poder leerlos y modificarlos. Para ello se definen una serie de métodos conocidos como «getter» (del inglés get, obtener) y «setter» (del inglés set, definir). Estos métodos se encargan de modificar los atributos de la clase mediante los parámetros indicados.

Definición e Instanciación en Python

class Persona:
	def __init__(self, nombre, edad):
		self._nombre = nombre
		self._edad = edad

	def mostrarPersona(self):
		print("Nombre: %s; Edad: %d." % (self._nombre, self._edad))
	
if __name__ == '__main__':
	p = Persona("Jacinto", 34)
	p.mostrarPersona()

Definir una clase en Python resulta bastante sencillo en comparación a algunos otros lenguajes. En primer lugar, utilizamos la sentencia class para determinar el bloque que representará a la clase. El constructor de la misma viene definido por defecto mediante el identificador __init__.

A la hora de definir este y otros métodos hemos de tener en cuenta que estos necesitan como primer parámetro el identificador self, el cual hace referencia al propio objeto en si. Si no hiciéramos esto, el método no tendría acceso a los atributos del objeto. En este ejemplo hemos definido los atributos dentro del constructor, ya que ambos son necesarios para la creación de un objeto de clase Persona(). De no ser así, podrían ser externos al mismo sin problemas.

En este ejemplo también se ha creado un método para mostrar una persona por pantalla, el cual consiste en un simple print(). Este método es nuestro «getter» para los atributos de nuestra clase. Aunque Python no tiene parte privada y podríamos acceder directamente a ellos, esto está considerado una Mala Práctica de Programación.

Por último, en la línea 10 instanciamos un nuevo objeto perteneciente a la clase Persona().

Convención de Nombres

Una Buena Práctica de Programación es el uso de una Convención de Nombres, de forma que simplemente viendo como está escrita una entidad sepamos directamente el tipo al que pertenece. Existen muchas convenciones diferentes, a continuación os muestro una posible:

• Clases: Sus nombres deben ser sustantivos escritos con la primera letra en mayúscula, y sin espacio entre las diversas palabras que lo formen.
  Ejemplos: Persona(), ListaCompra()
• Métodos: Su principal parte debe ser un verbo, preferiblemente en definitivo, empezando siempre por minúscula, estando las siguientes palabras su primera letra en mayúscula.
  Ejemplos: mostrarPersona(), definirNombre(), insertarElemento()
• Variables: Deben estar escritas completamente en minúsculas y sin espacios dentro de las mismas. Su nombre debe indicar de manera obvia cual es el objetivo de su uso. En caso de variables temporales para contar iteraciones, la tradición nos indica el uso de las letras i, j, k, m y n.
  Ejemplos: int suma, string nombre
• Atributos: Igual que las variables, pero para indicar que no son de acceso público al resto del programa deben empezar por un guión bajo (_). También existe la alternativa de utilizar el prefijo «mi».
  Ejemplos: _nombre, miApellido
• Constantes: Se deben escribir en mayúsculas completamente, separando sus distintas partes por un guión bajo.
  Ejemplos: GRAVEDAD, VELOCIDAD_LINEAL

---

Esta primera entrega nos ha presentado mucha información nueva, por lo que los mejor es leerla con calma y procesarla. Pero no te preocupes, poco a poco te irás familiarizando con todo.

¡Nos leemos!

---