Categoria: Todos os artigos

A programação orientada a objetos (POO) é um dos paradigmas mais conhecidos e utilizados na construção de sistemas computacionais. Baseada na ideia de aproximar o mundo real com o mundo da computação, a orientação a objetos nos permite estruturar o código de forma organizada e reutilizável, algo essencial para a construção de softwares robustos e escaláveis.

Neste texto, vamos explorar os fundamentos da orientação a objetos, seus conceitos-chave, e como aplicá-los na prática por meio de exemplos em Java, uma das linguagens mais populares nesse contexto. 

1 – Entendendo o conceito de programação orientada a objetos 

A programação orientada a objetos (OOP – Object-oriented programming) é um paradigma baseado no conceito de representar aquilo que existe no mundo real em sistemas computacionais através de classes e objetos.  

Esse paradigma serve como um modelo de análise, projeto e desenvolvimento de sistemas que procura aproximar o mundo real ao mundo da programação de computadores, tornando mais fácil o entendimento e solução de problemas complexos. 

Para entender esse paradigma pense, por exemplo, em um sistema bancário: nesse sistema temos uma classe principal chamada Conta Bancária. A partir desta classe, serão criados todos os tipos de contas bancárias disponibilizadas pelo banco. Note no exemplo abaixo que temos três tipos de contas: corrente, digital e salário. Estas contas e todas as demais que o banco vier a oferecer serão objetos da classe principal Conta Bancária. 

Essa relação entre classe e objeto é a base do paradigma da programação orientada a objetos. Uma classe pode ser entendida como um modelo, enquanto os objetos, são tudo aquilo que construímos com base nesse modelo (classe). Quando um objeto é construído ocorre o que chamamos de instância de classe.  

Dessa forma, quando usamos os princípios da orientação a objetos para desenvolver um sistema, transformamos cada um dos requisitos em classes e objetos. E para cada uma dessas classes e objetos definimos atributos e métodos próprios que serão utilizados para processar os dados recebidos e retornar as saídas do sistema. 

1.1 – O que são atributos e métodos? 

Atributo e métodos são dois conceitos fundamentais na programação orientada a objetos e podemos entendê-los da seguinte forma: os atributos são as características de cada classe e objeto, enquanto os métodos são as ações e comportamentos dessas classes e objetos. Atributos e métodos são definidos nas classes e compartilhados pelos objetos instanciados através delas.  

Pensando na classe conta bancária, alguns exemplos de atributos podem ser: número da conta, titular da conta, saldo. Enquanto, exemplos de métodos podem ser: depositar, sacar, consultar saldo, transferir.

Analisando a imagem acima, percebemos que os atributos e métodos são inseridos na classe Conta Bancária. Dessa forma, cada conta bancária criada, independe do seu tipo, será um objeto instanciado da classe principal Conta Bancária e herdará todos os atributos e métodos disponíveis nela. E isto gera uma das principais vantagens da orientação a objetos: a reutilização de códigos. 

Observe em nosso exemplo que, todas as contas criadas, independente do seu tipo, herdam da classe principal todas as características e comportamentos comuns. Assim, não é necessário, por exemplo, reescrever o código responsável por consultar saldo para cada tipo de conta existente, pois, todas as contas herdam esse método da classe principal. 

2 – Exemplo prático de programação orientada a objetos 

Para fins didáticos e um melhor entendimento desses conceitos, vamos ver um exemplo simples de Java para representar a classe conta bancária.  

Se você quiser executar esse projeto na sua máquina, precisará ter o Java 17 instalado e uma IDE compatível com a linguagem como o IntelliJ ou Visual Studio Code, por exemplo.  

O primeiro arquivo de todo projeto Java é o Main.java, responsável por executar a aplicação, vamos criá-lo:

@SpringBootApplication 
public class BancoApplication { 
public static void main(String[] args) { 
ApplicationContext context = SpringApplication.run(BancoApplication.class, args); 
        BancoService bancoService = context.getBean(BancoService.class); 
        bancoService.ExecutaContas(); 
} 
} 

No arquivo Main.java nós estamos chamando a função ExecutaContas() da classe BancoService. Vamos criar um arquivo chamado BancoService.java: 

