Programação Orientada a Objetos I – Prof. Ediberto.

Programação OO em Java – Objetos, Classes, Tipos de dados, Variáveis, Constantes, Atribuições,

Inicializações e Operadores, Métodos , Manipulação de Strings, Controle de Fluxo, Arrays, Herança e
Polimorfsmo

Por que a Orientação a Objetos?

O despertar do interesse da comunidade da computação pela Programação Orientada a Objetos deve-se,
em parte, à aceitação das linguagens constituídas (formadas) SIMULA E SMALLTALK. Ambas demonstraram o
poder da modelagem baseada em classes, onde os dados e procedimentos estão formalizados e m uma só
entidade.

Nome da classe

Atributos

Métodos

Houve o reconhecimento (principalmente no meio acadêmico) de que se poderia poup ar esforço de

implementação e de que objetos poderiam ser pré -programados e reaproveitados. No caso do SMALLTALK,
a filosofia do ambiente Windows que a linguagem proporcionava indicava o potencial deste tipo de interface.
Apesar disso, durante a década de 80 pode-se dizer que a adoção dos princípios da programação
Orientada a Objetos pela indústria ficou abaixo do esperado. Vários fatores contribuíram para que isto
ocorresse:
- As linguagens SIMULA E SMALLTALK ficaram praticamente cofinadas aos meios acadêmicos e aos
grupos que as criaram.
- Além desse confinamento, em algumas das utilizações a programação Orientada a Objetos com
SMALLTALK era encarada mais como técnica de programação por janelas (Windows) do que como
um novo paradigma (modelo) de programação.
- Outro ponto crítico na utilização comercial da programação Orientada a Objetos residia no fato de que
as linguagens disponíveis eram, em sua maioria, interpretadas. Como se sabe a indústria tem resistência
quanto à necessidade de tornar públicos os códigos-fonte de seus sistemas.

Classes, Objetos e Métodos

- As classes são descrições de um conjunto de objetos que compartilham os mesmos atributos, operações,
relacionamentos e semântica. Ou seja, as classes são modelos estáticos para os objetos que serão
instanciados a partir delas.
- Os atributos são os dados de cada objeto e podem ter valores diferentes para cada um deles, mas seguem
sempre o modelo descrito na sua respectiva classe (tipos, nomes, etc).
- As operações, chamadas de métodos, são as ações que podemos executar com aquele objeto, modificando
seus dados ou não. Os objetos de um sistema se comunicam através dos métodos.
- O conceito de classes no POO (Projeto Orientado a Objetos) define o encapsulamento do código das
operações junto com os dados, difere nte do projeto de sistemas estruturados, onde em geral se define o
fluxo de ações que alteram os dados do sistema, mesmo que estas ações estejam em módulos separados.
- Na POO, cada componente tem seus dados e suas operações bem definidas, podendo aproximar o projeto
e a implementação do sistema às entidades (pessoas, objetos, etc) e seus relacionamentos no mundo real
de uma forma mais natural.

1
 Programação Orientada a Objetos I – Prof. Ediberto.
Notação UML para Classes
- A UML (Unified Modeling Language) é uma linguagem para se modelar projetos bem estruturados, muito
usada para POO, indispensável em projetos de software complexos.
- As classes na UML são representadas por retângulos, geralmente incluindo seu nome, atributos (dados) e
operações (métodos).
Nome Primeiro
Atributos

Métodos
main( )

Exemplo de notação UML para uma classe (Primeiro).

Um Programa Simples em JAVA

