Programação Orientada a Objetos I

Notas de Aula – 11 de maio de 2023

Em Java, os atributos de classe são variáveis que são declaradas dentro de uma classe,
mas fora de qualquer método, e são compartilhadas por todos os objetos dessa classe.
Esses atributos são comuns a todas as instâncias da classe e podem ser acessados por
meio do nome da classe.
Para declarar um atributo de classe, utilizamos o modificador de acesso static antes
da definição do tipo da variável. Aqui está um exemplo de código que mostra como
declarar um atributo de classe e como usá-lo em um método:
- Exemplo
Suponha que temos duas classes, Pessoa e ContaBancaria. A classe Pessoa possui um
atributo de classe numPessoas que mantém o número total de instâncias da classe
Pessoa criadas. A classe ContaBancaria possui um atributo de instância titular do tipo
Pessoa que faz referência a uma instância da classe Pessoa. Para atribuir uma Pessoa à
ContaBancaria, precisamos primeiro criar uma instância da classe Pessoa.
Aqui está o código:
public class Pessoa {
static int numPessoas = 0;
private String nome;
private int idade;

public Pessoa(String nome, int idade) {

this.nome = nome;
this.idade = idade;
numPessoas++; // incrementa o número total de pessoas toda vez que um novo
objeto Pessoa é criado
}
//getters e setters
}

public class ContaBancaria {

private int numero;
private Pessoa titular;

public ContaBancaria(int numero, Pessoa titular) {

this.numero = numero;
this.titular = titular;
}

public static void main(String[] args) {

Pessoa pessoa1 = new Pessoa("João", 30);
Pessoa pessoa2 = new Pessoa("Maria", 25);

ContaBancaria conta1 = new ContaBancaria(123, pessoa1);

ContaBancaria conta2 = new ContaBancaria(456, pessoa2);
 System.out.println("Número total de pessoas: " + Pessoa.numPessoas); // imprime:
Número total de pessoas: 2
}
}

Neste exemplo, declaramos um atributo de classe numPessoas na classe Pessoa e

incrementamos seu valor toda vez que um novo objeto Pessoa é criado. Na classe
ContaBancaria, declaramos um atributo de instância titular do tipo Pessoa que faz
referência a uma instância da classe Pessoa. Na classe main, criamos duas instâncias da
classe Pessoa e duas instâncias da classe ContaBancaria e, em seguida, imprimimos o
valor do atributo de classe numPessoas da classe Pessoa, que é acessado por meio do
nome da classe Pessoa.
Dessa forma, podemos ter um atributo de classe em uma classe e usá-lo em outra classe
para compartilhar informações entre elas.

------------------------------------------------------------------------------------------------------------------------

As visibilidades em Java são modificadores de acesso que permitem controlar o

nível de acesso a classes, atributos e métodos em um programa. Existem quatro
tipos de modificadores de acesso em Java: public, protected, private e default.
• public: o acesso é permitido a todas as classes, independentemente do pacote em
que elas se encontram. Classes, atributos e métodos definidos como public são
acessíveis de qualquer lugar do programa.
• protected: o acesso é permitido apenas para as classes do mesmo pacote ou para
classes filhas (herdadas) fora do pacote. Atributos e métodos definidos como
protected são acessíveis para a própria classe, para as classes do mesmo pacote e
para as classes filhas.
• private: o acesso é permitido somente para a própria classe. Atributos e métodos
definidos como private não são acessíveis para outras classes, nem mesmo para
as classes do mesmo pacote.
• default (ou sem modificador): o acesso é permitido para as classes do mesmo
pacote. Atributos e métodos definidos sem um modificador de acesso são
considerados default.
Aqui está um exemplo que ilustra o uso desses modificadores de acesso:

package meuPacote;

public class MinhaClasse {

public int atributoPublico = 1;
protected int atributoProtegido = 2;
private int atributoPrivado = 3;
 int atributoDefault = 4; //sem modificador

public void metodoPublico() {

System.out.println("Método público");
}

protected void metodoProtegido() {

System.out.println("Método protegido");
}

private void metodoPrivado() {

System.out.println("Método privado");
}

void metodoDefault() {
System.out.println("Método default");
}
}