@Service 
public class BancoService { 
        public void ExecutaContas () { 
               ContaCorrente conta1 = new ContaCorrente(1, "João", 700.0, 200.00 ); 
               ContaDigital conta2 = new ContaDigital(2, "Maria", 500.0); 
               ContaSalario conta3 = new ContaSalario(3, "José", 1000.0); 

                conta1.consultarSaldo(); 
                conta2.consultarSaldo(); 
                conta3.consultarSaldo(); 
                conta1.depositar(200.0); 
                conta1.transferir(conta2,700.00); 
                conta2.sacar(500.00); 
                conta3.transferir(conta1,200.00); 
                conta1.consultarSaldo(); 
                conta2.consultarSaldo(); 
                conta3.consultarSaldo(); 
        }       
} 

Note que o arquivo BancoService.java instância três objetos e executa uma série de ações que simulam as transações realizadas em um sistema bancário. 
 
Agora vamos criar as classes que representam os tipos de contas que instanciamos em BancoService: 

ContaCorrente.java

 public class ContaCorrente extends ContaBancaria { 
    private double chequeEspecial; 

    public ContaCorrente(int numeroConta, String titularConta, double saldoInicial, double chequeEspecial) { 
        super(numeroConta, titularConta, saldoInicial, TipoConta.CORRENTE); 
this.chequeEspecial = chequeEspecial; 
    } 

    public double getChequeEspecial() { 
        return chequeEspecial; 
    } 

    @Override 
    public void consultarSaldo() { 
        double saldoTotal = getSaldo() + chequeEspecial; 
        System.out.println( "Conta: " + getNumeroConta() + " / " + "Titular: " + getTitularConta() + " / " + "Saldo atual: R$" + getSaldo() + " / Cheque Especial: R$" + chequeEspecial +  " / Saldo Total: R$" + saldoTotal); 
    } 
} 

ContaDigital.java 

public class ContaDigital extends ContaBancaria { 
    public ContaDigital(int numeroConta, String titularConta, double saldoInicial) { 
        super(numeroConta, titularConta, saldoInicial, TipoConta.DIGITAL); 
    } 
} 

ContaSalario.java 

public class ContaSalario extends ContaBancaria { 
    public ContaSalario(int numeroConta, String titularConta, double saldoInicial) { 
        super(numeroConta, titularConta, saldoInicial, TipoConta.SALARIO); 
    } 
} 

Veja que as classes Conta Corrente, Conta Digital e Conta Salário possuem a palavra-chave extends, indicando que elas herdam atributos e métodos da classe Conta Bancária. 

Vamos agora criar o arquivo ContaBancaria.java  que possui a classe principal Conta Bancária: 

public class ContaBancaria { 
    // Atributos da classe 
    private int numeroConta; 
    private String titularConta; 
    private double saldo; 

    // Construtor da classe 
    public ContaBancaria(int numeroConta, String titularConta, 
                         double saldoInicial, TipoConta tipoConta) { 
        this.numeroConta = numeroConta; 
        this.titularConta = titularConta; 
        this.saldo = saldoInicial; 
    } 

    // Métodos da classe 
    public void depositar(double valor) { 
        saldo += valor; 
        System.out.println("Conta "+numeroConta+" - Depósito de R$" + valor + " realizado com sucesso!"); 
    } 

    public void sacar(double valor) { 
        if (valor <= saldo) { 
            saldo -= valor; 
            System.out.println("Conta "+numeroConta+" - Saque de R$" + valor + " realizado com sucesso!"); 
        } else { 
            System.out.println("Saldo insuficiente para saque de R$" + valor); 
        } 
    } 

    public void consultarSaldo() { 
        System.out.println( 
                "Conta: "+numeroConta+" / "+"Titular: "+titularConta+" / "+"Saldo atual: R$" + saldo);  } 
    public void transferir(ContaBancaria destino, double valor) { 
        if (valor <= saldo) { 
            saldo -= valor; 
            destino.saldo += valor; 
            System.out.println("Conta "+numeroConta+" - Transferência de R$" + valor + " realizada para a conta " + destino.numeroConta); 
} else { 
            System.out.println("Saldo insuficiente para transferência de R$" + valor); 
        } 
    }

