CENTRO EDUCACIONAL NSL

(1)

P

ROGRAMAÇÃO

J

AVA

P

ROFESSOR

: V

ALKIRIO

A

NDRADE

T

URMA

: 6

º

I

NFORMÁTICA

(2)

1. Introdução à linguagem Java ---5

2. Características ---5

3. Princípios da linguagem ---6

3.1. Case sensitive--- 6

3.2. Nome do arquivo --- 6

3.3. Nomenclatura --- 6

3.4. Estrutura--- 7

3.5. Comentários --- 7

3.6. Identificadores reservados --- 7

4. Estrutura básica de uma classe ---8

5. JDK e JRE ---8

6. Ambiente de desenvolvimento ---8

7. Compilando e executando ---9

8. Tipos Primitivos---9

9. Valores literais --- 10

10. Variáveis --- 11

10.1. Declaração---11

11. Exibindo dados na tela --- 12

12. Operadores aritméticos --- 12

13. Operadores incrementais e decrementais --- 13

14. Operadores relacionais --- 15

15. Operadores lógicos --- 16

16. Comando de decisão --- 16

16.1. if / else ---17

16.2. switch / case ---18

17. Comando de laço de repetição --- 20

17.1. while ---20

17.2. do / while---20

17.3. For ---21

17.4. Break ---22

17.5. Continue ---22

18. Orientação a objetos --- 23

18.1. Princípios da orientação a objetos ---23

19. Classes--- 25

(3)

21. Instanciação--- 26

22. Métodos --- 27

22.1. Estrutura de métodos ---28

22.2. Criando métodos ---29

22.3. Chamada de métodos ---29

22.4. Passagem de parâmetros por valor ---30

22.5. Comando return ---32

22.6. Acesso a método ---32

22.7. Modificadores de métodos---33

22.8. Membros estáticos ---34

22.8.1. Atributos estáticos ---35

22.8.2. Métodos estáticos ---35

22.9. Método main () ---37

22.10. Sobrecarga de método ---38

22.11. Uso do this---39

23. Construtores--- 40

23.1. Construtor padrão ---40

24. Herança --- 41

24.1. Criando uma herança ---43

24.2. Acesso a classe pai com o uso do super ---44

24.3. Classe Object ---46

24.3.1. Classes abstratas ---46

25. Array--- 47

25.1. Construção de arrays ---48

25.1.1. Acesso aos elementos de um vetor ---48

25.1.2. Passando um array como parâmetro ---49

25.1.3. Criando um array do tipo construídos ---49

26. Polimorfismo --- 50

26.1. Run-time binding ---50

26.2. O uso do polimorfismo ---51

27. Interfaces --- 53

27.1. Variável de referência---55

27.2. Variáveis inicializadas ---55

28. Pacotes --- 55

29. Programação visual--- 56

29.1. Contêineres---57

29.1.1. Frames ---57

29.1.2. Caixa de diálogo ---58

29.2. Eventos---61

(4)

29.2.3. Eventos do mouse ---63

29.2.4. Tratamento de eventos ---65

29.2.5. Classes adaptadoras ---66

29.2.6. Classes internas ---67

29.3 Criando componentes por meio do swing ---67

29.2.7. Gerenciadores de layout ---68

29.2.8. Componentes ---70

(5)

1. Introdução à linguagem Java

Java é uma linguagem de programação resultante de um projeto desenvolvido em 1991 por um grupo de engenheiros da empresa “Sun Microsystems”. Na verdade, inicialmente esses engenheiros tinham a missão de criar uma linguagem que seria utilizada em diversos aparelhos, tais como fornos e telefones. Eles deveriam criar uma linguagem que permitisse a comunicação entre os aparelhos de uma casa e que gerasse pequenos códigos para serem executados nos mais diversos aparelhos.

A fim de desenvolver esse projeto, os engenheiros optaram por utilizar a linguagem C++ em conjunto a um conceito de maquinas virtuais. A opção por essa linguagem é devido a sua eficácia e ao fato de ser orientada a objetos, característica que indicavam a escolha mais adequada. Quanto ao conceito de maquinas virtuais, essa foi a solução encontrada para a execução de diversas arquiteturas, em que cada um dos fabricantes seria responsável por suportar determinadas funções do programa.

A linguagem Java apresenta simplicidade, ela é bastante completa e eficaz, e pode ser utilizada em três frentes de programação distintas apresentadas a seguir:

Frentes de programação Descrição

Applets

Os applets são programas criados por meio de recursos oferecidos somente pela linguagem Java.

Como esses programas não podem ser executados sozinhos, eles devem ser inseridos em paginas da

web (HTML).

Aplicativos

Os aplicativos escritos em diversas linguagens, como C, C++, Visual Basic, entre outras, também podem ser facilmente escrito em Java. A vantagem

dessa linguagem deve-se ao fato de que um aplicativo escrito em Java pode ser executado em

quase todos os micros disponíveis no mercado atualmente.

Sistemas embutidos

Sistemas embutidos são aqueles utilizados em outros aparelhos eletrônicos diferentes dos microcomputadores, e Java, devido aos seus

recursos e características, é uma linguagem utilizada para o desenvolvimento desses sistemas.

2. Características

Após termos visto alguns detalhes a respeito da criação da linguagem Java, veremos, agora suas características:

(6)

Orientada a objetos;

Interpretada e compilada;

Multiplataforma;

Robusta e confiável;

Segurança;

Portável;

Multithreaded.

3. Princípios da linguagem

É essencial que os princípios da linguagem Java, que serão descritos a seguir, sejam considerados pelo programador no momento em que estiver desenvolvendo aplicações nessa linguagem.

3.1. Case sensitive

Case sensitive é o principio da linguagem de programação Java que indica que está é capaz de distinguir letra em caixa alta (maiúsculas) e letra em caixa baixa (minúsculas).

3.2. Nome do arquivo

O nome do arquivo tem a extensão, “.java” e, preferencialmente, deve ser o mesmo nome de uma das classes declaradas dentro deste arquivo, por exemplo, para a class Cliente, teremos o arquivo com o nome Cliente.java. Seria um erro definir a classe como class Cliente e o nome do arquivo como cliente. java.

3.3. Nomenclatura

Os nomes atribuídos aos identificadores devem ser iniciados pelos caracteres underline ( _ ), pelo ($), ou por letras. Dentre os identificadores, temos as classes, os métodos, as variáveis, entre outros.

(7)

3.4. Estrutura

O inicio de um código ou de uma classe sempre será marcado pela abertura de chaves ({), e o termino, pelo fechamento de chaves (}). Quanto ao termino dos comandos, este, em geral, é marcado pelo sinal de ponto-e-vírgula (;).

3.5. Comentários

As linhas de comentários podem ser iniciadas de formas distintas, dependendo dos seguintes fatores:

Comentário de somente uma linha //(barra barra) Comentário de mais de uma linha /*inicio ... fim*/

Comentários para javadoc /**inicio...fim*/

3.6. Identificadores reservados

Os identificadores em Java são palavras especiais que tem uma funcionalidade para o compilador em que não pode ser utilizados como o nome de classes, métodos ou variáveis.

