DEV Community: felipe bs

Programação Orientada a Objetos - Java

felipe bs — Fri, 25 Oct 2024 02:26:49 +0000

A essência da POO está em criar modelos/templates de objetos do mundo real dentro do software. Objetos podem ser coisas concretas, como um carro, ou mais abstratas, como uma transação bancária. Cada objeto tem estados e comportamentos. Os estados são as características que definem o objeto, enquanto os comportamentos são as ações que ele pode realizar.

Por exemplo, imagine a classe Carro. Um carro possui atributos que descrevem suas características, como:

cor (estado),
marca (estado),
modelo (estado),
quantidade de portas (estado).

Além disso, um carro também pode realizar ações, como:

ligar (comportamento),
andar (comportamento),
parar (comportamento).

Aqui, a classe Carro define o que cada carro (objeto) deve ter e o que ele pode fazer. Podemos criar quantos carros quisermos a partir dessa classe, cada um com seus próprios atributos e comportamentos, mas sempre seguindo a "planta" definida pela classe.

Um exemplo de como seria criar isso no Java seria da seguinte forma:

public class Carro {

    String marca;
    String modelo;
    String cor;
    int quantidade_de_portas;

    // inicializamos a classe Carro sem nenhum valor inicial
    public Carro(Strin) {
    }
}

public static void main(String[] args) {
        Carro carro_exemplo = new Carro("Volkswagen ", "Gol", "prata", 4);
        Carro carro_exemplo2 = new Carro("Fiat", "Uno", "prata", 2);
}

Encapsulamento

O encapsulamento em Java é um dos pilares da Programação Orientada a Objetos (POO) e refere-se ao ato de restringir o acesso direto aos atributos de uma classe, tornando mais claro quais partes de um objeto podem ser acessadas ou modificadas diretamente. Com ele, podemos controlar o uso e a manipulação dos dados, garantindo maior segurança e integridade.

Em Java, o encapsulamento é implementado através de modificadores de acesso, como privatee public, e com o uso de métodos especiais, conhecidos como getters e setters, que permitem acessar ou modificar os atributos de uma classe de forma controlada.

No exemplo abaixo:

A classe ContaBancaria contém dois atributos: titular e saldo. Como ambos estão declarados com o modificador public, eles podem ser acessados e modificados diretamente de qualquer parte do sistema, sem qualquer controle ou validação. Isso pode ser perigoso, pois dados sensíveis podem ser alterados em momentos inadequados ou de forma incorreta.

Agora, com o uso de encapsulamento, podemos proteger esses dados:

public class ContaBancaria {
    private String titular;
    private double saldo;

    // Getter
    public String getTitular() {
        return titular;
    }

    public double getSaldo() {
        return saldo;
    }

    // Setter
    public void setTitular(String titular) {
        this.titular = titular;
    }

    public void setSaldo(double saldo) {
        this.saldo = saldo;
    }
}

Nesse exemplo, os atributos titular e saldo foram modificados para private, o que significa que não podem ser acessados diretamente de fora da classe ContaBancaria. Em vez disso, criamos métodos get e set para cada um desses atributos, que permitem o acesso controlado. Isso evita, por exemplo, que o saldo seja alterado diretamente por qualquer parte do sistema sem passar por regras de negócio ou validações.

É importante ressaltar que o getter é utilizado sempre que precisamos controlar como os dados são fornecidos a quem acessa um valor dessa classe de fora. Da mesma forma, o setter é criado para implementar mudanças de forma mais segura e restrita nos atributos, permitindo a aplicação de regras ou validações antes de alterar os valores.

Agora, para acessar ou modificar os atributos da ContaBancaria, o código deve chamar os métodos adequados:

ContaBancaria conta = new ContaBancaria();
conta.setTitular("Felipe");
conta.setSaldo(0.0);

System.out.println(conta.getTitular());

Com isso, garantimos que a única forma de alterar o titular ou o saldo é através dos métodos específicos, o que protege o sistema contra mudanças indesejadas ou erros, como:

conta.titular = "Bruno";

Herança

Herança é um dos pilares fundamentais da Programação Orientada a Objetos (POO). O conceito de herança permite que uma classe (chamada de subclasse) herde características e comportamentos de outra classe (chamada de superclasse). Com a herança, é possível reutilizar e especializar código existente, o que torna o desenvolvimento de sistemas mais eficiente e organizado.

Como a herança é útil?

Imagine que você tem uma classe chamada Cartao, que possui atributos e comportamentos comuns a diferentes tipos de cartões, como cartões de débito e crédito. Em vez de repetir esses atributos e comportamentos em cada tipo de cartão, você pode centralizá-los na classe Cartao e, em seguida, herdar essas características nas subclasses CartaoDebito e CartaoCredito.

