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.
Referências:
https://blog.betrybe.com/tecnologia/poo-programacao-orientada-a-objetos/
https://imasters.com.br/carreira-dev/a-linguagem-de-programacao-orientada-a-objetos-e-seus-beneficios
https://www.alura.com.br/artigos/poo-programacao-orientada-a-objetos
https://www.devmedia.com.br/programacao-orientada-a-objetos-e-programacao-estruturada/32813