- Veremos inicialmente o mais simples programa JAVA:
public class Primeiro
{
public static void main (String[] args)
{
System.out.println(“Primeiro programa em java!!!”);
}
}
- Após compilar e executar este programa, nós vamos analisar suas partes principais, que se repetem na
maioria dos programas JAVA:
o A palavra-chave public é um modificador de acesso; esses modificadores controlam o que outras
partes de um programa podem usar desse código;
o A palavra-chave class está lá porque tudo em JAVA está dentro de uma classe; por enquanto, uma
classe é um projeto preliminar para os dados e métodos (funções) que vão tomar parte de ou serão
todo o aplicativo;
o Os nomes das classes, neste exemplo a palavra Primeiro , precisam começar com uma letra e
depois desta quaisquer combinações de letras e dígitos; como padrão, os nomes são substantivos
que iniciam com uma maiúscula;
o Para começar a execução do programa compilado, o interpretador vai iniciar sempre pelo método
main da classe indicada; é absolutamente necessária a presença do main;
o As chaves, { e }, delimitam os blocos de comandos em JAVA;
o As palavras static void serão comentadas mais tarde; por enquanto tomemos que os cabeçalhos de
main são sempre idênticos ao exemplo acima;
o O método main contém apenas uma instrução (ou comando ou sentença da linguagem): a instrução
utiliza o método println do objeto System.out, para exibir uma string na console padrão; cada
chamada de println escreve uma nova linha;
o Java usa a sintaxe geral:
objeto.metodo(parametros);
o Os métodos em JAVA podem ter zero, um ou mais argumentos (ou parâmetros), até mesmo o
main, mas mesmo que o método não tenha argumentos, ele terá que possuir parênteses vazios;
o Existe também o método printf em System.out.
Comentários em JAVA

2
 Programação Orientada a Objetos I – Prof. Ediberto.
- Os comentários não aparecem no executável do programa; em JAVA temos comentários de uma linha,
sinalizados com //, e temos os comentários de mais de uma linha, entre /* e */:
// Este é um comentário de uma linha
/* Agora podemos escreve r
o comentário em várias linhas.
*/
- Os comentários não podem ser aninhados em JAVA, ao contrário de outras linguagens.
Exercício
Codifique um programa em JAVA que:
a) Escreva no início do programa como comentário: Nome do autor, Data e Objetivo do programa.
b) Exiba na tela a frase: Meu primeiro programa na linguagem Java
/*Nome do autor: Ediberto
Data: 22/08/2006
Objetivo do Programa: */
public class Primeiro
{ public static void main (String[] args)
{System.out.println(“Primeiro programa na linguagem java”);
}}
Tipos de dados, Variáveis e Constantes
- JAVA é fortemente tipada, ou seja, as variáveis precisam ter um tipo declarado.
- Há oito tipos primitivos de dados em JAVA: quatro tipos inteiros, dois tipos ponto flutuante, um tipo para
caracteres e outro para variáveis lógicas.
Inteiros
Tipo Descrição
long Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre –263 e
263 - 1 ( 8 bytes)
int Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre –
231 = 2.147.483.648 e 231 - 1 = 2.147.483.647 (4 bytes)
short Inteiro de 16 bits em notação de complemento de dois. Os valores possíveis cobrem a
faixa de –2-15 = - 32.768 a 2 15 - 1 = 32.767 (2 bytes)
byte Inteiro de 8 bits em notação de complemento de dois. Pode assumir valores entre –27 = -
128. e 27 - 1 = 127 (1 byte)
- O tipo int é o mais prático e o mais usado;
- O mais importante é que os intervalos possíveis não dependem da máquina;
Ponto Flutuante
Tipo Descrição
double Representa números em notação de ponto flutuante normalizada
em precisão dupla de 64 bits em conformidade com a norma
IEEE 754-1985.
O menor valor possível representável é 4.94065645841246544e-
324 e o maior é 1.7976931348623157e+308 (8 bytes)
float Representa números em notação de ponto flutuante normalizada em
precisão simples de 32 bits em conformidade com a norma IEEE
754-1985.
O menor valor possível representável é 1.40239846e-46 e o maior é
3.40282347e+38 (4 bytes)
- O tipo double tem duas vezes a precisão do float.
- O double é usado na maioria dos casos.
O Tipo Caractere (Char)

3
 Programação Orientada a Objetos I – Prof. Ediberto.