Neste exemplo, a classe MinhaClasse tem quatro atributos: um public, um protected, um

private e um default. A classe também tem quatro métodos: um public, um protected, um
private e um default.
Se essa classe estiver dentro de um pacote, os atributos e métodos public são acessíveis
por qualquer classe dentro ou fora do pacote. O atributo e o método protected são
acessíveis somente por classes dentro do pacote ou por classes filhas fora do pacote. O
atributo e o método private só são acessíveis dentro da própria classe. O atributo e o
método default são acessíveis somente por classes dentro do mesmo pacote.
Em resumo, os modificadores de acesso em Java permitem controlar o nível de acesso
de classes, atributos e métodos em um programa, ajudando a proteger o código e a
promover uma programação modular e organizada.

Em Java, pacotes são mecanismos para organizar classes relacionadas em um

mesmo grupo lógico. Pacotes ajudam a evitar conflitos de nomeação entre classes de
diferentes projetos, e também fornecem um meio de controle de acesso por meio dos
modificadores de acesso.
Os pacotes em Java são definidos no topo dos arquivos de código-fonte com o
comando package. Por exemplo, a seguinte classe é definida dentro do pacote
meuPacote:

package meuPacote;

public class MinhaClasse {

// conteúdo da classe
}
Para usar uma classe definida em outro pacote, é necessário importá-la com o comando
import. Por exemplo, a seguinte classe importa a classe OutraClasse definida no pacote
outroPacote:
package meuPacote;

import outroPacote.OutraClasse;

public class MinhaClasse {

// conteúdo da classe
}

A IDE NetBeans organiza os pacotes de uma maneira semelhante a outras IDEs Java. Ao
criar um novo projeto, você pode escolher um nome para o pacote raiz do projeto. Por
exemplo, se você criar um projeto chamado "MeuProjeto" e definir o pacote raiz como
"com.example", então a estrutura de diretórios do projeto será semelhante a esta:
(Veja a pasta em C:\Users\m135526\Documents\NetBeansProjects\MeuProjeto\nbproject)

MeuProjeto/
├── nbproject
│ ├── project.properties
│ └── project.xml
└── src
└── meu projeto
└── MinhaClasse.java
└── outroPacote
└── OutraClasse.java

Dentro da IDE NetBeans, você pode criar novos pacotes clicando com o botão direito na
pasta src e selecionando "New" > "Java Package". Você também pode criar novas classes
dentro desses pacotes clicando com o botão direito no pacote desejado e selecionando
"New" > "Java Class".

Vamos supor que temos duas classes definidas em pacotes diferentes, cada uma com um
atributo privado e um método que tenta acessar o atributo da outra classe. A visibilidade
dos atributos determina se o método será capaz de acessar o atributo da outra classe ou
não.
Na classe ClasseA, temos o atributo atributoPrivado com visibilidade private:
package pacoteA;

public class ClasseA {

private int atributoPrivado;

public void metodoA(ClasseB objB) {

// tenta acessar o atributo privado de ClasseB
objB.atributoPrivado = 10; // erro de compilação
}
}
Na classe ClasseB, temos o atributo atributoPrivado com visibilidade private:
package pacoteB;

public class ClasseB {

private int atributoPrivado;

public void metodoB(ClasseA objA) {

// tenta acessar o atributo privado de ClasseA
objA.atributoPrivado = 10; // erro de compilação
}
}

Note que, como os atributos são privados, não podemos acessá-los diretamente de outras
classes, mesmo que essas classes estejam em pacotes diferentes. Se tentarmos acessar
o atributo atributoPrivado de outra classe como mostrado acima, teremos um erro de
compilação.
No entanto, se mudarmos a visibilidade dos atributos para public, poderemos acessá-los
de outras classes, mesmo que essas classes estejam em pacotes diferentes. Por
exemplo, na classe ClasseA:
package pacoteA;