    public double getSaldo() { 
        return saldo; 
    } 

    public int getNumeroConta() { 
        return numeroConta; 
    } 

    public String getTitularConta() { 
        return titularConta; 
    } 
} 

Observe que a classe ContaBancaria possui três atributos (numeroConta, titularConta e saldo) e quatro métodos (depositar, sacar, consultarSaldo e transferir). Essa é a classe modelo de onde conta corrente, conta digital e conta salário irão herdar atributos e métodos.  

Para finalizar, vamos criar um arquivo chamado TipoConta.java que será um Enum de tipos de contas: 

public enum TipoConta { 
    CORRENTE, 
    SALARIO, 
    DIGITAL 
} 

Após finalizar a criação dos arquivos e códigos do projeto vamos executá-lo. Teremos esse resultado no console da IDE: 

 
Conta: 1 / Titular: João / Saldo atual: R$700.0 / Cheque Especial: R$200.0 / Saldo Total: R$900.0 
Conta: 2 / Titular: Maria / Saldo atual: R$500.0 
Conta: 3 / Titular: José / Saldo atual: R$1000.0 
Conta 1 - Depósito de R$200.0 realizado com sucesso! 
Conta 1 - Transferência de R$700.0 realizada para a conta 2 
Conta 2 - Saque de R$500.0 realizado com sucesso! 
Conta 3 - Transferência de R$200.0 realizada para a conta 1 
Conta: 1 / Titular: João / Saldo atual: R$400.0 / Cheque Especial: R$200.0 / Saldo Total: R$600.0 
Conta: 2 / Titular: Maria / Saldo atual: R$700.0 
Conta: 3 / Titular: José / Saldo atual: R$800.0 

Esses prints mostram os resultados das ações executadas na função ExecutaContas() da classe BancoService. Essas ações são realizadas pelos objetos de ContaCorrente, ContaDigital e ContaSalario, instanciados de ContaBancaria. Apesar de ser um simples exemplo, observe que através dele conseguimos visualizar claramente os conceitos fundamentais da programação orientada a objetos e entender melhor esse paradigma amplamente usado no desenvolvimento de software.

3 – Usando programação orientada no dia a dia 

A programação orientada a objetos está presente em praticamente todos os sistemas e aplicativos que utilizamos diariamente. Amplamente usada em serviços back-end, mas não restrita somente a isso, a orientação a objetos está presente em redes sociais, streaming de vídeos, jogos, ERPs e muitas outras aplicações que fazem parte de nosso cotidiano. 

Aprender e entender os conceitos de orientação a objetos é fundamental para desenvolver sistemas funcionais e eficientes, que atendam aos objetivos e requisitos definidos nos projetos que trabalhamos.  

A orientação a objetos também é suportada por muitas linguagens e tecnologias. No exemplo acima, usamos Java que, certamente, é a linguagem orientada a objetos mais conhecida no mercado. Entretanto, outras linguagens como C++, C#, Python, PHP e Kotlin e vários frameworks de desenvolvimento como Laravel, Djano, .NET e Flutter, aceitam os conceitos de POO. A escolha de qual linguagem e tecnologia usar dependerá, diretamente, das preferências do desenvolvedor e dos requisitos do projeto, dispondo de um amplo leque de opções para atender a todos os públicos. 

Mas, é válido lembra que, a programação orientada a objetos vai além dos conceitos de classes, objetos, atributos e métodos, apresentados acima. Outros quatro conceitos se destacam na programação orientada a objetos, são eles: abstração, encapsulamento, herança e polimorfismo. Esses conceitos são conhecidos como pilares da programação orientada a objetos e se você quiser saber mais sobre esse assunto, clique aqui, para ler um artigo que escrevi sobre este assunto.   

Conclusão 

A programação orientada a objetos é uma poderosa ferramenta para desenvolver sistemas funcionais, robustos e escaláveis. Sua estrutura baseada em classes, objetos, atributos e métodos permite organizar o código de forma clara, coesa e reutilizável, agilizando o desenvolvimento de sistemas.  