- Apóstrofos definem valores char; por exemplo ‘J’ é um caractere e “J” é uma string contendo um único
caractere.
Caracteres Especiais
Seqüência de Controle Significado
\b backspace (volta um caracter)
\t tab (tabulação)
\n linefeed (quebra de linha)
\r carriage return (início da linha)
\“ aspas duplas
\’ apóstrofos
\\ barra invertida
O Tipo Lógico (Boolean)
- O tipo boolean tem dois valores possíveis, false e true.
Variáveis
- Declaram-se as variáveis JAVA colocando o tipo primeiro e depois o nome da variável, finalizando com
ponto e vírgula:
byte b;
//para casos em que o tamanho de memória importa
int numerointeiro1, numerointeiro2;
long inteirolongo;
//para o valor da nossa divida externa em centavos
char letra;
- Não podem ser usados espaços em nomes de variáveis ou de identificadores quaisquer;
Variáveis de Classe
- É possível que sejam necessárias variáveis ou constantes acessíveis por todos os métodos da classe. As
variáveis de classe são declaradas fora de qualquer método da classe como no modelo anterior no lugar de:
//declaração das variáveis de classe
- Estas declarações são feitas da mesma maneira que as declarações comuns de variáveis com a adição das
palavras private static se for preciso definir que é uma variável visível apenas naquela classe.
Veja:
private static double juros = 0.0123456;
As variáveis de classe, diferente das variáveis locais, recebem valores a priori automaticamente (objetos recebem
null , booleanas recebem false e variáveis numéricas recebem 0 (zero)).
Constantes
- A palavra final denota uma constante (utilize maiúsculas nos nomes das constantes):
final double CMPORPOL = 2.54;
- É mais comum definir uma constante que fique disponível para vários métodos dentro de uma classe. As
chamadas Constantes de Classe são definidas com static final:
public class Constantes
{ public static final double G = 9.81;
//gravitacao em metros por segundo ao quadrado
public static void main (String[] args)
{ System.out.println(G + “ metros por segundo ao quadrado é a
aceleração da gravidade.”);
System.out.println(“A constante de classe G= ” + G + “ pode ser
acessada em qualquer método da classe.”);
}
}

4
 Programação Orientada a Objetos I – Prof. Ediberto.
Atribuições, Inicializações e Operadores
- Deve-se inicializar uma variável antes de utilizá- la, em geral após a sua declaração ou na mesma
instrução, exemplos:
int numero; //esta é uma declaração
numero = 5; //esta é uma atribuição
char letra = ‘A’; //esta é uma inicialização
- As declarações podem aparecer em qualquer lugar do código, mas uma variável só pode ser declarada uma
vez em um bloco.
Operadores Aritméticos
- Operadores aritméticos:
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto inteiro de uma divisão
++ Incremento
-- Decremento
- ATENÇÃO: o operador / denota divisão inteira se os dois argumentos forem inteiros e divisão de ponto
flutuante se pelo menos um dos operandos for um número real.
- O resto inteiro é denotado por %. Exemplos: (15 / 4) é 3, (15 % 2) é 1.
- Pode-se utilizar inicializações do tipo:
int n = 3;
int dobron = n * 2;
- Pode-se utilizar a forma reduzida:
n += 4; //que equivale a n = n + 4;
Operadores Relacionais
> Maior que
>= Maior ou igual
< Menor que
<= Menor ou igual
== Igual a
= Atribuição
!= Diferente de
Operadores Lógicos
&& And (lógico)
|| Or (lógico)
Exponenciação
- Não há operador para exponenciação, deve-se usar o método Math.pow. Para xa, temos:
double y = Math.pow (x, a);

Métodos: construtor, acesso, modificador.

Métodos Construtores: È quando desejamos criar um objeto em programa empregando a instrução NEW,
conforme abaixo:
Button b1 = new Button(); (Veremos mais adiante..)
Métodos MATH
MATH – É uma classe de Java.lang, pacote padrão da linguagem. Não é necessário importar nenhum pacote.
Lista de métodos de Math
Método Descrição Exemplo
abs(x) Valor absoluto de x Se x = -3, então abs(x) é 3
ceil(x) Arredonda para o próximo inteiro Se x = 6.7, ceil(x) é 7.
5
 Programação Orientada a Objetos I – Prof. Ediberto.
maior que x Se x = -6.8, ceil(x) é –6
floor(x) Arredonda para o próximo inteiro Se x = 6.7, floor(x) é 6.
menor de x Se x = -6.8, floor(x) é –7
max(x,y) Maior valor entre x e y max(3,4) é 4
min(x,y) Menor valor entre x e y min(3,4) é 3
sqrt(x) Raiz quadrada de x sqrt(9) é 3
PI Valor da constante PI 3.14159265358979323846
Métodos da Classe java.text.NumberFormat:
- A classe NumberFormat do pacote java.text (é necessário importar este pacote) possui três
métodos para formatar números, valores monetários e valores percentuais. A localização é o conjunto de
propriedades específicas de cada país sobre strings e números, como símbolo de moeda, separador
decimal, etc. Para obter um formatador para a localização padrão, use:
NumberFormat.getNumberInstance() //Números
NumberFormat.getCurrencyInstance() //Moeda
NumberFormat.getPercentInstance() //Percentual