Palavras reservadas

abstract assert boolean

break byte case catch char class continue

default do double

enum extends

false final finally

float for

if try implements

import

instanceof int interface

native long new null package

private public return short static super switch synchronized

this throw transient transient

true void volatile

while

(8)

De acordo com a Java Language Specification, null, true e false são tecnicamente valores literais. Se tentarmos criar um identificador com esses valores, haverá um erro de compilação.

4. Estrutura básica de uma classe

Apresentaremos a seguir, uma estrutura básica de classe.

class <nome> {

Public static void main(String args[]) { //Declarações

//Comandos } }

5. JDK e JRE

Para que possamos desenvolver aplicativos a partir da linguagem Java, precisamos contar com o conjunto de ferramentas JDK (Java Development Kit) instalado na máquina. Esse JDK já contém o JRE (Java Runtime Environment).

Definimos JRE como um ambiente de execução que simula uma maquina responsável por realizar as interpretações Java por meio do qual não é possível realizar a compilação do código Java. Sendo assim, uma maquina JRE é indica aqueles que somente necessitam executar aplicações Java e contam com um pacote em cujo conteúdo está a maquina virtual e as bibliotecas necessárias para a execução.

6. Ambiente de desenvolvimento

A linguagem de programação Java conta com IDEs, que são ambientes de desenvolvimento gráfico capazes de auxiliar no desenvolvimento de sistemas de maneira mais produtiva. A seguir destacamos alguns dos principais ambiente de desenvolvimento:

Eclipse (http://www.eclipse.org);

NetBeans (http://www.netbeans.org);

Sun Java Studio Enterprise (http://developers.sun.com/jsenterprise/);

(9)

Oracle JDeveloper (http://www.oracle.com/technology/products/jdev);

Websphere WSAD (http://www.ibm.com/software/br/websphere);

Enterprise Jbuilder (http://www.borland.com/jbuilder).

7. Compilando e executando

Para que possamos compreender o processo de compilação e execução de uma classe em Java, é preciso abrir um editor de texto e digitar o exemplo descrito a seguir:

class Exemplo1{

public static void main(String args[]){

System.out.println(“Meu primeiro programa em JAVA!!!”);

} }

Após digitarmos o exemplo, devemos salva-lo como Exemplo1.java. Já para a compilação dessa classe, devemos abrir o prompt do DOS e digitar “javac Exemplo1.java”, em que :

javac é o comando do compilador Java;

Exemplo1.java refere-se ao nome do arquivo a ser compilado.

Uma vez concluído o processo, o compilador javac gera um arquivo de classe chamado de “Exemplo1.class” no diretório atual.

8. Tipos Primitivos

O Java é tido como uma linguagem de programação de grande robustez, uma qualidade adquirida pelo fato de apresentar, como característica, a tipagem forte.

Essa linguagem tem a capacidade de trabalhar com grande variedade de tipos de dados , cuja faixa de valores é altamente definida. Um inteiro no Java, por exemplo, não sofre variações conforme é executado em ambientes diferentes. Por apresentar valores

(10)

bem definidos. O Java mostra-se uma linguagem de grande portabilidade, que é a capacidade que o programa possui de ser executado em outras arquiteturas de computadores.

Na tabela a seguir, são apresentados os oitos tipos primitivos:

Tipo Descrição

byte 1 byte – 8 bits -128 a 127 Números inteiros

short 2 bytes – 16 bits -32768 a 32767 Números inteiros int 4 bytes – 32 bits -2147483648 a 2147483647 Números inteiros long 8 bytes – 64 bits -922337203685477808 a

922337203685477807

Números inteiros float 4 bytes – 32 bits Aproximadamente

3.40282347E+38

Ponto flutuante double 8 bytes – 64 bits Aproximadamente

1.79769313486231570E+308

Ponto flutuante char Caracteres

Unicode 16 bits

0 a 65536 Caracteres

Boolean Possuem valores true e false Booleano

9. Valores literais

O valor literal é utilizado para que possamos criar um valor constante em Java, também conhecido como constante em outras linguagem de prgramação.

Trata-se de uma representação literal do valor constante, e pode ser aplicada em qualquer parte cujo tipo é aceitável.

Contudo, existem caracteres que não podem ser representados diretamente dentro de aspas simples, então, nesse caso, devemos usar seqüência de escape.

Na tabela a seguir, estão descritas as seqüencias utilizadas por alguns caracteres de escape:

Seqüências de escape Descrição

\ddd Caractere em octal

\uxxxx Caractere Unicode hexadecimal

\’ Aspas simples

\” Aspas duplas

\\ Barra invertida

\r Caractere de retorno

\n Nova linha

\f Alimentação de formulário

\t Tabulação

\v Tabulação vertical

\b Backspace

(11)

10. Variáveis

Variável é um espaço de memória utilizado para armazenar temporariamente um valor. Identificada por um nome, a variável combina um identificador, um tipo e um inicializador opcional. O responsável por definir a visibilidade de uma variável e por quanto tempo a mesma ira durar é o escopo.

A variável pode receber um valor, que é determinado por um programa.

Conforme esse programa é utilizado, o valor que a variável previamente recebeu pode sofre alterações.

10.1. Declaração

Antes de utilizarmos as variáveis em uma aplicação Java, devemos declará-las, pois só assim, elas serão validas, conforme podemos observar a seguir:

class ExemploVariaveis {

public static void main(String args[ ]){

int a,b;

char sexo='f';

String curso="Linguagem Java", escola="NSL";

double VAL_PI=3.14;

float faixa= 4.21f;

boolean resposta= true;

a=10;b=20;

System.out.println("O valor de A é: " + a);

System.out.println("O valor de B é: " + b);

System.out.println("O valor de SEXO é: " + sexo);

System.out.println("O valor do PI é: " + VAL_PI);

System.out.println("O valor da FAIXA é: " + faixa);

System.out.println("O valor da RESPOSTA é: " + resposta);

} }

(12)

11. Exibindo dados na tela

O comando System.out.println() é utilizado para exibir dados na tela. Por meio de um único comando como esse, é possível , mostrar mais de um dado, de tipos iguais ou diferentes. Essa concatenação e feita por meio do sinal +(adição).

O exemplo a seguir ilustra a concatenação de dados:

class ExemploConcatenacaoDados {

public static void main(String args[ ]) {

int seculo;

String cidade, estado;

seculo=21;

cidade="santos"; estado="sp";

System.out.println("Cidade= " + cidade + " ---> " + estado);

System.out.println(seculo);

System.out.println("Cidade = " + cidade);

System.out.println("Seculo = " + seculo);

System.out.println("Cidade = " + cidade + "\nEstado = "+estado);

System.out.println("Estado = " + estado + "\nSeculo = "+seculo);

} }

12. Operadores aritméticos

Os operadores aritméticos são utilizados nos cálculos matemáticos e são os seguintes:

Operadores aritméticos Descrição

+ Adição

- Subtração

* Multiplicação

/ Divisão

% Modulo (resto da divisão)

(13)

Exemplo:

class OperadoresAritmeticos {

public static void main(String args[ ]){

int a = 10, b = 25, c = 40, d = 50;

System.out.println(a + b);

System.out.println(b - a);

System.out.println(c * d);

System.out.println(c / a);

System.out.println(d % a);

} }

13. Operadores incrementais e decrementais

Os operadores incrementais e decrementais tem a função de aumentar ou diminuir exatamente o valor 1 em uma variável. Eles podem ser pré ou pós-incremental e pré ou pós-decremental. Vejamos:

Incremental (++)

Pré-incremental ou prefixo

Significa se o sinal for colocado antes da variável, primeiramente será somado o valor 1 para essa variável, continuando em seguida, a resolução da expressão;

Pós-incremental ou sufixo

Significa se o sinal for colocado após a variável, primeiro será resolvido toda a expressão (adição, subtração, divisão, etc.) para, em seguida ser adicionado o valor 1 à variável.

DecreDecreDecreDecremental (mental (mental (mental (------)))) --

Pré-decremental ou prefixo

Significa que se o sinal for colocado antes da variável, primeiramente será subtraído o valor 1 dessa variável, continuando em seguida, a resolução da expressão;

Pós-decremental ou sufixo

Significa se o sinal for colocado após a variável, primeiro será resolvido toda a expressão (adição, subtração, divisão, etc.) para, em seguida ser subtraído o valor 1 à variável.

(14)

Exemplo:

class IncrementoDecremento {

public static void main(String args[]) {

int a=5;

System.out.println("a = "+a);

System.out.print("++a +2 = ");

//Exemplo de pré-incremento System.out.println(++a +2);

//Pula uma linha System.out.println();

a=5;

System.out.print("a++ +2 = ");

//Exemplo pós-incremento System.out.println(a++ +2);

System.out.println("a = " +a);

System.out.println();

a=5;

System.out.print("--a +2 = ");

//Exemplo de pré-decremento System.out.println(--a +2);

a=5;

System.out.print("a-- +2 = ");

//Exemplo pós-descremento System.out.println(a-- +2);

} }

(15)

14. Operadores relacionais

Os operadores relacionais comparam dois valores e retornam um valor booleano (true ou false). Vejamos quais são esses operadores na tabela a seguir:

Operador relacional Descrição

= = Igual a

! = Diferente de

> Maior do que

< Menor do que

> = Maior do que ou igual a

< = Menor do que ou igual a

Exemplo:

class OperadoresRelacionais {

int a=20, b=30, c=1, d=20;

System.out.println("################# OPERADORES RELACIONAIS

#################\n\n\n ");

System.out.println("####### A resposta é B<A: ####### ");

System.out.println(b<a );

System.out.println("####### A resposta é A=D: ####### ");

System.out.println(a == d);

System.out.println("####### A resposta é C>B: ####### ");

System.out.println(c>b);

System.out.println("####### A resposta é A!=D: ####### ");

System.out.println(a!=d);

System.out.println("####### A resposta é A<B: ####### ");

System.out.println(a<d);

System.out.println("####### A resposta é A<=D: ####### ");

System.out.println(a<=d);

System.out.println("####### A resposta é C>B: ####### ");

System.out.println(c>=b);

} }

(16)

15. Operadores lógicos

Os operadores lógicos trabalham com valores booleano, e seu resultado também será booleano (true ou false). Eles são utilizados somente em expressões lógica e são o seguinte:

Operadores lógicos Descrição

&& AND

|| OR

! NOT

Em um teste lógico utilizando o operador && (and) , o resultado somente será verdadeiro (true) se todas as expressões lógicas forem avaliadas como verdadeiras.

Porém se o operador utilizado for || (or), basta que uma das expressões lógicas seja verdadeira para que também o resultado seja verdadeiro.

O operador lógico ! (NOT) é utilizado para gerar uma negação, invertendo a lógica de uma expressão.

class OperadoresLogicos {

int a=20, b=30, c=1, d=20;

System.out.println(b<a || c==1);

System.out.println(a==d && d!=a);

System.out.println(!(c>b));

} }

16. Comando de decisão

Para decidirmos que ação será tomada em determinada parte de um programa, solicitamos a este que avalie uma expressão. Caso essa expressão seja avaliada como verdadeira, uma seqüência de comandos será executada.

As seguintes instruções de decisão devem ser consideradas:

if / else;

switch / case.

(17)

16.1. if / else

Quando utilizamos uma instrução if, apenas expressões com resultado booleanos podem ser avaliadas. Para definirmos uma instrução if, utilizamos a seguinte sintaxe:

if (Teste Condicional) { Comandos;

}

Nela, a instrução avaliará a expressão booleana. Em caso verdadeiro, o bloco de instruções que se encontra entre a chave ({}) será executado. Se o resultado for falso, o bloco de comandos não será executado, ou pode haver outro bloco de comandos para serem executados.

Exemplo:

class ExemploIf {

int x = 10;

if (x<15){

System.out.println(“X é maior que 15”);

System.out.println(“O valor de X é: “ +x);

} } }

É importante saber que as chaves ({}) não são obrigatórias quando existir apenas uma instrução dentro do bloco de comandos. Porém por motivo de melhor legibilidade, e interesante que as chaves sejam utilizadas.

Além disso, recomendamos que as instruções if/else sejam aninhadas em quantidade moderada, também por ser mais legível.

Para executar comandos, caso a condição seja falsa, é necessário digitar a cláusula else após as instruções de condição verdadeira e, na linha seguinte, inserir o bloco de instruções as serem executados. Confira a estrutura abaixo:

class ExemploIfElse{

int x = 20;

if (x<15){

System.out.println("X é menor que 15");

System.out.println("O valor de X é: " +x);

}

(18)

else{

System.out.println("X é maior que 15");

System.out.println("Como X é maior que 15, seu valor é: : " +x);

} } }

16.2. switch / case

A instrução switch pode ser um outro modo para simular a utilização de várias instruções if, e ela somente pode verificar uma relação de igualdade. Os tipos de dados que podem ser utilizados na instrução switch são os seguintes:

byte;

char;

int;

short.

Com relação à instrução case, ela avalia apenas o argumento que apresenta o mesmo tipo definido na instrução switch. Mas, devemos atentar para o fato de que o argumento da instrução case é final, ou seja, ele precisa ser resolvido no tempo de compilação. Devido a isso, utilizamos uma variável final constante com um valor literal na instrução case. Caso mais de uma instrução case apresente o mesmo valor, ela não será valida.

Enquanto uma instrução switch estiver sendo executada, o programa pode encontrar um comando break, ou seja, uma indicação que o programa deverá executar a instrução seguinte ao bloco switch. Mas, se esse comando não existir no código-fonte do programa, todas as instruções case serão executadas até que toda a instrução switch finalize, ou mesmo até que um comando break seja encontrado.

O comando switch/case não pode utilizar operadores lógicos (&&, || ou !). Sendo assim, ele pode ser utilizado somente para comparar valores simples, cujo tipos de dados podem ser apenas: int, short, byte e char.

Podemos completar o uso da instrução switch/case com o comando default. Este será executado sempre que o valor assumido pela variável não encantar um valor case correspondente.

(19)

Vejamos, a seguir, um exemplo com a instrução switch/case utilizando o comando default:

class ExemploSwitchCase {

//as variaveis podem ser do tipo inteira e char int hora=2;

switch(hora) {

case 1: System.out.println("--> Uma hora <--");

break;

case 2: System.out.println("--> Duas horas <--");

break;

case 3: System.out.println("--> Três horas <--");

break;

case 4: System.out.println("--> Quatro horas <--");

break;

case 5: System.out.println("--> Cinco horas <--");

break;

case 6: System.out.println("--> Seis horas <--");

break;

case 7: System.out.println("--> Sete horas <--");

break;

case 8: System.out.println("--> Oito horas <--");

break;

case 9: System.out.println("--> Nove horas <--");

break;

case 10: System.out.println("--> Dez horas <--");

break;

case 11: System.out.println("--> Onze horas <--");

break;

case 12: System.out.println("--> Doze horas <--");

break;

default:

System.out.println("Hora incorreta!!!");

} }

}

(20)

17. Comando de laço de repetição

Muitas vezes, precisamos repetir a execução de um bloco de códigos do programa até que uma determinada condição seja verdadeira, ou mesmo até que uma quantidade de vezes seja satisfeita. Para que essa repetição seja possível, utilizamos os laços de repetição de linguagem que, em Java, são os seguintes:

while;

do/while;

for.

17.1. while

Quando não sabemos quantas vezes um determinado bloco de instruções precisa ser repetido, utilizamos o laço de repetição while. Com ele, a execução das instruções vai continuar até que uma condição seja verdadeira. A condição a ser anualizada para execução do laço de repetição deverá retornar um valor booleano. Veja o xemplo a seguir:

class ExemploWhile {

int num=10;

while(num<1500) num*=10;

System.out.println("Valor de num: "+num);

} }

Devemos saber que o laço de repetição while pode não ser executado. Isso ocorrerá quando, na primeira verificação da condição, está for falsa. Então, o programa passará para a execução da próxima instrução após o laço.

17.2. do / while

O comando do/while tem basicamente o mesmo funcionamento do comando while, com uma diferença de que utilizando-se o do/while, teremos os comandos

(21)

executados ao menos uma única vez: Isso acontecerá mesmo se a condição não for verdadeira:

Observemos o exemplo a seguir:

class ExemploDoWhile {

int num=10;

do{

System.out.println("Numero maior que 100!");

}

while(num>=100);

} }

17.3. For

Quando sabemos exatamente quantas vezes queremos repetir um bloco de instruções, utilizamos o laço de repetição for. Ele possui o corpo do laço e as seguintes partes principais:

Declaração e inicialização de variáveis

Nesta primeira parte da instrução for. Podemos declarar e inicializar uma ou mais variáveis, quando houver. Elas são colocadas entre parêntese, após a palavra chave for e, se houver mais de uma variável do mesmo tipo, elas são separadas por virgulas, conforme o exemplo a seguir:

for (int a=1, b=1, c=1; ...){ }

É importante lembrarmos que a declaração e a inicialização das variáveis na instrução for acontece sempre antes de outros comandos. Eles acontece apenas uma vez no laço de repetição, sendo que o teste booleano e a expressão de iteração são executados a cada laço de programa.

Vejamos o exemplo a seguir:

(22)

class ExemploFor{

public static void main(String args[]) { for(int i=1; i<10; i++){

System.out.println("O valor é: " +i);

} }

}

17.4. Break

O comando break é utilizado em laço de repetição while, do/while, for e com os comandos switch/case. Quando utilizamos em laço de repetição, causa uma interrupção imediata do mesmo, continuando a execução do programa na próxima linha após o laço.

Isso acontece caso a condição imposta seja atendida.

Vejamos o exemplo a seguir:

class ExemploForBreak{

public static void main(String args[]) { for(int i=1; i<13; ++i){

if(i==5)

break; //interrompe o loop

System.out.println("O valor de I é: " +i);

}

System.out.println("Próxima linha após o loop");

} }

17.5. Continue

O comando continue é utilizado somente em laços de repetição. Quando ele é executado, o laço volta imediatamente para o teste de condição de laço de repetição.

Normalmente utilizamos o comando continue em um teste if.

Observemos a seguir:

class ExemploContinue{

int num=0;

while(num<10){

++num;

if(num==5){

continue;

(23)

}

System.out.println("Valor de num ==>" +num);

} }

}

18. Orientação a objetos

Os programas desenvolvidos com base na orientação a objetos são compostos por um grupo de objetos que, por meio da troca de mensagens, realizam um processo de interação entre si. De fato, essa troca de mensagens refere-se à invocação de métodos, que é realizada entre objetos.

Os programas que se baseiam nessa orientação são facilmente alterados em um momento posterior para um a melhor adaptação às necessidades apresentadas por usuários ou organizações.

A essência da programação orientada a objetos e a possibilidade de alterar ou substituir partes de um sistema, sem que haja riscos de ocorrência de erros. Isso é possível devido ao fato de os objetos serem definidos de forma clara e com interfaces confiáveis.

Ainda, é importante destacar que a base da linguagem de programação Java envolve os conceitos de orientação a objetos, dentre os quais temos:

Abstração;

Encapsulamento;

Herança;

Polimorfismo.

18.1. Princípios da orientação a objetos

A implementação de um modelo orientado a objetos e auxiliada por meio de um mecanismo. A linguagem de programação Java, a fim de adequar tais mecanismos, utiliza três tipos de estruturas distintos, que são:

Encapsulamento;

Herança;

(24)

Polimorfismo.

O encapsulamento, a herança e o polimorfismo são mecanismo que, em conjunto, formam um ambiente de programação capaz de suportar o desenvolvimento de programas com maior estabilidade de robustez. Na tabela a seguir, temos mais detalhes a respeito desses mecanismos:

Mecanismo Descrição

Encapsulamento

É uma técnica que permite que os atributos da classe permaneçam ocultos, pois, assim, esses atributos podem ser lidos ou alterados somente pelos métodos da própria classe. Com isso e desnecessário conhecer a implementação inteira da classe.

Herança

O conceito relacionado ao mecanismo de herança é um dos maiores diferencias entre a programação orientada a objetos e outros tipos de programação. Por meio da herança é possível estender as definições existentes. Quando temos uma hierarquia de classes de forma adequada, temos a base para que um código possa ser utilizado novamente, o que permite poupar esforço e tempo na medida em que o desenvolvimento de um código exige ambos de forma considerável.

Polimorfismo

O polimorfismo é o mecanismo por meio do qual selecionamos a funcionalidades utilizadas de forma dinâmica por um programa no decorrer de sua execução. Os códigos que o polimorfismo permite criar apresentam diversas características, dentre as quais destacamos a lógica, a robustez, a legibilidade e a limpeza.

Exemplo da comunicação por meio de um telefone ilustra a orientação a objetos.

O telefone é um aparelho utilizado para transmitir sons a distância. Ele é construído, basicamente, de dispositivos para converter ondas sonoras em ondas eletromagnéticas.

Nesse ponto, vale considerar o microfone, para reverter esse processo, o receptor, o gancho que serve como interruptor, a campainha, que dá o sinal que o aparelho está recebendo uma ligação e o disco, ou teclas, que selecionam o telefone com o qual se pretende estabelecer comunicação.

Todos os usuários de telefone s utilizam a herança para se comunicar por meio de diferentes tipos (subclasses) de aparelhos telefônicos. Seja o telefone um celular, um fixo por ondas de radio ou um fixo por fibra ótica, quem o está utilizando terá um teclado para discar o numero desejado, uma campainha indicando que o aparelho está recebendo uma ligação, entre outros itens.

O polimorfismo reflete-se a possibilidade que os fabricantes de aparelhos telefônicos têm de oferecer uma ampla variedade de opções no mesmo telefone básico.

Não importa a tecnologia utilizada ou modelo, sempre utilizaremos um teclado para discar o numero desejado. Assim, temos que o controle de diversas implementações pode ser realizado por uma mesma interface.

A mesma situação descrita para o telefone também se aplica aos conceitos da programação orientada a objetos na medida em que as partes de um programa, quando

(25)

unidas, transforma-se em um produto final com robustez, coerência e com pouca complexidade de manutenção. E importante compreendermos os conceitos de encapsulamento, herança e polimorfismo, uma vez que todos os programas desenvolvidos em linguagem Java são orientados a objetos.

19. Classes

Tendo em vista que a linguagem de programação Java é orientada a objetos, o conceito de classes torna-se um de suas principais bases. Uma classe tem a função de determinar não somente a natureza, mas também a forma de um objeto. Por meio de classes, é possível realizar o processo de construção de objetos, denominado instanciação. Classe é, portanto, uma abstração de um conjunto de objetos, os quais são agrupados por possuírem similaridades em termos de comportamento e características.

Em termos gerais, classes são capazes de auxuliar na organização de um conjunto de dados, bem como de auxiliar na definição dos métodos mais adequados para a alteração e a utilização desses dados.

Em Java, a criação de classes deve ter inicio apenas depois de estabelecidas as classes que formarão a aplicação.

A fim que possamos declarar as classes de maneira adequada. É preciso analisar algumas regras, as quais serão descritas a seguir:

Regras Descrição

Classe pública

Cada arquivo de código fonte possui somente uma classe pública e, ainda, o nome atribuído a esse arquivo deve ser igual ao nome da classe em questão.

Instruções

O arquivo de código fonte deve apresentar, em sua primeira linha, a instrução do pacote. Tanto as instruções de pacote quanto as instruções de importação são aplicadas a todas as classes pertencentes ao arquivo de código-fonte.

Modificadores

Antes de uma classe seja declarada, podemos adicionar modificadores a ela. Esses modificadores podem ser de acesso e podem ser aqueles que não se refere ao acesso. Dentre os modificadores de acesso, temos o private, o protected e o public.

Já dentre os modificadores que não são de acesso, temos o abstract, o final, entre outros.

Com relação às instruções, sejam elas de pacote ou de importação, também é preciso destacar que:

(26)

A inserção das instruções de importação deve ser realizada entre a declaração da classe e a instrução do pacote;

As instruções de importação, devem ser colocadas na primeira linha referente ao arquivo de código fonte caso não haja uma instrução de pacote;

A primeira linha do arquivo de código-fonte deve ser destinada à inserção da declaração de classe, caso não haja instruções de pacote ou instruções de operação.

É importante destacar que as linhas de comentário não precissam necessariamente ser as primeiras linhas de um arquivo de código-fonte, elas podem estar presentes em qualquer local desse arquivo.

20. Tipos construídos

Podemos criar uma variável de tipo construídos. Isso significa que é possível criar variáveis a partir das classes que já existe. As variáveis de tipo construídos estão diretamente relacionadas a algum tipo de classe que é criada ou, ainda, que já exista como as classes que acompanham a linguagem de programação.

O processo de criação de variáveis por meio de tipos construídos recebe o nome de instanciação. Este é um processo diferente da criação de variáveis do tipo básico, tais como: int, boolean, long, double, entre outras.

21. Instanciação

A instanciação é um processo por meio do qual se realiza a cópia de um objeto (classe) existente. Uma classe, que tem a função de determinar um tipo de dado, deve ser instanciada para que possamos utilizá-la. Sendo assim, devemos criar sua instancia, a qual definirmos como um objeto referente ao tipo de dado que foi definido pela classe.

Ressaltamos que, exceto a classe abstract , qualquer outra classe pode ser instanciada como um tipo de dado de Java.

Para que possamos compreender adequadamente o processo de instanciação, destacamos um exemplo a seguir da classe Pessoa.

Observemos:

(27)

class Pessoa {

//atributos char sexo;

String nome;

int idade;

}

class Cadastro {

Pessoa joao;

joao= new Pessoa();

joao.sexo='m';

joao.nome=" ### João ###";

joao.idade=45;

System.out.println(joao.nome);

System.out.println(joao.sexo);

System.out.println(joao.idade);

Pessoa maria=new Pessoa();

maria.sexo='f';

maria.nome="\n ### Maria ###";

maria.idade=17;

System.out.println(maria.nome);

System.out.println(maria.sexo);

System.out.println(maria.idade);

} }