public class ClasseA {

public int atributoPublico;

public void metodoA(ClasseB objB) {

// acessa o atributo público de ClasseB
objB.atributoPublico = 10;
}
}

E na classe ClasseB:
package pacoteB;

public class ClasseB {

public int atributoPublico;

public void metodoB(ClasseA objA) {

// acessa o atributo público de ClasseA
objA.atributoPublico = 10;
}
}

Nesse caso, como os atributos são públicos, podemos acessá-los diretamente de outras
classes, mesmo que essas classes estejam em pacotes diferentes.
Agora vamos estender o exemplo anterior para incluir os atributos com visibilidade default
e protected.
Primeiro, vamos relembrar o que cada uma dessas visibilidades significa:
 • public: o atributo ou método é acessível de qualquer classe em qualquer pacote.
• protected: o atributo ou método é acessível dentro da mesma classe, de classes do
mesmo pacote e de subclasses (mesmo que estejam em pacotes diferentes).
• default (sem especificação de visibilidade): o atributo ou método é acessível dentro
da mesma classe e de classes do mesmo pacote.
• private: o atributo ou método é acessível somente dentro da mesma classe.
Agora, vamos supor que temos a seguinte hierarquia de classes:

pacoteA
├── ClasseA
└── ClasseC (subclasse de ClasseA)

pacoteB
└── ClasseB

Na classe ClasseA, temos os atributos atributoPublico, atributoDefault e atributoProtected,

com visibilidades public, default e protected, respectivamente:
package pacoteA;

public class ClasseA {

public int atributoPublico;
int atributoDefault;
protected int atributoProtected;

public void metodoA(ClasseB objB) {

// acessa o atributo público de ClasseB
objB.atributoPublico = 10;

// acessa o atributo default de ClasseB

objB.atributoDefault = 20;

// acessa o atributo protected de ClasseB

objB.atributoProtected = 30;
}
}

Na classe ClasseB, temos os atributos atributoPublico e atributoProtected, com

visibilidades public e protected, respectivamente:
package pacoteB;

public class ClasseB {

public int atributoPublico;
protected int atributoProtected;

public void metodoB(ClasseA objA) {

// acessa o atributo público de ClasseA
objA.atributoPublico = 10;

// acessa o atributo protected de ClasseA

 objA.atributoProtected = 20; // erro de compilação
}
}

Na classe ClasseC, que é uma subclasse de ClasseA, temos o método metodoC que
tenta acessar os atributos de ClasseA:
package pacoteA;

public class ClasseC extends ClasseA {

public void metodoC() {
// acessa o atributo público de ClasseA
atributoPublico = 10;

// acessa o atributo default de ClasseA

atributoDefault = 20;

// acessa o atributo protected de ClasseA

atributoProtected = 30;
}
}

Note que, como ClasseC é uma subclasse de ClasseA, ela pode acessar os atributos
public, default e protected de ClasseA. No entanto, se tentarmos acessar o atributo
atributoProtected de ClasseA a partir de ClasseB, teremos um erro de compilação, porque
ClasseB não é uma subclasse de ClasseA.

------------------------------------------------------------------------------------------------------------------------

Propostas de exercícios sobre Orientação a objetos em Java:

1. Métodos construtores:
• Crie uma classe chamada "Pessoa" com atributos nome e idade. Em seguida, crie
um construtor que receba como parâmetros o nome e a idade da pessoa e
inicialize os atributos.
• Crie uma classe "Livro" com atributos título, autor e ano de lançamento. Em
seguida, crie um construtor sem parâmetros que inicialize os atributos com valores
padrão e um construtor que receba os valores do título, autor e ano de lançamento
como parâmetros.

2. Métodos sem retorno:

• Crie uma classe chamada "Calculadora" com métodos para somar, subtrair,
multiplicar e dividir dois números. Esses métodos não devem retornar valores,
apenas imprimir o resultado na tela.
 • Crie uma classe "Retângulo" com métodos para calcular a área e o perímetro do
