Curso Java Matéria(1.2.3.4.5.6)

Prévia do material em texto

Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 1 
 
 
 
 
 
 
BÁSICO COMPLETO 
O desafio …. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 2 
 
 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 3 
 
FORMAÇÃO BÁSICA DE JAVA 
OBJECTIVO: LEVAR ao conhecimento do estudante, os conceitos fundamentais da 
linguagem Java. Desde a sua forma estruturada até a base da orientação a objectos. A 
versão da linguagem apresentada no curso é o Java 7 
 
PÚBLICO-ALVO 
Todas as pessoas que dominam pelo menos uma linguagem de programação ou 
conhecedores de lógica de programação. Este curso também é indicado para quem já 
conhecem Java de forma muito superficial, e deseja aprofundar seus conhecimentos no 
funcionamento da linguagem e na forma de desenvolver aplicações. 
 
PRÉ-REQUESITOS 
Ter feito o curso de lógica de programação ou conhecer alguma linguagem de 
programação, mesmo que não seja orientada a objetos. Ou ainda, passar nos nossos 
testes de avaliação de conhecimento sobre programação. 
 
CARGA HORÁRIA 
Equivalente a 50 horas, isto é, 5 semanas e 2 dias, 3 horas por dia, 3 dias por semanas. 
 
APTIDÕES APÓS O CURSO 
No final do curso, o estudante terá uma base sólida na linguagem Java e orientação a 
objetos. Esta base possibilitará o aprendizado de outros temas futuramente, como Java 
voltado para o ambiente web e desenvolvimento de aplicativos para Android e algumas 
Frameworks. 
 
CERTIFICADO 
Ao concluir o curso com nota igual ou superior aos 10 valores, o aluno recebe o 
certificado de conclusão do curso em formato digital e impresso. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 4 
 
CONTEÚDO 
1. Introdução ao Java ............................................................................................................ 6 
1.1. História do Java ......................................................................................................... 6 
1.2. JDK, JRE E JVM .......................................................................................................... 7 
1.3. Instalando e configurando o ambiente de desenvolvimento .................................... 8 
2. Programação Java: Conceitos iniciais ................................................................................. 9 
2.1. Variáveis (Identificadores) ......................................................................................... 9 
2.2. Tipos primitivos e operadores .................................................................................. 10 
2.2.1. Tipos Numéricos inteiros ..................................................................................... 10 
2.2.1.1. Tipos Numérico com Ponto flutuante ............................................................... 10 
2.2.2. Tipo Caractere ..................................................................................................... 11 
2.2.3. Tipo Booleano ...................................................................................................... 12 
2.3. Operadores ............................................................................................................. 12 
2.3.1. Atribuição ............................................................................................................ 12 
2.3.2. Operadores aritméticos ....................................................................................... 12 
2.3.3. Operadores relacionais e lógicos .......................................................................... 13 
2.3.4. Um caso especial: Atribuição composta ............................................................... 14 
2.4. Casting .................................................................................................................... 14 
Referência bibliográfica do capítulo 2 .................................................................................. 16 
3. Classes e objectos ........................................................................................................... 16 
3.1. Introdução aos conceitos de classes e objetos ......................................................... 16 
3.2. Notação UML........................................................................................................... 18 
3.3. Sobrecarga de métodos ........................................................................................... 20 
3.4. Operador this .......................................................................................................... 22 
Referência bibliográfica do capítulo 3 .................................................................................. 23 
4. Modificadores de acesso, construtores e elementos estáticos ......................................... 23 
4.1. Modificadores de acesso e encapsulamento ................................................................. 23 
4.2. Construtores ................................................................................................................ 24 
4.3. Atributos e métodos estáticos ...................................................................................... 26 
Referência bibliográfica do capítulo 4 .................................................................................. 27 
5. Herança e Polimorfismo .................................................................................................. 28 
5.1. Herança ........................................................................................................................ 28 
5.1.1. Sobrescrita de métodos ............................................................................................. 29 
5.1.2. Palavra-chave super e o operador instanceof ............................................................ 29 
5.2. Polimorfismo ................................................................................................................ 31 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 5 
 
Conclusão ........................................................................................................................... 32 
Referência bibliográfica do capítulo 5 .................................................................................. 32 
6. Tratamento de Exceções ................................................................................................. 33 
6.1. Lançando e tratando excepções ................................................................................... 33 
Comando finally .............................................................................................................. 34 
Comandos throw e throws ............................................................................................... 35 
Referência bibliográfica do capítulo 6 .................................................................................. 36 
Concatenação ..................................................................................................................... 37 
Tamanho da string - length() ............................................................................................... 38 
Letras Maiúsculas e Minúsculas........................................................................................... 38 
Comparação ........................................................................................................................... 38 
Caracter na posição ............................................................................................................. 39 
Índice da String ...................................................................................................................39 
Substituir string ou parte dela ............................................................................................. 40 
Substring ............................................................................................................................. 41 
Características ................................................................................................................. 42 
Declaração Enum ............................................................................................................ 42 
Inicializando valores ........................................................................................................ 42 
Percorrendo Valores ....................................................................................................... 44 
Comparando Valores Enum ............................................................................................. 44 
 Criar Pacotes ............................................................................................................... 49 
 Definir Pacotes ............................................................................................................ 49 
 Importar Pacotes ......................................................................................................... 50 
Referência bibliográfica do capítulo 10 ................................................................................ 53 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 6 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1. INTRODUÇÃO AO JAVA 
1.1.História do Java 
 
 A Sun criou um time (conhecido como Green Team) para desenvolver 
inovações tecnológicas em 1992. Esse time foi liderado por James Gosling, 
considerado o pai do Java. O time voltou com a idéia de criar um interpretador 
(já era uma máquina virtual, veremos o que é isso mais a frente) para pequenos 
dispositivos, facilitando a reescrita de software para aparelhos eletrônicos, como 
vídeo cassete, televisão e aparelhos de tv a cabo. 
 