22. Métodos

Para determinarmos o comportamento dos objetos existentes de uma classe, utilizamos os métodos, que são a implementação de uma operação para uma classe.

Eles podem ser aplicados a varias classes diferentes, mas todos os objetos que estão em uma mesma classe compartilharam os métodos aplicados a eles.

Quando o método e aplicado a varias classes temos o polimorfismo, ou seja, o método assume formas diferentes em classes também diferentes.

(28)

Tomemos como exemplo, a classe Carro. Aos objetos dessa classe, atribuirmos os seguintes métodos: andar, abastecer e parar. O método abastecer pode ser implementado de varias formas nos objetos da classe Carro, e isso varia conforme o tipo de abastecimento que o carro pode ter (álcool, gasolina ou diesel). A partir disso, vimos que esse método terá sempre a mesma função, que é abastecer, mas cada tipo de abastecimento será implementado de uma forma diferente.

Em Java, assim como nas demais linguagens, os métodos são comparados com as antigas funções presentes em linguagens procedurais. Eles são declarados e chamados dentro de programas em Java, que são classes ou interfaces.

Cada método tem a função especificada. Para utilizá-lo, devemos ser definidos em um método.

Modificador (es);

Tipo de retorno;

Nome;

Parâmetros recebidos, quando houver;

Comandos (corpo do método);