Ao compreendermos e aplicarmos esses conceitos, estamos melhor preparados para criar soluções tecnológicas que as expectativas de nossos clientes e usuários. 

Espero que este artigo seja útil de alguma forma para você. Em caso de dúvidas, sugestões ou reclamações, fique à vontade para entrar em contato. 

E se você quiser aprender mais sobre programação, acesse aqui a seção que tenho dedicada ao assunto. 

Ao trabalhar com desenvolvimento de software, diferentes paradigmas de programação oferecem abordagens distintas para a solução de problemas computacionais. Entre eles, destaca-se a programação funcional, uma metodologia que tem ganhado cada vez mais relevância devido à sua capacidade de produzir código mais previsível, testável e manutenível.  

Neste artigo iremos explorar os fundamentos da programação funcional e suas principais características.  Também veremos exemplos simples e práticos de códigos que nos ajudarão a entender melhor como esse paradigma pode ser aplicado no dia a dia dos programadores. 

1 – Entendendo o conceito de programação funcional 

A programação funcional (FP – Functional Programming) é um paradigma baseado no conceito de expressões e funções matemáticas. Ao aplicar a programação funcional em um projeto, os problemas serão decompostos em partes menores, as quais serão atribuídas para funções.  

As funções recebem valores de entrada, aplicam uma lógica de processamento e retornam novos valores como saída. Assim, um sistema é fracionado em um conjunto de funções, cujo somatório destas funções compõem um sistema maior.  

A programação funcional possui algumas características próprias. Abaixo vamos conhecer essas características e ver alguns exemplos de código escrito em JavaScript para facilitar o entendimento.  

2 – As características da programação funcional 

– Funções puras: são funções que retornam sempre o mesmo valor quando passados os mesmos parâmetros.  

// Funções Puras+
const multiplicarPor2 = (numero) => numero * 2;

console.log(multiplicarPor2(3)); // Saída: 6  
console.log(multiplicarPor2(4)); // Saída: 8  
console.log(multiplicarPor2(3)); // Saída: 6  
console.log(multiplicarPor2(4)); // Saída: 8 

No exemplo acima, a função multiplicarPor2(), recebe um valor e multiplica-o por 2. Observe nas saídas que, sempre que uma função pura recebe o mesmo valor de entrada irá retornar o mesmo valor de saída.  

– Funções de ordem superior: trata-se de uma função capaz de receber outras funções como argumento ou retornar  outras funções como resultado.  

// Funções de Ordem Superior  
const executarOperacao = (operacao, a, b) => operacao(a, b);  
const soma = (x, y) => x + y;  
const multiplicacao = (x, y) => x * y;

console.log(executarOperacao(soma, 5, 3)); // Saída: 8  
console.log(executarOperacao(multiplicacao, 5, 2)); // Saída: 10   

No exemplo acima, executarOperacao() assume o papel de uma função de ordem superior, enquanto soma() e multiplicação(), são funções de cálculos aritméticos que podem ser passadas como argumento para a função superior executarOperacao().  

– Composição de funções: é a capacidade de criar uma função a partir da junção de outras funções.  

//Composição de funções  
const somar = (a, b) => a + b;  
const dobrar = (x) => x * 2;  
const composta = () => dobrar(somar(5, 10));  

console.log(composta()); // Saída: 30   

No exemplo acima, temos três funções distintas: somar(), responsável por realizar um cálculo de adição entre dois valores, dobrar() que recebe um valor e multiplica-o por 2, e composta(), a qual assume o papel de uma função composta de somar() e dobrar().   

– Imutabilidade: os valores após serem atribuídos para as variáveis não sofrem mudanças, mantendo-se fixos durante toda a execução do código.  Ao trabalhar com dados imutáveis, novos valores são criados, ao invés de ocorrerem modificações nos valores existentes. Dessa forma, a imutabilidade torna o código mais previsível e estável, evitando efeitos colaterais inesperados no processamento. 

Para um melhor entendimento desse conceito, imagine que temos um array de números e queremos adicionar um novo número a ele.  Vamos visualizar dois exemplos: um utilizando uma função mutável e outro uma função imutável.  