A idéia não deu certo, tentaram 
fechar diversos contratos com 
grandes fabricantes de 
eletrônicos, como a Panasonic, 
mas não houve êxito devido ao 
conflito de interesses. Hoje 
sabemos que o Java domina o 
mercado de aplicações para 
celulares, porém parece que em 
1994 ainda era muito cedo. Com 
o advento da web, a Sun 
percebeu que poderia utilizar a 
idéia criada em 1992 para poder 
rodar pequenas aplicações 
dentro do browser. A 
semelhança era que na internet 
havia uma grande quantidade de 
sistemas operacionais e browser, 
e com isso seria grande 
vantagem poder programar 
numa única linguagem, 
independente da plataforma. Foi 
aí que o Java 1.0 foi lançado: 
focado em deixar o browser não 
apenas um cliente burro, fazendo 
com que ele possa também 
realizar operações, não apenas 
renderizar html. Sabemos que 
hoje os applets realmente não 
são o foco da Oracle. É 
engraçado que a tecnologia Java 
nasceu com um objetivo em 
mente, foi lançado com outro 
mas no final decolou mesmo no 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 7 
 
desenvolvimento de aplicações 
do lado do servidor. Sorte? 
 
Leia mais: http://www.oracle.com/us/technologies/java/overview/index.html 
 
 
 
 
 
 
 
 
 
1.2.JDK, JRE E JVM 
 
JDK – Java Development Kit (JDK) significa Kit de Desenvolvimento 
Java, e é um conjunto de utilitários que permitem criar sistemas de software 
para a plataforma Java. É composto por compilador e bibliotecas. 
JVM – do inglês Java Virtual Machine (Máquina virtual Java em 
Português) é um programa que carrega e executa os aplicativos Java, 
convertendo os bytecodes em código executável de máquina. A JVM é 
responsável pela gestão dos aplicativos, à medida que são executados. 
Graças à máquina virtual Java, os programas escritos em Java podem 
funcionar em qualquer plataforma de hardware e software que possua uma 
versão da JVM, tornando assim essas aplicações independentes da 
plataforma onde funcionam. 
 
JRE – Java Runtime Environment (JRE) significa Ambiente de Tempo de 
Execução Java, e é utilizado para executar as aplicações da plataforma Java. 
É composto por bibliotecas (APIs
1
) e pela Máquina virtual Java (JVM). 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 8 
 
 
 
Figura 2 - JDK, JRE E JVM 
 
 
 
 
 
1.3.Instalando e configurando o ambiente de desenvolvimento 
 Instalação do JDK e do Netbeans 7.4 
- Vamos primeiramente assumir que não possuir nenhuma versão JDK 
instalada no teu computador. Em caso de dúvida execute o seguinte 
comando na linha de código (calma, basta pressionar o botão + R do 
teclado e digitar cmd, posteriormente clique em OK) 
 
 
 
Depois de abrir a famosa tela preta, finalmente digite o comando “java” e 
pressione a tecla ENTER. 
1 API, de Application Programming Interface (ou Interface de Programação de Aplicativos) é um conjunto de rotinas e padrões estabelecidos por um software para a 
utilização das suas funcionalidades por aplicativos que não pretendem envolver-se em detalhes da implementação do software, mas apenas usar seus serviços. 
Fonte: http://www.javatpoint.com/difference-between-jdk-jre-and-jvm 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 9 
 
 
 
Já tenho certeza que não possuímos o java instalado no computador, 
então vamos aceder o seguinte endereço electrónico para baixar: 
http://www.oracle.com/technetwork/java/javase/downloads/index.html 
 
 
No nosso caso é importante frisar que iremos utilizar o netbeans, então 
vamos escolher a 2ª Opção (JDK 7u45 & NetBeans 7.4). 
 
 
 
 
 
2. PROGRAMAÇÃO JAVA: CONCEITOS INICIAIS 
2.1. Variáveis (Identificadores) 
 O conceito de variáveis ao nosso nível já dispensa comentários, mas deixa lhe 
recordar que, uma variável, fisicamente é um espaço que reservamos na 
memória do computador para guardar algum dado de um determinado tipo. 
Logicamente é uma referência única e não ambígua á um espaço da memória do 
computador. A criação e utilização de uma variável no Java obedece regras, e 
tendo sempre em atenção que ele é case-sensentive
3
. 
 
 O nome de um identificador deve começar por uma letra, underscore 
ou o símbolo do dólar $. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 10 
 
Exemplo de identificadores válidos: identificador, meu_Carro, 
desofpro_1, _atributo, $bola,_2seg. 
 
OBS  Evita utilizar caracteres especias no nome de um 
identificador (Seja ela uma variável, nome de um método, nome de 
um objeto, etc). 
 
 
2.2.Tipos primitivos e operadores 
 
 No Java Existe somente 8 tipos primitivos de dados, o resto são objeto
1
. 
Como não são objetos a sua declaração já cria a variável em memória não 
necessitando de construtores
2
. 
 
2.2.1. Tipos Numéricos inteiros 
 
 O valor default (valor por defeito ou valor inicial) para os tipos 
numéricos inteiros é 0 e cada vez que se usar uma constante numérica no 
código fonte ela será um int (inteiro) a não ser que se coloque a constante 
L no final do número. 
Os tipos numéricos inteiros são: 
 byte - Tamanho de 8 bits com sinal. Valores de - 128 a + 127. 
 short - Tamanho de 16 bits com sinal. Valores de - 32.768 a + 32.767. 
 int - Tamanho de 32 bits com sinal. Valores de - 2.147.483.648 a + 