Valor de retorno, quando houver.

22.1. Estrutura de métodos

A partir de agora, estudaremos alguns fundamentos dos métodos. Começaremos pela sintaxe, que é a seguinte:

<modificador> <tipo de retorno> <nome do método> (<lista-de-parâmetro>){

//CORPO DO MÉTODO COM INSTRUÇÕES }

Vejamos as explicações a seguir:

Modificador (es) Refere-se a um ou mais modificadores que podem existir e que irão definir as regras de visibilidade e sobrescrita do método;

(29)

Tipo de retorno Refere-se ao tipo de dados valido, retornado pelo método.

Esse tipo pode ser qualquer um, incluindo aqueles de classes desenvolvidas pelo programador. Se o método não devolver um valor, o tipo de retorno será void;

Nome do método Refere-se ao nome do método, que pode ser um identificador legal que não seja utilizado por outros itens do escopo atual;

Lista-de-parâmetros Refere-se à seqüência de pares compostos de um tipo e um identificador. Ambos estão separados por vírgulas.

22.2. Criando métodos

Para criarmos um método, primeiramente, devemos considerar a utilização da sintaxe definida anteriormente, ou seja:

<modificador> <tipo de retorno> <nome do método> (<lista-de-parâmetro>){

//CORPO DO MÉTODO COM INSTRUÇÕES }

Agora, suponhamos que precisamos criar um método que efetue a soma de dois números recebidos como parâmetros:

public int somar(int valor1, int valor2){

int resultado;

resultado = valor1 + valor2;

return resultado;

}

22.3. Chamada de métodos

Depois de definirmos um método, é necessário referenciá-lo, ou seja, fazer uma chamada ao método. Vejamos como isso é feito:

(30)

No arquivo Calculadora.java temos:

public class Calculadora {

public int somar(int valor1, int valor2) {

int resultado;

resultado = valor1+valor2;

return resultado;

} }

No arquivo UsaCalculadora.java, temos:

public class UsaCalculadora {

int s;

//Criando uma instancia de Calculadora Calculadora calc = new Calculadora();

// S chama método somar com dois valores s = calc.somar(15,15);

//Mostrar o valor na tela System.out.println("S = "+s);

} }

22.4. Passagem de parâmetros por valor

Na linguagem Java, a passagem de argumento é feita apenas por valor, isso significa que o valor do argumento não pode ser alterado dentro do método.

Quando se passa um objeto como argumento de um método, na realidade, está sendo passado o valor de referencia do objeto, e não o próprio objeto. Sendo assim, quando o valor de referencia do objeto é passado como argumento, o conteúdo do objeto (valores dos atributos) pode ser alterado, mas a referencia não pode ser alterada dentro do método.

Parâmetro refere-se a uma variável definida por método. Quando esse método é chamado, a variável recebe um valor.

Argumento refere-se a um valor atribuído a um método, quando este é invocado.

(31)

O exemplo a seguir mostra melhor o conceito de passagem por valor em Java:

Nome do primeiro arquivo: Pessoa.java public class Pessoa

{

//atributos String nome;

int idade;

char sexo;

public void exibirDados(){

System.out.println("Nome da pessoa = " + nome);

System.out.println("idade da pessoa = " + idade);

System.out.println("Sexo da pessoa = " + sexo);

} }

Nome do segundo arquivo: PassagemPorValorObjeto.java public class PassagemPorValorObjeto{

int valor = 1500;

//TENTATIVA DE ALTERAR O VALOR

System.out.println("Antes da chamada do método alterarValor: valor = "

+ valor);

alterarValor(valor);

System.out.println("Depois da chamada do método alterarValor: valor=

" + valor);

//INSTANCIANDO OBJETO Pessoa maria = new Pessoa();

maria.nome = "Maria";

maria.idade = 50;

maria.sexo = 'f';

System.out.println("Valores antes da chamada do método alterarReferenciaObjetos :");

maria.exibirDados();

//TENTATIVA DE ALTERAR A REFERENCIA DO OBJETO alterarReferenciaObjeto(maria);

System.out.println("Valores depois da chamada do método alterarReferenciaObjetos :");

System.out.println("Valores antes da chamada do método alterarConteudoObjetos :");

//ALTERANDO O CONTEUDO OBJETO alterarConteudoObjeto(maria);

System.out.println("Valores depois da chamada do método alterarConteudoObjeto :");

(32)

}

static void alterarValor(int valor){

//ALTERANDO O VALOR valor = 137;

}

static void alterarConteudoObjeto(Pessoa p){

//ALTERANDO O CONTEUDO DO OBJETO REFERENCIADO POR P p.nome = "João";

p.idade = 40;

p.sexo = 'm';

}

static void alterarReferenciaObjeto(Pessoa p){

Pessoa ana = new Pessoa();

ana.nome = "Ana";

ana.idade = 25;

ana.sexo = 'f';

p = ana; //ALTERANDO O VALOR DE P }

}

22.5. Comando return

Para retornarmos de um método explicitamente, utilizamos o comando return.

Com ele, a execução do programa volta para o chamador do método, terminando, então, o método no qual é executado.

Observemos o exemplo a seguir:

class ExemploReturn{

int num = 5;

System.out.println("Linha anterior ao comando return");

if(num <=5) return;

System.out.println("Está linha não será executada!!!");

} }

22.6. Acesso a método

Quando precisamos restringir o acesso a um método, utilizamos os modificadores de acesso. São os modificadores que definem o nível de visibilidade de

(33)

método em relação às outras classes. Porém, devemos saber que um método sempre é acessível pelos métodos da própria classe, independente do modificador que for escolhido para a restrição. Isso significa que podemos utilizar outro método qualquer que está na mesma classe para chamar o método cujo acesso está restrito.

A seguir, estão descritos os modificadores de acesso disponível na linguagem Java:

public Quando utilizamos o modificador public, significa que o método pode ser chamado a partir de outros métodos de qualquer classe. Isso ocorre porque o método é público;

protected Quando utilizamos o modificador protected, significa que o método pode ser chamado apenas pelas classes derivadas da classe que possui o método protected, independente se a classe derivada pertence ou não ao mesmo pacote;

private Utilizando este modificador, indicamos que o método é particular da classe em que ele se encontra. Sendo assim, ele somente pode ser utilizado nesta classe;

friendly Este modificador de acesso é o padrão e será utilizado sempre que não for definido um outro modificador explicitamente. Com ele o método pode ser utilizado apenas pelas classes que pertence ao mesmo pacote.

22.7. Modificadores de métodos

O método possui propriedades que precisa ser especificada. Para isso, utilizamos o modificador de método, a partir do qual determinamos se as classes derivadas podem ou não alterar ou redefinir o método.

Adicionalmente, o modificador nos permite definir o modo como o método será apresentado.

Vejamos, a seguir, quais são os modificadores de métodos disponíveis na linguagem Java:

abstract O método que possui o modificador abstract é abstrato, ou seja, não tem seu corpo especificado. Podemos dizer que esse modificador pede para que o corpo seja completado por uma declaração feito por uma classe derivada.

(34)

Devemos saber que não podemos instanciar uma classe que possui o método abstrato, ou uma classe derivada de outra em que existe um método abstrato;

final Com este modificador, o método não pode ser alterado nem redefinido por nenhuma classe derivada. É importante sabermos que é obrigatório que o método declarado como final possua um corpo;

native Ao utilizar este modificador, apenas o cabeçalho é declarado, ou seja, não há corpo. Adicionalmente, o native designa um método implementado em outra linguagem;

static Esse modificador permite que o método seja compartilhado pelos objetos instanciados pela mesma classe. O método static não faz definição entre os objetos que o compartilham, sendo assim, ele não pode acessar as variáveis declaradas dentro de uma classe. Mas se a variável também for declarada como static, ela poderá ser acessada pelo método static;

synchronized O modificador de método synchronized impede que os dados de uma classe sejam acessados ao mesmo tempo por dois métodos que estão em execução concorrentemente. Sendo assim, os outros métodos precisam esperar para acessar os dados que estiverem sendo acessados por outros métodos. O synchronized é utilizado para o desenvolvimento de um programa de processamento concorrente.

22.8. Membros estáticos

Para especificarmos que um membro é estático, devemos prefixar à sua declaração o modificador static.

Uma característica importante de membros estáticos é que os membros podem ser referenciados pelo próprio nome da classe em que foram definidos, sem a necessidade de criarmos objetos dessa classe para que possamos acessar os membros estáticos fora da mesma. Por esse motivo, podemos nos referenciar a eles como membros de classe.

(35)

22.8.1. Atributos estáticos

Ao colocarmos o modificador static juntamente com a definição de um atributo, este se torna estático. Isso significa que o valor do atributo será o mesmo em todas as instancias da classe a que pertence.

Caso um atributo estático possui 100 instancias provenientes da mesma classe, quando alterarmos esse atributo em uma dessas instancia, automaticamente, a alteração refletirá nas demais instancias da classe.

22.8.2. Métodos estáticos

Ao colocarmos o modificador static juntamente com a definição de um atributo, este se torna estático. Isso não significa que seu valor não possa mudar, mas sim que somente haverá uma referencia para esse método disponível em memória.

O static é um modificador da linguagem Java que, quando colocamos junto ao método, indica que dentro dele somente podemos acessar outros métodos ou atributos que também sejam declarados como static. Essa é a principal característica de um método static, e devemos sempre nos lembrar dela.

Para acessarmos um membro ou método que não seja estático, devemos criar um a instancia da classe correspondente para chamar o item desejado. Porém, quando os métodos não são estáticos, podemos acessar ambas as propriedades: as estáticas e as não estáticas.

Isso tudo ocorre porque não há, dentro do método estático, uma referencia para o ponteiro this, o qual é utilizado quando precisamos referenciar as propriedades da classe com a qual se está trabalhando.

Observemos a seguir, um exemplo em que utilizamos static:

Nome do arquivo: Elevador.java class Elevador{

Boolean rodando = true;

static Boolean ligado = true;

void desligar(){

rodando = false;

}

static void mudarForca(){

ligado = !ligado;

} }

(36)

Nome do arquivo: Manutencao.java class Manutencao{

private final int NOITE = 22;

private final int FECHAR = 24;

private final int ABRIR = 8;

Elevador elevadorPar, elevadorImpar;

Manutencao(){

elevadorPar = new Elevador();

elevadorImpar = new Elevador();

}

void controlar(int hora){

if(hora==NOITE){

elevadorImpar.desligar();

elevadorPar.desligar();

}

else if(hora==FECHAR || hora == ABRIR) Elevador.mudarForca();

}

void exibirSituacao(){

//ELEVADOR PAR System.out.println();

System.out.print("ELEVADOR PAR !!!");

if(!elevadorPar.rodando) System.out.print("não ");

System.out.print("Está rodando");

//ELEVADOR IMPAR System.out.println();

System.out.print("ELEVADOR IMPAR!!!");

if(!elevadorImpar.rodando){

System.out.print("Não ");

}

System.out.print("Está rodando ");

//SITUAÇÃO ELEVADORES System.out.println();

System.out.print("SITUAÇÃO DOS ELEVADORES!!!");

if(!Elevador.ligado){

System.out.print("Não ");

}

System.out.println("Está rodando");

} }

(37)

Nome do arquivo: SistemaControleElevedores.java

class SistemaControleElevadores{

Manutencao corredor = new Manutencao();

System.out.println("07:00 - HORA de checar Elevadores");

corredor.controlar(7);

corredor.exibirSituacao();

System.out.println("22:00 - HORA de checar elevadores");

System.out.println("24:00 - HORA de checar elevadores");

} }