Exemplo abaixo:

No diagrama acima, a classe Cartao possui três atributos comuns: codigo_cartao, numero_cartao e digito_cartao. Esses atributos são marcados como protected, o que significa que eles podem ser acessados e modificados diretamente pelas subclasses, mas não por outras classes externas.

Agora, temos duas subclasses:

CartaoDebito: herda os atributos da classe Cartao e adiciona comportamentos e atributos específicos, como data_pagamento_deposito e data_saque, além de métodos para sacar dinheiro e depositar dinheiro.
CartaoCredito: também herda os atributos de Cartao, mas adiciona características específicas, como se_pode_aproximacao e comportamentos para pagar com/sem aproximação e verificar o limite do cartão.

Nesse exemplo, as classes CartaoDebito e CartaoCredito herdam atributos e métodos da classe Cartao. Dessa forma, reutilizamos o código base da superclasse, o que simplifica a manutenção e o desenvolvimento. Além disso, cada subclasse pode implementar suas próprias versões de métodos ou adicionar novos comportamentos específicos, garantindo a flexibilidade e a especialização necessárias para cada tipo de cartão.

Exemplo abaixo:

public abstract class Cartao {
    protected String codigo_cartao;
    protected String numero_cartao;
    protected String digito_cartao;

    // Métodos comuns
    public abstract void sacarDinheiro(double valor);
    public abstract void depositarDinheiro(double valor);
}

// Subclasse Cartão de Débito
public class CartaoDebito extends Cartao {
    private String data_deposito;
    private String data_saque;

    @Override
    public void sacarDinheiro(double valor) {
        System.out.println("Sacando dinheiro do Cartão de Débito");
        // Lógica específica para o saque
        // Adicionar data de saque;
    }

    @Override
    public void depositarDinheiro(double valor) {
        System.out.println("Depositando dinheiro no Cartão de Débito");
        // Lógica específica para o depósito
        // Adicionar data de deposito;
    }
}

// Subclasse Cartão de Crédito
public class CartaoCredito extends Cartao {
    private String data_pagamento;
    private boolean se_pode_aproximacao;

    @Override
    public void sacarDinheiro(double valor) {
        System.out.println("Sacando dinheiro do Cartão de Crédito");
        // Lógica específica para o saque
    }

    @Override
    public void depositarDinheiro(double valor) {
        System.out.println("Depositando dinheiro no Cartão de Crédito");
        // Lógica específica para o depósito
    }

    public void pagar() {
        if (se_pode_aproximacao) {
            System.out.println("Pagamento com aproximação");
        } else {
            System.out.println("Pagamento sem aproximação");
        }
        // Adiciona data de pagamento;
    }

    public void verificarSeTemLimite() {
        // Lógica para verificar o limite do cartão
        System.out.println("Verificando limite do Cartão de Crédito");
    }
}

Nesse exemplo, as classes CartaoDebito e CartaoCredito herdam atributos e métodos da classe Cartao. Dessa forma, reutilizamos o código base da superclasse, o que simplifica a manutenção e o desenvolvimento. Além disso, cada subclasse pode implementar suas próprias versões de métodos ou adicionar novos comportamentos específicos, garantindo a flexibilidade e a especialização necessárias para cada tipo de cartão.

Polimorfismo

Agora que entendemos a herança, vamos falar algo que esta muito ligado a ele, o polimorfismo em termos simples significa “muitas formas” — ou seja, a capacidade de um objeto de assumir diferentes formas. No contexto da POO, o polimorfismo permite que uma mesma ação (como usar um procedimento) se comporte de maneiras diferentes, dependendo do objeto que a executa.

Isso é extremamente útil porque permite que tratemos diferentes objetos de forma uniforme, mas ainda permitindo que cada objeto tenha seu próprio comportamento específico.

No exemplo que vimos anteriormente, temos uma classe base chamada Cartao, que é estendida por duas classes: CartaoDebito e CartaoCredito. Cada uma dessas subclasses implementa comportamentos específicos para o tipo de cartão, como sacarDinheiro() e depositarDinheiro().

Agora, vamos ver como o polimorfismo pode ser utilizado para tratar diferentes tipos de cartões de maneira uniforme, mas permitindo que cada cartão aja de acordo com suas características.

public class Main {
    public static void processarSaque(Cartao cartao, double valor) {
        cartao.sacarDinheiro(valor);
    }

    public static void processarDeposito(Cartao cartao, double valor) {
        cartao.depositarDinheiro(valor);
    }