2.147.483.647. 
 long - Tamanho de 64 bits com sinal.Valores de - 
9.223.372.036.854.775.808 a + 9.223.372.036.854.775.807. 
 
Exemplo: 
1. 15L  long 
2. 15  int 
3. 0L  long 
4. 0  int 
 
2.2.1.1. Tipos Numérico com Ponto flutuante 
 
 O valor default (valor por defeito ou valor inicial) 
para os tipos numéricos com ponto flutuante é 0.0 e cada 
vez que se usar uma constante numérica com ponto no 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 11 
 
código fonte ela será considerada um float (real) a não ser 
que se coloque o caractere d ou D no final do número. 
Os tipos numéricos com ponto flutuante são: 
 float - Tamanho de 32 bits. Valores de - 1.40239846E-45 
a + 3.40282347E + 38 (com nove dígitos significativos de 
precisão). 
 double - Tamanho de 64 bits. Valores de - 
4.94065645841246544E-324 a + 1.79769313486231570E 
+ 308 (com 18 dígitos significativos de precisão). 
 
Exemplo: 
1. 100.0  float 
2. 100.00d double 
3. 0  float 
4. 0f float 
5. 0d  double 
 
 
 
 
 
 
2.2.2. Tipo Caractere 
 
 
O caractere guarda o valor traduzido de um código ASCII
1
. Seu 
valor default é o código zero, \0. 
O tipo caractere utilizado no Java é: 
 
char - Caractere Unicode com tamanho 16 bits sem sinal. Valores 
possíveis 0 a 65535. 
 
O char também pode ser representado por um número inteiro de 
16 bits sem sinal, ou seja, pode-se atribuir à uma variável char o valor 
100 ou o valor 65535, pois neste caso estamos operando com os valores 
da tabela ASCII
1 
que representam caracteres de qualquer idioma. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 12 
 
 
 
2.2.3. Tipo Booleano 
 
 Tipos boleanos identificam verdadeiro ou falso e podem ser 
utilizados diretamente em expressões de retorno para testes como (if, 
switch, while e for)
2
. 
O tipo booleano utilizado no Java é: 
 
boolean - Valor indicando true ou false. Tamanho de 8 bit. 
 
 
 
2.3.Operadores 
2.3.1. Atribuição 
 
O sinal de atribuição em Java é o " = " igual ao " = " do C. Uma 
atribuição é feita com a seguinte sintaxe: identificador = valor ou 
expressão 
Ex: 
java = 2014; 
it = “Fantástico”; 
 
2.3.2. Operadores aritméticos 
 
 Operadores aritméticos são aqueles que efetuam operações 
aritméticas em um ou mais tipos primitivos. 
 
A seguir são apresentados os operadores aritméticos unários, que 
atuam sobre um único identificador. 
 
 
Operador 
 
Nome 
 
Utilização 
 
Descrição 
 
 
++ 
 
Incremento 
 
var++ / ++var 
 
Retorna e adiciona / adiciona e retorna 
 
 
- - 
 
Decremento 
 
var-- / --var 
 
Retorna e subtrai / subtrai e retorna 
 
 
+ 
 
Negativo 
 
- var 
 
Inverte o sinal da variável 
 
- 
 
Positivo 
 
+var 
 
Não tem efeito 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 13 
 
Abaixo estão os operadores aritméticos que actuam sobre duas variáveis. 
 
Operador 
 
Nome 
 
Utilização 
 
Descrição 
 
 
+ 
 
Adição 
 
x + y 
 
Soma x com y Soma x com y 
 
 
- 
 
Subtracção 
 
x - y 
 
Subtrai y de x 
 
 
* 
 
Multiplicação 
 
x * y 
 
Multiplica x por y 
 
/ 
 
Divisão 
 
x / y 
 
Divide x por y 
 
% 
 
Resto 
 
x % y 
 
Resto da divisão de x por y 
 
 
 
 
 
 
 
 
2.3.3. Operadores relacionais e lógicos 
Os operadores relacionais e lógicos são utilizados em testes e 
condições de entrada em um fluxo do programa. Abaixo estão todos eles 
relacionados. 
 
Operador 
 
Nome 
 
Utilização 
 
Descrição 
 
 
> 
 
Maior que 
 
x > y 
 
x maior que y 
 
 
>= 
 
Maior ou igual a 
 
x >= y 
 
x maior ou igual a y 
 
 
< 
 
Multiplicação 
 
x < y 
 
x menor que y 
 
<= 
 
Menor ou igual a 
 
x <= y 
 
x menor ou igual a y 
 
== 
 
Igual a 
 
x == y 
 
x igual a y 
 
!= 
 
Diferente de 
 
x != y 
 
x diferente de y 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 14 
 
! NÃO lógico (NOT) !y contrário de y 
 
&& 
 
E lógico (AND) 
 
x && y 
 
x e y 
 
|| 
 
OU lógico (OR) 
 
x || y 
 
x ou y 
 
instanceof 
 
Verifica Instância 
 
x instanceof XCla 
 
x é instância da classe XCla 
 
2.3.4. Um caso especial: Atribuição composta 
Embora já falamos sobre o operador de atribuição, mas agora nos 
deparamos com um caso muito especial e que reduz muito o tempo de 
execução das instruções. Observe o exemplo abaixo: 
 Int x = 1; // Atribui 1 a x 
 x + = 5; 
 
 Neste exemplo a variável inteira x é inicializada com 1 e na linha 
seguinte é realizado uma operação composta: A soma e atribuição. Esta 
instrução é semelhante a esta: x = x + 5;. O resultado em x será 6. Outros 
exemplos são: 
 Nota: Considera o valor anterior de x, a cada operação. 
 int x = 1; // Atribui 1 a x 
 x += 5; // Equivalente a x = x + 5; x é igual a 6 
 x *= 2; // Equivalente a x = x * 2; x é igual a 12 
 x /= 2; // Equivalente a x = x / 2; x é igual a 6 
 x -= 3; // Equivalente a x = x - 3; x é igual a 3 
 x %= 5; // Equivalente a x = x % 5; x é igual a 3 
 