Tabela com os caracteres que podem ser usados no DecimalFormat:

Símbolo Significado
0 Um dígito
# Um dígito; não mostra se for um zero na frente ou no fim.
. (ponto) Localização de separador decimal
, (vírgula) Localização de separador de grupo
; (pto. e vírgula) Separa formatos de números positivos e negativos
- (sinal de menos) Prefixo negativo
% (percentual) Multiplica por 100 e mostra na forma percentual
Outro símbolo Inclui o símbolo na string de saída
Exemplos:
String de Formatação Número Explicação
,##0.00 1,234.50 Dois dígitos depois do separador decimal; mostra os zeros na
frente. Separa os grupos dos milhares com vírgulas. Se o número
for < 1, mostra zeros na frente.
$,##0.00;($,##0.00) ($1,234.50) Números negativos entre parênteses em vez de usar o sinal de
menos; insere $.
0.###### 1234.5 Se número entre –1 e 1 mostra zero na frente. Não mostra zeros no
final.

- DecimalFormat funciona bem para formatar valores monetários. Não é adequada para notação
científica, tabelas com colunas de largura fixa ou números em formato hexadecimal ou octal.

Métodos de Classes (Funções Definidas pelo Usuário)

- Funções predefinidas: pertencem à linguagem e estão prontas para serem utilizadas. Exemplo:
double n = 64, raiz;
raiz = Math.sqrt(n); // sqrt = raiz quadrada
- Métodos do usuário (programador): devem ser criados para executar tarefas específicas às necessidades do
programa. Sempre são escritos dentro de uma classe.
- Para criar um método, é preciso especificar o tipo de valor que o método retorna, o seu nome, dois
parênteses e duas chaves delimitando o código a ser executado. O último comando de um método deve
ser:
return (valor_retorno);

6
 Programação Orientada a Objetos I – Prof. Ediberto.
- valor_retorno é uma variável ou constante de mesmo tipo (ou compatível) que o valor de retorno do
método.
- Se o método não possui valor de retorno, deve ser especificado como void e não deve possuir o comando
return.
- Para utilizar um método, deve-se escrever seu código dentro da classe, como no modelo abaixo:
public class <nome>
{ //declaração das variáveis de classe
<tipo_do_método> <nome_do_método>()
{//declaração das variáveis locais ao método
//código do método
return (valor_de_retorno); //se não for void
}
public static void main (String[] args)
{//declaração das variáveis locais
//código do trecho principal
nome_var = nome_do_método (); //chamada
}}

- Onde:
o <tipo_do_método> pode ser um dos vários tipos de métodos em JAVA, mas neste capítulo
será usado sempre public static acompanhado do tipo de retorno do método (int,
double, long, etc.);
o <nome_do_método>() é um nome para o mé todo que segue a mesma regra de formação dos
identificadores de variáveis, de classe, etc, mas em geral são escritos iniciando com minúsculas e
as palavras subseqüentes iniciando com maiúsculas como: calcularAumento(). Os
parênteses são obrigatórios tanto na definição do método como na sua chamada e devem conter as
variáveis locais caso sejam necessários parâmetros, como no exemplo a seguir:
- Exemplo: Com retorno e com argumento
public class Ex06
{public static double calculaTriplo (double numero)
{double x = 3 * numero;
return ( x );}
public static void main (String[] args)
{ double num1 = 7;
double triplo = calculaTriplo (num1);
System.out.println("Triplo de "+num1+" é "+triplo);}}
Resposta: Triplo de 7 = 21
- Onde:
o public static double calculaTriplo define o tipo de retorno (double) do método
chamado calculaTriplo;
o (double numero) define a variável local numero que receberá o parâmetro, passado sempre
POR VALOR (a não ser que seja um objeto) na chamada ao método. Um método também pode ser
definido sem passagem de parâmetros, devendo-se então incluir os parênteses () de qualquer
forma;
o return (x); é o comando final do método, retornando o valor calculado;
o double triplo = calculaTriplo (num1); é a chamada ao método
calculaTriplo, passando o valor num1 como parâmetro para o cálculo. O valor de num1
nunca será alterado pelo método. O valor retornado pelo método será armazenado na variável
triplo.

