Programação OO e Java

Prof. Fernando Anselmo

Objetos e Classes em Java

Uma classe é um modelo ou esboço para criar objetos. Define um conjunto de atributos e métodos
que os objetos criados a partir dela terão. Em Java, uma classe é declarada usando a palavra-chave
class. Por exemplo:
1 public class Carro {
2 // Atributos
3 private String marca;
4 private String modelo;
5 private int ano;
6
7 // Métodos
8 public void atribuirMarca(String valor) {
9 marca = valor;
10 }
11
12 public void atribuirModelo(String valor) {
13 modelo = valor;
14 }
15
16 public void atribuirAno(int valor) {
17 ano = valor;
18 }
19
20 public void ligar() {
21 System.out.println("O carro está ligado.");
22 }
23
24 public void desligar() {
25 System.out.println("O carro está desligado.");
26 }
27 }

Neste exemplo, a classe Carro possui três atributos (marca, modelo, ano) e dois métodos (ligar e
desligar).

Um atributo de classe, em programação tradicional é conhecido como variável, no caso da pro-

gramação OO é uma variável que é associada à classe como um todo. Os atributos representam
caracterı́sticas ou propriedades do objeto que a classe está modelando. Por exemplo, se tivermos
uma classe Carro, seus atributos podem incluir marca, modelo, ano, cor, entre outros.

Declarar os atributos como private (restrito ao uso da classe) é uma prática comum e faz parte do
conceito de encapsulamento (que veremos mais tarde). O encapsulamento é uma das caracterı́sticas
fundamentais da programação orientada a objetos e envolve a ocultação dos detalhes internos de
uma classe, protegendo seus atributos e fornecendo um acesso controlado a eles.

Já os métodos são blocos de código associados a uma classe ou a um objeto especı́fico dessa classe.
Representam as ações ou operações que um objeto pode realizar. Métodos são usados para realizar
tarefas especı́ficas e podem receber parâmetros, processá-los e retornar um resultado.

Em 14 de fevereiro de 2024 Folha 1 de 4

 Programação OO e Java

No contexto de uma classe, os métodos são frequentemente usados para interagir com os atributos da
classe, manipular dados e realizar operações especı́ficas relacionadas ao comportamento do objeto.

A visibilidade dos métodos é controlada por modificadores de acesso, que são: public (acesso geral),
private (restrito ao uso da classe), protected (restrito a famı́lia da classe) e default (quando nenhum
modificador é especificado, sendo mais restritivo que o protected ). A escolha de declarar métodos
como public está relacionada ao princı́pio do encapsulamento, com ganhos na modularidade e
reusabilidade do código.

Um objeto é uma instância de uma classe. Ou seja, é uma representação concreta da classe, com
seus próprios valores para os atributos. Para criar um objeto em Java, você usa a palavra-chave
new. Aqui está como você pode criar um objeto da classe Carro:
1 public class ExemploCarro {
2 public static void main(String[] args) {
3 // Criar um objeto da classe Carro
4 Carro meuCarro = new Carro();
5
6 // Atribuir valores aos atributos
7 meuCarro.atribuirMarca("Toyota");
8 meuCarro.atribuirModelo("Corolla");
9 meuCarro.atribuirAno(2022);
10
11 // Chamando métodos
12 meuCarro.ligar();
13 meuCarro.desligar();
14 }
15 }

O método main é a entrada principal para a execução de um programa Java, implementar o código
dessa maneira possui enormes desvantagens que podem impactar a manutenção e organização do
código em projetos mais extensos:

• Falta de Encapsulamento: O método é declarado como public static, o que significa que
pode ser acessado de qualquer lugar. Isso pode levar a problemas de encapsulamento, uma
vez que o método principal frequentemente manipula diretamente os membros estáticos da
classe ou cria instâncias de objetos sem encapsulamento adequado.
• Fragilidade da Interface: Quando o método main está presente na classe principal, qualquer
mudança na assinatura desse método (por exemplo, mudanças nos argumentos ou no retorno)
pode resultar em erros de compilação. Isso pode ser uma desvantagem, especialmente quando
se trabalha com frameworks ou ambientes que exigem uma assinatura especı́fica do método
main.
• Dificuldade na Reutilização do Código: Colocar a lógica principal diretamente neste
método pode dificultar a reutilização do código em outras partes do programa. É preferı́vel
encapsular a lógica em métodos mais pequenos e especı́ficos, promovendo a reusabilidade.
• Dificuldade de Testabilidade: O método muitas vezes contém lógica crucial para a execução
do programa. Se essa lógica não estiver modularizada e for diretamente integrada ao método
main, pode ser desafiador testar unidades especı́ficas de código isoladamente.
• Dificuldade na Manutenção: Em programas grandes, o método main pode se tornar
extenso e difı́cil de manter. Colocar toda a lógica principal neste método pode resultar em um
código menos organizado e mais difı́cil de entender.
• Limitações na Extensibilidade: Projetos maiores podem se beneficiar de uma arquitetura