2.4.Casting 
 
Alguns valores são incompatíveis se você tentar fazer uma atribuição 
direta. Enquanto um número real costuma ser representado em uma variável do 
tipo double, tentar atribuir ele a uma variável int não funciona pois é um código 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 15 
 
que diz: “i deve valer d”, mas não se sabe se d realmente é um número inteiro 
ou não. 
double d = 3.1415; 
int i = d; // não compila 
 
O mesmo ocorre no seguinte trecho: 
int i = 3.14; 
 
O mais interessante, é que nem mesmo o seguinte código compila: 
double d = 5; // ok, o double pode conter um número inteiro 
int i = d; // não compila 
 
 Apesar de 5 ser um bom valor para um int, o compilador não tem como 
saber que valor estará dentro desse double no momento da execução. Esse valor 
pode ter sido digitado pelo usuário, e ninguém vai garantir que essa conversão 
ocorra sem perda de valores. 
 
Já no caso a seguir é o contrário: 
int i = 5; 
double d2 = i; 
 
O código acima compila sem problemas, já que um double pode guardar 
um número com ou sem ponto flutuante. Todos os inteiros representados por 
uma variável do tipo int podem ser guardados em uma variável double. 
 
Às vezes, precisamos que um número com ponto flutuante seja 
arredondado e armazenado num número inteiro. Para fazer isso sem que haja o 
erro de compilação, é preciso ordenar que o número seja moldado (casted) 
como um número inteiro. Esse processo recebe o nome de casting. 
 
 
 Observe o exemplo abaixo: 
 
double d3 = 3.14; 
int i = (int) d3; 
 
O casting foi feito para moldar a variável d3 como um int. O valor dela agora é 
3. 
O mesmo ocorre entre valores int e long. 
 
long x = 10000; 
int i = x; // nao compila, pois pode estar perdendo informação 
 
E, se quisermos realmente fazer isso, fazemos o casting: 
long x = 10000; 
int i = (int) x; 
Abaixo, mostra uma tabela com os possíveis castings. 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 16 
 
 
 
 
 
 
 
Referênciabibliográfica do capítulo 2 
 
http://javafree.uol.com.br/artigo/871496/Tutorial-Java-2-
Caracteristicas-Basicas.html 
 
 
 
 
 
 
 
 
 
 
3. CLASSES E OBJECTOS 
 
Nesta parte do curso é importante saber que estamos a entrar verdadeiramente 
naquilo que é o foco do Java. A programação virada para Objetos é muito frequente 
(Não podia ser diferente). O conceito de Classe e Objectos darão o início então no 
entendimento do Java, pois ele é uma linguagem totalmente orientada á objeto. Os 
subcapítulos 3.2, 3.3 e 3.4 são complementos essenciais deste valioso tema. 
 
3.1.Introdução aos conceitos de classes e objetos 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 17 
 
Vamos imaginar situações reais, já ouviu falar de escola? Ou pessoa? Ou 
ainda Carro? Claro que todos já ouvimos falar. Mas o que imaginas quando 
ouves a palavra Carro ou Pessoa? Bom, todos tem uma imagem de Carro como 
algo que tenha rodas, volante, chassis, Motor etc. E Pessoa como algo que tenha 
uma cabeça, tronco e membros…A toda esta lógica surgiu então o conceito de 
Classe. Definida como um modelo abstrato suficiente para gerar vários 
objectos. Os objectos já representam a concretização de uma classe. Ou seja a 
classe passa de um modelo abstrato para algo concreto ou real. No caso da classe 
Carro, teríamos como objecto o meu carro, o teu carro e o carro de outrem. Isto 
porque o meu carro já tem uma cor e chassis bem definidas e que poderá ser 
diferente do seu carro, embora pertençam a mesma classe Carro. 
 
Observe a figura abaixo: 
 
 
 O carro do lado esquerdo representa a classe Carro e os que estão na 
direita (o carro azul e o vermelho) representam os objetos. 
Qualquer programa Java utiliza pelo menos uma classe. Utilizando a 
seguinte sintaxe: 
class Nome_da_Classe { 
 // Variáveis e Métodos 
} 
No caso da classe carro ficaria assim: 
 class Carro { 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 18 
 
 // Variáveis e Métodos do Carro 
} 
 Ter objetos desta classe seria muito trivial, bastando apenas fazer o 
seguinte: Carro meu_carro, teu_carro; 
 Os identificdores meu_carro e teu_carro são objetos da classe Carro, 
portanto poderão aceder “tudo” que foi definida na classe. Nota bem, embora os 
dois identificadores fazem referência a mesma Classe, eles são diferentes. 
 
 
 
 
 
 
 
 
 
 
3.2.Notação UML 
 
UML significa Unified Modeling Language é uma linguagem de 
unificada, muito utilizada quando se deseja desenvolver um projecto 
utilizando uma linguagem orientada a objectos, tal como no nosso caso. O 
Java. 
 Abaixo a representação de uma classe na UML: 
Nome da Classe 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 19 
 
 
 
 
 
 
 
 No caso da Classe Carro e considerando atributos como cor, peso, tipo de 
combustível etc. e métodos como acelerar, travar , buzinar etc. Teríamos algo assim: 
 
 
 
 
 
 
Bom! E agora, como ficam os objetos? Neste caso os objetos serão 
instâncias da Classe Carro. Observe abaixo: 
 
 
 
 
 
 
 
 
Atributos ou Variáveis 
 
 
Operações ou Métodos 
 