7
 Programação Orientada a Objetos I – Prof. Ediberto.
Método com retorno de valor e com retorno e com argumento
Criar o método calculaQuadrado retornando o quadrado tipo inteiro em que atribua o numero 7 a uma variável
num1
public class Ex07
{public static int calculaQuadrado (int numero)
{ int x = numero * numero;
return ( x );
}
public static void main (String[] args)
{ int num1 = 7;
int quadrado = calculaQuadrado (num1);
System.out.println("Quadrado "+num1+" = "+quadrado);
}}
Método com retorno de valor e com retorno e com argumentos
Criar o método calculaSoma retornando a soma tipo inteiro de dois numeros com valores = num1 = 7, num2 = 3
public class Ex08
{public static int calculaSoma (int num1, int num2)
{ int x = num1 + num2;
return ( x );
}
public static void main (String[] args)
{ int num1 = 7;
int num2 = 3;
int soma = calculaSoma (num1, num2);
System.out.println("Soma dos numeros "+num1+"+"+num2 +" = "+soma);
}}
Manipulação de Strings
- Strings são seqüências de caracteres como “tudo bem ?”. Não há um tipo String em JAVA, e sim uma
classe predefinida chamada String, que faz parte do pacote padrão de Java. Cada conjunto de caracteres
entre aspas é uma instância da classe String:
String e = “”; //uma string vazia
String saudacoes = “Olá”;
Métodos da Classe java.lang.String
- A classe java.lang.String possui muitos métodos (verifique na referência da linguagem). Seguem
os mais interessantes:
o charAt(int indice)
//retorna o caractere na posição especificada
o int compareTo(String outraString)
//retorna um valor negativo se a string vier antes de outraString na
//ordem do dicionário, um valor positivo se outraString vier antes e
//0 (zero) caso forem iguais
o boolean endsWith(String sufixo)
//retorna true se a string terminar com sufixo
o boolean equals(String outra)
//retorna true se a string for igual à outra
o boolean equalsIgnoreCase(String outra)
//retorna true se a string for igual à outra, ignorando maiúsculas e
//minúsculas
o String toLowerCase()
//retorna uma nova string convertendo maiúsculas para minúsculas
8
 Programação Orientada a Objetos I – Prof. Ediberto.
o String toUpperCase()
//retorna uma nova string convertendo minúsculas para maiúsculas
o String trim()
//elimina espaços iniciais e finais
Concatenação
String uniao = “use o sinal de + para ” + “concatenar Strings”;
Substrings
- Java possui um método para se obter um subconjunto de uma string, que é o método
nomestring.substring(posicaoinicial, posicaolimite)
onde:
o posicaoinicial é a primeira posição a ser inclusa na substring
o posicaolimite a posição imediatamente posterior a última a ser inclusa.
- Lembre-se que em JAVA conta-se a partir do 0 (zero), ou seja, a primeira posição de uma string é a
posição 0.
String saudacao = “Bem vindo”;
String s = saudacao.substring(0, 3); //s = “Bem”
Edição de Strings
- Para descobrir o tamanho de uma string, usa-se o método nomestring.length():
String saudacao = “Bem vindo”;
int tamanho = saudacao.length(); //tamanho = 9

Teste de Igualdade entre Strings

- Para testar se duas strings são iguais, usa-se nomestring1.equals(nomestring2). O valor true
será retornado se forem iguais. Ex:
String saudacao = “Bem vindo”;
boolean igual = “Bem vindo”.equals(saudacao);
//igual = true
- Para testar se duas strings são iguais ignorando maiúsculas e minúsculas, usa-se
nomestring1.equalsIgnoreCase(nomestring2).
Não use o operador ‘= =’ para testar se duas strings são iguais!
SUFIXO
o boolean endsWith(String sufixo)
//retorna true se a string terminar com sufixo
MAIÚSCULA PARA MINÚSCULA
o String toLowerCase()
//retorna uma nova string convertendo maiúsculas para minúsculas
MINÚSCULA PARA MAIÚSCULA
o String toUpperCase()
//retorna uma nova string convertendo minúsculas para maiúsculas
ELIMINA ESPAÇOS INICIAIS E FINAIS EM UMA STRING
o String trim()
//elimina espaços iniciais e finais
CONTROLE DE FLUXO: ESTRUTURAS DE SELEÇÃO E REPETIÇÃO
Instruções Condicionais
- Forma mais simples:
if (condicao) instrucao;
- Com bloco de instruções:
if (condicao)
{ instrucao1;
instrucao2;
...
9
 Programação Orientada a Objetos I – Prof. Ediberto.
}