Em 14 de fevereiro de 2024 Folha 2 de 4

 Programação OO e Java

mais modular e orientada a objetos. A dependência direta de uma lógica extensa no método
main pode limitar a extensibilidade do código.

Para superar essas desvantagens, é uma prática comum encapsular a lógica principal em métodos
separados, criar classes especı́ficas para diferentes responsabilidades e seguir princı́pios de design de
software, como princı́pios SOLID, para criar um código mais coeso, modular e fácil de manter.

S.O.L.I.D.
Os princı́pios SOLID são um conjunto de cinco princı́pios de design de software que foram introduzidos
por Robert C. Martin e são amplamente aceitos como boas práticas na programação orientada a
objetos. Eles são fundamentais para criar código modular, flexı́vel e fácil de entender. Aqui estão os
cinco princı́pios SOLID:

• Princı́pio da Responsabilidade Única (Single Responsibility Principle - SRP): Uma

classe deve ter apenas uma razão para mudar, ou seja, ela deve ter apenas uma responsabilidade.
Cada classe deve se concentrar em fazer uma coisa e fazê-la bem. Isso facilita a manutenção,
reduz a complexidade e aumenta a coesão.
• Princı́pio do Aberto/Fechado (Open/Closed Principle - OCP): Este princı́pio pre-
coniza que uma classe deve estar aberta para extensão, mas fechada para modificação. Isso
significa que novos comportamentos podem ser adicionados sem alterar o código existente. A
extensibilidade é alcançada através de herança, interfaces e polimorfismo.
• Princı́pio de Substituição de Liskov (Liskov Substitution Principle - LSP): Os
objetos de uma superclasse devem ser substituı́veis por objetos de suas subclasses sem afetar
a integridade do programa. Isso significa que as subclasses devem ser capazes de serem usadas
no lugar de suas superclasses sem causar problemas.
• Princı́pio da Segregação de Interface (Interface Segregation Principle - ISP):
Uma classe não deve ser forçada a implementar interfaces que ela não usa. Em vez de ter
interfaces grandes e genéricas, é preferı́vel ter interfaces pequenas e especı́ficas, evitando assim
a implementação desnecessária de métodos.
• Princı́pio da Inversão de Dependência (Dependency Inversion Principle - DIP):
Propõe que as dependências devem ser invertidas, de modo que módulos de alto nı́vel não
dependam de módulos de baixo nı́vel, mas ambos dependam de abstrações. Além disso,
abstrações não devem depender de detalhes, mas sim detalhes devem depender de abstrações.
Isso é frequentemente alcançado por meio do uso de interfaces e inversão de controle (IoC).

Adotar esses princı́pios SOLID ajuda a criar sistemas mais flexı́veis, fáceis de entender, extensı́veis
e sustentáveis ao longo do tempo. Eles promovem a criação de código mais robusto e facilitam a
adaptação a mudanças nos requisitos do software.

S.O.L.I.D. em Java
Deste modo vamos reprogramar nossa classe ExemploCarro seguindo SOLID:
1 public class ExemploCarro {
2
3 // Criar um objeto da classe Carro
4 private Carro meuCarro = new Carro();
5
6 public static void main(String[] args) {
7 ExemploCarro exemploCarro = new ExemploCarro();

Em 14 de fevereiro de 2024 Folha 3 de 4

 Programação OO e Java

8 exemploCarro.testarObjeto();
9 }
10

11 public void testarObjeto() {

12 atribuirValores();
13 chamarMetodos();
14 }
15
16 private void atribuirValores() {
17 meuCarro.atribuirMarca("Toyota");
18 meuCarro.atribuirModelo("Corolla");
19 meuCarro.atribuirAno(2022);
20 }
21
22 private void chamarMetodos() {
23 meuCarro.ligar();
24 meuCarro.desligar();
25 }
26 }

Notamos que a classe ficou bem maior, porém mais fácil de entender ou proporcionar uma manutenção
na mesma, observamos também que o método main poderia ser retirado sem causar qualquer prejuı́zo
na lógica de programação desta.

Sobre o Autor
Especialista com forte experiência em Linguagens de Programação, Banco de Dados SQL e NoSQL.
Escolhido como Java Champion desde Dezembro/2006 e Coordenador do DFJUG. Experiência
em diversos frameworks de mercado e na interpretação das tecnologias para sistemas e aplicativos.
Realiza programação de acordo com as especificações, normas, padrões e prazos estabelecidos.
Disposição para oferecer apoio e suporte técnico e apoio a outros profissionais, autor de 17 livros,
diversos artigos em revistas especializadas e palestrante em seminários sobre tecnologia. Atualmente
ocupa o cargo de Analista de Sistemas na CNI.

Em 14 de fevereiro de 2024 Folha 4 de 4