Carro 
- char[20] cor 
- double peso 
- char[20] combustivel 
+ acelerar ( ): void 
+ travar ( ): void 
+ buzinar (int pressao): void 
Meu_Carro 
Azul 
700 kg 
Gasolina 
meu_acelerar() 
meu_travar() 
meu_buzinar(5) 
Teu_Carro 
Vermelho 
850 kg 
Gasóleo 
teu_acelerar() 
teu_travar() 
teu_buzinar(3) 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 20 
 
 
 No Java seria mais o menos assim: 
meu_carro.cor = “Azul”; 
meu_carro.peso = 700; 
meu_carro.combustivel = “Gasolina”; 
 
Quanto aos métodos: 
meu_carro. meu_acelerar(); 
meu_carro. meu_travar (); 
meu_carro. meu_buzinar (); 
 
Agora analise a seguinte questão! Conseguiria colocar a altura do meu 
carro no objeto meu_carro? 
A resposta é não! Pois a classe Carro não possui nenhum atributo altura. 
 
 
 
 
 
 
 
 
 
3.3.Sobrecarga de métodos 
 
 A linguagem Java, permite a criação de métodos com nomes iguais, 
desde que as suas assinaturas sejam diferentes. 
 
A assinatura de um método é composta de seu nome mais os tipos de 
argumentos que são passados para este método, independente dos nomes de 
variáveis usadas na declaração do método. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 21 
 
 
A possibilidade de criar mais de um método com o mesmo nome e 
assinaturas diferentes é conhecida como Sobrecarga de métodos.A decisão 
sobre qual método será chamado quando existem dois ou mais métodos será 
feita pelo compilador, baseado na assinatura dos métodos. 
 
Por exemplo, vamos declarar, num mesmo aplicativo, dois métodos 
quadrados: um que recebe e retorna inteiros e outro que recebe e retorna 
double. 
class Sobrecarga { 
public static int quadrado(int num){ 
 int quadrado; 
 quadrado = num * num; 
 return quadrado; 
 
 } 
 
 public static double quadrado(double num){ 
 double quadrado; 
 quadrado = num * num; 
 return quadrado; 
 } 
} 
Quando declaramos estes dois métodos, estamos fazendo sobrecarga de 
métodos, ou method overloading em Java. 
O que acontece, então, quando fazemos a chamada da função? Já que 
existem duas. 
Embora os nomes sejam os mesmos, elas atuam de forma diferentes e 
ocupam espaços diferentes em memória, pois estão lidando com tipos 
diferentes de variáveis. 
Quando invocamos o método com um inteiro como um argumento, o 
Java é inteligente o suficiente para invocar correctamente o método que foi 
declarado com inteiro como parâmetro. 
 
 Caso invoquemos o método usando um double como um argumento, o 
Sobrecarga 
 
quadrado(int num): int 
quadrado(double num): double 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 22 
 
método a ser executado será aquele que foi declarado com o tipo double em 
seu parâmetro. 
 
3.4.Operador this 
 
A linguagem Java utiliza a palavra reservada this para uso muito 
especial em classes por exemplo: Em Java não podemos chamar um 
construtor directamente. Felizmente ela cria, internamente para cada 
instância, uma “auto-referência”, ou seja, uma referência à própria instância. 
Esta referência é representada pela palavra-chave this. Para chamar um 
construtor de dentro de outro, basta usar a palavra-chave this substituindo o 
nome do construtor 
 
Um exemplo simples: Vamos imaginar uma classe Pessoa que possui 
um atributo (idade) e dois métodos ou operações (falar( ) e comer()). Em 
java: 
class Pessoa { 
// Variáveis ou Atributos 
 int idade; 
// Métodos ou Operações 
void falar( ){ 
 idade = 10 // Valor Atribuído ao atributo idade 
} 
void comer( int qtd ){ 
 int idade; //Caso declararmos uma variável com o nome do 
atributo (idade) 
 idade = 15 // Valor Atribuído a variável idade deste método 
comer 
 this.idade = 15 // Valor Atribuído ao atributo idade da 
classe 
} 
} 
A classe acima mostra uma das formas mais comuns de utilizar o 
operador this, observe que no método falar() não foi utilizada o operador, 
isto porque, não existe nenhuma outra variável que tenha o mesmo nome 
que o atributo declarado no inicio da classe. Já no caso do método comer () 
fomos obrigados a utilizar o this no caso de fazermos uma atribuição no 
atributo, isto porque internamente o métodopossui uma variável com o 
mesmo nome que a variável declarada na classe. 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 23 
 
 
No capítulo 5 vamos abordar também sobre os construtores e veremos 
que o operador this desempenha um papel fundamental. 
 
 
Referência bibliográfica do capítulo 3 
 
http://www.javaprogressivo.net/2012/09/sobrecarga-de-metodos-
method.html 
 
http://pt.wikipedia.org/wiki/Sobrecarga 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. MODIFICADORES DE ACESSO, CONSTRUTORES E ELEMENTOS ESTÁTICOS 
 
4.1. Modificadores de acesso e encapsulamento 
 
Na Linguagem Java entende-se de modificadores de acesso como a 
forma de como uma classe, método ou atributo será invocada. Ou seja 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 24 
 
determina o acesso à variável, método ou uma classe. São modificadores de 
acesso as seguintes palavras reservadas: public, protected, private e 
static.(existem mais). 
 modificador de acesso private quando aplicado a um atributo ou a um 
método indica que os mesmos só podem ser acessados dentro da classe que 
os criou (encapsulamento). 
A instrução protected indica que o método ou a variável assim declarada 
possa ser acessada somente dentro do pacote em que está contida através de 
uma subclasse. 
A instrução public indica que a classe, método ou variável assim 
declarada possa ser acessada em qualquer lugar e a qualquer momento da 
execução do programa. 
A instrução static serve: 
 Na declaração de uma variável dentro de uma classe, para se criar 