retângulo. Esses métodos não devem retornar valores, apenas imprimir o resultado
na tela.

3. Métodos com retorno:

• Crie uma classe chamada "Pessoa" com atributos nome e idade. Em seguida, crie
um método chamado "maiorIdade" que retorna true se a idade da pessoa é maior
ou igual a 18 e false caso contrário.
• Crie uma classe "Círculo" com atributo raio e métodos para calcular a área e o
perímetro do círculo. Esses métodos devem retornar os valores calculados.

4. Encapsulamento (get/set):
• Crie uma classe "ContaBancária" com atributos saldo e número. Utilize os métodos
get e set para acessar e alterar os valores desses atributos.
• Crie uma classe "Cliente" com atributos nome, idade e cpf. Utilize os métodos get e
set para acessar e alterar os valores desses atributos.

5. Visibilidade de atributos (protected, public, default e private):

• Crie uma classe "Animal" com atributo protected "nome" e método public
"emitirSom". Crie uma subclasse "Cachorro" que herda de Animal e implemente um
método public "latir" que chama o método emitirSom.
• Crie uma classe "Funcionário" com atributos public "nome" e private "salário". Crie
métodos get e set apenas para o atributo "salário".
• Crie uma classe "Carro" com atributos private "modelo" e default "ano". Crie
métodos get e set apenas para o atributo "modelo".

6. Atributo de classe (instância):

• Crie uma classe "Círculo" com atributo de classe "pi" e atributo de instância "raio".
O atributo "pi" deve ter o valor de 3.14 e o atributo "raio" deve ser passado pelo
construtor. Crie um método para calcular a área do círculo e utilize o valor de "pi".

------------------------------------------------------------------------------------------------------------------------

Métodos construtores:
1)

public class Pessoa {

private String nome;
private int idade;
 public Pessoa(String nome, int idade) {
this.nome = nome;
this.idade = idade;
}

// getters e setters omitidos

}

2)

public class Livro {

private String titulo;
private String autor;
private int anoLancamento;

public Livro() {
this.titulo = "Sem título";
this.autor = "Autor desconhecido";
this.anoLancamento = 0;
}

public Livro(String titulo, String autor, int anoLancamento) {

this.titulo = titulo;
this.autor = autor;
this.anoLancamento = anoLancamento;
}

// getters e setters omitidos

}

Obs.: Note que, para facilitar a leitura do código, foram omitidos os métodos getters e
setters das classes Pessoa e Livro. Esses métodos devem ser implementados para
garantir o encapsulamento dos atributos e permitir o acesso e a modificação desses
atributos por outras classes.

Métodos sem retorno em Java:

1. Classe "Calculadora"
public class Calculadora {
public void somar(int num1, int num2) {
int resultado = num1 + num2;
System.out.println("O resultado da soma é: " + resultado);
}

public void subtrair(int num1, int num2) {

int resultado = num1 - num2;
System.out.println("O resultado da subtração é: " + resultado);
}

public void multiplicar(int num1, int num2) {

 int resultado = num1 * num2;
System.out.println("O resultado da multiplicação é: " + resultado);
}

public void dividir(int num1, int num2) {

if (num2 == 0) {
System.out.println("Não é possível dividir por zero!");
return;
}
double resultado = (double) num1 / num2;
System.out.println("O resultado da divisão é: " + resultado);
}
}

2. Classe "Retângulo"
public class Retangulo {
private double altura;
private double largura;

public Retangulo(double altura, double largura) {

this.altura = altura;
this.largura = largura;
}

public void calcularArea() {

double area = altura * largura;
System.out.println("A área do retângulo é: " + area);
}

public void calcularPerimetro() {

double perimetro = 2 * (altura + largura);
System.out.println("O perímetro do retângulo é: " + perimetro);
}
}

