Inclusão dos códigos da cadeira de padrões de projeto 2020.2

S08 - Padrões de projeto/abstract_factory/.gitignore

@@ -0,0 +1,2 @@
+.vscode
+__pycache__

S08 - Padrões de projeto/abstract_factory/Readme.MD

@@ -0,0 +1,4 @@
+# Abstract Factory
+
+Exemplo escrito em python e baseado no do [
+Refactoring.Guru](https://refactoring.guru/pt-br) sobre o padrão de projeto [Abstract Factory](https://refactoring.guru/pt-br/design-patterns/abstract-factory).

S08 - Padrões de projeto/abstract_factory/computador.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from teclado import TecladoAbstrato
+
+
+class ComputadorAbstrato(ABC):
+    @abstractmethod
+    def detalhes_do_hardware(self) -> str:
+        pass
+
+
+class ComputadorModeloA(ComputadorAbstrato):
+    def detalhes_do_hardware(self) -> str:
+        return "Processador Core 2 + 8G Memória RAM + 1Tb de ssd"
+
+
+class ComputadorModeloB(ComputadorAbstrato):
+    def detalhes_do_hardware(self) -> str:
+        return "Processador Core 8 + 16G Memória RAM + 2Tb de ssd"

S08 - Padrões de projeto/abstract_factory/fabrica.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from computador import ComputadorAbstrato, ComputadorModeloA, ComputadorModeloB
+from teclado import TecladoAbstrato, TecladoModeloA, TecladoModeloB
+
+
+class FabricaAbstrataKit(ABC):
+    @abstractmethod
+    def criar_computador(self) -> ComputadorAbstrato:
+        pass
+
+    @abstractmethod
+    def criar_teclado(self) -> TecladoAbstrato:
+        pass
+
+
+class Kit1(FabricaAbstrataKit):
+    def criar_computador(self) -> ComputadorAbstrato:
+        return ComputadorModeloA()
+
+    def criar_teclado(self) -> TecladoAbstrato:
+        return TecladoModeloA()
+
+
+class Kit2(FabricaAbstrataKit):
+    def criar_computador(self) -> ComputadorAbstrato:
+        return ComputadorModeloB()
+
+    def criar_teclado(self) -> TecladoAbstrato:
+        return TecladoModeloB()

S08 - Padrões de projeto/abstract_factory/main.py

@@ -0,0 +1,22 @@
+from fabrica import FabricaAbstrataKit, Kit1, Kit2
+
+
+def kit_do_cliente(kit: FabricaAbstrataKit) -> None:
+
+    computador = kit.criar_computador()
+    teclado = kit.criar_teclado()
+
+    print(f"{computador.detalhes_do_hardware()}")
+    print(f"{teclado.detalhes()}")
+
+
+if __name__ == "__main__":
+    print("Testando o primeiro tipo de factory")
+    print("Detalhes do kit 1")
+    kit_do_cliente(Kit1())
+
+    print("\n")
+
+    print("Mesmo cliente só que estando o segundo tipo de factory")
+    print("Detalhes do kit 2")
+    kit_do_cliente(Kit2())

S08 - Padrões de projeto/abstract_factory/teclado.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class TecladoAbstrato(ABC):
+    @abstractmethod
+    def detalhes(self) -> str:
+        pass
+
+
+class TecladoModeloA(TecladoAbstrato):
+    def detalhes(self) -> str:
+        return "Teclado de membrana"
+
+
+class TecladoModeloB(TecladoAbstrato):
+    def detalhes(self) -> str:
+        return "Teclado mecânico"

S08 - Padrões de projeto/adapter/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/adapter/README.md

@@ -0,0 +1,7 @@
+# adapter
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Adapter](https://www.youtube.com/watch?v=qG286LQM6BU)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/adapter/adaptador_robo_inimigo.py

@@ -0,0 +1,16 @@
+from interface_atacante_inimigo import AtacanteInimigo
+from robo_inimigo import RoboInimigo
+
+
+class AdaptadorRoboInimigo(AtacanteInimigo):
+    def __init__(self, robo: RoboInimigo):
+        self.robo: RoboInimigo = robo
+
+    def atirar(self) -> None:
+        self.robo.esmagar_com_as_maos()
+
+    def seguir_em_frente(self) -> None:
+        self.robo.ande_para_frente()
+
+    def atribuir_motorista(self, nome_motorista: str) -> None:
+        self.robo.reagir_ao_humano(nome_motorista=nome_motorista)

S08 - Padrões de projeto/adapter/interface_atacante_inimigo.py

@@ -0,0 +1,15 @@
+from abc import abstractmethod, ABC
+
+
+class AtacanteInimigo(ABC):
+    @abstractmethod
+    def atirar(self) -> None:
+        pass
+
+    @abstractmethod
+    def seguir_em_frente(self) -> None:
+        pass
+
+    @abstractmethod
+    def atribuir_motorista(self, nome_motorista: str) -> None:
+        pass

S08 - Padrões de projeto/adapter/main.py

@@ -0,0 +1,24 @@
+from tanque_inimigo import TanqueInimigo
+from robo_inimigo import RoboInimigo
+from adaptador_robo_inimigo import AdaptadorRoboInimigo
+
+
+if __name__ == "__main__":
+    tanque_rx7: TanqueInimigo = TanqueInimigo()
+    fred: RoboInimigo = RoboInimigo()
+    adaptador: AdaptadorRoboInimigo = AdaptadorRoboInimigo(fred)
+
+    print("O robô...")
+    fred.reagir_ao_humano("Paul")
+    fred.ande_para_frente()
+    fred.esmagar_com_as_maos()
+
+    print("\nO tanque inimigo...")
+    tanque_rx7.atribuir_motorista("Frank")
+    tanque_rx7.seguir_em_frente()
+    tanque_rx7.atirar()
+
+    print("\nO robô com o adaptador...")
+    adaptador.atribuir_motorista("Mark")
+    adaptador.seguir_em_frente()
+    adaptador.atirar()

S08 - Padrões de projeto/adapter/robo_inimigo.py

@@ -0,0 +1,18 @@
+from random import randint
+
+
+class RoboInimigo:
+    def __init__(self):
+        self.dano = 0
+        self.movimento = 0
+
+    def esmagar_com_as_maos(self):
+        self.dano = randint(1, 10)
+        print(f"O robô iminigo causa {self.dano} de dano com suas mãos")
+
+    def ande_para_frente(self):
+        self.movimento = randint(1, 5)
+        print(f"O robô iminigo anda {self.movimento} casas para frente")
+
+    def reagir_ao_humano(self, nome_motorista):
+        print(f"O robô inimigo vai para cima do {nome_motorista}")

S08 - Padrões de projeto/adapter/tanque_inimigo.py

@@ -0,0 +1,19 @@
+from interface_atacante_inimigo import AtacanteInimigo
+from random import randint
+
+
+class TanqueInimigo(AtacanteInimigo):
+    def __init__(self):
+        self.dano: int = 0
+        self.movimento: int = 0
+
+    def atirar(self) -> None:
+        self.dano: int = randint(1, 10)
+        print(f"O tanque causa {self.dano} de dano")
+
+    def seguir_em_frente(self) -> None:
+        self.movimento = randint(1, 5)
+        print(f"O tanque se moveu {self.movimento} casas")
+
+    def atribuir_motorista(self, nome_motorista: str) -> None:
+        print(f"{nome_motorista} está dirigindo o tanque")

S08 - Padrões de projeto/bridge/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/bridge/README.md

@@ -0,0 +1,7 @@
+# bridge
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Facade](https://www.youtube.com/watch?v=9jIgSsIfh_8)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/bridge/botao_remoto.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from dispositivo_de_entretenimento import DispositivoDeEntretenimento
+
+
+class BotaoRemoto(ABC):
+    def __init__(self, dispositivo: DispositivoDeEntretenimento):
+        self._dispositivo = dispositivo
+
+    @abstractmethod
+    def botao_cinco_pressionado(self):
+        self._dispositivo.botao_cinco_pressionado()
+
+    @abstractmethod
+    def botao_seis_pressionado(self):
+        self._dispositivo.botao_seis_pressionado()
+
+    @abstractmethod
+    def feedback_do_dispositivo(self):
+        self._dispositivo.feedback_do_dispositivo()
+
+    @abstractmethod
+    def botao_nove_pressionado(self):
+        pass

S08 - Padrões de projeto/bridge/dispositivo_de_entretenimento.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+
+
+class DispositivoDeEntretenimento(ABC):
+    def __init__(self):
+        self.estado_do_dispositivo = 0
+        self.configuracao_maxima = 0
+        self.volume = 0
+
+    @abstractmethod
+    def botao_cinco_pressionado(self):
+        pass
+
+    @abstractmethod
+    def botao_seis_pressionado(self):
+        pass
+
+    @abstractmethod
+    def botao_sete_pressionado(self):
+        self.volume += 1
+        print(f"Volume em {self.volume}")
+
+    @abstractmethod
+    def botao_oito_pressionado(self):
+        self.volume -= 1
+        print(f"Volume em {self.volume}")
+
+    @abstractmethod
+    def feedback_do_dispositivo(self):
+        if self.estado_do_dispositivo > self.configuracao_maxima or self.estado_do_dispositivo < 0:
+            self.estado_do_dispositivo = 0
+
+        print(f"No canal {self.estado_do_dispositivo}")

S08 - Padrões de projeto/bridge/principal.py

@@ -0,0 +1,21 @@
+from tv_remoto_mudo import TvRemotaMuda
+from tv_remoto_pausa import TvRemotaPausa
+from tv import Tv
+
+if __name__ == '__main__':
+    botao_remoto_tv_1 = TvRemotaMuda(Tv(1, 200))
+    botao_remoto_tv_2 = TvRemotaPausa(Tv(1, 200))
+
+    print("Teste da tv mutada")
+    botao_remoto_tv_1.botao_cinco_pressionado()
+    botao_remoto_tv_1.botao_seis_pressionado()
+    botao_remoto_tv_1.botao_nove_pressionado()
+
+    print("\nTeste da tv pausada")
+    botao_remoto_tv_2.botao_cinco_pressionado()
+    botao_remoto_tv_2.botao_seis_pressionado()
+    botao_remoto_tv_2.botao_seis_pressionado()
+    botao_remoto_tv_2.botao_seis_pressionado()
+    botao_remoto_tv_2.botao_seis_pressionado()
+    botao_remoto_tv_2.botao_nove_pressionado()
+    botao_remoto_tv_2.feedback_do_dispositivo()

S08 - Padrões de projeto/bridge/tv.py

@@ -0,0 +1,26 @@
+from dispositivo_de_entretenimento import DispositivoDeEntretenimento
+
+
+class Tv(DispositivoDeEntretenimento):
+    def __init__(self, estado_do_dispositivo: int, configuracao_maxima: int):
+        super().__init__()
+        self.estado_do_dispositivo = estado_do_dispositivo
+        self.configuracao_maxima = configuracao_maxima
+
+    def botao_cinco_pressionado(self):
+        print("Diminuindo o canal")
+        self.estado_do_dispositivo -= 1
+
+    def botao_seis_pressionado(self):
+        print("Aumentando o canal")
+        self.estado_do_dispositivo += 1
+
+    def botao_sete_pressionado(self):
+        super(Tv, self).botao_sete_pressionado()
+
+    def botao_oito_pressionado(self):
+        super(Tv, self).botao_oito_pressionado()
+
+    def feedback_do_dispositivo(self):
+        super(Tv, self).feedback_do_dispositivo()
+

S08 - Padrões de projeto/bridge/tv_remoto_mudo.py

@@ -0,0 +1,19 @@
+from botao_remoto import BotaoRemoto
+from dispositivo_de_entretenimento import DispositivoDeEntretenimento
+
+
+class TvRemotaMuda(BotaoRemoto):
+    def botao_cinco_pressionado(self):
+        super(TvRemotaMuda, self).botao_cinco_pressionado()
+
+    def botao_seis_pressionado(self):
+        super(TvRemotaMuda, self).botao_seis_pressionado()
+
+    def feedback_do_dispositivo(self):
+        super(TvRemotaMuda, self).feedback_do_dispositivo()
+
+    def __init__(self, dispotivo: DispositivoDeEntretenimento):
+        super().__init__(dispositivo=dispotivo)
+
+    def botao_nove_pressionado(self):
+        print(f"A tv foi mutada")

S08 - Padrões de projeto/bridge/tv_remoto_pausa.py

@@ -0,0 +1,19 @@
+from botao_remoto import BotaoRemoto
+from dispositivo_de_entretenimento import DispositivoDeEntretenimento
+
+
+class TvRemotaPausa(BotaoRemoto):
+    def botao_cinco_pressionado(self):
+        super(TvRemotaPausa, self).botao_cinco_pressionado()
+
+    def botao_seis_pressionado(self):
+        super(TvRemotaPausa, self).botao_seis_pressionado()
+
+    def feedback_do_dispositivo(self):
+        super(TvRemotaPausa, self).feedback_do_dispositivo()
+
+    def __init__(self, dispotivo: DispositivoDeEntretenimento):
+        super().__init__(dispositivo=dispotivo)
+
+    def botao_nove_pressionado(self):
+        print(f"A tv foi pausada")

S08 - Padrões de projeto/builder/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/builder/README.md

@@ -0,0 +1,5 @@
+# builder
+
+O código desse repositório foi feito em python e é baseado no [vídeo do Derek Banas sobre o padrão de projeto Builder](https://www.youtube.com/watch?v=9XnsOpjclUg&feature=emb_logo)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site [Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/builder/construtor_robo_antigo.py

@@ -0,0 +1,29 @@
+from interface_construtor_robo import InterfaceConstrutorRobo
+from robo import Robo
+
+
+class ConstrutorRoboAntigo(InterfaceConstrutorRobo):
+    _robo: Robo
+
+    def __init__(self):
+        self.resetar()
+
+    def criar_cabeca_robo(self) -> None:
+        self._robo.criar_cabeca("cabeça de lata")
+
+    def criar_tronco_robo(self) -> None:
+        self._robo.criar_troco("tronco de lata")
+
+    def criar_bracos_robo(self) -> None:
+        self._robo.criar_bracos("braços de maçarico")
+
+    def criar_pernas_robo(self) -> None:
+        self._robo.criar_pernas("pernas de patins")
+
+    def resetar(self) -> None:
+        self._robo = Robo()
+
+    def retornar_robo_criado(self) -> Robo:
+        robo_pronto = self._robo
+        self.resetar()
+        return robo_pronto

S08 - Padrões de projeto/builder/construtor_robo_moderno.py

@@ -0,0 +1,29 @@
+from interface_construtor_robo import InterfaceConstrutorRobo
+from robo import Robo
+
+
+class ConstrutorRoboModerno(InterfaceConstrutorRobo):
+    _robo: Robo
+
+    def __init__(self):
+        self.resetar()
+
+    def criar_cabeca_robo(self) -> None:
+        self._robo.criar_cabeca("cabeça de fibra de carbono")
+
+    def criar_tronco_robo(self) -> None:
+        self._robo.criar_troco("tronco de fibra de carbono")
+
+    def criar_bracos_robo(self) -> None:
+        self._robo.criar_bracos("braços de fibra de carbono")
+
+    def criar_pernas_robo(self) -> None:
+        self._robo.criar_pernas("pernas de fibra de carbono")
+
+    def resetar(self) -> None:
+        self._robo = Robo()
+
+    def retornar_robo_criado(self) -> Robo:
+        robo_pronto = self._robo
+        self.resetar()
+        return robo_pronto

S08 - Padrões de projeto/builder/diretor.py

@@ -0,0 +1,23 @@
+from interface_robo import InterfaceRobo
+from interface_construtor_robo import InterfaceConstrutorRobo
+from robo import Robo
+
+
+class Diretor:
+    _construtor: InterfaceConstrutorRobo
+
+    def __init__(self, construtor_de_robo: InterfaceConstrutorRobo):
+        self.definir_construtor(construtor_de_robo)
+
+    def definir_construtor(self, construtor_de_robo: InterfaceConstrutorRobo):
+        self._construtor = construtor_de_robo
+
+    def criar_robo(self) -> Robo:
+        self._construtor.criar_cabeca_robo()
+        self._construtor.criar_tronco_robo()
+        self._construtor.criar_bracos_robo()
+        self._construtor.criar_pernas_robo()
+
+    def retornar_robo_criado(self) -> Robo:
+        return self._construtor.retornar_robo_criado()
+

S08 - Padrões de projeto/builder/interface_construtor_robo.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from robo import Robo
+
+
+class InterfaceConstrutorRobo(ABC):
+    @abstractmethod
+    def criar_cabeca_robo(self) -> None:
+        pass
+
+    @abstractmethod
+    def criar_tronco_robo(self) -> None:
+        pass
+
+    @abstractmethod
+    def criar_bracos_robo(self) -> None:
+        pass
+
+    @abstractmethod
+    def criar_pernas_robo(self) -> None:
+        pass
+
+    @abstractmethod
+    def resetar(self) -> None:
+        pass
+
+    @abstractmethod
+    def retornar_robo_criado(self) -> Robo:
+        pass
+

S08 - Padrões de projeto/builder/interface_robo.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+
+class InterfaceRobo(ABC):
+    @abstractmethod
+    def criar_cabeca(self, cabeca: str) -> None:
+        pass
+
+    @abstractmethod
+    def criar_troco(self, tronco: str) -> None:
+        pass
+
+    @abstractmethod
+    def criar_bracos(self, bracos: str) -> None:
+        pass
+
+    @abstractmethod
+    def criar_pernas(self, pernas: str) -> None:
+        pass

S08 - Padrões de projeto/builder/main.py

@@ -0,0 +1,25 @@
+from construtor_robo_antigo import ConstrutorRoboAntigo
+from construtor_robo_moderno import ConstrutorRoboModerno
+from diretor import Diretor
+
+
+if __name__ == "__main__":
+    construtor = ConstrutorRoboAntigo()
+    diretor = Diretor(construtor_de_robo=construtor)
+    diretor.criar_robo()
+    robo_criado = diretor.retornar_robo_criado()
+
+    print("Robo antigo criado:")
+    print(robo_criado)
+
+    construtor = ConstrutorRoboModerno()
+    diretor.definir_construtor(construtor)
+    diretor.criar_robo()
+    robo_criado = diretor.retornar_robo_criado()
+
+    print("\nRobo moderno criado:")
+    print(robo_criado)
+
+
+
+

S08 - Padrões de projeto/builder/robo.py

@@ -0,0 +1,39 @@
+from interface_robo import InterfaceRobo
+
+
+class Robo(InterfaceRobo):
+    _cabeca: str
+    _tronco: str
+    _bracos: str
+    _pernas: str
+
+    def __str__(self) -> str:
+        return f"cabeça: {self._cabeca}\ntronco: {self._tronco}\nbracos: {self._bracos}\npernas: {self._pernas}"
+
+    def criar_cabeca(self, cabeca: str) -> None:
+        self._cabeca = cabeca
+
+    def criar_troco(self, tronco: str) -> None:
+        self._tronco = tronco
+
+    def criar_bracos(self, bracos: str) -> None:
+        self._bracos = bracos
+
+    def criar_pernas(self, pernas: str) -> None:
+        self._pernas = pernas
+
+    @property
+    def cabeca(self) -> str:
+        return self._cabeca
+
+    @property
+    def tronco(self) -> str:
+        return self._tronco
+
+    @property
+    def bracos(self) -> str:
+        return self._cabeca
+
+    @property
+    def pernas(self) -> str:
+        return self._pernas

S08 - Padrões de projeto/chain_of_responsibility/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/chain_of_responsibility/README.md

@@ -0,0 +1,7 @@
+# chain of responsibility
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Chain of Responsibility](https://www.youtube.com/watch?v=jDX6x8qmjbA)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/chain_of_responsibility/dividir_numeros.py

@@ -0,0 +1,17 @@
+from interface_cadeia import Cadeia
+from numeros import Numeros
+
+
+class DividirNumeros(Cadeia):
+    def __init__(self):
+        self._proximo_na_cadeia: Cadeia = None
+
+    def definir_proximo_na_cadeia(self, proxima_cadeia: Cadeia):
+        self._proximo_na_cadeia = proxima_cadeia
+
+    def calcular(self, requisicao: Numeros):
+        if requisicao.calculo_desejado == "dividir":
+            print(f"{requisicao.numero_1} / {requisicao.numero_2} = {requisicao.numero_1 / requisicao.numero_2}")
+        else:
+            print("As operações disponíveis até o momento são somar, subtrair, multiplicar e dividir")
+

S08 - Padrões de projeto/chain_of_responsibility/interface_cadeia.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from numeros import Numeros
+
+
+class Cadeia(ABC):
+    @abstractmethod
+    def definir_proximo_na_cadeia(self, proxima_cadeia: "Cadeia"):
+        pass
+
+    @abstractmethod
+    def calcular(self, requisicao: Numeros):
+        pass

S08 - Padrões de projeto/chain_of_responsibility/multiplicar_numeros.py

@@ -0,0 +1,17 @@
+from interface_cadeia import Cadeia
+from numeros import Numeros
+
+
+class MultiplicarNumeros(Cadeia):
+    def __init__(self):
+        self._proximo_na_cadeia: Cadeia = None
+
+    def definir_proximo_na_cadeia(self, proxima_cadeia: Cadeia):
+        self._proximo_na_cadeia = proxima_cadeia
+
+    def calcular(self, requisicao: Numeros):
+        if requisicao.calculo_desejado == "multiplicar":
+            print(f"{requisicao.numero_1} * {requisicao.numero_2} = {requisicao.numero_1 * requisicao.numero_2}")
+        else:
+            self._proximo_na_cadeia.calcular(requisicao=requisicao)
+

S08 - Padrões de projeto/chain_of_responsibility/numeros.py

@@ -0,0 +1,17 @@
+class Numeros:
+    def __init__(self, numero_1: int, numero_2: int, calculo_desejado: str):
+        self._numero_1: int = numero_1
+        self._numero_2: int = numero_2
+        self._calculo_desejado: str = calculo_desejado
+
+    @property
+    def numero_1(self) -> int:
+        return self._numero_1
+
+    @property
+    def numero_2(self) -> int:
+        return self._numero_2
+
+    @property
+    def calculo_desejado(self) -> str:
+        return self._calculo_desejado

S08 - Padrões de projeto/chain_of_responsibility/principal.py

@@ -0,0 +1,37 @@
+from somar_numeros import AdicionarNumeros
+from subtrair_numeros import SubtrairNumeros
+from multiplicar_numeros import MultiplicarNumeros
+from dividir_numeros import DividirNumeros
+from interface_cadeia import Cadeia
+from numeros import Numeros
+
+
+if __name__ == '__main__':
+    cadeia_1: Cadeia = AdicionarNumeros()
+    cadeia_2: Cadeia = SubtrairNumeros()
+    cadeia_3: Cadeia = MultiplicarNumeros()
+    cadeia_4: Cadeia = DividirNumeros()
+
+    cadeia_1.definir_proximo_na_cadeia(proxima_cadeia=cadeia_2)
+    cadeia_2.definir_proximo_na_cadeia(proxima_cadeia=cadeia_3)
+    cadeia_3.definir_proximo_na_cadeia(proxima_cadeia=cadeia_4)
+
+    print("operação de soma")
+    requisicao: Numeros = Numeros(numero_1=20, numero_2=10, calculo_desejado="somar")
+    cadeia_1.calcular(requisicao=requisicao)
+
+    print("\noperação de subtração")
+    requisicao: Numeros = Numeros(numero_1=20, numero_2=10, calculo_desejado="subtrair")
+    cadeia_1.calcular(requisicao=requisicao)
+
+    print("\noperação de multiplicação")
+    requisicao: Numeros = Numeros(numero_1=20, numero_2=10, calculo_desejado="multiplicar")
+    cadeia_1.calcular(requisicao=requisicao)
+
+    print("\noperação de divisão")
+    requisicao: Numeros = Numeros(numero_1=20, numero_2=10, calculo_desejado="dividir")
+    cadeia_1.calcular(requisicao=requisicao)
+
+    print("\noperação que não existe na cadeia -> raiz quadrada")
+    requisicao: Numeros = Numeros(numero_1=20, numero_2=10, calculo_desejado="raiz quadrada")
+    cadeia_1.calcular(requisicao=requisicao)

S08 - Padrões de projeto/chain_of_responsibility/somar_numeros.py

@@ -0,0 +1,17 @@
+from interface_cadeia import Cadeia
+from numeros import Numeros
+
+
+class AdicionarNumeros(Cadeia):
+    def __init__(self):
+        self._proximo_na_cadeia: Cadeia = None
+
+    def definir_proximo_na_cadeia(self, proxima_cadeia: Cadeia):
+        self._proximo_na_cadeia = proxima_cadeia
+
+    def calcular(self, requisicao: Numeros):
+        if requisicao.calculo_desejado == "somar":
+            print(f"{requisicao.numero_1} + {requisicao.numero_2} = {requisicao.numero_1 + requisicao.numero_2}")
+        else:
+            self._proximo_na_cadeia.calcular(requisicao=requisicao)
+

S08 - Padrões de projeto/chain_of_responsibility/subtrair_numeros.py

@@ -0,0 +1,17 @@
+from interface_cadeia import Cadeia
+from numeros import Numeros
+
+
+class SubtrairNumeros(Cadeia):
+    def __init__(self):
+        self._proximo_na_cadeia: Cadeia = None
+
+    def definir_proximo_na_cadeia(self, proxima_cadeia: Cadeia):
+        self._proximo_na_cadeia = proxima_cadeia
+
+    def calcular(self, requisicao: Numeros):
+        if requisicao.calculo_desejado == "subtrair":
+            print(f"{requisicao.numero_1} - {requisicao.numero_2} = {requisicao.numero_1 - requisicao.numero_2}")
+        else:
+            self._proximo_na_cadeia.calcular(requisicao=requisicao)
+

S08 - Padrões de projeto/command/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+.vscode

S08 - Padrões de projeto/command/.replit

@@ -0,0 +1,2 @@
+language = "python3"
+run = "python principal.py"

S08 - Padrões de projeto/command/README.md

@@ -0,0 +1,5 @@
+# command
+
+O código desse repositório foi feito em python e é baseado no [vídeo do Derek Banas sobre o padrão de projeto Command](https://www.youtube.com/watch?v=7Pj5kAhVBlg&feature=emb_logo)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site [Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/command/botao_dispositivo.py

@@ -0,0 +1,9 @@
+from comando import Comando
+
+
+class BotaoDispositivo:
+    def __init__(self, comando: Comando):
+        self.comando = comando
+
+    def apertar(self):
+        self.comando.executar()

S08 - Padrões de projeto/command/comando.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Comando(ABC):
+    @abstractmethod
+    def executar(self):
+        pass

S08 - Padrões de projeto/command/comando_aumentar_volume_tv.py

@@ -0,0 +1,11 @@
+from comando import Comando
+from dispositivo_eletronico import DispositivoEletronico
+
+
+class ComandoAumentarVolumeTV(Comando):
+    def __init__(self, dispositivo: DispositivoEletronico):
+        self.dispositivo = dispositivo
+
+    def executar(self):
+        self.dispositivo.aumentar_volume()
+

S08 - Padrões de projeto/command/comando_desligar_tv.py

@@ -0,0 +1,11 @@
+from comando import Comando
+from dispositivo_eletronico import DispositivoEletronico
+
+
+class ComandoDesligarTV(Comando):
+    def __init__(self, dispositivo: DispositivoEletronico):
+        self.dispositivo = dispositivo
+
+    def executar(self):
+        self.dispositivo.desligar()
+

S08 - Padrões de projeto/command/comando_diminuir_volume_tv.py

@@ -0,0 +1,11 @@
+from comando import Comando
+from dispositivo_eletronico import DispositivoEletronico
+
+
+class ComandoDiminuirVolumeTV(Comando):
+    def __init__(self, dispositivo: DispositivoEletronico):
+        self.dispositivo = dispositivo
+
+    def executar(self):
+        self.dispositivo.diminuir_volume()
+

S08 - Padrões de projeto/command/comando_ligar_tv.py

@@ -0,0 +1,11 @@
+from comando import Comando
+from dispositivo_eletronico import DispositivoEletronico
+
+
+class ComandoLigarTV(Comando):
+    def __init__(self, dispositivo: DispositivoEletronico):
+        self.dispositivo = dispositivo
+
+    def executar(self):
+        self.dispositivo.ligar()
+

S08 - Padrões de projeto/command/controle_tv.py

@@ -0,0 +1,8 @@
+from televisao import Televisao
+from dispositivo_eletronico import DispositivoEletronico
+
+
+class ControleRemoto:
+    @classmethod
+    def pegar_dispositivo_eletronico(cls) -> DispositivoEletronico:
+        return Televisao()

S08 - Padrões de projeto/command/dispositivo_eletronico.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+
+class DispositivoEletronico(ABC):
+    @abstractmethod
+    def ligar(self):
+        pass
+
+    @abstractmethod
+    def desligar(self):
+        pass
+
+    @abstractmethod
+    def aumentar_volume(self):
+        pass
+
+    @abstractmethod
+    def diminuir_volume(self):
+        pass
+
+

S08 - Padrões de projeto/command/principal.py

@@ -0,0 +1,32 @@
+from controle_tv import ControleRemoto
+from comando_ligar_tv import ComandoLigarTV
+from comando_desligar_tv import ComandoDesligarTV
+from comando_aumentar_volume_tv import ComandoAumentarVolumeTV
+from comando_diminuir_volume_tv import ComandoDiminuirVolumeTV
+from botao_dispositivo import BotaoDispositivo
+
+
+if __name__ == '__main__':
+    tv = ControleRemoto.pegar_dispositivo_eletronico()
+
+    ligar_tv = ComandoLigarTV(dispositivo=tv)
+    botao = BotaoDispositivo(comando=ligar_tv)
+    botao.apertar()
+
+    aumentar_volume = ComandoAumentarVolumeTV(dispositivo=tv)
+    botao = BotaoDispositivo(comando=aumentar_volume)
+    botao.apertar()
+    botao.apertar()
+    botao.apertar()
+    botao.apertar()
+    botao.apertar()
+
+    diminuir_volume = ComandoDiminuirVolumeTV(dispositivo=tv)
+    botao = BotaoDispositivo(comando=diminuir_volume)
+    botao.apertar()
+    botao.apertar()
+
+    desligar_tv = ComandoDesligarTV(dispositivo=tv)
+    botao = BotaoDispositivo(comando=desligar_tv)
+    botao.apertar()
+

S08 - Padrões de projeto/command/televisao.py

@@ -0,0 +1,20 @@
+from dispositivo_eletronico import DispositivoEletronico
+
+
+class Televisao(DispositivoEletronico):
+    _volume = 0
+
+    def ligar(self):
+        print("Televisão ligada")
+
+    def desligar(self):
+        print("Televisão desligada")
+
+    def aumentar_volume(self):
+        self._volume += 1
+        print(f"O volume da televisão é {self._volume}")
+
+    def diminuir_volume(self):
+        self._volume -= 1
+        print(f"O volume da televisão é {self._volume}")
+

S08 - Padrões de projeto/composite/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/composite/README.md

@@ -0,0 +1,7 @@
+# Composite
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Composite](https://www.youtube.com/watch?v=2HUnoKyC9l0)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/composite/cancao.py

@@ -0,0 +1,41 @@
+from componente_cancao import ComponenteCancao
+
+
+class Cancao(ComponenteCancao):
+    def adicionar(self, cancao) -> None:
+        super(Cancao, self).adicionar()
+
+    def remover(self, cancao) -> None:
+        super(Cancao, self).remover()
+
+    def obter_componente(self, indice: int) -> "ComponenteCancao":
+        super(Cancao, self).obter_componente()
+
+    def obter_nome_cancao(self) -> None:
+        super(Cancao, self).obter_nome_cancao()
+
+    def obter_nome_da_banda(self) -> None:
+        super(Cancao, self).obter_nome_da_banda()
+
+    def obter_ano_de_lancaomento(self) -> None:
+        super(Cancao, self).obter_ano_de_lancaomento()
+
+    def __init__(self, nome: str, nome_da_banda: str, ano_de_lancamento: int):
+        self._nome = nome
+        self._nome_da_banda = nome_da_banda
+        self._ano_de_lancamento = ano_de_lancamento
+
+    @property
+    def nome(self):
+        return self._nome
+
+    @property
+    def nome_da_banda(self):
+        return self._nome_da_banda
+
+    @property
+    def ano_de_lancamento(self):
+        return self._ano_de_lancamento
+
+    def mostrar_informacoes_da_cancao(self) -> None:
+        print(f"{self.nome} foi gravado por {self.nome_da_banda} no ano de {self.ano_de_lancamento}")

S08 - Padrões de projeto/composite/componente_cancao.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+from excecoes import *
+
+
+class ComponenteCancao(ABC):
+    @abstractmethod
+    def adicionar(self, cancao) -> None:
+        raise OperacaoDeAdicaoInvalida("Operação não supoerta: Não é possível adicionar uma nova canção")
+
+    @abstractmethod
+    def remover(self, cancao) -> None:
+        raise OperacaoDeRemocaoInvalida("Operação não supoerta: Não é possível remove essa canção")
+
+    @abstractmethod
+    def obter_componente(self, indice: int) -> "ComponenteCancao":
+        raise OperacaoNaoSuportada("Operação não supoerta: Não é possível obter um componente")
+
+    @abstractmethod
+    def obter_nome_cancao(self) -> None:
+        raise OperacaoNaoSuportada("Operação não supoerta: Não é possível obter o nome dessa canção")
+
+    @abstractmethod
+    def obter_nome_da_banda(self) -> None:
+        raise OperacaoNaoSuportada("Operação não supoerta: Não é possível obter o nome da banda")
+
+    @abstractmethod
+    def obter_ano_de_lancaomento(self) -> None:
+        raise OperacaoNaoSuportada("Operação não supoerta: Não é possível obter o ano de lançamento")
+
+    @abstractmethod
+    def mostrar_informacoes_da_cancao(self) -> None:
+        raise OperacaoNaoSuportada("Operação não supoerta: Não é possível obter as informações da canção")

S08 - Padrões de projeto/composite/excecoes.py

@@ -0,0 +1,10 @@
+class OperacaoDeAdicaoInvalida(Exception):
+    pass
+
+
+class OperacaoDeRemocaoInvalida(Exception):
+    pass
+
+
+class OperacaoNaoSuportada(Exception):
+    pass

S08 - Padrões de projeto/composite/grupo_cancao.py

@@ -0,0 +1,45 @@
+from componente_cancao import ComponenteCancao
+from typing import List
+from collections.abc import Iterator
+
+
+class GrupoCancao(ComponenteCancao):
+    def __init__(self, nome: str, descricao: str):
+        self._nome: str = nome
+        self._descricao: str = descricao
+        self.elementos: List["GrupoCancao", ComponenteCancao] = []
+
+    @property
+    def nome(self):
+        return self._nome
+
+    @property
+    def descricao(self):
+        return self._descricao
+
+    def adicionar(self, cancao: ComponenteCancao) -> None:
+        self.elementos.append(cancao)
+
+    def remover(self, cancao: ComponenteCancao) -> None:
+        self.elementos.remove(cancao)
+
+    def obter_componente(self, indice: int) -> ComponenteCancao:
+        return self.elementos.__getitem__(indice)
+
+    def obter_nome_cancao(self) -> None:
+        super(GrupoCancao, self).obter_nome_cancao()
+
+    def obter_nome_da_banda(self) -> None:
+        super(GrupoCancao, self).obter_nome_da_banda()
+
+    def obter_ano_de_lancaomento(self) -> None:
+        super(GrupoCancao, self).obter_ano_de_lancaomento()
+
+    def mostrar_informacoes_da_cancao(self) -> None:
+        print(f"\nnome do grupo: {self.nome}"
+              f"\ndescricao: {self.descricao}")
+
+        for elemento in self.elementos:
+            elemento.mostrar_informacoes_da_cancao()
+
+

S08 - Padrões de projeto/composite/principal.py

@@ -0,0 +1,30 @@
+from componente_cancao import ComponenteCancao
+from grupo_cancao import GrupoCancao
+from cancao import Cancao
+from tocador_de_disco import TocadorDeDiscos
+
+
+if __name__ == '__main__':
+    industrial: ComponenteCancao = GrupoCancao(nome="\nindustrial", descricao="vai 1")
+    heavy_metal: ComponenteCancao = GrupoCancao(nome="\nheavy metal", descricao="vai 2")
+    pisadinha: ComponenteCancao = GrupoCancao(nome="\npisadinha", descricao="vai 3")
+
+    tudo: ComponenteCancao = GrupoCancao(nome="grupo de músicas", descricao="todas as músicas disponíveis")
+    tudo.adicionar(industrial)
+    industrial.adicionar(Cancao(nome="Head Like a Hole", nome_da_banda="NIN", ano_de_lancamento=1990))
+    industrial.adicionar(Cancao(nome="Head Hunter", nome_da_banda="Front 242", ano_de_lancamento=1988))
+
+    industrial.adicionar(pisadinha)
+    pisadinha.adicionar(
+        Cancao(
+            nome="Basta Você Me Ligar (part. Xand Avião)",
+            nome_da_banda="Os Barões da Pisadinha",
+            ano_de_lancamento=2020
+        )
+    )
+
+    tudo.adicionar(heavy_metal)
+    heavy_metal.adicionar(Cancao(nome="To Tame a Land", nome_da_banda="Iron Maiden", ano_de_lancamento=1983))
+
+    tocador: TocadorDeDiscos = TocadorDeDiscos(lista_de_cancoes=tudo)
+    tocador.obter_lista_de_cancoes()

S08 - Padrões de projeto/composite/tocador_de_disco.py

@@ -0,0 +1,9 @@
+from componente_cancao import ComponenteCancao
+
+
+class TocadorDeDiscos:
+    def __init__(self, lista_de_cancoes: ComponenteCancao):
+        self._lista_de_cancoes: ComponenteCancao = lista_de_cancoes
+
+    def obter_lista_de_cancoes(self):
+        self._lista_de_cancoes.mostrar_informacoes_da_cancao()

S08 - Padrões de projeto/decorator/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+.vscode

S08 - Padrões de projeto/decorator/README.md

@@ -0,0 +1,5 @@
+# decorator
+
+O código desse repositório foi feito em python e é baseado no [vídeo do Derek Banas sobre o padrão de projeto Decorator](https://www.youtube.com/watch?v=j40kRwSm4VE&feature=emb_logo)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site [Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/decorator/cobertura_decorator.py

@@ -0,0 +1,13 @@
+from abc import ABC
+from pizza import Pizza
+
+
+class CoberturaDecorator(Pizza, ABC):
+    def __init__(self, pizza: Pizza):
+        self._pizza = pizza
+
+    def pegar_descricao(self) -> str:
+        return self._pizza.pegar_descricao()
+
+    def pegar_valor(self) -> float:
+        return self._pizza.pegar_valor()

S08 - Padrões de projeto/decorator/main.py

@@ -0,0 +1,11 @@
+from pizza import Pizza
+from molho_de_tomate import MolhoDeTomate
+from mussarela import Mussarela
+from pizza_simples import PizzaSimples
+
+
+if __name__ == '__main__':
+    minha_pizza: Pizza = MolhoDeTomate(Mussarela(PizzaSimples()))
+    print(f"ingredientes: {minha_pizza.pegar_descricao()}")
+    print(f"valor: {minha_pizza.pegar_valor()}")
+

S08 - Padrões de projeto/decorator/molho_de_tomate.py

@@ -0,0 +1,14 @@
+from cobertura_decorator import CoberturaDecorator
+
+
+class MolhoDeTomate(CoberturaDecorator):
+    def __init__(self, pizza):
+        super().__init__(pizza)
+
+        print("Adicionando tomate")
+
+    def pegar_descricao(self) -> str:
+        return self._pizza.pegar_descricao() + ", molho de tomate"
+
+    def pegar_valor(self) -> float:
+        return self._pizza.pegar_valor() + 0.35

S08 - Padrões de projeto/decorator/mussarela.py

@@ -0,0 +1,15 @@
+from cobertura_decorator import CoberturaDecorator
+
+
+class Mussarela(CoberturaDecorator):
+    def __init__(self, pizza):
+        super().__init__(pizza)
+
+        print("Adicionando massa")
+        print("Adicionando mussarela")
+
+    def pegar_descricao(self) -> str:
+        return self._pizza.pegar_descricao() + ", mussarela"
+
+    def pegar_valor(self) -> float:
+        return self._pizza.pegar_valor() + 0.50

S08 - Padrões de projeto/decorator/pizza.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod, ABC
+
+
+class Pizza(ABC):
+    @abstractmethod
+    def pegar_descricao(self) -> str:
+        pass
+
+    @abstractmethod
+    def pegar_valor(self) -> float:
+        return 4.0

S08 - Padrões de projeto/decorator/pizza_simples.py

@@ -0,0 +1,9 @@
+from pizza import Pizza
+
+
+class PizzaSimples(Pizza):
+    def pegar_descricao(self) -> str:
+        return "massa fina"
+
+    def pegar_valor(self) -> float:
+        return 4.0

S08 - Padrões de projeto/delegation/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/delegation/README.md

@@ -0,0 +1,5 @@
+# delegation
+
+O código desse repositório foi feito em python e é baseado no 
+vídeo do canal [Receitas de Código](https://www.youtube.com/channel/UC9XwbqDtIgEsAnYFDPZJuiA) que fala sobre o 
+padrão de projeto [Delegation](https://www.youtube.com/watch?v=KtZlDhC_ycs)

S08 - Padrões de projeto/delegation/conta.py

@@ -0,0 +1,17 @@
+from conversor import Conversor
+
+
+class Conta:
+    def __init__(self):
+        self.__valor_total = 100.0
+
+    @property
+    def saldo(self) -> float:
+        return self.__valor_total
+
+    @saldo.setter
+    def saldo(self, novo_valor: float):
+        self.__valor_total = novo_valor
+
+    def obter_saldo_convertido(self, conversao: Conversor) -> float:
+        return conversao.converter(valor=self.__valor_total)

S08 - Padrões de projeto/delegation/conversor.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Conversor(ABC):
+    @abstractmethod
+    def converter(self, valor: float) -> float:
+        pass

S08 - Padrões de projeto/delegation/conversor_para_dolar.py

@@ -0,0 +1,6 @@
+from conversor import Conversor
+
+
+class ConversorDolar(Conversor):
+    def converter(self, valor: float) -> float:
+        return valor * 5.5

S08 - Padrões de projeto/delegation/principal.py

@@ -0,0 +1,14 @@
+from conta import Conta
+from conversor import Conversor
+from conversor_para_dolar import ConversorDolar
+
+
+if __name__ == '__main__':
+    conta: Conta = Conta()
+    conta.saldo = 10.0
+
+    conversor: Conversor = ConversorDolar()
+    print(f"saldo normal: {conta.saldo}")
+
+    valor_convertido = conversor.converter(valor=conta.saldo)
+    print(f"saldo em dolar: {valor_convertido}")

S08 - Padrões de projeto/facade/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/facade/README.md

@@ -0,0 +1,7 @@
+# facade
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Facade](https://www.youtube.com/watch?v=B1Y8fcYrz5o)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/facade/banco_boas_vindas.py

@@ -0,0 +1,4 @@
+class BancoBoasVindas:
+    def __init__(self):
+        print("Bem vindo ao banco ABC")
+        print("Estamos felizes em lhe dar eu dinheiro se pudermos encontrá-lo")

S08 - Padrões de projeto/facade/codigo_seguranca.py

@@ -0,0 +1,10 @@
+class CodigoSeguranca:
+    def __init__(self):
+        self.codigo = 1234
+
+    def validar_codigo_seguranca(self, codigo: int):
+        resultado = False
+        if codigo == self.codigo:
+            resultado = True
+
+        return resultado

S08 - Padrões de projeto/facade/fachada.py

@@ -0,0 +1,38 @@
+from numero_conta import NumeroContaDoBanco
+from codigo_seguranca import CodigoSeguranca
+from fundos import Fundos
+from banco_boas_vindas import BancoBoasVindas
+
+
+class ContaBancoFachada:
+    def __init__(self, novo_numero_conta: int, novo_codigo_segunranca: int):
+        self.numero_da_conta = novo_numero_conta
+        self.codigo_seguranca = novo_codigo_segunranca
+
+        self.banco = BancoBoasVindas()
+        self.checagem_numero_conta = NumeroContaDoBanco()
+        self.checagem_codigo_seguranca = CodigoSeguranca()
+        self.checagem_fundos = Fundos()
+
+    def retirar_dinheiro(self, valor: float):
+        if (
+            self.checagem_numero_conta.validar_numero_conta(self.numero_da_conta)
+            and self.checagem_codigo_seguranca.validar_codigo_seguranca(
+                self.codigo_seguranca
+            )
+            and self.checagem_fundos.tem_dinheiro_suficiente(valor)
+        ):
+            print("Transação completada!!!")
+        else:
+            print("Transação falhou!!!")
+
+    def depositar_dinheiro(self, valor: float):
+        if self.checagem_numero_conta.validar_numero_conta(
+            self.numero_da_conta
+        ) and self.checagem_codigo_seguranca.validar_codigo_seguranca(
+            self.codigo_seguranca
+        ):
+            self.checagem_fundos.fazer_deposito(valor)
+            print("Transação completada!!!")
+        else:
+            print("Transação falhou!!!")

S08 - Padrões de projeto/facade/fundos.py

@@ -0,0 +1,25 @@
+class Fundos:
+    def __init__(self):
+        self.dinheiro_em_conta = 1000.0
+
+    def retirar_dinheiro_da_conta(self, valor: float):
+        self.dinheiro_em_conta -= valor
+
+    def depositar_dinheiro_na_conta(self, valor: float):
+        self.dinheiro_em_conta += valor
+
+    def tem_dinheiro_suficiente(self, valor_para_retirar: float) -> float:
+        if valor_para_retirar > self.dinheiro_em_conta:
+            print("Erro: Você não tem dinheiro o suficiente")
+            print(f"Valor atual em conta: {self.dinheiro_em_conta}")
+            return False
+        else:
+            self.retirar_dinheiro_da_conta(valor=valor_para_retirar)
+            print(
+                f"Retirada finalizada com sucesso. Novo saldo: {self.dinheiro_em_conta}"
+            )
+            return True
+
+    def fazer_deposito(self, valor_a_depositar: float):
+        self.depositar_dinheiro_na_conta(valor=valor_a_depositar)
+        print(f"Depósito concluído com sucesso. Novo saldo: {self.dinheiro_em_conta}")

S08 - Padrões de projeto/facade/numero_conta.py

@@ -0,0 +1,10 @@
+class NumeroContaDoBanco:
+    def __init__(self):
+        self.numero_conta = 123456
+
+    def validar_numero_conta(self, numero: int):
+        resultado = False
+        if numero == self.numero_conta:
+            resultado = True
+
+        return resultado

S08 - Padrões de projeto/facade/principal.py

@@ -0,0 +1,8 @@
+from fachada import ContaBancoFachada
+
+if __name__ == "__main__":
+    conta = ContaBancoFachada(novo_numero_conta=123456, novo_codigo_segunranca=1234)
+    conta.retirar_dinheiro(50.0)
+    conta.retirar_dinheiro(900.0)
+    conta.retirar_dinheiro(900.0)
+    conta.depositar_dinheiro(200)

S08 - Padrões de projeto/factory/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/factory/README.md

@@ -0,0 +1,3 @@
+# factory
+
+O código desse repositório foi feito em python e é baseado no [vídeo do Derek Banas sobre o padrão de projeto Factory Design](https://www.youtube.com/watch?v=ub0DXaeV6hA&feature=emb_logo)

S08 - Padrões de projeto/factory/fabrica_de_navios.py

@@ -0,0 +1,20 @@
+from navio_inimigo import NavioInimigo
+from navio_inimigo_ufo import NavioInimigoUFO
+from navio_inimigo_foguete import NavioInimigoFoguete
+from grande_navio_inimigo_ufo import GrandeNavioInimigoUFO
+
+
+class FabricaDeNavios:
+    def __init__(self, tipo_navio_inimigo: str):
+        self.navio = None
+        if tipo_navio_inimigo == "U":
+            self.navio = NavioInimigoUFO()
+        elif tipo_navio_inimigo == "R":
+            self.navio = NavioInimigoFoguete()
+        elif tipo_navio_inimigo == "B":
+            self.navio = GrandeNavioInimigoUFO()
+
+        self.retornar_navio_fabricado
+
+    def retornar_navio_fabricado(self) -> NavioInimigo:
+        return self.navio

S08 - Padrões de projeto/factory/grande_navio_inimigo_ufo.py

@@ -0,0 +1,6 @@
+from navio_inimigo import NavioInimigo
+
+
+class GrandeNavioInimigoUFO(NavioInimigo):
+    def __init__(self):
+        super().__init__("grande navio inimigo UFO", 40.0)

S08 - Padrões de projeto/factory/main.py

@@ -0,0 +1,25 @@
+from navio_inimigo_foguete import NavioInimigoFoguete
+from navio_inimigo_ufo import NavioInimigoUFO
+from navio_inimigo import NavioInimigo
+
+from fabrica_de_navios import FabricaDeNavios
+
+from typing import Optional
+
+
+def ataque_inimigo(navio: Optional[NavioInimigo]):
+    if navio:
+        navio.exibir_navio_inimigo_na_tela()
+        navio.seguir_navio_do_heroi()
+        navio.atirar()
+    else:
+        print("Digite U ou R ou B na próxima vez ;)")
+
+
+if __name__ == "__main__":
+    tipo_navio_inimigo = input(
+        "Qual tipo de navio inimigo você quer criar? (digite U / R / B) -> "
+    ).upper()
+    fabrica = FabricaDeNavios(tipo_navio_inimigo)
+
+    ataque_inimigo(fabrica.retornar_navio_fabricado())

S08 - Padrões de projeto/factory/navio_inimigo.py

@@ -0,0 +1,31 @@
+class NavioInimigo:
+    def __init__(self, nome: str, quantidade_de_dano: float):
+        self.__nome: str = nome
+        self.__quantidade_de_dano: float = quantidade_de_dano
+
+    @property
+    def nome(self) -> str:
+        return self.__nome
+
+    @nome.setter
+    def nome(self, novo_nome: str) -> None:
+        self.__nome = novo_nome
+
+    @property
+    def quantidade_de_dano(self) -> float:
+        return self.__quantidade_de_dano
+
+    @quantidade_de_dano.setter
+    def quantidade_de_dano(self, nova_quantidade_de_dano: float) -> None:
+        self.__quantidade_de_dano = nova_quantidade_de_dano
+
+    def seguir_navio_do_heroi(self) -> None:
+        print(f"{self.__nome} está seguindo o herói")
+
+    def exibir_navio_inimigo_na_tela(self) -> None:
+        print(f"{self.__nome} está na tela")
+
+    def atirar(self) -> None:
+        print(
+            f"{self.__nome} está atacando e causando {self.__quantidade_de_dano} de dano"
+        )

S08 - Padrões de projeto/factory/navio_inimigo_foguete.py

@@ -0,0 +1,6 @@
+from navio_inimigo import NavioInimigo
+
+
+class NavioInimigoFoguete(NavioInimigo):
+    def __init__(self):
+        super().__init__("navio inimigo foguete", 10.0)

S08 - Padrões de projeto/factory/navio_inimigo_ufo.py

@@ -0,0 +1,6 @@
+from navio_inimigo import NavioInimigo
+
+
+class NavioInimigoUFO(NavioInimigo):
+    def __init__(self):
+        super().__init__("navio inimigo UFO", 20.0)

S08 - Padrões de projeto/flyweight/.gitignore

@@ -0,0 +1,2 @@
+.vscode
+__pycache__

S08 - Padrões de projeto/flyweight/Readme.MD

@@ -0,0 +1,9 @@
+# Flyweight
+
+Exemplo escrito em python e baseado no do [Refactoring.Guru](https://refactoring.guru/pt-br) 
+sobre o padrão de projeto [Flyweight](https://refactoring.guru/pt-br/design-patterns/flyweight).
+
+
+Um ótimo vídeo com outras explicações sobre esse padrão de projeto é o do 
+[Derek Banas](https://www.youtube.com/watch?v=0vV-R2926ss).
+Nesse caso, o exemplo é feito em Java :coffee:

S08 - Padrões de projeto/flyweight/fabrica.py

@@ -0,0 +1,29 @@
+from typing import List, Dict
+from flyweight import Flyweight
+
+
+class FabricaFlyweight:
+    _flyweights: Dict[str, Flyweight] = {}
+
+    def __init__(self, flyweights_iniciais: List) -> None:
+        for estado in flyweights_iniciais:
+            self._flyweights[self.obter_chave(estado)] = Flyweight(estado)
+
+    def obter_chave(self, estado: Dict) -> str:
+        return "_".join(sorted(estado))
+
+    def obter_flyweight(self, estado_compartilhado: Dict) -> Flyweight:
+        chave = self.obter_chave(estado_compartilhado)
+
+        if not self._flyweights.get(chave):
+            print("Fábrica: Não foi achado o flyweight. Criando um novo.")
+            self._flyweights[chave] = Flyweight(estado_compartilhado)
+        else:
+            print("Fábrica: Reutilizano um flyweight já existente.")
+
+        return self._flyweights[chave]
+
+    def listar_flyweights(self) -> None:
+        quantidade_de_objetos = len(self._flyweights)
+        print(f"Fábrica: Temos {quantidade_de_objetos} flyweights:")
+        print("\n".join(map(str, self._flyweights.keys())), end="")

S08 - Padrões de projeto/flyweight/flyweight.py

@@ -0,0 +1,11 @@
+import json
+
+
+class Flyweight:
+    def __init__(self, estado_compartilhado: str) -> None:
+        self._estado_compartilhado = estado_compartilhado
+
+    def operacao(self, estado_unico: str) -> None:
+        compartilhado = json.dumps(self._estado_compartilhado)
+        unico = json.dumps(estado_unico)
+        print(f"Flyweight: Exibindo compartilhado ({compartilhado}) e o estado ({unico}) único.", end="")

S08 - Padrões de projeto/flyweight/principal.py

@@ -0,0 +1,38 @@
+from typing import Dict
+from fabrica import FabricaFlyweight
+
+
+def adicionando_carro_ao_banco_de_dados_da_policia(
+    fabrica: FabricaFlyweight, placa: str, nome_do_dono: str,
+    marca: str, modelo: str, cor: str
+) -> None:
+    print("\n\nCliente: Adicionando carro...")
+    flyweight = fabrica.obter_flyweight([marca, modelo, cor])
+    flyweight.operacao([placa, nome_do_dono])
+
+
+if __name__ == "__main__":
+    """
+    The client code usually creates a bunch of pre-populated flyweights in the
+    initialization stage of the application.
+    """
+
+    fabrica = FabricaFlyweight([
+        ["Chevrolet", "Camaro2018", "pink"],
+        ["Mercedes Benz", "C300", "black"],
+        ["Mercedes Benz", "C500", "red"],
+        ["BMW", "M5", "red"],
+        ["BMW", "X6", "white"],
+    ])
+
+    fabrica.listar_flyweights()
+
+    adicionando_carro_ao_banco_de_dados_da_policia(
+        fabrica, "CL234IR", "James Doe", "BMW", "M5", "red")
+
+    adicionando_carro_ao_banco_de_dados_da_policia(
+        fabrica, "CL234IR", "James Doe", "BMW", "X1", "red")
+
+    print("\n")
+
+    fabrica.listar_flyweights()

S08 - Padrões de projeto/grasp-creator/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/grasp-creator/README.md

@@ -0,0 +1 @@
+# grasp creator

S08 - Padrões de projeto/grasp-creator/pedido.py

@@ -0,0 +1,19 @@
+from typing import List
+from pedido_item import PedidoItem
+from produto import Produto
+
+
+class Pedido:
+    def __init__(self):
+        self.__items: List[PedidoItem] = []
+
+    def adicionar_item_na_compra(self, produto: Produto):
+        item: PedidoItem = PedidoItem(produto=produto)
+        self.__items.append(item)
+
+    def calcular_valor_total_da_venda(self) -> float:
+        valor_total: float = 0.0
+        for item in self.__items:
+            valor_total += item.calcular_valor_total_do_item()
+
+        return valor_total

S08 - Padrões de projeto/grasp-creator/pedido_item.py

@@ -0,0 +1,11 @@
+from produto import Produto
+
+
+class PedidoItem:
+    def __init__(self, produto: Produto):
+        self.__nome: str = produto.nome
+        self.__preco_unitario: float = produto.valor_unitario
+        self.__quantidade_unidades_compradas: int = 2
+
+    def calcular_valor_total_do_item(self) -> float:
+        return self.__quantidade_unidades_compradas * self.__preco_unitario

S08 - Padrões de projeto/grasp-creator/principal.py

@@ -0,0 +1,49 @@
+"""
+class Pedido {
+
+    private List itens;
+
+    public void criarNovoPedidoItem(Produto produto) {
+        //Criamos a instancia de pedido item
+        PedidoItem pedidoItem = new PedidoItem(produto);
+        this.itens.add(pedidoItem);
+    }
+}
+
+class Produto {
+
+    private String nome;
+    private String preco;
+
+}
+
+class PedidoItem {
+
+    private String nome;
+    private String precoUnitario;
+    private int quantidade;
+
+    public PedidoItem(Produto produto){
+        this.nome = produto.getNome();
+        this.precoUnitario = produto.getPreco();
+        this.quantidade = 1;
+    }
+
+}
+"""
+from produto import Produto
+from pedido import Pedido
+
+
+if __name__ == '__main__':
+    pedido: Pedido = Pedido()
+
+    leite_condensado: Produto = Produto(nome="leite moça", valor_unitario=6.50)
+    nescau: Produto = Produto(nome="nescau 150ml", valor_unitario=1.50)
+
+    pedido.adicionar_item_na_compra(leite_condensado)
+    pedido.adicionar_item_na_compra(nescau)
+
+    valor_final = pedido.calcular_valor_total_da_venda()
+
+    print(f"o valor total da compra foi: {valor_final}")

S08 - Padrões de projeto/grasp-creator/produto.py

@@ -0,0 +1,12 @@
+class Produto:
+    def __init__(self, nome: str, valor_unitario: float):
+        self.__nome: str = nome
+        self.__valor_unitario: float = valor_unitario
+
+    @property
+    def valor_unitario(self) -> float:
+        return self.__valor_unitario
+
+    @property
+    def nome(self) -> str:
+        return self.__nome

S08 - Padrões de projeto/grasp-information-expert/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/grasp-information-expert/README.md

@@ -0,0 +1 @@
+# grasp information expert

S08 - Padrões de projeto/grasp-information-expert/item_vendido.py

@@ -0,0 +1,10 @@
+from produto import Produto
+
+
+class ItemVendido:
+    def __init__(self, produto: Produto, quantidade_unidades_compradas: int):
+        self.__produto: Produto = produto
+        self.__quantidade_unidades_compradas: int = quantidade_unidades_compradas
+
+    def calcular_valor_total_do_item(self) -> float:
+        return self.__quantidade_unidades_compradas * self.__produto.valor_unitario

S08 - Padrões de projeto/grasp-information-expert/principal.py

@@ -0,0 +1,16 @@
+from venda import Venda
+from item_vendido import ItemVendido
+from produto import Produto
+
+
+if __name__ == '__main__':
+    leite_condensado: Produto = Produto(nome="leite moça", valor_unitario=6.50)
+    nescau: Produto = Produto(nome="nescau 150ml", valor_unitario=1.50)
+
+    venda: Venda = Venda()
+    venda.adicionar_item_na_compra(ItemVendido(produto=leite_condensado, quantidade_unidades_compradas=2))
+    venda.adicionar_item_na_compra(ItemVendido(produto=nescau, quantidade_unidades_compradas=10))
+
+    valor_final = venda.calcular_valor_total_da_venda()
+
+    print(f"o valor total da compra foi: {valor_final}")

S08 - Padrões de projeto/grasp-information-expert/produto.py

@@ -0,0 +1,12 @@
+class Produto:
+    def __init__(self, nome: str, valor_unitario: float):
+        self.__nome: str = nome
+        self.__valor_unitario: float = valor_unitario
+
+    @property
+    def valor_unitario(self) -> float:
+        return self.__valor_unitario
+
+    @property
+    def nome(self) -> str:
+        return self.__nome

S08 - Padrões de projeto/grasp-information-expert/venda.py

@@ -0,0 +1,17 @@
+from typing import List
+from item_vendido import ItemVendido
+
+
+class Venda:
+    def __init__(self):
+        self.__items: List[ItemVendido] = []
+
+    def adicionar_item_na_compra(self, item: ItemVendido):
+        self.__items.append(item)
+
+    def calcular_valor_total_da_venda(self) -> float:
+        valor_total: float = 0.0
+        for item in self.__items:
+            valor_total += item.calcular_valor_total_do_item()
+
+        return valor_total

S08 - Padrões de projeto/interpreter/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/interpreter/README.md

@@ -0,0 +1,8 @@
+# Interpreter
+
+Código baseado no do [Matheus Castiglioni](https://blog.matheuscastiglioni.com.br/interpreter-padroes-de-projeto-em-java/),
+em que ele explica o funcionamento desse padrão.
+
+Um ótimo vídeo com mais explicações sobre esse padrão de projeto é o do 
+[Derek Banas](https://www.youtube.com/watch?v=6CVymSJQuJE).
+Nesse caso o exemplo é em Java :coffee:

S08 - Padrões de projeto/interpreter/divisao.py

@@ -0,0 +1,10 @@
+from operador import Operador
+
+
+class Dividir(Operador):
+    def __init__(self, esquerda: Operador, direita: Operador):
+        self._esquerda: Operador = esquerda
+        self._direita: Operador = direita
+
+    def interpretar(self) -> float:
+        return self._esquerda.interpretar() / self._direita.interpretar()

S08 - Padrões de projeto/interpreter/multiplicacao.py

@@ -0,0 +1,10 @@
+from operador import Operador
+
+
+class Multiplicar(Operador):
+    def __init__(self, esquerda: Operador, direita: Operador):
+        self._esquerda: Operador = esquerda
+        self._direita: Operador = direita
+
+    def interpretar(self) -> int:
+        return self._esquerda.interpretar() * self._direita.interpretar()

S08 - Padrões de projeto/interpreter/numero.py

@@ -0,0 +1,9 @@
+from operador import Operador
+
+
+class Numero(Operador):
+    def __init__(self, valor: int):
+        self._valor: int = valor
+
+    def interpretar(self) -> int:
+        return self._valor

S08 - Padrões de projeto/interpreter/operador.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Operador(ABC):
+    @abstractmethod
+    def interpretar(self) -> int:
+        pass

S08 - Padrões de projeto/interpreter/principal.py

@@ -0,0 +1,24 @@
+from operador import Operador
+from numero import Numero
+from soma import Somar
+from subtracao import Subtrair
+from multiplicacao import Multiplicar
+from divisao import Dividir
+
+
+if __name__ == '__main__':
+    somar: Operador = Somar(Numero(1), Numero(4))
+    # 1 + 4 = 5
+    print(f"resultado da soma: {somar.interpretar()}")
+
+    # 5 - 2 = 3
+    subtrair: Operador = Subtrair(somar, Numero(2))
+    print(f"resultado da subtração: {subtrair.interpretar()}")
+
+    # 5 * 3 = 15
+    multiplicar: Operador = Multiplicar(subtrair, somar)
+    print(f"resultado da multiplicação: {multiplicar.interpretar()}")
+
+    # 30 / 15 = 2
+    dividir: Operador = Dividir(Numero(30), multiplicar)
+    print(f"resultado da divisão: {dividir.interpretar()}")

S08 - Padrões de projeto/interpreter/soma.py

@@ -0,0 +1,10 @@
+from operador import Operador
+
+
+class Somar(Operador):
+    def __init__(self, esquerda: Operador, direita: Operador):
+        self._esquerda: Operador = esquerda
+        self._direita: Operador = direita
+
+    def interpretar(self) -> int:
+        return self._esquerda.interpretar() + self._direita.interpretar()

S08 - Padrões de projeto/interpreter/subtracao.py

@@ -0,0 +1,10 @@
+from operador import Operador
+
+
+class Subtrair(Operador):
+    def __init__(self, esquerda: Operador, direita: Operador):
+        self._esquerda: Operador = esquerda
+        self._direita: Operador = direita
+
+    def interpretar(self) -> int:
+        return self._esquerda.interpretar() - self._direita.interpretar()

S08 - Padrões de projeto/iterator/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/iterator/README.md

@@ -0,0 +1,9 @@
+# Iterator
+
+Exemplo escrito em python e baseado no do [
+Refactoring.Guru](https://refactoring.guru/pt-br) sobre o padrão de projeto 
+[Iterator](https://refactoring.guru/pt-br/design-patterns/iterator).
+
+Um ótimo vídeo com mais explicações sobre esse padrão de projeto é o do 
+[Derek Banas](https://www.youtube.com/watch?v=VKIzUuMdmag&feature=emb_logo).
+Nesse caso o exemplo é em Java :coffee:

S08 - Padrões de projeto/iterator/cardapio.py

@@ -0,0 +1,20 @@
+from collections.abc import Iterable
+from iterador import IteradorDoCardapio
+
+
+class Cardapio(Iterable):
+
+    def __init__(self, cardapio_inicial=None) -> None:
+        if cardapio_inicial is None:
+            cardapio_inicial = []
+
+        self._items_do_cardapio = cardapio_inicial
+
+    def __iter__(self) -> IteradorDoCardapio:
+        return IteradorDoCardapio(self._items_do_cardapio)
+
+    def get_reverse_iterator(self) -> IteradorDoCardapio:
+        return IteradorDoCardapio(items_do_cardapio=self._items_do_cardapio, percorrer_reversamente=True)
+
+    def adicionar_novo_item(self, item: str):
+        self._items_do_cardapio.append(item)

S08 - Padrões de projeto/iterator/iterador.py

@@ -0,0 +1,29 @@
+from collections.abc import Iterator
+from typing import List
+
+
+class IteradorDoCardapio(Iterator):
+
+    _posicao: int = None
+    _percorrer_reversamente: bool = False
+
+    def __init__(self, items_do_cardapio: List[str], percorrer_reversamente: bool = False) -> None:
+        self._items_do_cardapio = items_do_cardapio
+        self._percorrer_reversamente = percorrer_reversamente
+        self._posicao = 0
+        if percorrer_reversamente:
+            self._posicao = -1
+
+    def __next__(self):
+        try:
+            valor = self._items_do_cardapio[self._posicao]
+
+            indice_a_ser_somado = 1
+            if self._percorrer_reversamente:
+                indice_a_ser_somado = -1
+
+            self._posicao += indice_a_ser_somado
+        except IndexError:
+            raise StopIteration()
+
+        return valor

S08 - Padrões de projeto/iterator/principal.py

@@ -0,0 +1,16 @@
+from cardapio import Cardapio
+
+
+if __name__ == "__main__":
+
+    cardapio = Cardapio()
+    cardapio.adicionar_novo_item("Tilápia")
+    cardapio.adicionar_novo_item("Carne do Sol")
+    cardapio.adicionar_novo_item("Macaxeira")
+
+    print("Percorrendo na ordem normal:")
+    print("\n".join(cardapio))
+    print("")
+
+    print("Percorrendo inversamente:")
+    print("\n".join(cardapio.get_reverse_iterator()), end="")

S08 - Padrões de projeto/mediator/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/mediator/README.md

@@ -0,0 +1,8 @@
+# Mediator
+
+Exemplo escrito em python e baseado no do [Refactoring.Guru](https://refactoring.guru/pt-br) sobre o padrão de projeto 
+[Mediator](https://refactoring.guru/pt-br/design-patterns/mediator).
+
+Um ótimo vídeo com mais explicações sobre esse padrão de projeto é o do 
+[Derek Banas](https://www.youtube.com/watch?v=8DxIpdKd41A).
+Nesse caso o exemplo é em Java :coffee:

S08 - Padrões de projeto/mediator/principal.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from abc import ABC
+
+
+class Mediador(ABC):
+    def notificar(self, remetente: object, evento: str) -> None:
+        pass
+
+
+class MediadorConcreto(Mediador):
+    def __init__(self, componente_1: Componente1, componente_2: Componente2) -> None:
+        self._componente_1 = componente_1
+        self._componente_1.mediador = self
+        self._componente_2 = componente_2
+        self._componente_2.mediador = self
+
+    def notificar(self, remetente: object, evento: str) -> None:
+        if evento == "A":
+            print("O mediador reage com A e dispara as seguintes operações:")
+            self._componente_2.para_c()
+        elif evento == "D":
+            print("O mediador reage com D e dispara as seguintes operações:")
+            self._componente_1.para_b()
+            self._componente_2.para_c()
+
+
+class ComponenteBase:
+    def __init__(self, mediador: Mediador = None) -> None:
+        self._mediador = mediador
+
+    @property
+    def mediador(self) -> Mediador:
+        return self._mediador
+
+    @mediador.setter
+    def mediador(self, mediator: Mediador) -> None:
+        self._mediador = mediator
+
+
+class Componente1(ComponenteBase):
+    def para_a(self) -> None:
+        print("Componente 1 dispara A")
+        self.mediador.notificar(self, "A")
+
+    def para_b(self) -> None:
+        print("Componente 1 dispara B")
+        self.mediador.notificar(self, "B")
+
+
+class Componente2(ComponenteBase):
+    def para_c(self) -> None:
+        print("Componente 2 dispara C")
+        self.mediador.notificar(self, "C")
+
+    def para_d(self) -> None:
+        print("Componente 2 dispara D")
+        self.mediador.notificar(self, "D")
+
+
+if __name__ == "__main__":
+    componente_1 = Componente1()
+    componente_2 = Componente2()
+    mediator = MediadorConcreto(componente_1, componente_2)
+
+    print("Cliente dispara a operação A.")
+    componente_1.para_a()
+
+    print("\n", end="")
+
+    print("Cliente dispara a operação D.")
+    componente_2.para_d()

S08 - Padrões de projeto/memento/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/memento/README.md

@@ -0,0 +1,7 @@
+# memento
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Memento](https://www.youtube.com/watch?v=jOnxYT8Iaoo)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/memento/momento.py

@@ -0,0 +1,6 @@
+class Momento:
+    def __init__(self, artigo_para_salvar: str):
+        self.__artigo: str = artigo_para_salvar
+
+    def obter_artigo_salvo(self) -> str:
+        return self.__artigo

S08 - Padrões de projeto/memento/originador.py

@@ -0,0 +1,23 @@
+from momento import Momento
+
+
+class Originador:
+    def __init__(self):
+        self.__artigo = ""
+
+    def modificar_artigo(self, novo_artigo: str):
+        print(f"Do originador: versão atual do artigo\n{self.__artigo}")
+        self.__artigo = novo_artigo
+
+    def salvar_momento(self) -> Momento:
+        print(f"Do originador: salvando estado atual no momento")
+        return Momento(artigo_para_salvar=self.__artigo)
+
+    @staticmethod
+    def restaurar_versao_do_momento(momento: Momento) -> str:
+        artigo = momento.obter_artigo_salvo()
+        print(f"Do originador: versão anteriormente salva no momento: {artigo}")
+
+        return artigo
+
+    pass

S08 - Padrões de projeto/memento/principal.py

@@ -0,0 +1,33 @@
+from originador import Originador
+from zelador import Zelador
+
+
+if __name__ == '__main__':
+    zelador: Zelador = Zelador()
+    origem: Originador = Originador()
+    quantidade_de_arquivos_salvos: int = 0
+
+    for _ in range(3):
+        artigo: str = input("Digite algo no artigo e aperte ENTER: ")
+        origem.modificar_artigo(artigo)
+        zelador.adicionar_versao(origem.salvar_momento())
+        quantidade_de_arquivos_salvos += 1
+        print(f"versão salva: {quantidade_de_arquivos_salvos}\n")
+
+    print("\n========================================================")
+    artigo_restaurado: str = origem.restaurar_versao_do_momento(
+        zelador.obter_versao(indice=2)
+    )
+    print(f"versão recuperada número 3: {artigo_restaurado}")
+
+    print("\n========================================================")
+    artigo_restaurado: str = origem.restaurar_versao_do_momento(
+        zelador.obter_versao(indice=1)
+    )
+    print(f"versão recuperada número 2: {artigo_restaurado}")
+
+    print("\n========================================================")
+    artigo_restaurado: str = origem.restaurar_versao_do_momento(
+        zelador.obter_versao(indice=0)
+    )
+    print(f"versão recuperada número 1: {artigo_restaurado}")

S08 - Padrões de projeto/memento/zelador.py

@@ -0,0 +1,15 @@
+from typing import List
+from momento import Momento
+
+
+class Zelador:
+    def __init__(self):
+        self.__artigos_salvos: List[Momento] = []
+
+    def adicionar_versao(self, versao: Momento) -> None:
+        self.__artigos_salvos.append(versao)
+
+    def obter_versao(self, indice: int) -> Momento:
+        return self.__artigos_salvos.__getitem__(indice)
+
+    pass

S08 - Padrões de projeto/object_pool/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/object_pool/README.md

@@ -0,0 +1,4 @@
+# object pool
+
+O código desse repositório foi feito em python e é baseado
+[no exemplo do site source making sobre o padrão de projeto Object Pool](https://sourcemaking.com/design_patterns/object_pool)

S08 - Padrões de projeto/object_pool/gerenciador.py

@@ -0,0 +1,20 @@
+from reutilizavel import Reutilizavel
+
+
+class Gerenciador:
+    """
+    Gerenciar objetos Reutilizáveis para uso por objetos Cliente.
+    """
+
+    def __init__(self, size):
+        print(f"Instanciando gerenciador com {size} objetos que os clientes podem reutilizar")
+        self.__objetos_reutilizaveis = [Reutilizavel() for _ in range(size)]
+
+    def adquirir(self):
+        print("Adquirindo um obejto reutilizável")
+        return self.__objetos_reutilizaveis.pop()
+
+    def adicionar(self, objeto_para_reutilizar: Reutilizavel):
+        print("Adicionando um objeto reutilizável ao gerenciador")
+        self.__objetos_reutilizaveis.append(objeto_para_reutilizar)
+

S08 - Padrões de projeto/object_pool/principal.py

@@ -0,0 +1,16 @@
+from gerenciador import Gerenciador
+from reutilizavel import Reutilizavel
+from time import sleep
+
+
+if __name__ == "__main__":
+    gerenciador: Gerenciador = Gerenciador(10)
+    sleep(5)
+
+    print("Cliente requisitando um objeto disponível no gerenciador...")
+    objeto_reusavel: Reutilizavel = gerenciador.adquirir()
+    print("Cliente está usando o objeto reutilizável...")
+    sleep(5)
+
+    print("Terminou de usar. Devolvendo ao gerenciador...")
+    gerenciador.adicionar(objeto_reusavel)

S08 - Padrões de projeto/object_pool/reutilizavel.py

@@ -0,0 +1,2 @@
+class Reutilizavel:
+    pass

S08 - Padrões de projeto/observer/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/observer/Readme.MD

@@ -0,0 +1,3 @@
+# Padrão de projeto Observer
+
+Esse código em python foi baseado no [vídeo do Derek Banas sobre o padrão de projeto Observer](https://www.youtube.com/watch?v=wiQdrH2YpT4&feature=emb_logo)

S08 - Padrões de projeto/observer/main.py

@@ -0,0 +1,35 @@
+from stock_grabber import AdministradorAcoes
+from stock_observer import ObservadorAcoes
+from time import sleep
+
+
+if __name__ == "__main__":
+    administrador = AdministradorAcoes()
+    observador_1 = ObservadorAcoes(identificador=1, assunto=administrador)
+
+    print("\nprimeira atualização...")
+    administrador.preco_ibm = 200.0
+    sleep(1)
+
+    print("\nsegunda atualização...")
+    administrador.preco_apple = 300.0
+    sleep(1)
+
+    print("\nterceira atualização...")
+    administrador.preco_google = 400.0
+    sleep(1)
+
+    print()
+    observador_2 = ObservadorAcoes(identificador=2, assunto=administrador)
+
+    print("\nquarta atualização...")
+    administrador.preco_ibm = 20000.0
+    sleep(1)
+
+    print("\nquinta atualização...")
+    administrador.preco_apple = 30000.0
+    sleep(1)
+
+    print("\nsexta atualização...")
+    administrador.preco_google = 40000.0
+    sleep(1)

S08 - Padrões de projeto/observer/observer_interface.py

@@ -0,0 +1,9 @@
+import abc
+
+
+class Observador(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def atualizar(
+        self, preco_ibm: float, preco_apple: float, preco_google: float
+    ) -> None:
+        pass

S08 - Padrões de projeto/observer/stock_grabber.py

@@ -0,0 +1,55 @@
+from subject_interface import Assunto
+from observer_interface import Observador
+from typing import List
+
+
+class AdministradorAcoes(Assunto):
+    def __init__(self):
+        self.__observadores: List[Observador] = []
+        self.__preco_ibm: float = 0.0
+        self.__preco_apple: float = 0.0
+        self.__preco_google: float = 0.0
+
+    def registrar_novo_observador(self, novo_observador: Observador) -> None:
+        self.__observadores.append(novo_observador)
+        print("observador adicionado")
+
+    def cancelar_registro_de_um_observador(self, observador: Observador) -> None:
+        self.__observadores.remove(observador)
+        print("observador removido")
+
+    def notificar_observadores(self) -> None:
+        print("atualizando os valores dos observadores")
+        for observador in self.__observadores:
+            observador.atualizar(
+                preco_ibm=self.__preco_ibm,
+                preco_apple=self.__preco_apple,
+                preco_google=self.__preco_google,
+            )
+
+    @property
+    def preco_ibm(self) -> float:
+        return self.__preco_ibm
+
+    @property
+    def preco_apple(self) -> float:
+        return self.__preco_apple
+
+    @property
+    def preco_google(self) -> float:
+        return self.__preco_google
+
+    @preco_ibm.setter
+    def preco_ibm(self, novo_valor: float) -> None:
+        self.__preco_ibm = novo_valor
+        self.notificar_observadores()
+
+    @preco_apple.setter
+    def preco_apple(self, novo_valor: float) -> None:
+        self.__preco_apple = novo_valor
+        self.notificar_observadores()
+
+    @preco_google.setter
+    def preco_google(self, novo_valor: float) -> None:
+        self.__preco_google = novo_valor
+        self.notificar_observadores()

S08 - Padrões de projeto/observer/stock_observer.py

@@ -0,0 +1,41 @@
+from observer_interface import Observador
+from subject_interface import Assunto
+
+
+class ObservadorAcoes(Observador):
+    def __init__(self, identificador: int, assunto: Assunto):
+        self.__preco_ibm: float = 100.0
+        self.__preco_apple: float = 100.0
+        self.__preco_google: float = 100.0
+        self.__identificador: int = identificador
+        self.__assunto: Assunto = assunto
+
+        print(f"Novo observador id -> {self.__identificador}")
+        self.__assunto.registrar_novo_observador(novo_observador=self)
+
+    def atualizar(
+        self, preco_ibm: float, preco_apple: float, preco_google: float
+    ) -> None:
+        self.__preco_ibm: float = preco_ibm
+        self.__preco_apple: float = preco_apple
+        self.__preco_google: float = preco_google
+
+        print(f"id do observador: {self.__identificador}")
+        self.printar_valores_atuais()
+
+    @property
+    def preco_ibm(self) -> float:
+        return self.__preco_ibm
+
+    @property
+    def preco_apple(self) -> float:
+        return self.__preco_apple
+
+    @property
+    def preco_google(self) -> float:
+        return self.__preco_google
+
+    def printar_valores_atuais(self) -> None:
+        print(f"ibm: {self.__preco_ibm}")
+        print(f"apple: {self.__preco_apple}")
+        print(f"google: {self.__preco_google}")

S08 - Padrões de projeto/observer/subject_interface.py

@@ -0,0 +1,16 @@
+import abc
+from observer_interface import Observador
+
+
+class Assunto(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def registrar_novo_observador(self, novo_observador: Observador) -> None:
+        pass
+
+    @abc.abstractmethod
+    def cancelar_registro_de_um_observador(self, observador: Observador) -> None:
+        pass
+
+    @abc.abstractmethod
+    def notificar_observadores(self) -> None:
+        pass

S08 - Padrões de projeto/private_class_data/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/private_class_data/README.md

@@ -0,0 +1,5 @@
+# private class data
+
+O código desse repositório foi feito em python e é baseado no 
+vídeo do canal [Desenvolvimento de Jogos](https://www.youtube.com/watch?v=DLV2pb4kJ5E) que fala sobre o 
+padrão de projeto [Private Class Data](https://www.youtube.com/watch?v=DLV2pb4kJ5E)

S08 - Padrões de projeto/private_class_data/particula.py

@@ -0,0 +1,14 @@
+from velocidade import Velocidade
+from math import pow
+
+
+class Particula:
+    def __init__(self, valor_velocidade: float, massa: float):
+        self.__velocidade: Velocidade = Velocidade(valor_velocidade)
+        self.__massa: float = massa
+
+    def calcular_energia_cinetica(self):
+        resultado = self.__massa * pow(self.__velocidade.obter_valor(), 2)
+        resultado = resultado / 2
+
+        return resultado

S08 - Padrões de projeto/private_class_data/principal.py

@@ -0,0 +1,11 @@
+from particula import Particula
+
+
+if __name__ == '__main__':
+    particula_1 = Particula(valor_velocidade=10.0, massa=2.0)
+    resultado_energia_cinetica = particula_1.calcular_energia_cinetica()
+    print(f"valor da energia cinética: {resultado_energia_cinetica}\n")
+
+    particula_2 = Particula(valor_velocidade=5.0, massa=10.0)
+    resultado_energia_cinetica = particula_2.calcular_energia_cinetica()
+    print(f"valor da energia cinética: {resultado_energia_cinetica}\n")

S08 - Padrões de projeto/private_class_data/velocidade.py

@@ -0,0 +1,6 @@
+class Velocidade:
+    def __init__(self, valor: float):
+        self.__valor = valor
+
+    def obter_valor(self) -> float:
+        return self.__valor

S08 - Padrões de projeto/prototype/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/prototype/README.md

@@ -0,0 +1,5 @@
+# prototype
+
+O código desse repositório foi feito em python e é baseado no [vídeo do Derek Banas sobre o padrão de projeto Prototype](https://www.youtube.com/watch?v=AFbZhRL0Uz8&feature=emb_logo)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site [Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/prototype/animal.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Animal(ABC):
+    @abstractmethod
+    def clonar(self):
+        pass

S08 - Padrões de projeto/prototype/clonador_de_animais.py

@@ -0,0 +1,6 @@
+from animal import Animal
+
+
+class ClonadorDeAnimais:
+    def clonar_animal(self, animal_a_ser_clonado: Animal):
+        return animal_a_ser_clonado.clonar()

S08 - Padrões de projeto/prototype/main.py

@@ -0,0 +1,38 @@
+from ovelha import Ovelha
+from clonador_de_animais import ClonadorDeAnimais
+
+if __name__ == "__main__":
+    clonador = ClonadorDeAnimais()
+    ovelha_dolly = Ovelha()
+    ovelha_fofolete = clonador.clonar_animal(ovelha_dolly)
+
+    print("\novelha dolly:")
+    print(ovelha_dolly)
+    print(f"id: {id(ovelha_dolly)}\n")
+
+    print("ovelha_fofolete:")
+    print(ovelha_fofolete)
+    print(f"id: {id(ovelha_fofolete)}\n")
+    msg = (
+        "Objetos iguais"
+        if id(ovelha_dolly) == id(ovelha_fofolete)
+        else "Objetos diferentes"
+    )
+    print(msg)
+
+    ovelha_dolly.tamanho = 20.0
+
+    print("\novelha dolly:")
+    print(ovelha_dolly)
+    print(f"id: {id(ovelha_dolly)}\n")
+
+    print(id(ovelha_fofolete))
+    print(ovelha_fofolete)
+    print(f"id: {id(ovelha_fofolete)}\n")
+
+    msg = (
+        "A mudança no tamanho não afetou os dois. Ou seja, deu certo"
+        if ovelha_dolly.tamanho != ovelha_fofolete.tamanho
+        else "Deu ruim"
+    )
+    print(msg)

S08 - Padrões de projeto/prototype/ovelha.py

@@ -0,0 +1,23 @@
+from animal import Animal
+from copy import copy, deepcopy
+
+
+class Ovelha(Animal):
+    def __init__(self):
+        self._tamanho = 10.0
+        print("ovelha criada bééééééé")
+
+    def __str__(self):
+        return f"tamanho: {self._tamanho}"
+
+    @property
+    def tamanho(self) -> str:
+        return str(self._tamanho)
+
+    @tamanho.setter
+    def tamanho(self, novo_tamanho: float):
+        self._tamanho = novo_tamanho
+
+    def clonar(self):
+        print("clonei a ovelha")
+        return copy(self)

S08 - Padrões de projeto/proxy/.gitignore

@@ -0,0 +1,2 @@
+.vscode
+__pycache__

S08 - Padrões de projeto/proxy/Readme.MD

@@ -0,0 +1,8 @@
+# Proxy
+
+Exemplo escrito em python e baseado no do [Refactoring.Guru](https://refactoring.guru/pt-br) sobre o padrão de projeto 
+[Proxy](https://refactoring.guru/pt-br/design-patterns/proxy).
+
+Um ótimo vídeo com mais explicações sobre esse padrão de projeto é o do 
+[Derek Banas](https://www.youtube.com/watch?v=cHg5bWW4nUI).
+Nesse caso o exemplo é em Java :coffee:

S08 - Padrões de projeto/proxy/interface_sujeito.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class InterfaceSujeito(ABC):
+    @abstractmethod
+    def requisicao(self) -> None:
+        pass

S08 - Padrões de projeto/proxy/principal.py

@@ -0,0 +1,19 @@
+from interface_sujeito import InterfaceSujeito
+from sujeito import Sujeito
+from proxy import Proxy
+
+
+def executar_cliente(sujeito: InterfaceSujeito) -> None:
+    sujeito.requisicao()
+
+
+if __name__ == "__main__":
+    print("Cliente: Executando cliente com o sujeito concreto:")
+    sujeito_real = Sujeito()
+    executar_cliente(sujeito_real)
+
+    print()
+
+    print("Cliente: Executando o mesmo cliente utilizando o proxy:")
+    proxy = Proxy(sujeito_real)
+    executar_cliente(proxy)

S08 - Padrões de projeto/proxy/proxy.py

@@ -0,0 +1,20 @@
+from interface_sujeito import InterfaceSujeito
+from sujeito import Sujeito
+
+
+class Proxy(InterfaceSujeito):
+    def __init__(self, sujeito_real: Sujeito) -> None:
+        self._sujeito = sujeito_real
+
+    def requisicao(self) -> None:
+        if self.verificar_acesso():
+            self._sujeito.requisicao()
+            self.registro_de_acesso()
+
+    def verificar_acesso(self) -> bool:
+        print("Proxy: Verificar acesso antes de fazer requisição.")
+        return True
+
+    def registro_de_acesso(self) -> None:
+        print("Proxy: Registrando a hora da solicitação.", end="")
+

S08 - Padrões de projeto/proxy/sujeito.py

@@ -0,0 +1,6 @@
+from interface_sujeito import InterfaceSujeito
+
+
+class Sujeito(InterfaceSujeito):
+    def requisicao(self) -> None:
+        print("Tratamento de requisição.")

S08 - Padrões de projeto/singleton/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/singleton/Readme.MD

@@ -0,0 +1,4 @@
+# singleton
+
+Exemplo escrito em python e baseado no do [
+Refactoring.Guru](https://refactoring.guru/pt-br) sobre o padrão de projeto [Singleton](https://refactoring.guru/pt-br/design-patterns/singleton).

S08 - Padrões de projeto/singleton/main.py

@@ -0,0 +1,24 @@
+from singleton import ConexaoBancoDeDados
+from threading import Thread
+
+
+def criando_conexao_banco(valor: str) -> None:
+    banco = ConexaoBancoDeDados(valor)
+    print(banco.nome_da_conexao)
+
+
+if __name__ == "__main__":
+    # Código do cliente
+
+    print(
+        "Teste com threads para ver se é criada apenas uma conexão.\n\n"
+        "Se você ver o mesmo valor, então a conexão com o banco está sendo reusada (ieeeeei \o/)\n"
+        "Se os valores forem diferentes, "
+        "então duas conexões distintas foram criadas. Ou seja, deu ruim, pessoal!! :(\n\n"
+        "Resultado:\n"
+    )
+
+    conexao_1 = Thread(target=criando_conexao_banco, args=("Mongo",))
+    conexao_2 = Thread(target=criando_conexao_banco, args=("Postgres",))
+    conexao_1.start()
+    conexao_2.start()

S08 - Padrões de projeto/singleton/singleton.py

@@ -0,0 +1,25 @@
+from threading import Lock
+
+
+class SingletonMeta(type):
+    _instancias = {}
+
+    _lock: Lock = Lock()
+
+    def __call__(cls, *args, **kwargs):
+        with cls._lock:
+            if cls not in cls._instancias:
+                instancia = super().__call__(*args, **kwargs)
+                cls._instancias[cls] = instancia
+
+        return cls._instancias[cls]
+
+
+class ConexaoBancoDeDados(metaclass=SingletonMeta):
+    nome_da_conexao: str = None
+
+    def __init__(self, nome_da_conexao: str) -> None:
+        self.nome_da_conexao = nome_da_conexao
+
+    def alguma_logica_de_negocio(self):
+        pass

S08 - Padrões de projeto/state/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/state/README.md

@@ -0,0 +1,8 @@
+# State
+
+Exemplo escrito em python e baseado no do [Refactoring.Guru](https://refactoring.guru/pt-br) sobre o padrão de projeto 
+[State](https://refactoring.guru/pt-br/design-patterns/state).
+
+Um ótimo vídeo com mais explicações sobre esse padrão de projeto é o do 
+[Derek Banas](https://www.youtube.com/watch?v=MGEx35FjBuo).
+Nesse caso o exemplo é em Java :coffee:

S08 - Padrões de projeto/state/principal.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+
+
+class Contexto:
+    _estado_atual = None
+
+    def __init__(self, estado: Estado) -> None:
+        self.transitar_para(estado)
+
+    def transitar_para(self, state: Estado):
+        print(f"Contexto: Transitando para o estado {type(state).__name__}")
+        self._estado_atual = state
+        self._estado_atual.contexto = self
+
+    def requisicao_1(self):
+        self._estado_atual.lidar_com_requisicao_1()
+
+    def requisicao_2(self):
+        self._estado_atual.lidar_com_requisicao_2()
+
+
+class Estado(ABC):
+    def __init__(self, contexto = None):
+        self._contexto = contexto
+
+    @property
+    def contexto(self) -> Contexto:
+        return self._contexto
+
+    @contexto.setter
+    def contexto(self, contexto: Contexto) -> None:
+        self._contexto = contexto
+
+    @abstractmethod
+    def lidar_com_requisicao_1(self) -> None:
+        pass
+
+    @abstractmethod
+    def lidar_com_requisicao_2(self) -> None:
+        pass
+
+
+class EstadoA(Estado):
+    def lidar_com_requisicao_1(self) -> None:
+        print("Estado A resolvendo a requisição 1.")
+        print("O estado A deseja alterar o estado do contexto.")
+        self.contexto.transitar_para(EstadoB())
+
+    def lidar_com_requisicao_2(self) -> None:
+        print("Estado A resolvendo a requisição 2.")
+
+
+class EstadoB(Estado):
+    def lidar_com_requisicao_1(self) -> None:
+        print("Estado B resolvendo a requisição 1.")
+
+    def lidar_com_requisicao_2(self) -> None:
+        print("Estado B resolvendo a requisição 2.")
+        print("O estado B deseja alterar o estado do contexto.")
+        self.contexto.transitar_para(EstadoA())
+
+
+if __name__ == "__main__":
+    contexto = Contexto(EstadoA())
+    contexto.requisicao_1()
+    contexto.requisicao_2()

S08 - Padrões de projeto/strategy/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/strategy/README.MD

@@ -0,0 +1,3 @@
+# Strategy
+
+Esse código é baseado em um exemplo demonstrado no canal do youtube [Código Fonte TV](https://www.youtube.com/watch?v=WPdrnuSHAQs)

S08 - Padrões de projeto/strategy/frete_servico.py

@@ -0,0 +1,8 @@
+import abc
+
+
+class FreteServico(metaclass=abc.ABCMeta):
+
+  @abc.abstractmethod
+  def calcula(self, peso: float) -> float:
+    pass

S08 - Padrões de projeto/strategy/main.py

@@ -0,0 +1,28 @@
+from sedex import Sedex
+from tnt import Tnt
+from frete_servico import FreteServico
+
+class Frete:
+    def __init__(self, empresa_que_fara_o_frete: FreteServico):
+        self._empresa = empresa_que_fara_o_frete
+
+    @property
+    def empresa(self):
+        return self._empresa
+
+    @empresa.setter
+    def empresa(self, empresa: FreteServico):
+        self._empresa = empresa
+
+    def calcular_valor(self, peso: float) -> float:
+        return self._empresa.calcula(peso)
+
+
+if __name__ == "__main__":
+    frete = Frete(empresa_que_fara_o_frete=Sedex())
+    resultado = frete.calcular_valor(10)
+    print(resultado)
+
+    frete.empresa = Tnt()
+    resultado = frete.calcular_valor(10)
+    print(resultado)

S08 - Padrões de projeto/strategy/sedex.py

@@ -0,0 +1,7 @@
+from frete_servico import FreteServico
+
+
+class Sedex(FreteServico):
+    def calcula(self, peso: float) -> float:
+        return peso * 10.0 + 10.0
+

S08 - Padrões de projeto/strategy/tnt.py

@@ -0,0 +1,6 @@
+from frete_servico import FreteServico
+
+
+class Tnt(FreteServico):
+    def calcula(self, peso: float) -> float:
+        return peso * 5.0 + 10.0

S08 - Padrões de projeto/template_method/.gitignore

@@ -0,0 +1 @@
+__pycache__

S08 - Padrões de projeto/template_method/README.md

@@ -0,0 +1,7 @@
+# template method
+
+O código desse repositório foi feito em python e é baseado no 
+[vídeo do Derek Banas sobre o padrão de projeto Template Method](https://www.youtube.com/watch?v=aR1B8MlwbRI&feature=emb_logo)
+
+Para mais informações/explicações sobre esse e outros padrões de projeto, recomendo a leitura do site 
+[Refactoring.Guru](https://refactoring.guru/pt-br/design-patterns) sobre o assunto. 

S08 - Padrões de projeto/template_method/hoagie.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+
+
+class Hoagie(ABC):
+    def fazer_sanduba(self):
+        self.cortar_pao()
+
+        if self.cliente_quer_carne():
+            self.adicionar_carne()
+
+        if self.cliente_quer_queijo():
+            self.adicionar_queijo()
+
+        if self.cliente_quer_verduras():
+            self.adicionar_verduras()
+
+        if self.cliente_quer_condimentos():
+            self.adicionar_condimentos()
+
+        self.embalar_sanduba()
+
+    def cortar_pao(self):
+        print(f"O sanduba foi cortado!")
+
+    @abstractmethod
+    def adicionar_carne(self):
+        pass
+
+    @abstractmethod
+    def adicionar_queijo(self):
+        pass
+
+    @abstractmethod
+    def adicionar_verduras(self):
+        pass
+
+    @abstractmethod
+    def adicionar_condimentos(self):
+        pass
+
+    @staticmethod
+    def cliente_quer_carne():
+        return True
+
+    @staticmethod
+    def cliente_quer_queijo():
+        return True
+
+    @staticmethod
+    def cliente_quer_verduras():
+        return True
+
+    @staticmethod
+    def cliente_quer_condimentos():
+        return True
+
+    def embalar_sanduba(self):
+        print("\nEmbalando o sanduba!")

S08 - Padrões de projeto/template_method/hoagie_italiano.py

@@ -0,0 +1,29 @@
+from hoagie import Hoagie
+
+
+class HoagieItaliano(Hoagie):
+    def __init__(self):
+        self.carnes_usadas = ["peperoni", "salame", "presunto de capicola"]
+        self.queijos_usados = ["provolone"]
+        self.vegetais_usados = ["alface", "tomate", "cebolas", "pimenta doce"]
+        self.condimentos_usados = ["óleo", "vinagre"]
+
+    def adicionar_carne(self):
+        print("adicionando a carne: ", end="")
+        for carne in self.carnes_usadas:
+            print(f"{carne}", end=" ")
+
+    def adicionar_queijo(self):
+        print("\nadicionando o queijo: ", end="")
+        for queijo in self.queijos_usados:
+            print(f"{queijo}", end=" ")
+
+    def adicionar_verduras(self):
+        print("\nadicionando verdura: ", end="")
+        for vegetal in self.vegetais_usados:
+            print(f"{vegetal}", end=" ")
+
+    def adicionar_condimentos(self):
+        print("\nadicionando condimento: ", end="")
+        for condimento in self.condimentos_usados:
+            print(f"{condimento}", end=" ")

S08 - Padrões de projeto/template_method/hoagie_vegano.py

@@ -0,0 +1,29 @@
+from hoagie import Hoagie
+
+
+class HoagieVegano(Hoagie):
+    def __init__(self):
+        self.vegetais_usados = ["alface", "tomate", "cebolas", "pimenta doce"]
+        self.condimentos_usados = ["óleo", "vinagre"]
+
+    def adicionar_verduras(self):
+        print("adicionando verdura: ", end="")
+        for vegetal in self.vegetais_usados:
+            print(f"{vegetal}", end=" ")
+
+    def adicionar_condimentos(self):
+        print("\nadicionando condimento: ", end="")
+        for condimento in self.condimentos_usados:
+            print(f"{condimento}", end=" ")
+
+    def adicionar_carne(self):
+        pass
+
+    def adicionar_queijo(self):
+        pass
+
+    def cliente_quer_carne(self):
+        return False
+
+    def cliente_quer_queijo(self):
+        return False

S08 - Padrões de projeto/template_method/principal.py

@@ -0,0 +1,12 @@
+from hoagie_italiano import HoagieItaliano
+from hoagie_vegano import HoagieVegano
+
+
+if __name__ == "__main__":
+    print("sanduba italiano")
+    sanduba_italiano = HoagieItaliano()
+    sanduba_italiano.fazer_sanduba()
+
+    print("\n\nsanduba vegano")
+    sanduba_vegano = HoagieVegano()
+    sanduba_vegano.fazer_sanduba()