Linguagem de Programação Java 1

Centro de Ensino Unificado de Teresina Ltda. - CEUT

Pós-Graduação Lato Sensu
Especialização em Desenvolvimento de Sistemas de
Informação para WEB

Linguagem de Programação Java

Prof. Ricardo Martins Ramos

ricardo@cefetpi.br

Outubro 2006
Linguagem de Programação Java 2

Capítulo 3 – Introdução à Programação Orientada a Objetos

3.0 - Introdução
“Paradigma é um conjunto de regras que estabelecem fronteiras e
descreve como resolver os problemas dentro destas fronteiras. Os paradigmas
influenciam nossa percepção; ajudam-nos a organizar e a coordenar a maneira
como olhamos para o mundo...”
A POO (Programação Orientada a Objetos) é o paradigma de
programação predominante dos dias atuais, tendo substituído as técnicas de
programação baseada em procedimentos, “estruturadas”, que foram
desenvolvidas nos anos 70.
A programação tradicional estruturada consiste em projetar um conjunto
de funções para resolver um problema. (Essas funções são geralmente
chamadas de algoritmos). O passo seguinte convencional é encontrar a forma
apropriada de armazenar os dados. É por isso que o criador do Pascal original,
Niklaus Wirth, chamou seu famoso livro de Algoritmos + Estrutura de Dados =
Programas (Algorithms + Data Structures = Programs, Prentice Hall, 1975).
Observe que no título do livro de Wirth, os algoritmos vinham antes e as
estruturas de dados depois. Isso imitava a forma com que os programadores
trabalhavam naqueles tempos. Primeiro, decidia-se como manipular os dados;
depois, que estrutura impor aos dados a fim de tornar mais fácil o
processamento. A POO inverte essa ordem e coloca as estruturas de dados em
primeiro lugar, examinando depois os algoritmos que vão processar os dados.

Orientação a Objetos
O termo orientação a objetos significa organizar o mundo real como uma
coleção de objetos que incorporam estrutura de dados e comportamento.
Linguagens de Programação Orientada a Objetos: Simula, Smalltalk, Flavours,
Objective C, C++, etc.
Linguagem de Programação Java 3

3.1 – Objetos e Classes

3.1.1 Classes
Uma classe é geralmente descrita como o modelo ou a forma a partir da
qual um objeto é criado.
Usamos as classes para construir objetos, o que é chamado de
instanciação. E os objetos consistem a essência da programação orientada a
objetos (ou OOP, do inglês Object-Oriented Programming). Falando
intuitivamente, as classes são uma maneira de organizar um conjunto de
dados e designar todos os métodos necessários para usar ou alterar esses
dados.

Exercício 1.1 Obs. Identificar e corrigir os erros

public class Semaforo

{
private int luzAcesa = 1; // 0=vermelho,1=verde,2=amarelo

public static void main ( String[] args)

{
Alternar();
}

public static void Alternar()

{
luzAcesa = ++luzAcesa % 3;
System.out.println("O semaforo esta com valor : " + luzAcesa );
}
}

Semáforo
Dados luzAcesa
Métodos Main(String[] args)
Alternar()

3.1.2 Atributos e Variáveis Locais

Podemos declarar variáveis no corpo de uma classe, chamadas atributos,
e variáveis no corpo de métodos, chamadas variáveis locais. A capacidade de
Linguagem de Programação Java 4

acessar uma variável de uma classe depende fundamentalmente de duas