    public static void main(String[] args) {
        Cartao cartaoDebito = new CartaoDebito();
        Cartao cartaoCredito = new CartaoCredito();

        // Polimorfismo em ação: o método sacarDinheiro se comporta de maneira diferente para cada tipo de cartão
        processarSaque(cartaoDebito, 100);  // Comportamento específico do Cartão de Débito
        processarSaque(cartaoCredito, 200); // Comportamento específico do Cartão de Crédito

        processarDeposito(cartaoDebito, 500);  // Depósito no Cartão de Débito
        processarDeposito(cartaoCredito, 1000); // Depósito no Cartão de Crédito
    }
}

No código acima, temos dois métodos chamados processarSaque e processarDeposito. Esses métodos recebem um objeto do tipo Cartao como argumento, o que significa que eles podem aceitar qualquer subclasse de Cartao, como CartaoDebito ou CartaoCredito.

O comportamento polimórfico acontece quando chamamos o método sacarDinheiro() e depositarDinheiro() em diferentes tipos de cartões. Mesmo que os métodos sejam chamados da mesma forma, o comportamento muda com base no tipo de objeto (se é um CartaoDebito ou um CartaoCredito). Isso é o polimorfismo em ação — o método se comporta de forma diferente dependendo do objeto que o invoca.

O polimorfismo torna o código mais flexível e escalável. Veja que no exemplo, os métodos processarSaque e processarDeposito não precisaram ser alterados ou duplicados para lidar com diferentes tipos de cartão. Eles aceitam qualquer objeto que seja uma instância da classe Cartao, e o comportamento apropriado é decidido dinamicamente, com base no tipo específico do cartão.

Interface

A interface, por último, mas não menos importante, é um dos pilares da Programação Orientada a Objetos (POO) e é amplamente utilizada. Ela tem o efeito oposto da herança: enquanto a herança permite que uma classe filha herde características da classe pai, a interface obriga todas as classes que a implementam a fornecer suas próprias lógicas para os métodos definidos. Isso garante que cada classe atenda a um contrato específico, promovendo consistência e reutilização de código.

Exemplo abaixo:

Nesse exemplo, temos a interface chamada Notificacao, que possui um método chamado enviarMensagem(mensagem). Temos duas classes que a implementam: NotificacaoSMS e NotificacaoEmail. Embora a interface seja semelhante à herança, onde estendemos uma classe abstrata, ela se concentra em definir apenas métodos/comportamentos, evitando a criação de regras de negócio. Isso obriga todas as classes que a implementam a fornecer suas próprias implementações desses métodos, permitindo que cada uma crie suas regras de negócio específicas.

Exemplo abaixo:

public interface Notificacao {
    void enviarMensagem(String mensagem);
}

public class NotificacaoEmail implements Notificacao {

    // compormanento "forçado" pela interface
    @Override
    public void enviarMensagem(String mensagem) {
        System.out.println("E-mail: " + mensagem);
    }
}


public class NotificacaoSMS implements Notificacao {

    // compormanento "forçado" pela interface
    @Override
    public void enviarMensagem(String mensagem) {
        System.out.println("SMS: " + mensagem);
    }
}


public class Main {
    public static void main(String[] args) {
        Notificacao notificacaoEmail = new NotificacaoEmail();
        Notificacao notificacaoSMS = new NotificacaoSMS();

        notificacaoEmail.enviarMensagem("Olá, esta é uma notificação via e-mail!");
        notificacaoSMS.enviarMensagem("Olá, esta é uma notificação via SMS");
    }
}

Como observado no exemplo acima, ambas as classes precisam enviar notificações ao usuário. Podemos obrigar que todas implementem essa funcionalidade, evitando a duplicação de código e promovendo a reutilização de componentes já criados. Na parte do Main, conseguimos ver as duas classes enviando mensagens de acordo com seus métodos de envio específicos.

Conclusão

A Programação Orientada a Objetos é uma abordagem poderosa para organizar seu código de forma clara e eficiente. Com conceitos como encapsulamento, herança e polimorfismo, agora quando você ouvir falar que uma linguagem é desenvolvida em cima do POO ou tem suporte, já consegue imaginar quais tipos de recursos ela tem a oferece.

Links auxiliares

Explicação sobre Abstract
Explicação sobre Interface

PARADIGMAS

felipe bs — Thu, 17 Oct 2024 22:57:48 +0000

Todo estudante de programação, ao começar sua jornada, geralmente entra em contato com várias linguagens como Python, JavaScript, Java, entre outras. Um ponto importante que você provavelmente vai notar é que cada linguagem tem sua própria maneira de ser usada, ou seja, cada uma delas tem suas características e estrutura. Isso acaba influenciando a forma como você vai programar, mesmo antes de ver uma linha de código.