22.9. Método main ()

O main( ) é o método estático mais famoso na linguagem Java, por meio do qual a aplicação passa a ser executada. Portanto, quando desejarmos utilizar algum método ou realizar operação no programa, fazemos isso dentro do main( ).

É importante observarmos que toda aplicação ou programa escrito na linguagem Java deve ter, obrigatoriamente, um único método main( ) para que possa ser executada.

Sendo assim, vejamos as regras para utilizarmos esse método:

O acesso deve ser public;

Deve ser static;

Deve ser void;

Deve receber como argumento um array de String (String args[ ]).

A seguir, temos um exemplo que nos mostra o fluxo de execução de um programa em Java quando existem chamadas de métodos:

(38)

class ExemploFluxoExecutandoComando{

/*** DEFINIÇÃO DO MÉTODO ExecutarTarefa***/

static void executarTarefa(){

System.out.println("Executar uma tarefa!!! ");

}

/*** TÉRMINO DA DEFINIÇÃO***/

static public void main(String args[]){

System.out.println("Executando o primeiro comando!!! ");

System.out.println("Executando o segundo comando!!! ");

System.out.println(" . ");

executarTarefa();

System.out.println("Sou o próximo comando que segue a chamada do método ");

System.out.println(" . \n");

System.out.println("Executando o ultimo comando \n");

} }