uma variável que poderá ser acessada por todas as instâncias de 
objetos desta classe como uma variável comum. Ou seja, a variável 
criada será a mesma em todas instâncias e quando seu conteúdo é 
modificado em uma das instâncias então ele será modificado em 
todas instâncias; 
 Na declaração de um método que deve ser acessado diretamente na 
classe e não nas suas instâncias. 
 
Exemplo: “Na Aula” 
 
Encapsulamento é a necessidade de ocultar ou esconder tudo 
aquilo que deve ser privatizado, permitindo que somente métodos 
específicos possam ser invocados isto é no caso da variável ou 
proporcionar alguma utilidade/serviço aos métodos da própria classe, isto 
é, no caso dos métodos. 
 
 Exemplo: “Na Aula” 
 
4.2. Construtores 
 
Também conhecidos pelo inglês constructors são os responsáveis por 
criar o objeto em memória, ou seja, instanciar a classe que foi definida. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 25 
 
Os construtores são obrigatórios e são declarados da seguinte forma: 
Exemplo: 
public class Carro{ 
 
/* CONSTRUTOR DA CLASSE Carro */ 
public Carro(){ 
 //Faça o que desejar na construção do objeto 
} 
 
} 
 
Para criar um objeto da Classe Carro, simplesmente usamos a palavra reservada 
“new” e o nosso construtor entra em ação neste momento. 
public class Carro{ 
 
/* CONSTRUTOR DA CLASSE Carro */ 
public Carro(){ 
 //Faça o que desejar na construção do objeto 
} 
 
} 
 
 
public class Aplicacao { 
 
 public static void main(String[] args) { 
 //Chamamos o construtor sem nenhum parâmetro 
 Carro toyota = new Carro(); 
 } 
 
} 
 
Por padrão o Java já cria esse construtor sem parâmetros para todas as 
Classes, então você não precisa fazer isso se irá utilizar apenas construtores sem 
parâmetros. Por outro lado, se você quiser poderá criar mais de um construtor 
para uma mesma classe, ou seja, posso criar um construtor sem parâmetros, ou 
com 2 parâmetros e outro com 3 parâmetros. E assim por diante sem problema. 
Exemplo: 
public class Carro{ 
 
private String cor; 
private double preco; 
private String modelo; 
 
/* CONSTRUTOR PADRÃO */ 
public Carro(){ 
 
} 
 
/* CONSTRUTOR COM 2 PARÂMETROS */ 
public Carro(String modelo, double preco){ 
 //Se for escolhido o construtor sem a COR do veículo 
 //Definimos a cor padrão como sendo PRETA 
 cor = “PRETA”; 
 this.modelo = modelo; 
 this.preco = preco; 
} 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 26 
 
 
/* CONSTRUTOR COM 3 PARÂMETROS */ 
public Carro(String cor, String modelo, double preco){ 
 this.cor = cor; 
 this.modelo = modelo; 
 this.preco = preco; 
} 
 
 } 
 
 
4.3. Atributos e métodos estáticos 
 
 Atributos estáticos 
Em uma classe são compartilhados por todas as instâncias desta 
classe – em outras palavras, somente um valor será armazenado em um 
campo estático, e caso este valor seja modificado por uma das instâncias 
(objeto) desta classe, a modificação será refletida em todas as outras 
instâncias (objeto) desta classe. 
 
Os atributos estáticos são declarados com o modificador static 
(modificador de acesso visto no capítulo anterior), que deve ser declarado 
antes do tipo de dado do campo e pode ser combinado com 
modificadores de acesso como public e private. 
 
Exemplo, São atributos estáticos os seguintes: 
 static int num1; 
 private static String nome; 
 
 Métodos estáticos 
São declarados com o modificador static, que deve preceder o 
tipo de retorno do método e que pode ser combinado com modificadores 
de acesso ao método. 
 
 Exemplo: 
 public static void arrancar( ){ … } 
 public static int soma( ){ return … } 
 
 
Conclusão: 
 
 Os elementos estáticos de uma classe ajudam muito a 
manter os objetos criados unidos ou seja, todos poderão beneficiar 
de um mesmo valor ou de uma operação. O melhor de tudo é que 
não precisamos criar um objeto aparte para fazer está operação, 
mas sim acedemos diretamente da própria classe 
(Nome_da_Classe.Atributo/Operação). 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 27 
 
 
 
 
 
 
Referência bibliográfica do capítulo 4 
 
http://www.devmedia.com.br/construtores-em-java/28618#ixzz2qJp5StvW 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 28 
 
5. HERANÇA E POLIMORFISMO 
 
5.1. Herança 
 
Com certeza que em toda sua vida já ouviu está palavra “Herança”. É isto 
mesmo que estas a pensar, mas no Java a implementação “dessa ideia” pode 
ser diferente e mais simples do que imagina. 
 Herança é o mecanismo utilizado para que uma classe herde os métodos 
e atributos da outra classe. A palavra reservada que indica a herança é o 
extends. 
 Por exemplo imagine que, a existe uma classe A e outra classe B. E quer 
que B herde de A: 
 
Notação UML, mostra que B herda de A 
 Então isto implicará o seguinte: 
 
B herda de A todas as variáveis e métodos de instância (os atributos 
declarados como private em A, só podem ter acesso pelos métodos 
public de A, e não directamente, isto é dentro da classe B) 
 
B pode definir novas variáveis e novos métodos próprios. 
 
B pode redefinir variáveis e métodos herdados. 
 
 Forma geral: 
 
