Object oriented paradigm

Pilares POO

• Abstracción
• Encapsulación
• Herenecia
• Polimorfismo

Dependencia

• Relación más básica y débil entre clases.
• Cambios en la definición de una clase puede provocar modificaciones en otra.
• Ocurre normalmente cuando utilizas nombres de clases concretas en tu código.

class Student:
  def remember(self):
    pass


class Course:
  def get_knowledge(self):
    pass


class Teacher:
  def __init__(self, student: Student):
    self.student = student

  def teach(self, course: Course):
    self.student.remember(
      course.get_knowledge()
    )

• Si alguien cambia el método get_knowledge() de la clase Course (es decir, si cambia su nombre o añade algún parámetro requerido, etc.) nuestro código se va a romper.

Asociación

• La asociación es una relación en la que un objeto utiliza o interactúa con otro.
• La asociación puede verse como un tipo especializado de dependencia, en la que un objeto siempre tiene acceso a los objetos con los que interactúa, mientras que la dependencia simple no establece un vínculo permanente entre los objetos.

class Student:
  def remember(self):
    pass


class Course:
  def get_knowledge(self):
    pass


class Teacher:
  def __init__(self):
    self.student = Student()

  def teach(self, course: Course):
    self.student.remember(
      course.get_knowledge()
    )

• Mirando la clase Teacher, la clase Student también es una dependencia ya que cuando se crea el objeto, se crea ademas un Student, la diferencia es que el objeto self.student va a estar accesible para cualquier metodo, no solo para teach.

Agregación

• Tipo especializado de asociación que representa relaciones “uno a muchos”, “muchos a muchos” o “todo a parte” entre múltiples objetos.
• Normalmente, con la agregación, un objeto “tiene” un grupo de otros objetos y sirve como contenedor o colección.
• El componente puede existir sin el contenedor y puede vincularse a varios contenedores al mismo tiempo.

class Author:
  def __init__(self,name, surname):
    self.name = name
    self.surname = surname

  def __repr__(self):
    return f"{self.name} {self.surname}"

class Book:
  def __init__(self, title, author: Author):
    self.title = title
    self.author = author

  def __repr__(self):
    return f"Titulo: {self.title} - author: {self.author}"



author = Author("pedro", "lopez")

book = Book("Titulo", author)

print(book)

• En este ejemplo la clase Book conoce a la clase Author y la utiliza par mostrar el nombre del author del libro.
• Pero tambien son independientes, es decir Author puede existir sin Book.

Composición

• La composición es un tipo específico de agregación en la que un objeto se compone de una o más instancias del otro.
• La diferencia entre ésta y otras relaciones está en que el componente sólo puede existir como parte del contenedor.

class Book:
  def __init__(self, title):
    self.title = title
    self.chapters = []

  def add_chapter(self, chapter: Chapter):
    self.chapters.append(chapter)

  def total_pages(self):
    total = 0
    for chapter in self.chapters:
      total += chapter.pages
    return total


chapter_1 = Chapter("Chapter 1", 50)
chapter_2 = Chapter("Chapter 2", 25)

book = Book("Titulo")

book.add_chapter(chapter_1)
book.add_chapter(chapter_2)

print(book.total_pages())

• En este caso Chapter no tiene sentido si no es dentro de Book.

Herencia

• La herencia es la capacidad de crear nuevas clases sobre otras existentes.
• Principal ventaja de la herencia es la reutilización de código.
• La consecuencia del uso de la herencia es que las subclases tienen la misma interfaz que su clase padre. (No se puede ocultar un metodo de la superclase)

Polimorfismo

• El polimorfismo es la capacidad que tiene un programa de detectar la verdadera clase de un objeto e invocar su implementación, incluso aunque su tipo real sea desconocido en el contexto actual.

Relaciones entre objetos y clases

Referencia

• https://refactoring.guru/es/design-patterns/book

Share on: Twitter ❄ Facebook ❄ Email