22.10. Sobrecarga de método

Na linguagem Java, podemos definir dois ou mais métodos de mesmo nome e lista de parâmetros diferentes dentro de uma mesma classe. Esse procedimento é conhecido como sobrecarga de métodos, pois os métodos são sobrecarregados. Nesse procedimento, as declarações da lista de parâmetros devem ser diferentes em tipo ou número, porém, o nome utilizado é o mesmo.

Quando chamamos um método sobrecarregado, utilizamos um guia para definir qual versão desse método deve ser executada. Esse guia corresponde ao tipo e ao número dos argumentos, por esse motivo, ambos devem ser diferentes para cada um dos métodos sobrecarregado.

Mas devemos atentar para a questão de que o tipo retornado dos métodos sobrecarregados não é suficiente para que as suas versões do método sejam distintas.

Isso ocorre porque a versão do método possui parâmetros correspondentes com os argumentos da chamada é executada quando for encontrada uma chamada a um dos métodos sobrecarregados.

(39)

22.11. Uso do this

Quando precisamos fazer referencia a um objeto criado dentro da própria classe, utilizamos a palavra this. Vejamos as duas situações que, a principio, exige a utilização dessa palavra:

Quando uma referencia de uma classe deve ser passada pela própria classe a um método;

Quando a classe possui duas variáveis com o mesmo nome, sendo que uma variável pertence à classe, e a outra pertence aos métodos dessa classe.