class <nome-da-classe> extends SuperClass 
é permitido apenas uma superclasse, não há herança múltipla 
em Java 
No caso do nosso exemplo ficaria assim: 
 class B extends A { } 
 
 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 29 
 
 
 5.1.1. Sobrescrita de métodosQualquer classe que herda um método de uma superclasse tem a 
oportunidade de sobrescrever o método (exceto métodos marcados como 
final). O benefício de sobrepor é a capacidade de definir um 
comportamento que é específico para um tipo de subclasse particular. 
 
Por exemplo: 
Temos uma classe Pessoa 
 public class Pessoa { 
 public void cadastrar() { 
 System.out.println("Cadastro de Pessoa"); 
 } 
} 
 
E outra classe Animal 
 public class Animal extends Pessoa { 
 //método sobrescrito da classe Pessoa 
 public void cadastrar() { 
 System.out.println("Cadastro de Animal"); 
 } 
 
 public void listar() { 
 System.out.println("Listar todos Animais"); 
 } 
 
} 
 
5.1.2. Palavra-chave super e o operador instanceof 
 
 Palavra-chave super 
Lembra-se da palavra-chave this? Bom vamos pelo sim! A 
palavra-chave this faz referência a própria classe! 
 
A palavra super normalmente é utilizada quando estamos diante 
de uma herança, ou seja é utilizada principalmente nas classes derivadas 
para fazer referência a superclasse ou classe mãe. 
 
 
 
 
 
Por exemplo: 
Temos uma classe Pessoa 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 30 
 
 public class Pessoa { 
 Pessoa(){…} //Costrutor 
} 
 
E outra classe Animal 
 public class Animal extends Pessoa { 
//Costrutor da classe 
Animal(){ 
super();//Costrutor da superClasse 
} 
} 
 
 Operador instanceof 
 Conforme uma aplicação for crescendo, facilmente ela 
atingirá dezenas ou centenas de classes, subclasses, superclasses, 
classes abstratas, etc. Somente pelo nome do objeto pode ficar 
difícil descobrir a qual classe ela pertence. 
Porém, o Java provém uma solução simples para isso, a palavra-
chave: instanceof. Segue-se a sintaxe: 
nomeObjeto instanceof Classe 
Essa é uma expressão, que retorna true ou false. 
 Por exemplo: 
