1.

Orientação a Objetos em Java

Sumário
1.Orientação a Objetos em Java...........................................................................................................1
1.1.Introdução...................................................................................................................................2
1.2.Classe..........................................................................................................................................2
1.3.Objeto.........................................................................................................................................2
1.4.Atributos.....................................................................................................................................2
1.4.1.Atributos de Instância..........................................................................................................2
1.4.2.Atributos de Classe..............................................................................................................2
1.5.Métodos......................................................................................................................................3
1.5.1.Métodos de Instância...........................................................................................................3
1.5.2.Métodos de Classe...............................................................................................................3
1.5.3.Métodos Construtores..........................................................................................................4
1.5.4.Método destrutor - finalize()...............................................................................................4
1.5.5.Sobrecarga de Métodos (overloading).................................................................................5
1.5.6.Sobreposição ou Sobrescrita de Métodos (overriding).......................................................5
1.6.A palavra chave “this”................................................................................................................5
1.7.A palavra chave "super".............................................................................................................6
1.8.Modificadores.............................................................................................................................6
1.9.Classes Aninhadas......................................................................................................................7
1.9.1.Classes Internas (classes aninhadas não-estáticas)..............................................................8
1.9.2.Classes Internas Estáticas (classes aninhadas estáticas)......................................................8
1.10.Blocos de Inicialização.............................................................................................................8
1.11.Herança.....................................................................................................................................9
1.12.Classes Abstratas....................................................................................................................10
1.13.Interfaces................................................................................................................................10
1.14.Polimorfismo..........................................................................................................................10
1.15.Exemplo TestaMetodos..........................................................................................................12
1.16.Exemplo Aluno.......................................................................................................................14
1.17.Exemplo AlunoB....................................................................................................................17
1.18.Exemplo AlunoC....................................................................................................................23
1.19.Exemplo AlunoD....................................................................................................................30

1
1.1.Introdução
Nesta seção são mostrados os conceitos de orientação a objetos disponíveis na linguagem java.

1.2.Classe
Uma classe é um modelo para a construção (instanciação) de objetos. Abaixo é mostrado como
implementar uma classe na linguagem Java. Vide exemplos classes/aluno/Aluno.java e TestaAluno.java
(Sec. 1.16).
class NomeDaClasse {
//Aqui ficam os membros da classe.
//São considerados membros:
// - os atributos (ou campos),
// - os métodos
// - os tipos aninhados (nested type).
}
Costuma-se chamar de membros de uma classe ou de um tipo
• seus atributos ou campos (fields)
• seus métodos
• seus tipos aninhados (nested type).

1.3.Objeto
Objeto é uma instância de uma classe. Criar um objeto significa "instanciar uma classe". Um
objeto é criado chamando-se um método construtor da classe através do operador new. Exemplo:
Aluno a; //declarando um objeto da classe Aluno.
a = new Aluno(); //criando um objeto da classe Aluno.
Vide exemplos classes/aluno/Aluno.java e TestaAluno.java (Sec. 1.16).

1.4.Atributos
Também chamados de campos, dividem-se em dois tipos: atributos de instância (ou variáveis de
instância) e atributos de classe (ou variáveis de classe). Os atributos são sempre inicializados com null,
false ou zero, dependendo do tipo (referencial, boolean, outro).

1.4.1.Atributos de Instância
Também chamados de variáveis de instância (campos não-estáticos): são as variáveis (atributos)
declaradas dentro de uma classe sem o modificador static (vide seção 1.7 para mais informações sobre os
modificadores). Cada instância da classe (objeto) possuirá seu próprio valor. Uma variável de instância só
pode ser acessada através de um objeto. Exemplo:
Aluno a1 = new Aluno();
a1.idade = 30;
Vide exemplos Aluno e AlunoB (Sec. 1.16 e 1.17).

1.4.2.Atributos de Classe
Também chamados de variáveis de classe (campos estáticos): são as variáveis (atributos)
declaradas dentro de uma classe com o modificador static. É considerada uma variável da classe, e não
das instâncias, ou seja, a variável existe independentemente da criação de objetos. As instâncias da classe,
ou seja, os objetos, podem acessar a variável, porém, todos eles compartilham a mesma variável. Em

2
outras palavras, existe uma única variável na memória. Uma variável estática pode ser acessada através da
classe ou de um objeto, entretanto, por questões de clareza, é mais adequado utilizar a classe para acessar
a variável. Exemplo:
public class Bicicleta {
static int totalBicicletas = 0;
}
int x;
Bicicleta minhaBicicleta = new Bicicleta();
//Essas duas linhas são equivalentes.
x = Bicicleta.totalBicicletas; //acesso através da classe.
x = minhaBicicleta.totalBicicletas; //acesso através do objeto (inadequado!!!).

Vide exemplos classes/alunoC/AlunoC.java, TestaAlunoC1.java e TestaAlunoC2 (Sec. 1.18).

1.5.Métodos
São as operações que podem ser requisitadas a um objeto ou classe, ou seja, as mensagens que
podem ser enviadas a um objeto ou classe. Os métodos são declarados e implementados na classe. Devem
sempre conter um tipo de retorno ou void caso não se deseje retornar um valor. A exceção é para os
métodos construtores, que não podem ter tipo de retorno. Para o método retornar um valor, usa-se o
operador return. Podem ser passados parâmetros de qualquer tipo (primitivos ou referenciais) para um
método. A passagem de parâmetros é sempre por valor.
Java não permite passar métodos em parâmetros, mas pode-se passar um objeto como parâmetro
do método e chamar o método do objeto passado.
Parâmetros: lista de variáveis contidas na declaração de um método.
Argumentos: Valores passados aos parâmetros quando o método é chamado.
Quantidade arbritária de parâmetros:
Pode-se utilizar uma construção chamada "var args" (argumentos variáveis) para se passar um
número arbitrário de valores para um método. Nesse caso pode-se chamar o método passando um array ou
vários argumentos.
Vide exemplos classes/diversos/Metodos.java e TestaMetodos.java (Sec. 1.15)

1.5.1.Métodos de Instância
Um método de instância é um método associado a uma instância da classe, ou seja, é como se
fosse um método do objeto. Para se invocar um método de instância é necessário que exista uma instância
da classe (um objeto). Todos os métodos que não possuírem o modificador static são métodos de
instância.
Vide exemplos classes/alunoB/AlunoB.java, TestaAlunoB1.java e TestaAlunoB2 (Sec. 1.17).

1.5.2.Métodos de Classe
Um método de classe é um método associado à classe, e não ao objeto. São declarados com o
modificador static. Pode-se invocar um método de classe através do nome da classe ou do objeto.
Entretanto, é aconselhável utilizar o nome da classe. Exemplo:
int x;
class Bicicleta {
static int totalBicicletas = 0;
public static int getTotalBicicletas() {
return totalBicicletas;
}
}
x = Bicicleta.getTotalBicicletas();
Um uso comum para métodos estáticos é acessar campos estáticos. Nem todas as combinações de
variáveis e métodos de instância e de classe são permitidos:

3
 • Métodos de instância podem acessar variáveis de instância e métodos de instância diretamente;
• Métodos de instância podem acessar variáveis de classe e métodos de classe diretamente;
• Métodos de classe podem acessar variáveis de classe e métodos de classe diretamente;
• Métodos de classe não podem acessar variáveis de instância nem métodos de instância
diretamente. Eles devem usar uma referência a um objeto. Da mesma forma, métodos de classe
não podem usar a palavra reservada this, visto que não há instância para this referenciar.

Vide exemplos classes/alunoC/AlunoC.java, TestaAlunoC1.java e TestaAlunoC2 (Sec. 1.18).

1.5.3.Métodos Construtores
Um construtor é um método especial que é invocado (chamado) toda vez que se instancia uma
classe. É no método construtor que o objeto é criado e seus atributos são inicializados. Uma classe pode
possuir vários construtores, dos quais um deverá ser chamado para que possamos criar um objeto da
classe. Em Java, um construtor é um método público, com o mesmo nome da classe e sem tipo de retorno.
Exemplo:
class Aluno {
private String nome;

//Método construtor.
public Aluno(String nome) {
this.nome = nome;
}//Final do método construtor.

}
Para se criar uma instância de uma classe, deve-se chamar um construtor da classe com o
operador new. Exemplo:
Aluno a; //declara a variável/objeto "a" do tipo Aluno.
a = new Aluno("João"); //chama o construtor para criar o objeto da classe Aluno.
Se durante a definição de uma classe não for implementado nenhum construtor para a mesma, o
compilador criará um construtor padrão, sem parâmetros, o qual é chamado de "construtor default". No
exemplo mostrado acima, se não tivéssemos criado nenhum construtor, o Java teria criado o construtor
public Aluno() {
//Chamada implícita feita pelo Java. Será a primeira linha do construtor.
Super();
}
Além disso, no construtor de uma subclasse sempre será feita a chamada de um construtor de sua
superclasse. Se o construtor de uma subclasse não chamar explicitamente nenhum construtor de sua
superclasse, o compilador fará a chamada do construtor default da superclasse. Se a superclasse não
possuir o construtor default será gerado um erro de compilação. Exemplo:
public Aluno(String nome) {
//Chamada implícita feita pelo Java. Será a primeira linha do construtor.
super();
this.nome = nome;
}
Entretanto, se uma subclasse chamar explicitamente um construtor de sua superclasse, o
compilador não fará chamada a nenhum construtor. Além disso, essa chamada deverá ser a primeira linha
do construtor da subclasse.
Vide exemplos AlunoD (Sec. 1.19) e Heranca (Sec. ).