coisas: moderadores de acesso e localização da variável dentro da classe.
As variáveis locais somente são acessíveis pelo método que as declara,
enquanto que os atributos dependem dos moderadores. Apesar de ser possível
deixar todos os atributos de uma classe publicamente acessíveis, isto não é
recomendável. Do contrário estaríamos desperdiçando o sofisticado mecanismo
de proteção de dados fornecido pela OOP (encapsulamento), o qual permite
escrever programas mais robustos e livres de erros.
Os possíveis moderadores empregados na declaração de atributos são os
seguintes:
- friendly: todos os campos são friendly por default. Isto significa que são
acessíveis por outras classes integrantes do mesmo package e não são
acessíveis por nenhuma classe ou subclasse exterior ao package;
- public: idêntico ao moderador de acesso dos métodos. O campo é
acessível a partir de qualquer outra classe, independentemente do package;
- protected: os campos protected podem ser acessados a partir de
qualquer classe derivada da classe atual, mas não são acessíveis de fora do
package;
- private: é o maior grau de proteção. Um campo private é acessível
unicamente pela classe atual;
- static: um campo static é compartilhado por todas as instâncias de uma
classe, isto é, há um único valor para esse campo, independentemente da
quantidade de instâncias existentes, mesmo que não haja nenhuma;
- final: um modificador final precedendo um campo declara esse campo
como uma constante. Seu valor não pode mudar durante a execução do
programa.

3.1.3 Declarando uma Classe

A forma geral da declaração de uma classe é a seguinte:
[modificadores] class nome_classe [extends nome_super] [implements
nome_interface]
As partes que aparecem entre colchetes são opcionais.
Linguagem de Programação Java 5

Modificadores
Ao declarar uma nova classe, é possível especificar um dos seguintes
modificadores:
- public: permite definir classes públicas. Estas classes são acessíveis a
partir de qualquer objeto, independentemente do package. Uma classe pública
deve ser a única classe desse tipo no arquivo em que está declarada e o nome
do arquivo deve ser igual ao da classe;
- friendly: se nenhum modificador de classe for especificado, então a
classe será considerada friendly. Apenas os objetos integrantes do mesmo
package podem utilizar uma classe friendly;
- final: uma classe final pode ser instanciada, mas não pode ser derivada,
isto é, não pode ser superclasse de nenhuma subclasse;
- abstract: classes abstratas são aquelas que contém ao menos um
método incompleto. Desse modo uma classe abstrata não pode ser
instanciada, mas pode ser derivada. Neste caso, a subclasse deve prover o
corpo do método para que possa ser instanciada. Isto é muito útil quando
desejamos definir em uma classe regras gerais para o comportamento de uma
parte do programa, para que, mais tarde, as regras mais específicas sejam
introduzidas por subclasses.

Super Classes (extends)

Um dos aspectos mais importantes da OOP é a capacidade de usar
atributos e métodos de uma classe previamente construída. Por meio da
extensão de classes simples podemos construir classes maiores, acrescentando
àquelas mais atributos e métodos, obtendo com isto mais funcionalidades. Ao
derivar uma classe, estamos primeiramente fazendo “uma cópia da classe
mãe” (herança).
Não existe herança múltipla em Java, ou seja, somente é possível derivar
uma classe a partir de uma outra e não de várias.
Linguagem de Programação Java 6

Exercício 1.2.

public class Empregado //classe pública