A partir dessas informações, vejamos o exemplo a seguir:

Nome do arquivo: Empregado.java class Empregado{

private String endereco;

private int idade;

void setEndereco(String endereco){

this.endereco = endereco;

}

void setIdade(int idade){

this.idade = idade;

}

String mostrar(){

return (endereco + idade);

} }

Nome do arquivo: TesteEmpregado.java class TesteEmpregado{

Empregado emprego = new Empregado();

emprego.setEndereco("CENTRO\n");

emprego.setIdade(30);

System.out.println(emprego.mostrar());

} }

Nesse exemplo, a palavra this refere-se aos atributos definidos da classe, e não aos parâmetros dos métodos. Observamos o método mostrar( ), verificamos que não foi necessário utilizar o this. Isso porque quando o atributo está claro e os parâmetros não

(40)

possuem nomes iguais, implicitamente, em qualquer referencia a nome ou endereço assume o atributo da classe.

23. Construtores

No momento em que um objeto é criado, ele imediatamente tem seu estado interno inicializado por meio do construtor. Essa estrutura, sintaticamente similar a um método, é identificada pelo mesmo nome da classe na qual ela está localizada.

Quando definido, o construtor é automaticamente solicitado logo que o objeto é criado. Isso é feito antes mesmo que o operador new complete seu procedimento de instanciação.