- Forma mais simples com else:

if ( condicao ) instrucao1 else instrucao2;
- Forma com else e bloco de instruções:
if ( condicao )
{ instrucao1;
instrucao2;
...
}
else
{ instrucao1;
instrucao2;
...
}
- Exemplo Maior.java:
public class Maior
{ public static void main (String[] args)
{int a = 5;
int b = 3;
if ( a > b )
{ System.out.println(“O maior é ” + a);
}
else
{ System.out.println(“O maior é ” + b);
}
}
}
Laços Indeterminados
- Usados quando não sabemos quantas vezes o conjunto de instruções deve ser processado. O while
executa o corpo do laço apenas enquanto a condição for true (verdadeira):
while ( condicao ) { bloco }
- O while executa o teste da condição antes do início do bloco. Se for preciso executar pelo menos uma
vez o bloco de comandos do laço, deve-se usar a versão do de um laço while:
do { bloco } while ( condicao );
Laços Determinados
- Se soubermos quantas vezes o conjunto de instruções deve ser processado, o mais simples é usar o
comando for:
for ( instrucao1; expressao1; expressao2 ) { bloco }
- Exemplo ContagemRegressiva.java:
public class ContagemRegressiva
{ public static void main (String[] args)
{ for ( int i = 10; i > 0; i-- )
{ System.out.println(“Contagem: ” + i);
}
System.out.println(“Lançamento!”);
}
}
Instruções BREAK e CONTINUE
BREAK – A instrução break, quando executada em um while, for, do...while e ou swite, ocasiona sua saída
imediata dessa instrução. A execução continua com a primeira instrução depois da instrução de controle.
10
 Programação Orientada a Objetos I – Prof. Ediberto.

CONTINUE – A instrução, quando executa em um while ou do...while, pula as instruções restantes no corpo do
loop e prossegue com a próxima interação do loop.
- É possíve l criar laços for também com variáveis e incrementos em ponto flutuante, com cuidado em
relação aos erros de arredondamento dos valores (a expressão limite deve ser bem definida). Também é
permitido utilizar laços com duas variáveis de controle.
Seleções M últiplas – A Instrução switch
- A instrução if...else pode ser incômoda quando temos várias seleções com múltiplas alternativas.
Com a instrução switch pode-se testar o tipo char e todos os inteiros menos long e não se pode usar
conjuntos de valores (esta instrução infelizmente não foi aprimorada de C++)
- Exemplo (trecho de código):
int opcao = 2;
switch ( opcao )
{ case 1:
System.out.println(“A opção é 1.”);
break; // fim do bloco para opcao = 1
case 2:
System.out.println(“A opção é 2.”);
break;
case 3:
System.out.println(“A opção é 3.”);
break;
default:
System.out.println(“Opção inválida.”);
break; // a cláusula default é opcional
}
É possível ainda retirar o comando break de uma cláusula fazendo com que a execução prossiga para os
comandos da cláusula seguinte, mas isso tem que ser feito com bastante cuidado. Nestes casos é aconselhável
acrescentar um comentário no código.

ARRAYS: dados e objetos

- Os arrays em JAVA são objetos que precisam ser criados explicitamente com a instrução new :
int[] arrayDeInts = new int[100];

- A instrução acima define um array de 100 inteiros cujos elementos são numerados de 0 a 99. Para o
preenchimento podemos usar:
for ( int i = 0; i > 100; i++ )
{ arrayDeInts[ i ] = i;
}

- Para arrays pequenos, podemos usar a forma abreviada (sem o operador new):
int[] primosMenores = { 2, 3, 5, 7, 11, 13 };

- O tamanho do array é definido por nomeDoArray.length:

for ( int i = 0; i < arrayDeInts.length; i++ )
{ System.out.println(arrayDeInts[i]);
}

- Pode-se executar cópias de variáveis arrays em outras de forma que as variáveis apontem para o mesmo
array (neste caso, com a modificação de um dos valores os dois arrays serão modificados!):