{
private String nome,funcao; //atributos acessíveis somente pela
private double salario; // classe atual;

//private static double salario;

public Empregado(String n, String f, double s)
{
nome = n;
funcao = f;
salario = s;
}

public void print()

{
System.out.println(nome + " " + funcao + " " + salario);
}

public void aumentarSalario(double aumento) //depois private

{
int valor = 2; // variável local a este método
salario = salario + aumento * valor;
}

Empregado
Dados Nome
função
salario
Métodos Empregado(n,f,s)
print()
aumentarSalario(aumento)

3.1.4 Objetos
Quando se cria um objeto a partir de uma classe, diz-se que foi criada
uma instância da classe.
Objetos são pacotes de software compostos de dados e procedimentos
que atuam sobre estes dados. Os procedimentos são também conhecidos como
métodos e determinam o comportamento do objeto.
Linguagem de Programação Java 7

Objeto = dado + método

Objeto = estado + comportamento

Encapsulamento (algumas vezes chamada de ocultamento de dados) é

outro conceito-chave ao se trabalhar com objetos. Formalmente, o
encapsulamento não é nada mais que combinar dados e comportamento em
um pacote e ocultar a implementação dos dados do usuário do objeto. Um
objeto específico que é uma instância de uma classe terá valores específicos
em seus campos que definem seu estado atual.
Todos os objetos que são instâncias de uma classe compartilham uma
semelhança de família apresentando um comportamento semelhante. O
comportamento de um objeto é definido pelas mensagens que ele aceita.
Em seguida, cada objeto guarda informações sobre o que ele é no
momento e como chegou a isso. Isto é o que geralmente é chamado do estado
do objeto. O estado de um objeto precisa resultar de mensagens enviadas a
esse objeto (caso contrário o encapsulamento seria desrespeitado).

Exercício 1.3. Obs: Identifique e corriga o(s) erro(s)

public class TestaEmpregado
{
public static void main(String[] args)
{
Empregado empregado1;
empregado1 = new Empregado("Fulano de tal",
"informatica",1000);
Empregado empregado2 = new Empregado("Sicrano de tal",
"almoxarifado",1500);
Empregado empregado3 = new Empregado("Tal", "rh",4000);

empregado1.salario = empregado1.salario + 720;

empregado1.aumentarSalario(450);
empregado1.print;
empregado2.aumentarSalario(450);
empregado2.print();
empregado3.aumentarSalario(450);
empregado3.print();

}
}
Linguagem de Programação Java 8

3.1.5 Construtores
Vamos examinar o primeiro método apresentado na classe Empregado:
public Empregado(String n, String f, double s)
{
nome = n;
funcao = f;
salario = s;
}

Este é um exemplo típico de um método construtor. Ele é usado para

inicializar objetos de uma classe – dando às variáveis de instância o estado
inicial que se quer que elas tenham.
O método new é sempre usado junto com um construtor para criar um
objeto da classe. Isso força o programador a especificar o estado inicial dos
objetos. Em Java, não se pode criar uma instância de uma classe sem
inicializar as variáveis de instância (seja explicitamente ou implicitamente).
Vamos manter o seguinte em mente:
- Um construtor tem o mesmo nome que a classe;
- Um construtor pode (como nesse exemplo) ter um ou mais parâmetros
(ou mesmo nenhum);
- Um construtor é sempre chamado através da palavra-chave new;
- Um construtor não retorna nenhum valor;

Lembre-se também, da importante diferença entre construtores e outros

métodos:
- Um construtor só pode ser chamado através de new. Não se pode aplicar
um construtor a um objeto existente para reinicializar os campos de instância.

3.1.6 – Variáveis Objeto

Para acessar os objetos, definem-se variáveis objeto. Por exemplo no
Exercício 1.4, a instrução Empregado empregado1; define uma variável
objeto, empregado1, que pode fazer referência a objetos do tipo
Empregado. É importante perceber que a variável empregado1 não é um
objeto e, na verdade, nem mesmo se refere a um objeto ainda. Não pode usar
Linguagem de Programação Java 9

nenhum método de Empregado com essa variável, por enquanto. Deve-se

usar o operador new para criar um objeto.
Pode explicitamente fazer uma variável objeto igual a null para indicar
que ela atualmente não faz referência a nenhum objeto.

Empregado empregado2 = new empregado();

...
empregado2=null;
...
if(empregado2 != null) empregado2.print();

Exercício 1.4. Obs: Identifique e corriga o(s) erro(s)

public class TestaEmpregado2

{
public static void main(String[] args)
{
Empregado empregado1; // variável objeto
empregado1.aumentarSalario(400);

empregado1 = new Empregado("Fulano de tal",

"informatica",1000);

indica o envio de mensagem para o objeto empregado1

empregado1.aumentarSalario(450);
// acionando o método aumentarSalario para o objeto definido em
//empregado1

empregado1.print;

}
}

3.1.7 – Métodos Mutator e Accessor

Há uma diferença conceitual entre o método get e os métodos set e add.
O método get somente consulta o estado do objeto e o informa. Já os métodos
set e add modificam o estado do objeto. Métodos que alteram campos de
instância são chamados de métodos mutator (que modificam), e aqueles que
somente acessam campos de instância sem modificá-los são chamados de
Linguagem de Programação Java 10

métodos accessor (que acessam). A convenção em Java é usar o prefixo em

letras minúsculas get para os métodos “acessadores” e set para os métodos
“modificadores”.

3.1.8. Sobrecarga ou Overloading

A sobrecarga ocorre se vários métodos têm o mesmo nome mas
argumentos diferentes. O interpretador Java precisa decidir qual método
chamar. (Isso é geralmente chamado de resolução de sobrecarga –
overloading resolution). Ele escolhe o método correto comparando os tipos
dos argumentos nos cabeçalhos dos vários métodos com os tipos dos valores
usados nas chamada do método específico. (Mesmo se não houver nenhum
argumento, é necessário usar os parênteses vazios). Ocorre um erro em tempo
de compilação se o compilador não puder casar os argumentos ou se mais de
uma coincidência for possível.
A linguagem Java permite sobrecarregar qualquer método.

Exercício 1.5

public class Ponto

{
protected double x, y;

public Ponto()
{
setPonto( 0, 0 );
}

public Ponto( double a, double b )

{
setPonto( a, b );
}

public void setPonto( double a, double b )

{
x = a;
y = b;
}

public String posicao()

Linguagem de Programação Java 11

{
return "O ponto tem x = " + x + ", e y = " + y;
}

3.1.9 Construtores Padrão

É um construtor sem argumentos. Se você escrever o código para uma
classe sem construtores de nenhum tipo, a linguagem Java vai providenciar
um construtor padrão. Esse construtor padrão inicializa todas as variáveis de
instância com seus valores padrão. Assim, todos os dados numéricos contidos
nos campos de instância serão zerados, todas as variáveis objeto vão apontar
para nulo e todas as variáveis lógicas serão falsas.

Exercício 1.6. Obs: Identifique e corriga o(s) erro(s)

class TestaPonto
{
public static void main(String args[])
{
Ponto meuponto;

meuponto = new Ponto(); //construtor padrão

System.out.println(meuponto.posicao());

meuponto.setponto(10,23);
System.out.println(meuponto.posicao());

}
}

3.1.10 Referência a Objetos this

Ocasionalmente, é preciso acessar o objeto atual em sua totalidade e não
uma variável de instância particular. A linguagem Java tem um atalho
conveniente para fazer isso – a palavra-chave this. Em um método, a palavra-
chave this faz referência ao objeto no qual o método opera (Exercício 1.7).
A palavra this substitui uma referência à própria classe. Há basicamente
duas situações em que devemos empregar a palavra this:
- Quando houver duas variáveis com mesmo nome numa mesma classe –
uma pertencendo à classe e outra pertencendo a algum dos métodos da
Linguagem de Programação Java 12

classe. Nesse caso, apenas esse método específico requer o uso do this se
quiser fazer referência ao campo da classe;
- Quando uma classe precisa passar uma referência de si própria a um
método.
Há um outro significado para a palavra-chave this. Se o primeiro
elemento de um construtor tiver a forma this (...), então o construtor chama
outro construtor da mesma classe.

Exemplo.

public Ponto()
{
this( 0, 0 );
}

Ao fazer new Ponto(), o construtor Ponto() chama o construtor Ponto(

double a, double b ).

Exercício 1.7. Obs: Criar um arquivo com nome TestaPonto que possua
as duas classes abaixo. Identifique e corriga o(s) erro(s)

public class TestaPonto

{
public static void main(String args[])
{
Ponto p1 = new Ponto(0,0);
Ponto p2 = new Ponto(10,20);

p1.mover(3,25);
p2.mover(1,14);

System.out.println(p1.distancia(p2));

}
}

public class Ponto

{
int x, y;

Ponto (int a, int b)

{
x = a;
Linguagem de Programação Java 13

y = b;
}

void mover (int dx, int dy)

{
x += dx;
y += dy;
}

double distancia (Ponto p)

{
int dx = this.x – p.x;
int dy = this.y – p.y;
return Math.sqrt(dx*dx + dy*dy);
}
}