Exemplo de uso:
public class Main {
public static void main(String[] args) {
// Testando a classe Calculadora
Calculadora calc = new Calculadora();
calc.somar(2, 3); // Output: O resultado da soma é: 5
calc.subtrair(5, 2); // Output: O resultado da subtração é: 3
calc.multiplicar(4, 2); // Output: O resultado da multiplicação é: 8
calc.dividir(10, 2); // Output: O resultado da divisão é: 5.0
calc.dividir(10, 0); // Output: Não é possível dividir por zero!

// Testando a classe Retangulo

Retangulo ret = new Retangulo(4.0, 5.0);
ret.calcularArea(); // Output: A área do retângulo é: 20.0
ret.calcularPerimetro(); // Output: O perímetro do retângulo é: 18.0
}
}

Métodos com retorno:

a) Classe Pessoa:
public class Pessoa {
private String nome;
private int idade;

public Pessoa(String nome, int idade) {

this.nome = nome;
this.idade = idade;
}

public boolean maiorIdade() {

if (idade >= 18) {
return true;
} else {
return false;
}
}
}

b) Classe Círculo:

public class Circulo {

private double raio;

public Circulo(double raio) {

this.raio = raio;
}

public double calcularArea() {

return Math.PI * Math.pow(raio, 2);
}

public double calcularPerimetro() {

return 2 * Math.PI * raio;
}
}

Exemplo de uso:

public class ExemploMetodosComRetorno {

public static void main(String[] args) {
// Testando a classe Pessoa
Pessoa pessoa1 = new Pessoa("João", 25);
Pessoa pessoa2 = new Pessoa("Maria", 17);
 System.out.println("A idade de " + pessoa1.nome + " é maior ou igual a 18? " +
pessoa1.maiorIdade());
System.out.println("A idade de " + pessoa2.nome + " é maior ou igual a 18? " +
pessoa2.maiorIdade());

// Testando a classe Circulo

Circulo circulo = new Circulo(3.5);

System.out.println("Área do círculo: " + circulo.calcularArea());

System.out.println("Perímetro do círculo: " + circulo.calcularPerimetro());
}
}

Encapsulamento (get/set)

public class ContaBancaria {

private double saldo;
private String numero;

public double getSaldo() {

return saldo;
}

public void setSaldo(double saldo) {

this.saldo = saldo;
}

public String getNumero() {

return numero;
}

public void setNumero(String numero) {

this.numero = numero;
}
}

public class Cliente {

private String nome;
private int idade;
private String cpf;

public String getNome() {

return nome;
}

public void setNome(String nome) {

this.nome = nome;
}

public int getIdade() {

return idade;
 }

public void setIdade(int idade) {

this.idade = idade;
}

public String getCpf() {

return cpf;
}

public void setCpf(String cpf) {

this.cpf = cpf;
}
}

Esses exemplos utilizam o encapsulamento para controlar o acesso aos atributos das
classes ContaBancaria e Cliente. Cada atributo é declarado como private, o que significa
que não pode ser acessado diretamente de fora da classe. Em vez disso, os métodos get
e set são utilizados para permitir o acesso controlado aos atributos. Os métodos get
retornam o valor do atributo e os métodos set permitem alterar o valor do atributo.

Visibilidade de atributos (protected, public, default e private):

1)
public class Animal {
protected String nome;

public void emitirSom() {

System.out.println("Som do animal");
}
}

public class Cachorro extends Animal {

public void latir() {
emitirSom();
}
}

2)
public class Funcionario {
public String nome;
private double salario;

public void setSalario(double salario) {

this.salario = salario;
}

public double getSalario() {

return salario;
 }
}

3)
public class Carro {
private String modelo;
int ano;

public void setModelo(String modelo) {

this.modelo = modelo;
}

public String getModelo() {

return modelo;
}
}

Atributo de classe

1)
public class Circulo {
private double raio;
private static double pi = 3.14;

public Circulo(double raio) {

this.raio = raio;
}

public double calcularArea() {

return pi * raio * raio;
}
}