Agg Engine - Car

engine-car.py

def main( a, b = None, c = None):

    print( a, b, c )

main( 1, 2, 3 )

# Agregare in programarea orientata obiect

"""
Agregarea este un concept important in programarea orientata pe obiecte si reprezinta o relatie de tip "has a" (are un) intre doua clase.
In aceasta relatie de tip "has a" o clasa contine o referinta  catre un obiect al altei clase. dar acel obiect poate exista independent de clasa care il contine.

In agregare:

- o clasa container contine o referinta  catre un obiect al alte clase
- obiectul inclus poate exista independent de obiectul container
- relatia este de tipul "has-a"
- este o forma de asociere mai slaba decat compozitia.

Exemplu elocvent de agregare
            has-a
Department -------> Professor
"""

class Professor:
    # constructorul clasei: name, specializare
    def __init__(self, name, specializare):
        self.name = name;
        self.specializare = specializare

    def descrie(self):
        return f"Professor {self.name}, specializarea {self.specializare}"

class Department:

    def __init__(self, nume):
        self.nume = nume
        #lista care contine o referinta catre obiecte Professor
        self.professors = []

    def adauga_professor(self, professor):

        self.professors.append( professor )

    def listeaza_profesori(self):

        result = f"Department {self.nume} include profesorii: \n"

        for profesor in self.professors:
            result += f"{profesor.descrie()}\n"
        return result

def main():
    prof1 = Professor("John", "Matematica")
    prof2 = Professor("Maria", "Informatica")
    prof3 = Professor("Peter", "Fizica")

    departament_stiinte = Department("Stiinte Exacte")

    departament_stiinte.adauga_professor(prof1)
    departament_stiinte.adauga_professor(prof2)
    departament_stiinte.adauga_professor(prof3)

    print(departament_stiinte.listeaza_profesori())


    prof4 = Professor("Lyly", "Literatura comparata")
    prof5 = Professor("Calinescu", "Engleza")
    prof6 = Professor("Maiorescu", "Franceza")

    departament_umanist = Department("Umanist")
    departament_umanist.adauga_professor(prof4)
    departament_umanist.adauga_professor(prof5)
    departament_umanist.adauga_professor(prof6)

    print(departament_umanist.listeaza_profesori())

    """
    Explicatia exemplului de mai sus:

    - Avem doua clase Profesor si Department

    - Un departament contine mai multi profesori (prin lista de profesori)

    - Profesorii sunt creati independent de departament

    - un profesor poate exista in mai multe departmente simultan (profilul este adaugat in ambele departmente)

    - daca un departament este sters, profesorii ar continua sa existe

    Aceasta este o relatie de agregare clara pentru ca :
    - Departament "are" profesori
    - profesorii exista in mod independent
    - aceeasi profesori pot fi asociati cu mai multe departamente
    """

#main()

class Engine:

      def __init__(self, tip, putere):
            self.tip = tip
            self.putere = putere
            self._este_pornit = False

      def porneste(self):
          if not self._este_pornit:
              self._este_pornit = True
              return f"Motorul {self.tip} a pornit cu un zgomot puternic"
          return "Motorul este deja pornit"

      def opreste(self):

          if self._este_pornit:
              self._este_pornit = False
              return "Motorul s-a oprit"
          return "Motorul este deja oprit."

      def descriere(self):
            return f"Motorul {self.tip} cu putere de {self.putere} CP"

class Automobil:
    def __init__(self, marca, model, motor):

        self.marca = marca
        self.model = model
        self.motor = motor

    def porneste_masina(self):
        return f"{self.marca} {self.model}: {self.motor.porneste()}"

    def opreste_masina(self):
        return f"{self.marca} {self.model}: {self.motor.opreste()}"

    def specificatii(self):
        return f"Automobilul {self.marca} {self.model} are instalat un {self.motor.descriere()}"


def main2():

    motor_diesel = Engine("Diesel", 150)
    motor_benzina = Engine("Benzina", 120)
    motor_electric = Engine("Electric", 200)

    bmw = Automobil("BMW","Z3", motor_diesel)

    print(bmw.specificatii())
    print(bmw.porneste_masina())
    print(bmw.porneste_masina())

    ford = Automobil("Ford","Focus",motor_benzina)
    print(ford.specificatii())
    print(ford.porneste_masina())
    print(ford.porneste_masina())
    print(ford.opreste_masina())
    print(ford.opreste_masina())

    # motorul poate fi folosit independent
    print(motor_electric.descriere())
    print(motor_electric.porneste())

main2()

"""
alt exemplu de ilustrare a conceptului de agregare prin relatia dintre clasele Engine si Automobil

- Motoarele sunt create independent de automobile
- un motor poate exista fara sa fie atasat unui automobil

- relatia "are un"
- un automobil are un motor (nu il creeaza, ci primeste o referinta catre un motor existent)

- reutilizarea obiectelor
- acelasi motor - diesel - este utilizat in doua automobile diferite (DAcia si la BMW)

- asta inseamna ca acelasi motor poate fi partajat intre mai multe obiecte container.
"""