O construtor tem a capacidade de receber valores, que serão repassados ao objeto quando esse for criado. Além disso, o método citado tem a finalidade de desempenhar alguma operação ou cálculo antes mesmo de partir para qualquer tipo de operação junto ao objeto.

Uma das principais características do construtor é a de não possuir tipo retornado, isto porque o construtor de uma classe retorna o mesmo tipo da própria classe. Nem mesmo o tipo void é retornado pelo construtor.

É possível fazer sobrecarga de construtores, ou seja, criar na classe vários construtores cada um com uma lista de parâmetros diferente, dessa forma, um mesmo objeto pode ser criado de diversas maneiras.

23.1. Construtor padrão

Um procedimento que o programador deve empregar e definir explicitamente um método construtor para uma classe mais sufisticada. Quando tal tarefa não é feita, o próprio compilador do Java se encarrega de criar um construtor padrão.

O construtor padrão definido pelo compilador do java é muitas vezes eficaz, se estivermos trabalhando com classes simples. Já para classe mais complexas, o ideal é definir métodos construtores de maneira explicita.

(41)

Com base em uma classe qualquer, identificamos um método construtor padrão como aquele cuja lista de parâmetros formais está vazia.

class Calcado{

//ESTE É O MÉTODO CONSTRUTOR PADRÃO DA CLASSE Calcado(){

//AS INSTRUÇÕES AQUI É OPCIONAIS }

}

class CriaCalcado{

Calcado sandalia = new Calcado();

} }

A partir do momento em que o programador define um construtor, o construtor padrão deixa de ser utilizado. Quando uma nova instancia da classe for feita, devemos sempre informar os parâmetros exigidos pelo método anteriormente.

class Calcado{

//ESTE É O MÉTODO CONSTRUTOR PADRÃO DA CLASSE Calcado(String cor, int tamanho){

//AS INSTRUÇÕES AQUI É OPCIONAIS }

}

class CriaCalcado{

Calcado sandalia = new Calcado("Verde", 38);

//EXIBE CÓDIGO DE DA LOCALIZAÇÃO DO DADO NA MÉMORIA System.out.print(sandalia);

} }

24. Herança

A herança possibilita que as classes compartilhem seus atributos e métodos entre si. Para essa ligação entre as classes, a herança adota um relacionamento esquematizado hierarquicamente. Na herança, temos dois tipos principais de classe.

Superclasse A classe que se encontra em nível mais elevado da hierarquia e concede as características a uma outra classe;

Subclasse A classe que se encontra em nível mais baixo na hierarqui e que herda as características da superclasse.

(42)

A herança atua de maneira interativa com o encapsulamento, suponho que uma certa classe tenha alguns atributos encapsulados. Assim, uma subclasse dessa classe herdará esses atributos encapsulados, além de outros atributos adicionais que fazem parte da especialização da subclasse.

O fato de conceito de subclasse ter herdado atributos de classes ancestrais assegura que programas orientados a objetos cresçam de forma linear e não geometricamente em complexibilidade. Cada nova subclasse não possui interações imprevisíveis em relação ao restante do código do sistema.

De maneira bem natural, as pessoas visualizam o mundo formado por objetos, que estão relacionados hierarquicamente entre si. Vejamos, por exemplo, a relação entre os animais, mamíferos e cachorros.

Os animais, sob uma descrição abstrata, apresentam atributos, tais como tamanho, inteligência e estrutura óssea, e aspectos comportamentais descritos definem a classe dos animais.

Se analisarmos os mamíferos, que estão inseridos na classe animais, notaremos atributos mais particulares, como o tipo de dente, pêlos e glândula mamárias.

Os mamíferos são classificados como uma subclasse dos animais, os quais, por sua vez, é uma superclasse de mamíferos.

Pela chamada hierarquicamente de classes, a subclasse mamíferos recebe todos os atributos de animais, partindo do principio da subclasse recebe por herança todos os atributos de seus ancestrais.

No exemplo a seguir, temos a hierarquia de classe do cachorro:

Reino: animal;

Filo: Cordata (cão, lobo, raposa, gato, cobra, sapo, peixe);

Classe: Mamalia (cão, lobo, raposa, gato, cavalo);

Ordem: Carnívora (cão, lobo, raposa, gato);

Família: Canídea (cão, lobo, raposa);

Gênero: Canis (cão, lobo);

Espécies: Canis familiares (cão): dálmata, pastor, dobermann, etc.

(43)

Adotemos como exemplo, um cão de raça dálmata, pertence à espécie “Canis familiares”, como visto no exemplo anterior. Por herança, o dálmata herda as características do gênero Canis, o qual, por sua vez, herda as características da família Canídea, que herda as características da ordem Carnívora e, assim, sucessivamente.

24.1. Criando uma herança

Com herança, podemos criar classes que herdem características de classes adotadas de funcionalidades próprias do java, como applets, criação de componentes gráficos, multiprocessadores e outras.

A seguir, temos um exemplo de Funcionário e Programador utilizando o recurso de herança:

public class FuncionarioMatriz{

//ATRIBUTOS

protected String nome;

protected String email;

//CONSTRUTORES

public FuncionarioMatriz(){}

public FuncionarioMatriz(String nome, String email){

this.nome = nome;

this.email = email;

} }

public class Programador extends FuncionarioMatriz{

//ATRIBUTOS PRIVADOS private String linguagem;

private String sistemaOperacional;

//CONSTRUTORES public Programador(){}

public Programador(String n, String e, String linguagem, String sistemaOperacional){

//OS ATRIBUTOS nome e email SÃO HERDADOS DA SUPERCLASSE FuncionarioMatriz

nome = n;

email = e;

this.linguagem = linguagem;

this.sistemaOperacional = sistemaOperacional;

}

//MÉTODOS GETTERS E SETTERS public String getLinguagem(){

return linguagem;