1.5.4.Método destrutor - finalize()

Em Java, o método destrutor é o método finalize(). Esse método é invocado automaticamente pelo
coletor de lixo da Máquina Virtual Java antes do objeto ser removido da memória. Nesse método deve-se
implementar o código responsável por liberar os recursos alocados pelo objeto em questão. Deve-se

4
observar que o destrutor da superclasse não é invocado automaticamente, devendo-se fazer explicitamente
no método finalize da subclasse, como mostra o exemplo abaixo:
protected void finalize() throws Throwable {
//Executa a liberação dos recursos alocados pelo objeto
//...
//Invoca o destrutor da superclasse
super.finalize();
}

1.5.5.Sobrecarga de Métodos (overloading)

É a possibilidade de se redeclarar um método com o mesmo nome, mas com parâmetros diferentes.
Exemplos:
public class MinhaClasse {
...
public void imprime(String s) {
...
}
public void imprime(int i) {
...
}
public void imprime(double d) {
...
}
public void imprime(int i, double d) {
...
}
}
O método efetivamente chamado dependerá dos parâmetros passados. Exemplos:
MinhaClasse c = new MinhaClasse();
c.imprime("teste");//Chama o método imprime(String s)
c.imprime(5, 8.3); //Chama o método imprime(int i, double d)

1.5.6.Sobreposição ou Sobrescrita de Métodos (overriding)

É a redefinição de um método em uma subclasse, contendo a mesma assinatura (nome e
parâmetros). Veja mais na seção 1.11 (Herança).

1.6.A palavra chave “this”

É uma referência para o próprio objeto, sendo utilizada em dois contextos:
• Quando se necessita acessar um atributo do objeto que tem o mesmo nome de uma variável local.
• Dentro de um construtor, quando se deseja invocar um outro construtor da própria classe.
Exemplos:
public class Aluno {
private String nome;

public Aluno () {
this.nome = "";
}

public Aluno(String nome) {

this(); //invocando o construtor Aluno()
this.nome = nome; //atributo nome recebe variável local nome
}

5
}
Vide exemplos classes/alunoC/AlunoC.java (Sec. 1.18) e classes/alunoD/AlunoD.java (Sec. 1.19).

1.7.A palavra chave "super"

É uma referência para a superclasse, sendo utilizada em dois contextos:
Quando se deseja invocar um método da superclasse que foi redefinido na subclasse. Vide exemplo
classes2/heranca/Aluno.java (Sec. ).
public void mostraDados() {
System.out.println("============================================");
super.mostraDados(); //Invoca o método mostraDados() da superclasse Pessoa.
//...
}
Quando se deseja chamar um construtor da superclasse. Vide exemplos
classes2/heranca/Aluno.java e Professor.java (Sec. ).
public Professor(int c, String n, char s) {
//Chama o construtor da superclasse Pessoa(int, String, char).
super(c, n, s);
//...
}

1.8.Modificadores
Modificadores de Acesso
Os modificadores de acesso (ou visibilidade) controlam quais classes podem utilizar um elemento.
Considere um elemento como sendo: classes, variáveis membro, métodos, construtores e classes
aninhadas. Um elemento só pode ter um modificador de acesso. Se não for especificado um modificador de
acesso, o elemento ficará com um modo de acesso padrão (default), também conhecido como pacote.

• Modificadores de acesso a nível topo: public, padrão (restrito ao pacote).

• Modificadores de acesso a nível de membro: public, protected, padrão, private.

public: o elemento pode ser acessado em qualquer lugar.

protected: o elemento pode ser acessado pela própria classe, subclasses e outras classes dentro
do mesmo pacote.
padrão (sem modificador): o elemento pode ser acessado pela própria classe e por outras classes
dentro do mesmo pacote.
private: o elemento só pode ser acessado pela própria classe.
Tabela 1: Modificadores de Acesso

Nível de Acesso
Modificador Classe Pacote Subclasse Público
public S S S S
protected S S S N
padrão (sem modificador) S S N N
private S N N N

Vide exemplos classes3/visibilidade/Pessoa.java, Aluno.java, Professor.java (Sec. ).

6
 Outros Modificadores
final: significa que o elemento não pode mudar. Um atributo final não pode receber valor, ou seja,
funciona como uma constante. Um método final não pode ser sobreposto (overriden) em uma subclasse.
Classes finais não podem ser herdadas.
abstract: o modificador abstract pode ser aplicado a classes e métodos. Uma classe abstrata não
pode ser instanciada. Um método abstrato deverá ser implementado por uma classe descendente. Se um
método for declarado abstrato, o compilador exigirá que a classe também seja declarada abstrata.
static: pode ser aplicado a variáveis, métodos e blocos de inicialização. Um elemento estático
pertence à classe, e não às instâncias da classe (objetos).
native: só pode ser aplicado a métodos. Indica que o corpo do método está totalmente fora do
ambiente da máquina virtual java, ou seja, em um biblioteca. Permite acessar código nativo da máquina
hospedeira. Entretanto, a ideia de independência de plataforma é violada.
transient: se aplica somente a variáveis. Uma variável transiente não é armazenada como parte do
estado persistente de um objeto, durante uma serialização.
volatile: se aplica somente a variáveis. Significa que a variável pode ser modificada
assincronamente.
synchronized: usado para controlar o acesso a seções críticas em programas multithread.

1.9.Classes Aninhadas
Uma classe aninhada é uma classe definida (implementada) dentro de outra classe. Existem dois
tipos de classes aninhadas:

• Classes Internas (Classes Aninhadas não-Estáticas)

• Classes Internas Estáticas (Classes Aninhadas Estáticas)