Primeiro ponto importante: todas as linguagens de programação são ferramentas. E como desenvolvedores, nossa responsabilidade é usar essas ferramentas para criar algo, para contar uma "história". Por exemplo, imagine que você queira construir um sistema de cadastro. Pensando como um usuário, você poderia descrever o que o sistema deveria fazer assim:

Pegar as informações básicas da pessoa que será cadastrada.
Verificar se essas informações estão corretas.
Salvar as informações do cadastro.
Mostrar todos os usuários cadastrados no sistema.

Agora, a questão principal é: como transformar essa descrição em código? Isso é o que chamamos de "paradigmas de programação", ou seja, o estilo ou o modelo de como programar. E dois paradigmas que são amplamente usados, mas não são os únicos, são o Paradigma Declarativo e o Paradigma Imperativo.

Por que esses dois paradigmas são importantes?
Porque eles formam a base para entender dois estilos muito comuns de programação: a Programação Orientada a Objetos (que herda do Paradigma Imperativo) e a Programação Funcional (que segue o Paradigma Declarativo).

Vamos entender o que cada um significa.

Programação Declarativa

A programação declarativa se concentra em o que você quer fazer, em vez de como fazer. Em outras palavras, você se preocupa mais com o resultado final do que com os passos necessários para chegar lá.

Exemplos de linguagens que seguem esse paradigma são: Haskell, Lisp, SQL e HTML. O que todas elas têm em comum? Elas focam em declarar o que você quer, e o sistema faz o resto. Vamos ver exemplos:

HTML:
<h1>Hello world</h1>

Aqui, você está dizendo que quer exibir um título "Hello world". Você não se preocupa com os detalhes de como o navegador vai renderizar o título, como o tamanho da fonte ou o estilo exato (isso poderia ser feito com CSS, que também é declarativo).

SQL:
SELECT * FROM Customers

Neste exemplo, você está dizendo que quer buscar todos os dados da tabela "Customers". O banco de dados sabe como fazer isso, e você não precisa dizer passo a passo como buscar ou ordenar esses dados (a menos que queira).

O ponto principal é que, com linguagens declarativas, o foco está no que você quer, e não nos detalhes de como chegar lá. Isso facilita seu trabalho, especialmente quando você precisa expressar uma ideia de forma simples.

Programação Imperativa

Por outro lado, a programação imperativa é o oposto: você precisa dizer como fazer. Aqui, você tem que detalhar o passo a passo que o programa deve seguir para atingir o resultado desejado.

Veja um exemplo em Java:

public class Main {
  public static void main(String[] args) {
    ArrayList<String> marca_carros = new ArrayList<String>();
    marca_carros.add("Volvo");
    marca_carros.add("BMW");
    marca_carros.add("Ford");
    marca_carros.add("KIA");

    for (String marca : marca_carros) {
      System.out.println(marca);
    }
  }
}

Neste exemplo, o código está dizendo exatamente como criar uma lista de carros, como adicionar marcas a essa lista, e como mostrar cada marca na tela. Ou seja, você precisa ser explícito sobre o que fazer e como fazer.

Outro exemplo é o JavaScript:

function adicionarCarros() {
  var marca_carros = [];
  marca_carros.push("Volvo");
  marca_carros.push("BMW");
  marca_carros.push("Ford");
  marca_carros.push("KIA");

  for (var marca of marca_carros) {
    console.log(marca);
  }
}

Aqui, o processo é muito parecido: você está detalhando como a lista de marcas deve ser criada, como os itens devem ser adicionados, e como eles serão mostrados.

Esses exemplos mostram a ideia básica do paradigma imperativo: você precisa controlar o como fazer em cada etapa do processo.

Como esses paradigmas se conectam?

Voltando ao exemplo do sistema de cadastro:

Você pode usar JavaScript (imperativo) para pegar as informações básicas do usuário.
Validar os dados usando uma linguagem como Java (também imperativo).
Salvar as informações no banco de dados com SQL (declarativo).
Exibir essas informações na tela usando HTML (também declarativo).

Ao entender como diferentes linguagens funcionam, você pode escolher a melhor ferramenta para cada parte do seu projeto, sem precisar ficar preso a um único estilo ou linguagem. Isso te ajuda a ser mais eficiente e flexível como desenvolvedor.

E, para finalizar, lembre-se de que um paradigma é apenas uma maneira de classificar como uma linguagem se comporta ou como ela organiza o código. Esse tema é bastante amplo, com diversos paradigmas e subparadigmas. Algumas linguagens, como JavaScript, podem adotar mais de um paradigma ao mesmo tempo — sendo funcionais, orientadas a objetos e até utilizando outros estilos. O mais importante é você entender quando usar cada paradigma para obter o melhor resultado no seu projeto. Com o tempo, você vai aprender a escolher a abordagem certa para resolver cada tipo de problema da melhor forma.