A abordagem mutável seria assim: 

//Mutabilidade 
const listaNumeros = [1, 2, 3];
listaNumeros.push(4); // Modifica o array original 

console.log(listaNumeros); // Saída: [1, 2, 3, 4] 

Observe que, em uma abordagem mutável, a constante original listaNumeros, foi modificada durante a execução através da função push(). 

Agora vamos observar como seria na abordagem imutável: 

//Imutabilidade  
const listaNumeros = [1, 2, 3];
const adicionarNumero = (lista) => [...lista, 4];  

// Acrescenta um valor sem modificar o array original  
const numerosAtualizados = adicionarNumero(listaNumeros);  

console.log(listaNumeros); // Saída: [1, 2, 3]   
console.log(numerosAtualizados); // Saída: [1, 2, 3, 4]

Observe no exemplo acima que, a função adicionarNumero() recebe um array  de valores numéricos chamado listaNumeros e acrescenta o número 4. O resultado dessa operação é atribuído para a constante numerosAtualizados.  

A imutabilidade dos dados pode ser observada nas saídas do código, pois, apesar da constante listaNumeros ser utilizada mais de uma vez, ela não teve seus valores alterados. Foi gerada uma nova constante chamada numerosAtualizados para gravar os dados da operação realizada com a constante listaNumeros.     

– Recursividade: na programação funcional, loops de repetição não são usados. No lugar dos loops é adotada a recursividade, que é a característica de uma função chamar a si mesma até que uma condição (chamada de caso base) seja atingida.  

//Recursividade  
const calcularFatorial = (n) => {  
if (n === 0) {  
   return 1; 
} else {  
   return n * calcularFatorial(n - 1);  
}};  
const numero = 5;  
const fatorial = calcularFatorial(numero); 
 
console.log(`O fatorial de ${numero} é: ${fatorial}`);  
//Saída: O fatorial de 5 é: 120   

No exemplo acima, calcularFatorial() é uma função recursiva que calcula o fatorial do valor informado em numero.   

3 – Usando paradigma funcional no dia a dia 

O paradigma funcional é suportado por diversas linguagens de programação. Entre as linguagens puramente funcionais destacam-se o Haskell e a família ML (Standard ML, OCaml e suas variantes). 

Nos exemplos acima, usamos JavaScript, uma linguagem multiparadigma, amplamente conhecida no mercado e compatível com os princípios da programação funcional. Mas além dela, existem outras opções disponíveis como C++, PHP, Python, TypeScript e Kotlin. Todas estas linguagens são multiparadigma e suportam a implementação de códigos seguindo o paradigma funcional. 

Na prática, a programação funcional encontra grande aplicação na Ciência de Dados, especialmente no processamento e análise de grandes volumes de dados. Isto se deve à natureza concisa e declarativa do código funcional, bem como à presença de funções de ordem superior como map, filter e reduce, que simplificam significativamente o tratamento de dados. 

Além disso, este paradigma mostra-se particularmente eficaz no desenvolvimento de algoritmos de busca e ordenação, assim como no processamento de eventos e sistemas reativos. 

Conclusão 

A programação funcional oferece uma abordagem poderosa e eficiente para o desenvolvimento de software, especialmente em aplicações que demandam alta confiabilidade e facilidade de manutenção. Ao adotar funções puras, imutabilidade, recursividade e outras características, este paradigma permite construir sistemas mais previsíveis e menos propensos a erros.  

O suporte a esse estilo de programação em diversas linguagens multiparadigma, usadas por desenvolvedores no dia a dia como JavaScript, Python e Kotlin, amplia ainda mais sua aplicabilidade em diversos contextos.  

Assim, a programação funcional não é apenas mais um recurso técnico, mas é um meio de transformar a maneira como abordamos problemas, tornando o código mais limpo, robusto e eficiente. 

Espero que este artigo seja útil de alguma forma para você. Em caso de dúvidas, sugestões ou reclamações, fique à vontade para entrar em contato. 

E se você quiser aprender mais sobre programação, acesse aqui a seção que tenho dedicada ao assunto.