FP 2022-11-28

# computador_v3.py
class Computador:
    # uma dunder function (dunder = double underscore)

    def __init__(
        self,
        pCPU="Intel",
        pRAM=16,
        pStorage=1024
    ):
        # aqui constrói-se cada objeto
        # do tipo
        # a palavra reservada "self"
        # significa "o objeto em construção"
        self.mCPU = pCPU
        self.mRAM = pRAM
        self.mStorage = pStorage
    # def __init__

    # método dinâmico
    # se a lista de params começa pela palavra
    # reservada self, o método é dinâmico
    # impacto na utilização?
    # para se usar um método dinâmico
    # o padrão, na chamada é:
    # nomeDoObjeto.nomeDoMétodo()
    # se o método fosse "static"/estático
    # partilhado por todas as instâncias,
    # NÃO poderia ter a palavra self
    # o padrão de utilização é:
    # nomeDaClass.nomeDoMétodo()

    # para ensinar a linguagem a representar
    # instâncias da class enquanto frases
    def __str__(self):
        strMsg:str = ""
        strMsg+=f"CPU: {self.mCPU} "
        strMsg+=f"RAM: {self.mRAM} "
        strMsg+=f"Storage: {self.mStorage}"
        return strMsg
    # def __str__

    @staticmethod
    def vaiAvariar():
        return True
    # def vaiAvariar


    def __gt__(self, other):
        return self.mRAM>other.mRAM
# class Computador

# 3 formas diferentes de usar uma função
# em linguagens FORTEMENTE tipificadas
# isso significa que têm que existir
# 3 implementações diferentes da mesma
# função, com 3 assinaturas diferentes,
# 3 listas de params diferentes.
# Cada uma dessas funções diz-se um "overloading"
# Em Python não há "overloading"
# o mesmo efeito atinge-se por
# valores por defeito para params
c2 = Computador("AMD", 32, 123456)
# o método __str__ é o comportamento por defeito
# default behaviour de QUALQUER objeto, de
# QUALQUER tipo
# ou seja, se NADA pedirmos a um objeto
# estamos a pedir-lhe o comportamento __str__
# por isso, print(c1) equivale a print(c1.__str__())
print(c2.__str__())
c1 = Computador("Intel", 16, 1024)
print(c1.__str__()) #???

print (Computador.vaiAvariar())
#print (c1.vaiAvariar())
#print (c2.vaiAvariar())

# também não sabe
print(c1>c2)