11
 Programação Orientada a Objetos I – Prof. Ediberto.
int[] sequencia = primosMenores;

- Para copiar realmente arrays, é necessário utilizar o método arraycopy da classe System :
System.arraycopy (arrayorigem, indiceorigem, arraydestino,
indicedestino, quantidade);

- Ao utilizar este método atenção para o fato do índice do primeiro elemento ser 0.
- Os arrays em JAVA são tratados por referência, logo, é possível utilizar um array como parâmetro para
um método onde não seja necessário retornar o array resultado, pois neste caso, o próprio array será
modificado diretamente pelo método. Ex:
public static void print (int[] a)
{ for (int i=0; i<a.length; i++)
System.out.println(a[i] + “ “);
}
- Mas podemos também utilizar os arrays em JAVA como valores de retorno. Ex:

public static int[] soma (int[] a, int[] b)

{ int tamanho = a.length();
int[] soma = new int[tamanho];
for (int i=0; i<tamanho; i++)
soma[i] = a[i] + b[i];
return soma;
}

- Os arrays multidimensionais (matrizes) em JAVA são declarados da seguinte forma (os cálculos e
manipulações são feitos de forma semelhante aos arrays unidimensionais):

int[][] matriz4x4DeInts = new int[4][4];

Polimorfismo
- Voltando ao assunto Herança, veremos um conceito muito importante, o de Polimorfismo.
- No nosso exemplo Firma, o vendedor deve ter x% de comissão. Suponha então que seja necessária a
construção de um método que calcule o salário de todos os empregados, descontando 15% de imposto.
- Por exemplo, se o salário de:
Empregado = 200;
Vendedor = 200; //Salário-base
Tecnico = 2.000;
- Supondo uma comissão de 20% , o salário de Vendedor seria:
Vendedor = 240; // 200 + 20% = 200 + 40 = 240
- Calculando o salário líquido de cada um:
Empregado = 170 // 200-15% = 200-30
Vendedor = 204 // 240-15% = 240-36
Tecnico = 1700 // 2.000-15% = 2.000- 300
- O método para cálculo do salário para a classe Empregado pode ser:
public double calc(double sal)
{ return ( 0.85 * sal ); // desconto de 15%
}
- E esse método será herdado pela classe Tecnico. Porém, a classe Vendedor deverá implementar seu
próprio método:
public double calc(double sal)
{ sal = sal * (1 + comissao/100);
12
 Programação Orientada a Objetos I – Prof. Ediberto.
//aumento de 20%
return ( 0.85 * sal );
//desconto de 15%
}
- Graficamente, os métodos são representados separadamente dos atributos, na parte inferior:

Empregado

matricula
nome
salario

calc()

Vendedor Tecnico

comissao titulo

calc()

Desta forma, poderíamos reescrever os códigos para um novo exemplo:

public class Empregado
{
String matricula;
String nome;
double salario;
public double calc (double sal)
{
return (0.85 * sal);
}
}
public class Vendedor extends Empregado
{
double comissao;
public double calc (double sal)
{
sal = sal * (1 + comissao/100);
return (0.85 * sal);
}
}
- No nosso caso, o método calc efetua um cálculo quando utilizado pelos objetos das classes Empregado
e Tecnico, e outro cálculo quando o objeto em questão foi instanciado da classe Vendedor.
- Pode-se observar que tanto Empregado como Tecnico utilizam o método calc para cálculo do
trabalho, e que Vendedor , apesar de utilizar o método calc, utiliza o seu próprio método, com corpo
diferente daquele definido na classe ancestral Empregado.

13
 Programação Orientada a Objetos I – Prof. Ediberto.
- Resumindo o conceito de Polimorfismo: Reutilização do mesmo nome para um conceito correlato em
tipos diferentes. O sistema escolherá qual o método que deve ser utilizado por meio de:
o Sobrecarga (Overloading) ? comparação feita em tempo de compilação que pergunta “Qual
método possui os tipos de argumentos correspondentes?” e escolhe o método que será usado.
Recurso usado no caso de métodos de mesmo nome, definidos em uma mesma classe, com
argumentos diferentes;
o Sobreposição (Overriding) ? comparação feita em tempo de execução que pergunta “Qual
método foi definido para este tipo de objeto? Existe uma redefinição deste método na classe do
objeto ou deve ser usado o método definido na superclasse?”.

14