Encapsulamento

Encapsulamento é o processo no qual protegemos a integridade interna dos dados em uma classe (Ex.: Carro - Não podemos acelerar um carro no pedal de freio), ou seja, todos os métodos ficam encapsulados (protegidos) dentro das suas devidas classes, separando o freio apenas para freiar e o acelerador apenas para acelerar, por exemplo. Em Python não tem declaração privada, então existem métodos chamadas mangling, que usando _nome(um underline antes do nome) , __nome(dois underline) ou __nome_ (dois underline antes do nome e um depois do nome) para informar o nível de privacidade dos dados. Há métodos especiais chamados getters e setters que nos permitem acessar atributos e métodos únicos. Imaginemos uma classe humana que tem um atributo único chamado _altura. Você só pode modificar este atributo dentro de certas restrições (é quase impossível ser superior a 3 metros).

Polimorfismo

O polimorfismo nos permite modificar ligeiramente os métodos e atributos das subclasses, que são previamente definidas na superclasse. O significado literal é “muitas formas“. Isso porque construímos métodos com o mesmo nome, mas com funcionalidades diferentes. No exemplo abaixo, a def saque da class Conta irá se comportar de uma forma diferente da def saque da class ContaEspecial, ambas tem o mesmo nome porém com comportamentos distintos.


                
                        # Polimorfismo

                        """
                        Declarando a Classe Conta
                        """
                        class Conta:

                            """
                            O parâmetro saldo é predefinido como zero
                            """
                            def __init__(self, cliente, numero, saldo = 0): 
                                self.saldo = saldo
                                self.cliente = cliente
                                self.numero = numero
                        
                            def resumo(self):
                                print("Titular: ", self.cliente.nome)
                                print("C/C: Número = {} Saldo: R$ {:.2f}"  .format(self.numero, self.saldo))
                        
                            def saque(self, valor):
                                if self.saldo >= valor:
                                    self.saldo -= valor
                                else:
                                    print("Saldo insuficiente, solicite Cheque Especial.")
                        
                            def credito(self, valor):
                                self.saldo += valor
                                

                        """
                        Declarando a Classe Cliente
                        """
                        class Cliente:

                            def __init__(self, nome, telefone):
                                self.nome = nome
                                self.telefone = telefone
                        
                            def imprime_perfil(self):
                                print(self.nome, "(", self.telefone, ")")

                        """
                        Importando Classe Conta e Classe Cliente 
                        """

                        from conta import Conta
                        from cliente import Cliente
                        
                        # Criando Conta Especial Polimorfa de Conta

                        """
                        Declarando a Classe ContaEspecial
                        """
                        class ContaEspecial(Conta):
                            """
                            Herdando da classe Conta
                            """
                            def __init__(self, cliente, numero, saldo = 0, limite = 0):
                                """
                                Chamando o construtor da superclasse na subclasse
                                """
                                Conta.__init__(self, cliente, numero, saldo)
                                """
                                Incluindo o parâmetro limite (Herança)
                                """
                                self.limite = limite
                            """
                            O saque vai se comportar de forma diferente (Polimorfismo)
                            """
                            def saque(self, valor):
                                if (self.saldo + self.limite >= valor):
                                    self.saldo -= valor
                                else:
                                    print("Valor acima do Cheque Especial disponível")
                        
                            def resumo(self):
                                Conta.resumo(self)
                                print("Limite do Cheque Especial: ", self.limite)
                        
                        # Programa Principal (Teste)
                        
                        francisco = Cliente("francisco", "83-342345")
                        josefa = Cliente("josefa", "83-3423455")
                        c1 = Conta(francisco, 1, 1000)
                        c2 = ContaEspecial(josefa, 2, 1000, 200)
                        print("\n Conta 1")
                        c1.resumo()
                        print("Solicitando saque de 1100 reais. Loading...")
                        c1.saque(1100)
                        c1.resumo()
                        print("\n Conta 2")
                        c2.resumo()
                        print("Solicitando saque de 1100 reais. Loading...")
                        c2.saque(1500)
                        c2.resumo()

Classes Abstratas

significa a habilidade de definir e usar estruturas ou operações complicadas de forma a permitir que muitos dos detalhes sejam ignorados. Uma abstração é uma visão ou representação de uma entidade que inclui apenas os atributos mais significativos.

De um modo geral, a abstração permite que alguém colete exemplares de entidades em grupos nos quais seus atributos comuns não precisam ser considerados. Por exemplo, suponha que definíssemos aves como criaturas com os seguintes atributos: duas asas, duas pernas, um rabo e penas. Então, se dissermos que um corvo é uma ave, uma descrição de um corvo não precisa incluir esses atributos.

O mesmo ocorre para os calopsitas, pardais e águias. Esses atributos comuns nas descrições de espécies específicas de pássaros podem ser abstraídos. Dentro de uma espécie em particular, apenas os atributos que a distinguem precisam ser considerados, resultando em uma simplificação significativa das descrições.

Uma visão menos abstrata de uma espécie, aquela de um pássaro, pode ser considerada quando for necessário ver um alto nível de detalhes. No mundo das linguagens de programação, a abstração é uma arma contra a complexidade da programação; seu propósito é simplificar o processo de programação. É uma arma efetiva, pois permite que os programadores foquem em atributos essenciais, enquanto ignoram os subordinados. A linguagem de programação que suporta abstração é muito importante para a facilidade da escrita.

Por padrão, o Python não possui implementação para classes abstratas. Para isso, utilizamos a biblioteca ABC (Abstract Base Class). Com ela, conseguimos implementar métodos e classes abstratas em nossos programas. Para importá-la, utilizamos o seguinte código no início do nosso arquivo: from abc import ABC, abstractmethod.

Interfaces

Uma das metas do projeto orientado a objeto é facilitar a manutenção do programa. para que você possa mantê-lo funcionando quando outras partes do sistema forem alteradas, e também poder alterar o programa para satisfazer novas condições. Pode acontecer que, depois de implementar uma nova classe, você descubra uma implementação melhor. Se outras partes do programa estiverem usando a sua classe, mudar a interface pode ser trabalhoso e induzir a erros. No entanto, se projetou a interface cuidadosamente, pode alterar a implementação sem mudar a interface, e não será preciso mudar outras partes do programa.