public class ClasseExterna {

int e;

void metodo1() {
}

class ClasseInterna {
int i;
void metodo1() {
}
}

static class ClasseAninhadaEstatica {

void metodo3() {
}
}

Classes aninhadas são consideradas membros de suas classes externas.

Classes aninhadas podem ser definidas com qualquer modificador de visibilidade.
Classes a nível topo só podem ser definidas como públicas ou pacote (default).

7
1.9.1.Classes Internas (classes aninhadas não-estáticas)
Instâncias de classes internas estão contidas em instâncias de sua classe externa. Instâncias de
uma classe interna possuem acesso a todos os membros de sua classe externa, inclusive os membros
privados. Por exemplo, para uma instância da ClasseInterna acessar o atributo "e" da ClasseExterna, utiliza-
se:
ClasseExterna.this.e;
Uma classe interna não pode conter métodos estáticos. Métodos estáticos só podem ser definidos
em classes aninhadas estáticas ou classes de nível topo.
Uma classe externa pode instanciar objetos de sua classe interna e acessar todos os seus
membros, inclusive os membros privados.
Existem outros dois tipos especiais de classes internas: classes internas locais e classes anônimas.
Classe Interna Local: é uma classe definida dentro do corpo de um método. Não pode conter
qualquer especificador de visibilidade. Só pode ser utilizada dentro do método onde foi definida. Uma classe
interna local pode acessar todos os membros da classe onde foi definida.
Classe Anômima: é uma classe definida dentro do corpo de um método, porém não possui um
nome.

1.9.2.Classes Internas Estáticas (classes aninhadas estáticas)

Uma classe aninhada declarada com o modificador static é chamada de classe aninhada estática ou
também de classe interna estática.
Uma classe interna estática não tem acesso aos membros de instância de sua classe externa.

Tabela 2: Tipos de Classes Aninhadas

Tipo Escopo Interna
Classe aninhada estática membro não
Classe interna (não-estática) membro sim
Classe local local sim
Classe anônima Somente no ponto onde está definida. sim

1.10.Blocos de Inicialização
É um bloco normal de código envolto por chaves { }. Podem ser estáticos ou não-estáticos. Os
blocos estáticos são precedidos pela palavra chave static. Uma classe pode conter qualquer quantidade de
blocos de inicialização estáticos, e eles podem aparecer em qualquer lugar do corpo da classe. Os blocos
são executados na ordem em que aparecem. Exemplo:
//Bloco estático.
Static {
b = 1;
}
Uma alternativa é a implementação de um método estático. A vantagem dessa alternativa é que o
método pode ser reutilizado (invocado novamente), caso se deseje reinicializar a variável da classe.
class ClasseA {
//Variável inicializada pelo método estático initVarC().
public static int c = initVarC();
//Método estático para inicializar a variável estática C.
private static int initVarC() {
return 1;
}

8
 Blocos de inicialização não-estáticos são utilizados para inicializar membros de instância.
Normalmente se coloca o código para inicializar membros de instância dentro de um construtor, entretanto
existem duas outras alternativas:
• blocos inicializadores e
• métodos finais.
Blocos inicializadores são parecidos com blocos de inicialização estáticos, mas sem a palavra
chaves static. O compilador Java copia o bloco inicializador em cada construtor. Portanto, essa abordagem
pode ser usada para compartilhar um bloco de código entre vários construtores. Exemplo:
//Bloco para inicializar variáveis de instância.
{
x = 10;
}
A segunda alternativa é inicializar a variável através da chamada de um método final. O método
deve ser final porque se for chamado um método não-final durante a inicialização de uma instância poderá
causar problemas.
class ClasseA {
//Variável inicializada pelo método de instância final initVarH().
public int h = initVarH();

//Método para inicializar variável de instância. Tem que usar final.

public final int initVarH() {
return 1;
}
}
Vide exemplo classes/diversos/BlocosInicializa.java

1.11.Herança
Uma subclasse herda todos os membros (campos, métodos e classes aninhadas) de sua
superclasse se esses forem públicos ou protegidos. Membros default são herdados se a superclasse
estiver no mesmo pacote. Membros privados não são herdados. Construtores não são considerados
membros de classe, logo, não são herdados, embora possam ser chamados (invocados).
Uma subclasse pode herdar os membros sem modificá-los, pode substituir um membro, esconder,
ou adicionar novos membros.
• Podem ser definidos novos campos na subclasse, que não existiam na superclasse.
• Se um campo existente na superclasse for redefinido, o campo da superclasse será escondido
(hidding), o que não é recomendado. Para se acessar o campo da superclasse será necessário usar
a cláusula super.
• Uma variável de instância redeclarada em uma subclasse esconde uma variável estática da sua
superclasse.
• Uma variável estática redeclarada em uma subclasse esconde uma variável de instância da sua
superclasse.
• Pode ser redefinido um método de instância que tenha a mesma assinatura de um método da
superclasse, acontecendo uma sobreposição (override). O método da superclasse pode ser
acessado com a cláusula super.
• Se o método redefinido possuir o mesmo nome, porém, uma assinatura diferente, acontecerá uma
sobrecarga (overload).
• Métodos estáticos podem ser redefinidos com os mesmos parâmetros, fazendo com que o método
da superclasse seja escondido (hide).
• Um método estático em uma subclasse esconde o método estático da sua superclasse.
• Um método de instância de uma subclasse não pode sobrepor um método estático de sua
superclasse.

9
 • Um método padrão (visibilidade default/pacote) de uma superclasse pode ser tornado privado em
uma subclasse, desde que essa subclasse não esteja no mesmo pacote que a superclasse.
• Pode ser criado um construtor na subclasse que invoca (chama) o construtor da superclasse,
implicitamente (se for o construtor default), ou explicitamente usando-se a palavra chave super.
• Podem ser definidos novos métodos na subclasse, que não existiam na superclasse.
Métodos em subclasses não podem ser sobrepostos para níveis mais proibitivos. Ou seja, um
método protected não pode ser sobreposto para padrão ou private em uma subclasse, mas pode ser
sobreposto para public. A exceção a essa regra é o caso de um método protected ser sobreposto para
private em uma subclasse, desde que a subclasse não esteja no mesmo pacote da superclasse. Já os
atributos podem ser sobrepostos para qualquer nível.
Métodos sobrepostos podem ser chamados com a utilização da palavra chave super.
Não é possível usar um nome qualificado ou um cast para acessar um método da superclasse que
foi sobreposto. Deve-se usar a palavra chave super.
Pode-se usar um cast para acessar um campo da superclasse.
Se uma subclasse não chamar explicitamente o construtor de sua superclasse, o Java tentará
chamar automaticamente o construtor padrão da superclasse. Se esse construtor não existir, ocorrerá um
erro em tempo de compilação.
Vide exemplos classes2/heranca//Pessoa.java, Aluno.java, Professor.java, TestaHeranca.java (Sec. ).

1.12.Classes Abstratas
Uma classe abstrata é uma classe declarada com o modificador abstract. É uma classe que não
pode ser instanciada, mas pode ser herdada. Ela pode conter tanto métodos abstratos quanto métodos
concretos. Um método abstrato é um método declarado mas não implementado. Se uma classe possuir pelo
menos um método abstrato, a classe deverá ser declarada abstrata. Classes abstratas podem conter
campos e métodos estáticos. Uma classe abstrata pode possuir construtores, embora não se possa
instanciar diretamente uma classe abstrata, devendo-se instanciar uma subclasse que seja concreta.
Vide seção Erro: Origem da referência não encontrada (classes2/polimorfismo/Animal.java)

1.13.Interfaces
Uma interface é um tipo referencial, similar a uma classe, que pode conter somente constantes,
assinaturas de métodos e tipos aninhados. Não pode haver corpo dos métodos. Interfaces não podem ser
instanciadas, somente implementadas por classes ou estendidas por outras interfaces. Pode-se dizer que
uma interface é um contrato. A classe que implementar a interface deverá respeitar esse contrato, ou seja,
deverá implementar os métodos declarados pela interface. Se a classe não o fizer, o Java irá gerar um erro
em tempo de compilação.
Uma interface pode estender várias outras interfaces (herança múltipla).
Para usar uma interface, deve-se escrever uma classe que implemente a interface. Uma variável de
um tipo interface deverá receber um objeto de uma classe que implemente a interface.
Métodos declarados em uma interface são públicos e abstratos por padrão.
Constantes declaradas em uma interface são public static final por padrão.
Vide seção Erro: Origem da referência não encontrada - Erro: Origem da referência não encontrada

1.14.Polimorfismo
Polimorfismo é capacidade que um objeto tem de se comportar de formas diferentes ao longo do
tempo. Existem diversas formas de polimorfismo.

10
Vide seção Erro: Origem da referência não encontrada - Erro: Origem da referência não encontrada
(classes2/polimorfismo/Animal.java, Cao.java, Gato.java, Vaca.java, TestaPolimorfismo.java)

11
1.15.Exemplo TestaMetodos
Neste exemplo são demonstrados os seguintes conceitos:
● métodos e passagem de parâmetros
● métodos com quantidade variável de parâmetros (varargs)
Neste exemplo são demonstrados diversos métodos com parâmetros e tipos de retorno diferentes.
O método exibeMensagem( ) recebe dois parâmetros: uma string e um valor inteiro. O método
imprime uma mensagem na tela usando os parâmetros passados. Esse método não retorna nenhum valor,
por isso o tipo de retorno void.
O método calculaDobro( ) recebe um valor inteiro e retorna o seu dobro. O tipo de retorno utilizado
nesse método também foi inteiro.
O método calculaImposto( ) recebe três parâmetros: dois valores reais de precisão dupla (double)
e um valor inteiro. O método declara uma variável local chamada imp para calcular o valor do imposto. O
método retorna a variável imp calculada. O tipo de retorno utilizado no método foi double.
O método mostraVetor( ) recebe um array como parâmetro e imprime na tela todos os valores
contidos nesse array. Esse método não retorna nenhum valor, por isso foi utilizado o tipo de retorno void.
O método mostraValores( ) utiliza uma construção do Java chamada varargs, ou quantidade
variável de argumentos. Com essa construção, pode-se passar qualquer quantidade de parâmetros para o
método. Internamente a variável v pode ser tratada como um array.
Vide exemplo classes/diversos/Metodos.java
/* Exemplo para demonstrar a implementação de métodos,
* passagem de parâmetros, parâmetros variáveis e
* retorno de método.
*/
public class Metodos {

//Recebe 2 parâmetros mas não retorna nada. Utiliza-se void.

public void exibeMensagem(String nome, int idade) {
System.out.println("Ola " + nome + ", voce tem " + idade + " anos de idade.");
}//exibeMensagem()

//Recebe um parâmetro inteiro e retorna o seu dobro, também inteiro.

public int calculaDobro(int n) {
return n * 2;
}//calculaDobro()

//Recebe 3 parâmetros e retorna um double.

public double calculaImposto(double capital, double tx, int meses) {
double imp;
imp = capital * tx * meses;
return imp;
}//calculaImposto()

//Recebe um array.
public void mostraVetor(int[] v) {
int i;
System.out.print("Vetor: ");
for(i=0; i<v.length; i++) {
System.out.print(" | " + v[i]);
}
System.out.println(" | ");
}//mostraVetor()

//Utilizando o conceito Varargs (quantidade arbitrária/variável de parâmetros)

public void mostraValores(int ... v) {
int i;
System.out.print("Valores: ");
for(i=0; i<v.length; i++) {
System.out.print(" | " + v[i]);
}
System.out.println(" | ");
}//mostraValores()

12
}//Metodos.

O exemplo TestaMetodos instancia um objeto da classe Metodos e faz chamada de seus métodos.
Note que o método exibeMensagem() não retorna nenhum valor. Os métodos calculaDobro() e
calculaImposto() retornam valores, os quais são armazenados nas variáveis locais i e d. O método
mostraVetor() recebe um vetor como argumento. O método mostraValores() aceita uma quantidade variável
de argumentos pois utiliza a construção varargs do Java.
Vide exemplo classes/diversos/TestaMetodos.java
/* Exemplo para demonstrar a implementação de métodos,
* passagem de parâmetros, parâmetros variáveis e
* retorno de método.
*/
public class TestaMetodos {

public static void main(String[] args) {

int i;
double d;
int[] meuVetor = {5, 6, 7, 8, 9};

Metodos calc = new Metodos();

//Chamando métodos que não retornam nada (void).

calc.exibeMensagem("Joao", 30);

//Chamando métodos que retornam números.

i = calc.calculaDobro(10); //retorna um valor inteiro.
d = calc.calculaImposto(1000, 0.1, 5); //retorna um valor double.
System.out.println("Dobro de 10 = " + i);
System.out.println("Imposto = " + d);

//Passando um array para um método.

calc.mostraVetor(meuVetor);

//Chamando um método com quantidade variável de parâmetros.

calc.mostraValores();
calc.mostraValores(3);
calc.mostraValores(3, 8);
calc.mostraValores(3, 8, 9, 1, 4, 2, 9, 3, 5);
calc.mostraValores(meuVetor); //Pode ser passado um array.

}//main()

}//TestaMetodos.

13
1.16.Exemplo Aluno
Neste exemplo são mostrados os seguintes conceitos:
● classe
● objeto
● atributos de instância
● métodos de instância
● modificador de visibilidade public
● programa Java
● método estático main()
● declaração de objeto
● criação de objeto (instanciação de classe)
● acesso a atributos
● acesso a métodos (invocação de método)
No arquivo Aluno.java é mostrada a implementação de uma classe chamada Aluno, contendo
alguns atributos e métodos. Os atributos definidos foram nome, sexo, idade, nota1 e nota2. Neste primeiro
exemplo, todos os atributos dessa classe foram definidos como públicos por uma questão de facilidade de
aprendizagem. Deve-se considerar que esta não é uma implementação adequada, visto que não respeita o
princípio do “ocultamento da informação”. Entretanto, como o objetivo deste exemplo é mostrar a
implementação de uma classe e a definição de atributos e métodos, deixou-se os atributos como públicos,
de modo a facilitar seu entendimento.
Além de atributos, a classe também possui dois métodos, media() e situacao(), que retornam a
média aritmética das notas e a situação do aluno, respectivamente.
Vide exemplo classes/aluno/Aluno.java
// Exemplo de uma classe com membros públicos:
// - propriedades ou atributos
// - métodos ou operações

public class Aluno {

//Campos, propriedades ou atributos
public String nome;
public char sexo; /*M ou F*/
public int idade;

public float nota1;

public float nota2;

//Exemplo de um método para calcular e retornar a

//média aritmética das provas do aluno.
public float media() {
return (nota1 + nota2) / 2;
}//media()

//Exemplo de um método para calcular a

//média aritmética das provas e retornar a situação do aluno.
public String situacao() {
if (media() >= 7) {
return "Aprovado";
}
else {
return "Reprovado";
}
}//situacao()

}//Aluno.

14
 Para testar a classe Aluno criou-se um programa chamado TestaAluno. Um programa em Java é
uma classe com um método estático chamado main(). Mais adiante será explicado o que é um método
estático.
Nessa classe é mostrado como criar um objeto aluno, ou seja, como criar uma instância da classe
Aluno. Lembre que
um objeto é uma instância de uma classe.
Para instanciar uma classe (criar um objeto) utiliza-se o operador new seguido do método construtor
da classe, neste exemplo, o método Aluno(). Para armazenar em uma variável o objeto criado, utiliza-se o
operador de atribuição.
a1 = new Aluno();
O programa TestaAluno declara dois objetos (a1 e a2) do tipo Aluno, cria os objetos e atribui
alguns valores para seus atributos públicos. Em seguida, chama os métodos media() e situacao() para obter
a média e a situação do aluno e mostrá-las na tela.
Para se acessar os membros (atributos ou métodos) de um objeto utiliza-se o nome do objeto
seguido de um ponto e do nome do membro.
Observe que apesar dos atributos serem definidos apenas uma vez (na classe), cada objeto possui
o seu valor particular para cada atributo. Isso é um atributo de instância, ou seja, um atributo que pertence
à instância (objeto), e não à classe. Cada instância (objeto) possui o seu valor para o atributo. Os métodos
aqui implementados também são métodos de instância, pois podem acessar os atributos de instância, ou
seja, os atributos de cada objeto. Atributos de classe e métodos de classe serão vistos mais adiante.
Vide exemplo classes/aluno/TestaAluno.java
/* Exemplo para demonstrar a instanciação da classe Aluno,
* ou seja, a criação e utilização de objetos da classe Aluno.
*/
class TestaAluno{
public static void main(String[] args){
//Declara objetos a1 e a2.
Aluno a1;
Aluno a2;

//Cria objetos (instancia classe).

a1 = new Aluno(); //Chama o método construtor da classe Aluno.
a2 = new Aluno(); //Chama o método construtor da classe Aluno.

System.out.println("*************************************************");
System.out.println("Testando objetos, atributos e metodos");
System.out.println("*************************************************");
System.out.println();

//Atribui valores aos atributos do objeto a1.

a1.nome = "Joao";
a1.sexo = 'M';
a1.idade = 30;
a1.nota1 = 6;
a1.nota2 = 7;

//Atribui valores aos atributos do objeto a2.

//Observe que é possível atribuir qualquer valor.
//Isso viola o princípio do ocultamento da informação.
a2.nome = "";
a2.sexo = 'x';
a2.idade = -30;
a2.nota1 = -2;
a2.nota2 = 15;

//Acessa os atributos do objeto a1 e mostra na tela.

System.out.println("Nome = " + a1.nome);
System.out.println("Sexo = " + a1.sexo);
System.out.println("Idade = " + a1.idade);
System.out.println("Nota 1 = " + a1.nota1);
System.out.println("Nota 2 = " + a1.nota2);

//Chama (invoca) métodos do objeto a1 para obter a média e a situação.

System.out.println("Media = " + a1.media());
System.out.println("Situacao = " + a1.situacao());

15
 System.out.println();

//Acessa os atributos do objeto a2 e mostra na tela.

System.out.println("Nome = " + a2.nome);
System.out.println("Sexo = " + a2.sexo);
System.out.println("Idade = " + a2.idade);
System.out.println("Nota 1 = " + a2.nota1);
System.out.println("Nota 2 = " + a2.nota2);

//Chama (invoca) métodos do objeto a2 para obter a média e a situação.

System.out.println("Media = " + a2.media());
System.out.println("Situacao = " + a2.situacao());
}
}//TestaAluno.

É importante ressaltar mais uma vez que, devido aos atributos do objeto serem públicos, o
programa TestaAluno pode atribuir qualquer valor aos mesmos, como por exemplo um nome vazio, um
sexo diferente de 'M' ou 'F', uma idade negativa ou uma nota negativa ou maior que 10, comprovando a
deficiência em se utilizar atributos públicos. No próximo exemplo essa deficiência é corrigida, tornando os
atributos privados e criando-se métodos para acessá-los.

16
1.17.Exemplo AlunoB
Neste exemplo são mostrados os seguintes conceitos:
● modificador de visibilidade private
● métodos assessores (getters) e modificadores (setters)
● método construtor
● método toString()
Para contornar o problema verificado no exemplo anterior (violação do princípio do ocultamento da
informação) pode-se usar os modificadores de acesso para especificar uma visibilidade diferente de pública.
Neste exemplo, a visibilidade de todos os atributos da classe AlunoB foi definida como privada (private), ou
seja, somente a própria classe terá acesso a eles. Com isso, o programa TestaAlunoB1 não tem acesso
aos atributos dos objetos AlunoB, não podendo ler nem atribuir diretamente valores a eles.
No entanto, deve-se fornecer algum mecanismo para que seja possível atribuir e recuperar os
atributos dos objetos AlunoB que forem criados. Isso pode ser feito através de métodos, os quais são
chamados, apenas por convenção, de métodos assessores (getters) e modificadores (setters). Também por
convenção, os nomes dos métodos assessores iniciam com o prefixo get e os métodos modificadores com
o prefixo set.
Os métodos assessores (getNome(), getSexo(), getIdade(), getNota1() e getNota2()) simplesmente
retornam o atributo correspondente. Já os métodos modificadores (setNome(), setSexo(), setIdade(),
setNota1() e setNota2()) fazem uma verificação dos valores sendo atribuídos, só efetivando a atribuição se
o valor for considerado válido:
• o nome só é atribuído se não for vazio,
• o sexo só é atribuído se for 'M' ou 'F',
• a idade só é atribuída se for maior que zero
• as notas só são atribuídas se estiverem entre 0 (zero) e 10 (dez).
Essa estratégia garante a integridade dos valores dos atributos dos objetos AlunoB que forem
criados. Ou seja, externamente à classe AlunoB não será possível atribuir valores inválidos aos objetos
AlunoB, já que a única forma de acesso aos atributos é através dos métodos assessores, e estes estão
efetuando a validação dos atributos.
Também é mostrado na classe AlunoB um método especial, conhecido como construtor. O
construtor serve para se construir e inicializar os atributos do objeto. É o método que é chamado quando se
invoca o operador new. Em Java, um construtor é um método público, sem valor de retorno e com o
mesmo nome da classe. Na classe AlunoB, é o método public AlunoB( ). Nesse exemplo, utilizou-se o
construtor somente para inicializar os atributos do objeto.
Nessa classe também foi implementado e sobrescrito o método toString(). Esse método está
implementado na classe Object e tem a função de retornar uma representação textual (String) do objeto. A
implementação padrão desse método simplesmente retorna a identificação do objeto, ou seja, sua
localização na memória. Em geral, esse valor não tem utilidade alguma. Portanto, ao se sobrescrever esse
método, normalmente retorna-se os valores dos atributos do objeto, e é isto que está sendo feito neste
exemplo.
Também foi implementado nesta classe um método chamado mostraDados(). Escolheu-se definir
esse método para que seja facilitada a impressão dos dados do aluno na tela. Deve-se observar que essa
não é a melhor prática: misturar lógica da aplicação com interface do usuário. Entretanto, como o intuito
deste exemplo é apenas demonstrar a implementação de um método, essa questão não foi levada em
consideração, mas será abordada mais adiante.
Vide exemplo em classes/AlunoB/AlunoB.java
/* Exemplo de uma classe para demonstrar os seguintes conceitos:
- especificador de visibilidade private
- getters e setters
- método construtor

17
*/
public class AlunoB {

//=============== Atributos de Instância ==========================

private String nome;
private char sexo; //M ou F
private int idade; //maior que zero
private float nota1; //entre 0 e 10
private float nota2; //entre 0 e 10

//=================================================================
//===================== Método Construtor =========================
//=================================================================
public AlunoB() {
nome = "-----";
sexo = '-';
idade = 0; //Valor default. Não é necessário.
nota1 = 0; //Valor default. Não é necessário.
nota2 = 0; //Valor default. Não é necessário.
}//AlunoB()

//=================================================================
//===================== Métodos de Instância ======================
//=================================================================

//-------------------------------------------------------
//Método: setNome()
//Atribui o nome. Não deixa atribuir um nome vazio.
//-------------------------------------------------------
public void setNome(String n) {
if (n.length() > 0 ) {
nome = n;
}
}//setNome()

//-------------------------------------------------------
//Método: getNome()
//Retorna o nome.
//-------------------------------------------------------
public String getNome() {
return nome;
}//getNome()

//-------------------------------------------------------
//Método: setSexo()
//Atribui o sexo.
//Não deixa atribuir um valor diferente de 'M' ou 'F'.
//-------------------------------------------------------
public void setSexo(char s) {
if ((s=='M') || (s=='F')) {
sexo = s;
}
}//setSexo()

//-------------------------------------------------------
//Método: getSexo()
//Retorna o sexo.
//-------------------------------------------------------
public char getSexo() {
return sexo;
}//getSexo()

//-------------------------------------------------------
//Método: setIdade()
//Atribui a idade. Não deixa atribuir uma idade negativa.
//-------------------------------------------------------
public void setIdade(int i) {
if (i > 0 ) {
idade = i;
}
}//setIdade()

//-------------------------------------------------------
//Método: getIdade()
//Retorna a idade.
//-------------------------------------------------------
public int getIdade() {

18
 return idade;
}//getIdade()

//-------------------------------------------------------
//Método: setNota1()
//Atribui a nota1.
//Não deixa atribuir uma nota inválida.
//-------------------------------------------------------
public void setNota1(float f) {
if ((f >= 0) && (f <= 10)) {
nota1 = f;
}
}//setNota1()

//-------------------------------------------------------
//Método: getNota1()
//Retorna a nota1.
//-------------------------------------------------------
public float getNota1() {
return nota1;
}//getNota1()

//-------------------------------------------------------
//Método: setNota2()
//Atribui a nota2.
//Não deixa atribuir uma nota inválida.
//-------------------------------------------------------
public void setNota2(float f) {
if ((f >= 0) && (f <= 10)) {
nota2 = f;
}
}//setNota2()

//-------------------------------------------------------
//Método: getNota2()
//Retorna a nota2.
//-------------------------------------------------------
public float getNota2() {
return nota2;
}//getNota2()

//-------------------------------------------------------
//Método: media()
//Calcula e retorna a média aritmética das notas 1 e 2.
//-------------------------------------------------------
public float media() {
return (nota1 + nota2) / 2;
}//media()

//-------------------------------------------------------
//Método: situacao()
//Calcula a média aritmética das notas 1 e 2 e retorna a situação do aluno.
//Media - Situacao
//(< 3) - Reprovado
//(>=3 E < 7) - Recuperacao
//(>=7 E < 9) - Aprovado - Bom
//(>=9 E <=10) - Aprovado - Otimo
//-------------------------------------------------------
//--- Situacao ---
public String situacao() {
if (media() < 3 ) {
return "Reprovado";
}
else {
if (media() < 7 ) {
return "Recuperacao";
}
else {
if (media() < 9 ) {
return "Aprovado - Bom";
}
else {
return "Aprovado - Otimo";
}
}
}
}//situacao()

19
 //-------------------------------------------------------
//Método: toString()
//Retorna uma String com uma descrição textual do objeto.
//-------------------------------------------------------
public String toString() {
return "Nome=" + nome +
", Sexo=" + sexo +
", Idade=" + idade +
", Nota1=" + nota1 +
", Nota2=" + nota2;
}//toString()

//-------------------------------------------------------
//Método: mostraDados()
//Mostra na tela todas as informações do aluno.
//-------------------------------------------------------
public void mostraDados() {
System.out.println("Nome = " + nome);
System.out.println("Sexo = " + sexo);
System.out.println("Idade = " + idade);
System.out.println("Nota 1 = " + nota1);
System.out.println("Nota 2 = " + nota2);
System.out.println("Media = " + media());
System.out.println("Situacao = " + situacao());
}//mostraDados()

}//AlunoB.

No programa TestaAlunoB1 mostra-se a execução do método construtor, a utilização dos métodos

assessores e modificadores, e também, que não é possível acessar diretamente os atributos privados dos
objetos AlunoB.
Nesse exemplo, primeiramente são instanciados dois objetos da classe AlunoB e em seguida
chama-se seus métodos assessores para se ler os valores de seus atributos. Note que os objetos estão
com os valores que foram definidos no construtor, o que prova que o construtor é executado quando o
objeto é construído.
Note também que não é possível acessar diretamente os atributos do objeto, pois eles foram
definidos como privados na classe AlunoB. Veja que não se tem acesso direto ao atributo, só se tem acesso
aos métodos assessores, pois estes são públicos. Como exemplo, tente acessar diretamente o atributo
nome do objeto a1 e verá um erro de compilação, informando que o atributo não está visível (acessível). A
única maneira de ler os atributos do objeto é chamando seus métodos assessores.
Em seguida, são atribuídos valores para os atributos do objeto a1, através dos métodos
modificadores. Veja novamente que não se pode acessar diretamente os atributos, ou seja, os atributos do
objeto estão protegidos de modificação externa. A única maneira de atribuir valores ao objeto é chamando
seus métodos modificadores, já que estes são públicos.
Além disso, não é possível atribuir valores inválidos ao objeto, pois os métodos modificadores estão
fazendo a validação dos dados sendo atribuídos, conforme foi explicado anteriormente. Como exemplo,
tente atribuir uma nota inválida (que não esteja entre 0 e 10) e verá que o objeto não aceitará a nota.
Observe que nesta implementação não está sendo gerada nenhuma mensagem de erro.
Vide exemplo em classes/alunoB/TestaAlunoB1.java
/* Exemplo para demonstrar a utilização da classe AlunoB. */
public class TestaAlunoB1{
public static void main(String[] args){
//Declara e instancia objetos.
AlunoB a1 = new AlunoB();
AlunoB a2 = new AlunoB();

System.out.println("****************************************************************");
System.out.println("Testando objetos, atributos, construtores e metodos");
System.out.println("****************************************************************");
System.out.println();

//Mostra dados do objeto recém criado (a1).

System.out.println("Mostra dados do objeto recém criado (a1):");
//Erro de compilação. O atributo nome não está visível (acessível)
//pois foi declarado como privado (private).

20
 //Só estão visíveis os métodos assessores.
//System.out.println("Nome = " + a1.nome);
System.out.println("Nome = " + a1.getNome());
System.out.println("Sexo = " + a1.getSexo());
System.out.println("Idade = " + a1.getIdade());
System.out.println("Nota 1 = " + a1.getNota1());
System.out.println("Nota 2 = " + a1.getNota2());
System.out.println("Media = " + a1.media());
System.out.println("Situacao = " + a1.situacao());
System.out.println();

//Mostra dados do objeto recém criado (a2).

System.out.println("Mostra dados do objeto recém criado (a2):");
System.out.println("Nome = " + a2.getNome());
System.out.println("Sexo = " + a2.getSexo());
System.out.println("Idade = " + a2.getIdade());
System.out.println("Nota 1 = " + a2.getNota1());
System.out.println("Nota 2 = " + a2.getNota2());
System.out.println("Media = " + a2.media());
System.out.println("Situacao = " + a2.situacao());
System.out.println();

//Atribui valores para o objeto a1:

a1.setNome("Pedro");
//a1.sexo = 'M'; //<<< erro de compilação. sexo é um campo privado.
a1.setSexo('M'); //tente colocar 'x'. Não irá atribuir.
a1.setIdade(30); //tente atribuir uma idade negativa. Não irá atribuir.
a1.setNota1(6); //tente colocar uma nota inválida. Não irá atribuir.
a1.setNota2(7);

//Atribui somente as notas para o objeto a2:

a2.setNota1(9);
a2.setNota2(10);

//Mostra dados do objeto (a1).

System.out.println("Mostra dados do objeto (a1):");
System.out.println("Nome = " + a1.getNome());
System.out.println("Sexo = " + a1.getSexo());
System.out.println("Idade = " + a1.getIdade());
System.out.println("Nota 1 = " + a1.getNota1());
System.out.println("Nota 2 = " + a1.getNota2());
System.out.println("Media = " + a1.media());
System.out.println("Situacao = " + a1.situacao());
System.out.println();

//Mostra dados do objeto (a2).

System.out.println("Mostra dados do objeto (a2):");
System.out.println("Nome = " + a2.getNome());
System.out.println("Sexo = " + a2.getSexo());
System.out.println("Idade = " + a2.getIdade());
System.out.println("Nota 1 = " + a2.getNota1());
System.out.println("Nota 2 = " + a2.getNota2());
System.out.println("Media = " + a2.media());
System.out.println("Situacao = " + a2.situacao());
System.out.println();
}
}//TestaAlunoB1.

No exemplo mostrado a seguir (TestaAlunoB2) não é demonstrado nenhum conceito diferente,

apenas é implementado um programa que pede para o usuário digitar o nome, o sexo, a idade e as notas
de um aluno, criando em seguida um objeto Aluno com esses valores e depois mostrando os valores na
tela.
Note que é feita a chamada ao método mostraDados() para que o próprio objeto Aluno mostre seus
dados na tela. Ressalta-se novamente que essa não é a melhor prática: misturar lógica da aplicação com
interface de usuário, conforme explicado no exemplo anterior, mas foi utilizado aqui com o intuito de facilitar
a aprendizagem.
No final do programa é feita uma chamada ao método toString() para se obter uma representação
textual do objeto, a qual é mostrada na tela.
Vide exemplo em classes/AlunoB/TestaAlunoB2.java
/* Exemplo para demonstrar a utilização da classe AlunoB. */

21
public class TestaAlunoB2{
public static void main(String[] args) {
//Objeto para ler do teclado.
Teclado teclado = new Teclado();

//Variaveis auxiliares
String n; //nome
char s; //sexo
int i; //idade
float n1, n2; //nota 1 e nota 2.

//Cria objeto aluno.

AlunoB a = new AlunoB();

//Le dados do aluno.

System.out.print("Digite o nome do aluno: ");
n = teclado.leString();

System.out.print("Digite o sexo do aluno: ");

s = teclado.leChar();

System.out.print("Digite a idade do aluno: ");

i = teclado.leInteiro();

System.out.print("Digite a primeira nota: ");

n1 = teclado.leFloat();

System.out.print("Digite a segunda nota : ");

n2 = teclado.leFloat();

//Atribui dados ao aluno (objeto a).

a.setNome(n);
a.setSexo(s);
a.setIdade(i);
a.setNota1(n1);
a.setNota2(n2);

a.mostraDados(); //Pede para o objeto a1 mostrar seus dados.

System.out.println();//Imprime uma linha em branco na saída.

//Mostra resultados.
String resultado = a.toString();
System.out.println();
System.out.println(resultado);
}
}//TestaAlunoB2.

22
1.18.Exemplo AlunoC
Neste exemplo são demonstrados os seguintes conceitos:
• modificador static
◦ atributos de classe
◦ métodos de classe
• membros de instância (não-estáticos) e membros de classe (estáticos);
◦ diferença entre variáveis de instância e variáveis de classe
◦ diferença entre métodos de instância e métodos de classe
• modificador final
◦ constantes (atributos estáticos e finais)
• sobrecarga de métodos
• palavra chave this
Neste exemplo foram implementados alguns atributos de classe, ou seja, atributos que pertencem à
classe e não às suas instâncias. Um atributo de classe é compartilhado entre todos os objetos da classe.
Para se definir um membro (atributo ou método) como sendo um membro de classe usa-se o modificador
static. Caso não se utilize o modificador static, trata-se de um membro de instância.
Como exemplo, na classe AlunoC, os atributos notaMinima, notaMinimaRecuperacao,
notaMinimaAprovBom, notaMinimaAprovOtimo e notaMaxima, os quais representam os valores
mínimos, máximos e faixas das notas, devem ser únicos, e compartilhados entre todos os objetos da classe
AlunoC. Logo, devem ser atributos pertencentes à classe AlunoC, e não às suas instâncias (objetos).
Note que, para não permitir a atribuição de qualquer valor às faixas das notas, as mesmas foram
definidas como privadas. Porém, foram criados os métodos de classe (estáticos) getNotaMinima(),
getNotaMinimaRecuperacao(), getNotaMinimaAprovBom(), getNotaMinimaAprovOtimo() e
getNotaMaxima() para acessar os valores desses atributos. Também foi criado o método de classe
(estático) setFaixas() para atribuir valores às faixas. Note que esse método faz uma validação nas faixas
sendo atribuídas.
Também foram modificados os métodos setNota1() e setNota2(), para que utilizem as faixas de
notas, e não mais os valores fixos como no exemplo anterior. Isso permite uma organização melhor da
classe. Se for necessário modificar os limites mínimo e máximo das notas, não será necessário sair
vasculhando a classe em busca dos métodos que utilizavam os valores literais 0 e 10. Basta modificar os
valores dos atributos de classe que estão definidos no início da classe. Com isso também se diminui a
chance de erros de digitação.
Nesta classe também foram declaradas duas constantes do tipo char (MASCULINO='M' e
FEMININO='F'). Como o nome sugere, uma constante é um identificador que não pode ser modificado. Para
se definir uma constante utiliza-se o modificador final. É muito comum se usar também o modificador static
ao se definir uma constante, como foi feito neste exemplo. Também foi modificado o método setSexo() para
que utilize as constantes e não mais os valores literais como no exemplo anterior.
Neste exemplo também é demonstrada a utilização da palavra chave this, que representa uma
referência para o próprio objeto. Utiliza-se this quando se quer deixar explícito que se está acessando um
atributo ou método do próprio o objeto, ou quando se tem um conflito de nomes, ou seja, um membro com o
mesmo nome de um identificador local. Veja sua utilização, por exemplo, nos métodos setNome() e
getNome().
Vide exemplo em classes/AlunoC/AlunoC.java
/* Exemplo de uma classe para demonstrar os seguintes conceitos:
- atributos de classe e atributos de instância
- métodos de classe e métodos de instância
- constantes (atributos estáticos e finais)
- palavra chave this
*/

23
public class AlunoC {

//============= Atributos de Classe (estáticos) ===================

public static String textoReprovado = "Reprovado";

public static String textoRecuperacao = "Recuperacao";
public static String textoAprovBom = "Aprovado - Bom";
public static String textoAprovOtimo = "Aprovado - Otimo";

private static float notaMinima = 0;

private static float notaMinimaRecuperacao = 3.0f;
private static float notaMinimaAprovBom = 7.0f;
private static float notaMinimaAprovOtimo = 9.0f;
private static float notaMaxima = 10;

//Constantes.
public static final char MASCULINO = 'M';
public static final char FEMININO = 'F';

//=============== Atributos de Instância ==========================

private String nome;
private char sexo; //M ou F
private int idade; //maior que zero
private float nota1; //entre 0 e 10
private float nota2; //entre 0 e 10

//=================================================================
//===================== Método Construtor =========================
//=================================================================
public AlunoC() {
//Inicializa os atributos do objeto Aluno.
nome = "-----";
sexo = '-';
idade = 0; //Não é necessário (zero já é o padrão).
nota1 = 0.0f; //Não é necessário (zero já é o padrão).
nota2 = 0.0f; //Não é necessário (zero já é o padrão).
}

//=================================================================
//============== Métodos de Classe (estáticos) ====================
//=================================================================

//-------------------------------------------------------
//Método: getNotaMinima()
//Retorna o valor da variável de classe notaMinima.
//-------------------------------------------------------
public static float getNotaMinima() {
return notaMinima;
}//getNotaMinima()

//-------------------------------------------------------
//Método: getNotaMinimaRecuperacao()
//Retorna o valor da variável de classe notaMinimaRecuperacao.
//-------------------------------------------------------
public static float getNotaMinimaRecuperacao() {
return notaMinimaRecuperacao;
}//getNotaMinimaRecuperacao()

//-------------------------------------------------------
//Método: getNotaMinimaAprovBom()
//Retorna o valor da variável de classe notaMinimaAprovBom.
//-------------------------------------------------------
public static float getNotaMinimaAprovBom() {
return notaMinimaAprovBom;
}//getNotaMinimaAprovBom()

//-------------------------------------------------------
//Método: getNotaMinimaAprovOtimo()
//Retorna o valor da variável de classe notaMinimaAprovOtimo.
//-------------------------------------------------------
public static float getNotaMinimaAprovOtimo() {
return notaMinimaAprovOtimo;
}//getNotaMinimaAprovOtimo()

//-------------------------------------------------------
//Método: getNotaMaxima()
//Retorna o valor da variável de classe notaMaxima.

24
//-------------------------------------------------------
public static float getNotaMaxima() {
return notaMaxima;
}//getNotaMaxima()

//-------------------------------------------------------
//Método: setFaixas()
//Atribui valores para as variáveis de classe:
// - notaMinima
// - notaMinimaRecuperacao
// - notaMinimaAprovBom
// - notaMinimaAprovOtimo
// - notaMaxima
// Atenção: Este método deverá ser chamado antes de se
// instanciar qualquer objeto AlunoC. Caso já tenha
// sido instanciado algum objeto AlunoC então este
// método não deverá ser chamado, pois poderá tornar
// inconsistente as notas dos alunos já instanciados.
//-------------------------------------------------------
public static void setFaixas(float min, float rec, float bom, float ot, float max) {
if ( (max>ot) && (ot>bom) && (bom>rec) && (rec>min) ) {
notaMinima = min;
notaMinimaRecuperacao = rec;
notaMinimaAprovBom = bom;
notaMinimaAprovOtimo = ot;
notaMaxima = max;
}
}//setFaixas()

//=================================================================
//===================== Métodos de Instância ======================
//=================================================================

//-------------------------------------------------------
//Método: setNome()
//Atribui o campo nome. Não deixa atribuir um nome vazio.
//-------------------------------------------------------
public void setNome(String nome) {
if (nome.length() > 0 ) {
this.nome = nome;
}
}

//-------------------------------------------------------
//Método: getNome()
//Retorna o campo nome.
//-------------------------------------------------------
public String getNome() {
return this.nome;
}

//-------------------------------------------------------
//Método: setSexo()
//Atribui o campo sexo.
//Não deixa atribuir um valor diferente de 'M' ou 'F'.
//-------------------------------------------------------
public void setSexo(char sexo) {
if ((sexo==MASCULINO) || (sexo==FEMININO)) {
this.sexo = sexo;
}
}

//-------------------------------------------------------
//Método: getSexo()
//Retorna o campo sexo.
//-------------------------------------------------------
public char getSexo() {
return this.sexo;
}

//-------------------------------------------------------
//Método: setIdade()
//Atribui o campo idade. Não deixa atribuir uma idade negativa.
//-------------------------------------------------------
public void setIdade(int idade) {
if (idade > 0 ) {
this.idade = idade;

25
 }
}

//-------------------------------------------------------
//Método: getIdade()
//Retorna o campo idade.
//-------------------------------------------------------
public int getIdade() {
return this.idade;
}

//-------------------------------------------------------
//Método: setNota1()
//Atribui o campo nota1.
//Não deixa atribuir uma nota inválida.
//-------------------------------------------------------
public void setNota1(float nota1) {
if ((nota1 >= notaMinima) && (nota1 <= notaMaxima)) {
this.nota1 = nota1;
}
}

//-------------------------------------------------------
//Método: getNota1()
//Retorna o campo nota1.
//-------------------------------------------------------
public float getNota1() {
return this.nota1;
}

//-------------------------------------------------------
//Método: setNota2()
//Atribui o campo nota2.
//Não deixa atribuir uma nota inválida.
//-------------------------------------------------------
public void setNota2(float nota2) {
if ((nota2 >= notaMinima) && (nota2 <= notaMaxima)) {
this.nota2 = nota2;
}
}

//-------------------------------------------------------
//Método: getNota2()
//Retorna o campo nota2.
//-------------------------------------------------------
public float getNota2() {
return this.nota2;
}

//-------------------------------------------------------
//Método: media()
//Calcula e retorna a média aritmética das notas 1 e 2.
//-------------------------------------------------------
public float media() {
return (this.nota1 + this.nota2) / 2;
}

//-------------------------------------------------------
//Método: situacao()
//Calcula a média aritmética das notas 1 e 2 e retorna a situação do aluno:
// - Reprovado
// - Recuperacao
// - Aprovado - Bom
// - Aprovado - Otimo
//-------------------------------------------------------
//--- Situacao ---
public String situacao() {
if (this.media() < notaMinimaRecuperacao ) {
return textoReprovado;
}
else {
if (this.media() < notaMinimaAprovBom ) {
return textoRecuperacao;
}
else {
if (this.media() < notaMinimaAprovOtimo ) {
return textoAprovBom;

26
 }
else {
return textoAprovOtimo;
}
}
}
}//situacao()

//-------------------------------------------------------
//Método: toString()
//Retorna uma String com uma descrição textual do objeto.
//-------------------------------------------------------
public String toString() {
return "Nome=" + this.nome +
", Sexo=" + this.sexo +
", Idade=" + this.idade +
", Nota1=" + this.nota1 +
", Nota2=" + this.nota2;
}//toString()

//-------------------------------------------------------
//Método: mostraDados()
//Mostra na tela todas as informações do aluno.
//-------------------------------------------------------
public void mostraDados() {
System.out.println("Nome = " + this.nome);
System.out.println("Sexo = " + this.sexo);
System.out.println("Idade = " + this.idade);
System.out.println("Nota 1 = " + this.nota1);
System.out.println("Nota 2 = " + this.nota2);
System.out.println("Media = " + this.media());
System.out.println("Situacao = " + this.situacao());
}//mostraDados()

}//AlunoC.

No exemplo TestaAlunoC1 é demonstrada a utilização das constantes MASCULINO e FEMININO

definidas na classe AlunoC. Note que com essa estratégia não é necessário lembrar-se como é definido o
sexo, se os caracteres M ou F, m ou F, 0 ou 1, etc. É muito mais fácil lembrar das constantes MASCULINO
e FEMININO. Além disso, dependendo do ambiente de programação utilizado, a própria ferramenta pode
sugerir os valores válidos.
Vide exemplo em classes/alunoC/TestaAlunoC1.java
public class TestaAlunoC1{
public static void main(String[] args){
//Declara e instancia objetos.
AlunoC a1 = new AlunoC();
AlunoC a2 = new AlunoC();

System.out.println("****************************************************************");
System.out.println("Testando constantes (atributos estáticos e finais)");
System.out.println("****************************************************************");
System.out.println();

a1.setNome("Joao");
a1.setSexo(AlunoC.MASCULINO);
a1.setIdade(30);
a1.setNota1(6);
a1.setNota2(7);

a2.setNome("Maria");
a2.setSexo(AlunoC.FEMININO);
a2.setIdade(20);
a2.setNota1(9);
a2.setNota2(10);

a1.mostraDados();
System.out.println();
a2.mostraDados();
System.out.println();
}//main()
}//TestaAlunoC1.

27
 No exemplo TestaAlunoC2 é feita a leitura e escrita dos atributos de classe.
Vide exemplo em classes/AlunoC/TestaAlunoC2.java
public class TestaAlunoC2{
public static void main(String[] args){

System.out.println("--------- Acessando atributos de Classe ----------");

System.out.println("textoReprovado = " + AlunoC.textoReprovado);
System.out.println("textoRecuperacao = " + AlunoC.textoRecuperacao);
System.out.println("textoAprovBom = " + AlunoC.textoAprovBom);
System.out.println("textoAprovOtimo = " + AlunoC.textoAprovOtimo);

System.out.println();
System.out.println("----- Modificando atributos de classe para -------");
AlunoC.textoReprovado = "Voce foi REPROVADO";
AlunoC.textoRecuperacao = "Voce está em RECUPERAÇÃO";
AlunoC.textoAprovBom = "Voce foi aprovado com BOM";
AlunoC.textoAprovOtimo = "Voce foi aprovado com ÓTIMO";

System.out.println("textoReprovado = " + AlunoC.textoReprovado);

System.out.println("textoRecuperacao = " + AlunoC.textoRecuperacao);
System.out.println("textoAprovBom = " + AlunoC.textoAprovBom);
System.out.println("textoAprovOtimo = " + AlunoC.textoAprovOtimo);

System.out.println();
System.out.println("--- Chamando métodos de classe (faixas de notas) ---");
System.out.println("Nota Mínima = " + AlunoC.getNotaMinima());
System.out.println("Nota Min. Recuperacao = " + AlunoC.getNotaMinimaRecuperacao());
System.out.println("Nota Min. Aprov. Bom = " + AlunoC.getNotaMinimaAprovBom());
System.out.println("Nota Min. Aprov. Otimo = " + AlunoC.getNotaMinimaAprovOtimo());
System.out.println("Nota Máxima = " + AlunoC.getNotaMaxima());

System.out.println();
System.out.println("--------- Modificando Faixas de Notas para ---------");
AlunoC.setFaixas(0, 30, 70, 90, 100);
System.out.println("Nota Mínima = " + AlunoC.getNotaMinima());
System.out.println("Nota Min. Recuperacao = " + AlunoC.getNotaMinimaRecuperacao());
System.out.println("Nota Min. Aprov. Bom = " + AlunoC.getNotaMinimaAprovBom());
System.out.println("Nota Min. Aprov. Otimo = " + AlunoC.getNotaMinimaAprovOtimo());
System.out.println("Nota Máxima = " + AlunoC.getNotaMaxima());

System.out.println();
System.out.println("Acessando atributos de Classe finais (constantes):");
System.out.println("Masculino = " + AlunoC.MASCULINO);
System.out.println("Feminino = " + AlunoC.FEMININO);

//Erro de compilação. Não é possível modificar um atributo final.

//AlunoC.MASCULINO = 'H';

//Declara e instancia objetos.

AlunoC a1 = new AlunoC();
AlunoC a2 = new AlunoC();

System.out.println();
System.out.println("****************************************************************");
System.out.println("Testando objetos");
System.out.println("****************************************************************");
System.out.println();

//Não utilizar esta forma para acessar membros de classe (estáticos)!!!

System.out.println("Nota Maxima = a1.getNotaMaxima() = " + a1.getNotaMaxima());//NÃO USAR!!!
System.out.println();

a1.setNome("Joao");
a1.setSexo(AlunoC.MASCULINO);
a1.setIdade(30);
a1.setNota1(60);
a1.setNota2(70);

a2.setNome("Maria");
a2.setSexo(AlunoC.FEMININO);
a2.setIdade(20);
a2.setNota1(90);
a2.setNota2(100);

a1.mostraDados();

28
 System.out.println();
a2.mostraDados();
System.out.println();

}//main()
}//TestaAlunoC2.

29
1.19.Exemplo AlunoD
Neste exemplo são demonstrados os seguintes conceitos:
• construtores
• palavra chave this
• sobrecarga de métodos
Nesse exemplo é demonstrado na classe AlunoD a implementação de 4 construtores. Lembre que
um construtor é um método público, com o mesmo nome da classe e sem tipo de retorno. Logo, todos os
construtores possuem o mesmo nome. Note porém, que os construtores possuem parâmetros diferentes.
Isso é um exemplo de sobrecarga de métodos. Dessa forma, será possível construir um objeto AlunoD
chamando-se qualquer um dos seus construtores. Também é demonstrada a utilização da cláusula this()
par invocar um outro método construtor da própria classe.
Vide exemplo em classes/AlunoD/AlunoD.java
/* Exemplo de uma classe para demonstrar os seguintes conceitos:
- métodos construtores
- palavra chave this
- sobrecarga dé métodos (overloading)
*/
public class AlunoD {

//============= Atributos de Classe (estáticos) ===================

private static float notaMinima = 0;

private static float notaMinimaRecuperacao = 3.0f;
private static float notaMinimaAprovBom = 7.0f;
private static float notaMinimaAprovOtimo = 9.0f;
private static float notaMaxima = 10;

//Constantes.
public static final char MASCULINO = 'M';
public static final char FEMININO = 'F';

//=============== Atributos de Instância ==========================

private String nome;
private char sexo; //M ou F
private int idade; //maior que zero
private float nota1; //entre 0 e 10
private float nota2; //entre 0 e 10

//=================================================================
//===================== Métodos Construtores ======================
//=================================================================

//-------------------------------------------------------
// Construtor padrão (default): AlunoD()
//-------------------------------------------------------
public AlunoD() {
//Chama o construtor default da superclasse (Object).
//Não é necessário, pois o compilador já o faz por padrão.
//Mas se for feito explicitamente, tem que ser a primeira linha do construtor.
super();

//Inicializa os atributos do objeto Aluno.

nome = "-----";
sexo = '-';
idade = 0; //Não é necessário (zero já é o padrão).
nota1 = 0.0f; //Não é necessário (zero já é o padrão).
nota2 = 0.0f; //Não é necessário (zero já é o padrão).
}

//-------------------------------------------------------
// Construtor: AlunoD(String)
//-------------------------------------------------------
public AlunoD(String n) {
//Chama o construtor AlunoC(). Deve ser a primeira linha.
this();

30
 //Atribui o nome.
setNome(n);
// nome = n; //Não recomendado.
//this.nome = n; //Não recomendado.
}

//-------------------------------------------------------
// Construtor: AlunoD(String, char)
//-------------------------------------------------------
public AlunoD(String n, char s) {
//Chama o construtor AlunoC(String). Deve ser a primeira linha.
this(n);
//Atribui o sexo.
setSexo(s);
}

//-------------------------------------------------------
// Construtor: AlunoD(String, char, int)
//-------------------------------------------------------
public AlunoD(String n, char s, int i) {
//Chama o construtor AlunoC(String, char). Deve ser a primeira linha.
this(n, s);
//Atribui a idade.
setIdade(i);
}

//-------------------------------------------------------
// Construtor: AlunoD(String, char, int, float, float)
// Esta versão do construtor não está aproveitando os
// construtores anteriormente implementados, fazendo
// a inicialização de todos os atributos no próprio construtor.
//-------------------------------------------------------
public AlunoD(String n, char s, int i, float n1, float n2) {
//Lembre que:
//Se não for chamado explicitamente o construtor da superclasse, o compilador o fará.
//super(); //Chama o construtor da superclasse (Object). Não é necessário pois já é o padrão.

//Inicializa os atributos do objeto Aluno.

//Note que não está sendo aproveitado nenhum construtor já implementado acima.
setNome(n);
setSexo(s);
setIdade(i);
setNota1(n1);
setNota2(n2);
}

//=================================================================
//===================== Métodos de Instância ======================
//=================================================================

//-------------------------------------------------------
//Método: setNome()
//Atribui o campo nome. Não deixa atribuir um nome vazio.
//-------------------------------------------------------
public void setNome(String nome) {
if (nome.length() > 0 ) {
this.nome = nome;
}
}

//-------------------------------------------------------
//Método: getNome()
//Retorna o campo nome.
//-------------------------------------------------------
public String getNome() {
return this.nome;
}

//-------------------------------------------------------
//Método: setSexo()
//Atribui o campo sexo.
//Não deixa atribuir um valor diferente de 'M' ou 'F'.
//-------------------------------------------------------
public void setSexo(char sexo) {
if ((sexo==MASCULINO) || (sexo==FEMININO)) {
this.sexo = sexo;
}

31
}

//-------------------------------------------------------
//Método: getSexo()
//Retorna o campo sexo.
//-------------------------------------------------------
public char getSexo() {
return this.sexo;
}

//-------------------------------------------------------
//Método: setIdade()
//Atribui o campo idade. Não deixa atribuir uma idade negativa.
//-------------------------------------------------------
public void setIdade(int idade) {
if (idade > 0 ) {
this.idade = idade;
}
}

//-------------------------------------------------------
//Método: getIdade()
//Retorna o campo idade.
//-------------------------------------------------------
public int getIdade() {
return this.idade;
}

//-------------------------------------------------------
//Método: setNota1()
//Atribui o campo nota1.
//Não deixa atribuir uma nota inválida.
//-------------------------------------------------------
public void setNota1(float nota1) {
if ((nota1 >= notaMinima) && (nota1 <= notaMaxima)) {
this.nota1 = nota1;
}
}

//-------------------------------------------------------
//Método: getNota1()
//Retorna o campo nota1.
//-------------------------------------------------------
public float getNota1() {
return this.nota1;
}

//-------------------------------------------------------
//Método: setNota2()
//Atribui o campo nota2.
//Não deixa atribuir uma nota inválida.
//-------------------------------------------------------
public void setNota2(float nota2) {
if ((nota2 >= notaMinima) && (nota2 <= notaMaxima)) {
this.nota2 = nota2;
}
}

//-------------------------------------------------------
//Método: getNota2()
//Retorna o campo nota2.
//-------------------------------------------------------
public float getNota2() {
return this.nota2;
}

//-------------------------------------------------------
//Método: media()
//Calcula e retorna a média aritmética das notas 1 e 2.
//-------------------------------------------------------
public float media() {
return (this.nota1 + this.nota2) / 2;
}

//-------------------------------------------------------
//Método: situacao()
//Calcula a média aritmética das notas 1 e 2 e retorna a situação do aluno.

32
 //Media - Situacao
//(< 3) - Reprovado
//(>=3 E < 7) - Recuperacao
//(>=7 E < 9) - Aprovado - Bom
//(>=9 E <=10) - Aprovado - Otimo
//-------------------------------------------------------
//--- Situacao ---
public String situacao() {
if (this.media() < notaMinimaRecuperacao ) {
return "Reprovado";
}
else {
if (this.media() < notaMinimaAprovBom ) {
return "Recuperacao";
}
else {
if (this.media() < notaMinimaAprovOtimo ) {
return "Aprovado - Bom";
}
else {
return "Aprovado - Otimo";
}
}
}
}//situacao()

//-------------------------------------------------------
//Método: toString()
//Retorna uma String com uma descrição textual do objeto.
//-------------------------------------------------------
public String toString() {
return "Nome=" + this.nome +
", Sexo=" + this.sexo +
", Idade=" + this.idade +
", Nota1=" + this.nota1 +
", Nota2=" + this.nota2;
}//toString()

//-------------------------------------------------------
//Método: mostraDados()
//Mostra na tela todas as informações do aluno.
//-------------------------------------------------------
public void mostraDados() {
System.out.println("Nome = " + this.nome);
System.out.println("Sexo = " + this.sexo);
System.out.println("Idade = " + this.idade);
System.out.println("Nota 1 = " + this.nota1);
System.out.println("Nota 2 = " + this.nota2);
System.out.println("Media = " + this.media());
System.out.println("Situacao = " + this.situacao());
}//mostraDados()

}//AlunoD.

No exemplo TestaAlunoD1 é demonstrada a criação de dois objetos da classe AlunoD utilizando-

se construtores diferentes.
Vide exemplo em classes/alunoD/TestaAlunoD1.java
public class TestaAlunoD1{
public static void main(String[] args){
//Declara e instancia objetos.
AlunoD a1 = new AlunoD("Joao");
AlunoD a2 = new AlunoD("Maria", AlunoC.FEMININO, 20);

System.out.println("****************************************************************");
System.out.println("Testando objetos, campos, construtores e metodos");
System.out.println("****************************************************************");
System.out.println();

//Atribui valores para a1:

a1.setSexo(AlunoC.MASCULINO);
a1.setIdade(30);
a1.setNota1(6);
a1.setNota2(7);

33
 //Atribui valores para a2:
a2.setNota1(9);
a2.setNota2(10);

//Mostra dados dos alunos:

a1.mostraDados();
System.out.println();
a2.mostraDados();
}//main()

}//TestaAlunoD1.

O programa TestaAlunoD2 mostra outro exemplo de instanciação da classe AlunoD utilizando um

construtor diferente do default.
Vide exemplo em classes/AlunoD/TestaAlunoD2.java
import java.util.Scanner;

public class TestaAlunoD2{

public static void main(String[] args) {

//Objeto para ler do teclado.

Scanner teclado = new Scanner(System.in);

//Variaveis auxiliares
String n; //nome
char s; //sexo
int i; //idade
float n1, n2; //nota 1 e nota 2.

//Declara o objeto aluno, mas ainda não instancia ele.

AlunoD a;

//Le dados do aluno.

System.out.print("Digite o nome do aluno: ");
n = teclado.nextLine();

System.out.print("Digite o sexo do aluno: ");

s = teclado.nextLine().charAt(0);

System.out.print("Digite a idade do aluno: ");

i = teclado.nextInt();
teclado.nextLine();

System.out.print("Digite a primeira nota: ");

n1 = teclado.nextFloat();
teclado.nextLine();

System.out.print("Digite a segunda nota : ");

n2 = teclado.nextFloat();
teclado.nextLine();

//Instancia o objeto aluno.

a = new AlunoD(n, s, i);
//Atribui notas ao aluno (objeto a).
a.setNota1(n1);
a.setNota2(n2);
//Mostra resultados.
System.out.println();
a.mostraDados();
}//main()

}//TestaAlunoD2.

34
35