class A { 
 int i, j; 
} 
class B { 
 int i, j; 
} 
class C extends A { 
 int k; 
} 
class InstanceOf { 
 public static void main(String args[]) { 
 A a = new A(); 
 B b = new B(); 
 C c = new C(); 
 
if(a instanceof A) 
 System.out.println("a é objeto de A"); 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 31 
 
 
if(b instanceof B) 
 System.out.println("b é objeto de B"); 
 
if(c instanceof C) 
 System.out.println("c é objeto de C"); 
 
if(c instanceof A) 
 System.out.println("c pode ser convertido 
para A"); 
if(a instanceof C) 
 System.out.println("a ser convertido para 
C"); 
System.out.println(); 
 } 
} 
 
 
 5.2. Polimorfismo 
 
 O princípio pelo qual duas ou mais classes derivadas de uma mesma 
superclasse podem invocar métodos que têm a mesma identificação (assinatura) 
mas comportamentos distintos. 
 
 No caso de polimorfismo, é necessário que os métodos tenham 
exactamente a mesma identificação, sendo utilizado o mecanismo de 
overriding.(Princípio da Sobrescrita de métodos). 
 
Polimorfismo significa que uma chamada de método pode ser executada 
de várias formas (ou polimorficamente). Quem decide "a forma" é o objeto que 
recebe a chamada. Invocações de métodos polimórficos são aplicadas somente 
para métodos de instância. 
 
public class Aplicacao { 
 public static void main(String[] args) { 
 Pessoa p1 = new Pessoa(); 
 Pessoa p2 = new Animal(); 
 
//Chamada Polimórfica (do método da Pessoa) 
 p1.cadastrar(); 
 
//Chamada Polimórfica (do método do Animal) 
 p2.cadastrar(); 
 
 //Pessoa não possui o método listar() 
 p1.listar(); //Erro 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 32 
 
 
 /* Apesar da Classe animal possuir o método 
 * listar(), a referência é da classe Pessoa 
 * que não possui tal método */ 
 p2.listar(); //Erro 
 
 } 
} 
 
 
Conclusão: 
 
 A herança desperta um conjunto de conceitos em torno da POO, que 
só conseguimos entende-la na íntegra quando o implementamos nos 
capítulos posteriores. 
 A classe que herda chama-se subclasse e a classe na qual é herdada 
chamamos de super classe. 
 Qualquer classe em java deriva (é subclasse) da classe Object. 
 Para uma melhor percepção tenha em atenção toda prática que 
envolve este rico tema. 
 
 
Em Java todos objetos acabam sendo polimórficas, excepto os Objectos 
do tipo Object e aquelas declaradas com o final. 
 
O polimorfismo só ocorre quando existe alguma herança. E em tempo de 
execução. 
 
 
 
Referência bibliográfica do capítulo 5 
 
http://kamilladoria.blogspot.com/2010/04/metodos-sobrescritos-overridden.html 
http://kamilladoria.blogspot.com/2010/04/polimorfismo.html 
http://www.javaprogressivo.net/2012/10/descobrindo-classe-de-um-objeto.html 
http://www.java-samples.com/showtutorial.php?tutorialid=332 
 
 
 
 
 
 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 33 
 
6. TRATAMENTO DE EXCEÇÕES 
6.1. Lançando e tratando excepções 
 Quando se cria programas de computador em Java, há possibilidade de 
ocorrer erros imprevistos durante sua execução, esses erros são conhecidos como 
exceções e podem ser provenientes de erros de lógica ou acesso a dispositivos ou 
arquivos externos. 
Alguns possíveis motivos externos para ocorrer uma excepção são: 
 Tentar abrir um arquivo que não existe. 
 Tentar fazer consulta a um banco de dados que não está 
disponível. 
 Tentar escrever algo em um arquivo sobre o qual não se tem 
permissão de escrita. 
 Tentar conectar em servidor inexistente. 
 
 Normalmente os editores da linguagem java mais comuns como 
Netbeans e Eclipse ajudam muito no tratamento de excepções, mas ainda assim 
não é possível prever todas elas principalmente as que ocorrem em tempo de 
execução. 
 
 Para tratar as excepções em Java são utilizados os comandos try e catch 
e os famosos throw e throws. 
Comando try/catch 
Sintaxe: 
try 
{ 
 //trecho de código que pode vir a lançar uma exceção 
} 
catch(tipo_exceçao_1 e) 
{ 
 //ação a ser tomada 
} 
catch(tipo_exceçao_2 e) 
{ 
 //ação a ser tomada 
} 
catch(tipo_exceçao_n e) 
{ 
 //ação a ser tomada 
} 
 
Onde: 
 try{ … } - Neste bloco são introduzidas todas as linhas de código que 
podem vir a lançar uma excepção. 
 catch(tipo_excessao e) { … } - Neste bloco é descrita a acção que 
ocorrerá quando a excepção for capturada. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 34 
 
Por exemplo: 
Imagine uma classe que tem um método principal main que tem como 
seu único objetivo alterar todas as letras de um frase para maiúsculas utilizando 
o método toUpperCase() da classe String, caso a frase esteja nula e se tente usar 
o método toUpperCase() na mesma será lançada uma exceção de 
NullPointerException. 
Primeiro vamos ver como ficaria a tal classe sem a utilização do try/catch. 
public class aumentaFrase { 
 public static void main(String args[]) 
 { 
 String frase = null; 
 String novaFrase = null; 
 novaFrase = frase.toUpperCase(); //um erro bem aqui 
 System.out.println("Frase antiga: "+frase); 
 System.out.println("Frase nova: "+novaFrase); 
 } 
} 
 
Para ajudar a melhorar a situação, deve-se utilizar o try/catch. 
 
public static void main(Stringargs[]) 
{ 
 String frase = null; 
 String novaFrase = null; 
 try 
 { 
 novaFrase = frase.toUpperCase(); 
 } 
 catch(NullPointerException e) //CAPTURA DA POSSÍVEL 
 { 
 //TRATAMENTO DA exceção 
 System.out.println("O frase inicial está nula, para 
solucional tal o problema, foi lhe atribuito um valor default."); 
 
 frase = "Frase vazia"; 
 novaFrase = frase.toUpperCase(); 
 } 
 System.out.println("Frase antiga: "+frase); 
 System.out.println("Frase nova: "+novaFrase); 
} 
 
 
 Quando este código for executado, o mesmo lançará uma 
NullPointerException, porém esta excepção será tratada desta vez, sendo a 
mesma capturada pelo catch{} e dentro deste bloco as devidas providências são 
tomadas. Neste caso é atribuído um valor default à variável frase. 
 
Comando finally 
 Imagine a seguinte situação: foi aberta uma conexão com o base de dados 
para realizar determinada ação, e no meio deste processo seja lançada alguma 
excepção, como por exemplo, NullPointerException ao tentar manipular um 
determinado atributo de um objeto. Neste caso seria necessário que mesmo 
sendo lançada uma excepção no meio do processo a conexão fosse fechada. Um 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 35 
 
outro exemplo bom seria a abertura de determinado arquivo para escrita no 
mesmo, e no meio deste processo é lançada uma excepção por algum motivo, o 
arquivo não seria fechado, o que resultaria em deixar o arquivo aberto. 
Quando uma excepção é lançada, é necessário que determinada acção 
seja tomada mesmo após a sua captura, utilizamos a palavra reservada finally. 
Sintaxe: 
try 
{ 
 //trecho de código que pode vir a lançar uma exceção 
} 
catch(tipo_exceçao_1 e) 
{ 
 //ação a ser tomada 
} 
catch(tipo_exceçao_2 e) 
{ 
 //ação a ser tomada 
} 
catch(tipo_exceçao _n e) 
{ 
 //ação a ser tomada 
} 
finally 
{ 
 //ação a ser tomada 
} 
 
 
 
Comandos throw e throws 
 Imagine uma situação em que não é desejado que uma excepção seja 
tratada na própria classe ou método, mas sim em outro que venha lhe chamar. 
Para solucionar tal situação utilizamos o comando throws na assinatura do 
método com a possível excepção que o mesmo poderá a vir lançar. 
Sintaxe: 
 
tipo_retorno nome_metodo() throws tipo_exceção_1,tipo_exceção_2, 
tipo_exceção_n 
{ 
 … 
} 
 
Onde: 
 tipo_retorno – Tipo de retorno do método. 
 nome_metodo() - Nome do método que será utilizado. 
 tipo_exceção_1 a tipo_exceção_n – Tipo de excepções separadas por virgula 
que o seu método pode vir a lançar. 
Curso Básico de Java 
Elaborado Por DESOFPRO, Lda – v1 (02/2014) Página 36 
 
 
 Durante as aulas práticas vamos resolver vários exemplos 
envolvendo o tratamento de excepção. 
 
 
Conclusão: 
O uso de comandos para controlar (capturar e tratar) os erros, são de 
suma importância porque desta forma conseguimos produzir programas com mais 
qualidade. 
Embora os IDEs de hoje sejam capazes (ajudam) de prever ou antecipar 
algumas excepções, ainda assim é responsabilidade do programador escrever os 
comandos necessários. 
 
 
 
Referência bibliográfica do capítulo 6 
 
Tratando exceções em Java http://www.devmedia.com.br/tratando-excecoes-em-
java/25514#ixzz2qTjRTMpC