Conceptos básicos de la programación orientada a objeto
Clase
Es un plano o plantilla que define los atributos y métodos de un objeto. Es una abstracción que describe las características y comportamientos comunes a todos los objetos de ese tipo.
Las clases permiten crear múltiples instancias de objetos con la misma estructura pero con datos distintos.
Ejemplo:
Clase Persona:
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad
def saludar(self):
print(f"Hola, soy {self.nombre} y tengo {self.edad} años.")
Aquí, Persona es una clase, y puedes crear objetos como persona1 = Persona("Juan", 30).
Atributos
Son las variables dentro de una clase que representan las propiedades o características de un objeto.
Los atributos se definen en el método especial __init__ (el constructor de la clase).
Ejemplo:
clase Coche:
def __init__(self, color, marca):
self.color = color # Atributo
self.marca = marca # Atributo
En este caso, color y marca son atributos de los objetos Coche.
Métodos
Son las funciones que se definen dentro de una clase y representan los comportamientos o acciones que los objetos de esa clase pueden realizar.
Los métodos pueden acceder y modificar los atributos del objeto.
Ejemplo:
clase Coche:
def __init__(self, marca, color):
self.marca = marca
self.color = color
def arrancar(self):
print(f"El coche {self.marca} de color {self.color} ha arrancado.")
El método arrancar es una acción que puede realizar un objeto Coche.
Encapsulamiento
Es el principio que consiste en ocultar los detalles internos de un objeto (sus atributos y métodos) y solo exponer lo necesario a través de una interfaz pública.
Esto se logra mediante el uso de modificadores de acceso, como público (accesible desde fuera de la clase) y privado (accesible solo desde dentro de la clase).
En Python, los atributos privados se indican poniendo un guion bajo (_) antes del nombre del atributo (por convención).
Ejemplo:
clase Coche:
def __init__(self, marca):
self._marca = marca # Atributo privado por convención
def obtener_marca(self):
return self._marca # Método público para acceder al atributo privado
Objeto
Es una instancia de una clase. Los objetos representan entidades del mundo real o conceptos abstractos y tienen atributos (datos) y métodos (funciones que operan sobre esos datos).
Los objetos encapsulan su estado y comportamiento.
Ejemplo: Si creamos una clase Coche, un objeto sería un coche específico con atributos como color y modelo, y métodos como acelerar o frenar.
clase Coche:
def __init__(self, color, modelo):
self.color = color
self.modelo = modelo
Es un paradigma de programación que organiza el código en "objetos" que representan entidades del mundo real o conceptos abstractos. Este enfoque facilita la modularidad, reutilización y mantenimiento del código
Herencia
Es un mecanismo que permite crear una nueva clase basada en una clase existente. La nueva clase hereda los atributos y métodos de la clase base y puede agregar o modificar su comportamiento.
La herencia promueve la reutilización del código y la extensión de funcionalidades sin necesidad de reescribir todo.
Ejemplo:
Clase Animal:
def __init__(self, nombre):
self.nombre = nombre
def hablar(self):
pass # Método abstracto
Clase Perro(Animal):
def hablar(self):
volver "Guau"
Clase Gato(Animal):
def hablar(self):
volver "Miau"
perro = Perro("Rex")
print(perro.hablar()) # Guau
Aquí, Perro y Gato heredan de Animal y cada uno implementa su propio método hablar.
Polimorfismo
Es la capacidad de usar un mismo nombre de método en diferentes clases y que cada clase lo implemente de manera diferente.
Permite que objetos de diferentes clases respondan de manera distinta al mismo mensaje o método.
Ejemplo:
Clase Ave:
def volar(self):
print("El ave está volando")
Clase Murciélago(Ave):
def volar(self):
print("El murciélago está volando en la oscuridad")
ave = Ave()
murciélago = murciélago()
ave.volar() # El ave está volando
murciélago.volar() # El murciélago está volando en la oscuridad
Aunque ambos objetos llaman al mismo método volar(), el comportamiento es diferente.
Abstracción
Es el proceso de ocultar la complejidad interna de un objeto y solo exponer las características esenciales.
En Python, esto se puede lograr mediante clases abstractas y métodos abstractos usando el módulo abc.
Ejemplo:pitónCopiar códigode abc import ABC, abstractmethodclase Animal (ABC): @abstractmethod def sonido(self): pasarClase Perro(Animal): def sonido(self): volver "Guau"Aquí, la clase Animal tiene un método abstracto sonido() que debe ser implementado por las subclases.