Java

Centro Federal de Educação

Tecnológica – CEFET/RN
 SUMÁRIO
• O que é Java?
• Um pouco de História...
• Principais Características
• O JDK
• Introdução “Oi Mundo”
• O Ambiente Java
• Tipos de Dados e Variáveis
• Operadores
– Aritméticos
– Relacionais
– Lógicos
 SUMÁRIO
• Estruturas Condicionais: If e Switch
• Estruturas de Repetição: While, Do...While e For
• Estruturas de Controle de Erros
• Programação Orientada ao Objeto POO
– Classes, Pacotes, Atributos, Instanciação, Métodos,
Construtores e Destrutores (Coleta de Lixo)
• Saída e Entrada de Dados
• Sobrecarga, Herança e Polimorfismo
• Aplicações Gráficas com AWT
• Applets
• Arquivos
 Programação Orientada ao Objeto
• Objetos: São pacotes de dados (variáveis) e
funções que, assim como os objetos reais possuem
estado e comportamento.
• Encapsulação: É usada para isolar de outros
objetos os detalhes de implementação que não são
relevantes. Dois grandes benefícios são a
modularidade e a abstração de informações, ou
seja, o código fonte de um objeto independe do
código fonte de outros objetos, podendo ser
facilmente reutilizados. Além disso, o objeto pode
ter uma interface pública com outros objetos.
 Programação Orientada ao Objeto
• Classes: São estruturas que definem as variáveis e
os métodos comuns a todos os objetos de um certo
tipo. Cada objeto é uma instância de uma
determinada classe de objetos.
• Quando uma classe é inicializada cria-se um
objeto que se comportará e se parecerá com outras
instâncias de mesma classe.
• Os dados associados a uma classe ou objetos são
chamados de variáveis, enquanto que o
comportamento é chamado de método.
 Programação Orientada ao Objeto
• Forma geral de uma definição de classe:
class nome
{
...
}
• Class é a palavra chave que define uma
classe. As variáveis e métodos são
envolvidas pelas chaves que iniciam e
terminam o bloco.
 Programação Orientada ao Objeto
• Um programa que utiliza uma interface
controladora de um motor elétrico provavelmente
definiria a classe motor.
• Os atributos desta classe seriam: temperatura,
velocidade, tensão aplicada. Eles poderiam ser
representados na classe por tipos como int ou
float. Os métodos desta classe seriam funções para
alterar a velocidade, ler a temperatura, etc.
• A velocidade do motor poderia ser representada
por um atributo inteiro (int).
 Programação Orientada ao Objeto
• Internamente o usuário da classe motor pode
desejar alterar a velocidade, cria-se então o
método: public void altera_velocidade(int novav)
• Esse código corresponde ao cabeçalho do método.
Ele é definido junto com a classe motor. O valor
de retorno da função que “implementa” o método
é void, poderia ser criado um valor de retorno
(boolean) que indicasse se o valor de velocidade
era permitido e foi alterado, ou não era permitido e
portanto não foi alterado.
 Programação Orientada ao Objeto
• Um diagrama simplificado da classe motor com
os atributos e métodos:
 Programação Orientada ao Objeto
• Exemplo: Para uma classe de nome
EstudanteDeGraduacao podemos ter vários objetos durante
a execução de um programa.
• Estudante de graduação Andre; Identificação 940718;
Curso Computacao | Estudante de graduação Luiza ,
Identificação 893249, Curso Medicina...
• A classe representa somente o molde para a criação dos
objetos que contém informação.
• O atributo Identificação tem valor 940718 para a instância
(objeto) André da classe Estudantes de Graduação.
 Programação Orientada ao Objeto
• Uma classe e suas instâncias:

• Cada estudante (ou instância) poderia ser

modelado, desenhado como:
 Programação Orientada ao Objeto
• Herança: Classes podem ser definidas usando
modelos de outras classes. As classes usadas para
isso são chamadas de superclasses e as classes
criadas a partir de outras são as subclasses.
• As subclasses herdam os estados e os métodos das
superclasses. Porém podem modificar ou adicionar
outras variáveis e métodos.
• A grande vantagem é a reutilização de códigos.
 Programação Orientada ao Objeto

• Sua utilização se dá usando a palavra chave

extends:
Class NomeDaSubclasse extends NomeDaSuperclasse
{
...
}
• Na verdade todas as classes são derivadas da
classe raiz chamada de Object.
 Programação Orientada ao Objeto
• Os métodos são as funções, que permitem uma
modularização do problema. Sua sintaxe é:
TipoDeRetorno NomeDoMetodo(parâmetros)
{
...
{
• Os parâmetros devem ser declarados
individualmente no método.
 Programação Orientada ao Objeto
• Variáveis de instância: são variáveis não
estáticas de uma classe fora do escopo de
um método. Por exemplo:
Class NomeDaClasse
{
int i=0;
...
{
 Programação Orientada ao Objeto
• Construtores: São métodos especiais usados para
inicialização. Eles têm o mesmo nome das classes
e nenhum tipo de retorno. Ele cria uma nova
instância de uma classe, inicializando todas as
variáveis e fazendo todo o trabalho necessário a
utilização da classe.
• Ele é criado com um método público com o
mesmo nome da classe.
 Programação Orientada ao Objeto
• Por exemplo:
Class NomeDaClasse
{
String home_page;
String url;

Public NomeDaClasse()
{
home_page = “”;
url = “”;
}
}
 Programação Orientada ao Objeto

• Operador new: Quando se cira um objeto

não se aloca memória, para que isso ocorra
usamos o operador new. Além da alocação
de memória, inicializa as variáveis de
instância e chama o método construtor, que
é quem inicializa o objeto.
• Porém não é necessário desalocar memória,
no java isso é feito automaticamente.
 Programação Orientada ao Objeto
• A desalocação do objeto é feita pelo “garbage
collector”. Após o fecha chaves de main, a memória
do objeto pode ser liberada, o que normalmente não
ocorre de imediato, pois o ambiente da linguagem que
executa o programa possui prioridades, e libera de
tempos em tempos os espaços inutilizados de
memória, tirando proveito por exemplo de eventuais
pausas de iteração do usuário com o programa.
• Para tanto, usamos o comando new da seguinte forma:
NovaIstancia = new NomeDoObjeto(Valor Inicial);
 Programação Orientada ao Objeto
• “Packages”, ou pacotes, são um recurso da linguagem que
permite formar grupos de classes relacionadas entre si de
forma que elas ofereçam facilidades umas as outras, são
como as bibliotecas do Pascal ou do C. Facilidades estas
que nem sempre são oferecidas ao usuário. Por exemplo,
um dos pacotes que usamos é o java.io, dois outros muito
importantes são o java.lang e o java.awt.
• Packages são acrescentados ao programa com a palavra
reservada import. Com isso podemos usar diversas classes
já criadas e pré-definidas. O pacote java.lang é o default,
mesmo que não sejam importados nenhum pacote, este
pacote é incluído.
 Outras Informações
• Constantes: Para declarar uma constante,
use a palavra chave final antes da
declaração da variável e inclua um valor
inicial para esta variável. Por exemplo:
final float pi=3.141592;
final boolean debug=false;
final int maxsize = 40000;
 Outras Informações
• Operador Condicional: Este operador
ternário (?: ), chamado assim porque tem
três termos como parâmetro, funciona da
seguinte maneira, se o teste for verdadeiro
atribui o primeiro resultado, senão atribui o
segundo resultado. Por exemplo:
• test ? trueresult : falseresult
• int menor = x < y ? x : y ;
 Outras Informações
• This: No corpo de uma definição de método, você pode querer
referir-se ao objeto corrente, para usar as variáveis de instância
ou para passar o objeto corrente como um argumento para um
outro método. Para este tipo de referência, você pode usar a
palavra chave this.
class Pessoa {
String nome;
int idade;
Pessoa ( String nome, int idade ) {
this.nome = nome;
this.idade = idade;}
public void imprimeDados () {
System.out.print ( “Nome: “ + this.nome + “ Idade:
“ + this.idade);}
}
 Outras Informações
• Arrays em Java são diferentes do que em outras
linguagens. Arrays em Java são objetos que podem ser
passados e acoplados a outros objetos.
• Arrays podem conter qualquer tipo de elemento valorado
(tipos primitivos ou objetos), mas você não pode
armazenar diferente tipos em um array simples.
• Ou seja, você pode ter um array de inteiros, ou um array de
strings, ou um array de array, mas você não pode ter um
array que contenha ambos os objetos strings e inteiros.
• A restrição acima descrita significa que os arrays
implementados em Java são genéricos homogêneos, ou
seja, um único array pode armazenar qualquer tipo de
objeto com a restrição que todos sejam do mesma classe.
 Outras Informações
• Declaração de Arrays:
• String difficult[];
• float hits[];
• int temp[];
• String[] difficult;
• float[] hits;
• int[] temp;
• Após a declaração de arrays é necessário alocar
espaço na memória e inicializar, se for o caso.
Para isso usa-se o operador new.
 Outras Informações
• Um dos caminhos é usar o operador new para criar
uma nova instância de um array, por exemplo:
– int[] temps = new int[99];
• Ou criar e inicializar o array ao mesmo tempo:
– String[] linguagens = { “C”, “VB”, “Delphi”};
• No caso de new o objeto é inicializado com 0 para
arrays numéricos, falso para boolean, ‘\0’ para
caracteres, e NULL para objetos
 Outras Informações
• Uma vez que você tem um array com
valores iniciais, você pode testar e mudar os
valores em cada índice de cada array.
• Os arrays em Java sempre iniciam-se na
posição 0 como no C++. Por exemplo:
– String[] arr= new String[10];
– arr[10]=”out”;
• Isto provoca um erro de compilação pois o
índice 10 não existe, pois isto está fora das
bordas do array.
– arr[9] = “inside”;
 Outras Informações
• Java não suporta arrays multidimensionais.
No entanto, você pode declarar e criar um
array de arrays e acessá-los como você
faria no estilo-C.
– int coords[][]= new int[12][12];
– coords[0][0] = 1;
– coords[0][1] = 2;
 Saída e Entrada de Dados
• Mesmo que você só vá fazer programas em
interfaces gráficas é interessante saber como
ler valores via teclado ou linha de comando.
Além do que você pode desejar fazer algum
programa de linha de comando (batch) em
Java, por exemplo um programa de
comunicação entre as diversas máquinas de
uma rede ou um programa que receba
argumentos via linha de comando.
 Saída e Entrada de Dados
• Em Java é praticamente um padrão ler dados em
bytes, seja do teclado, da rede, do disco ou de
qualquer outro lugar. Por este motivo o primeiro
exemplo lê em um vetor de bytes. Por exemplo,
vamos escrever um programa que apresente a
seguinte saída na tela.
Escreva algo:
“Texto digitado”
Voce escreveu: “Texto digitado”
 Saída e Entrada de Dados
import java.io.*;
class EntraDados {
public static void main (String args[]) {
byte vetortexto[] = new byte[200];
int byteslidos = 0;
System.out.println("Escreva algo:");
try {
byteslidos = System.in.read(vetortexto);
System.out.print("Voce escreveu:");
System.out.write(vetortexto,0,byteslidos);}
catch (IOException e) {
// Alguma acao de recuperacao da falha}
}
}
 Saída e Entrada de Dados
• Este programa usa o método System.in.read(vetortexto);
para ler do teclado. Este método precisa de um vetor de
bytes como argumento(onde serão lidos os caracteres) e
além disso retorna o número de bytes lidos, para que você
possa usar o vetor corretamente.
• Para descarregar o vetor no vídeo use o método
System.out.write(vetortexto,0,byteslidos); que imprime na
tela as posições de 0 até byteslidos do vetor de bytes
passado como o primeiro argumento.
• Você deve estar se perguntando qual a função dos blocos
de código try {} catch {} deste programa exemplo. Eles
são importantes no tratamento de exceções. Isso é muito
comum em leitura de dados.
 Estruturas de Controle de Erros
• Exceções: O tratamento de exceções permite lidar com as
condições anormais de funcionamento de seu programa.
Condições anormais podem ser acesso a um índice
inválido de um vetor, tentativa de uso de um objeto não
inicializado, uma falha não prevista, etc.
• Java é uma linguagem que faz forte uso do conceito de
tratamento de exceções. Em determinados trechos de
programa são necessários blocos de código try{} catch{}.
• Um dos motivos de o programador Java ter que saber
tratamento de exceções é que os métodos de classes
definidas na linguagem podem gerar exceções e na maioria
das vezes o compilador nos obriga a escrever tratadores
(blocos try{} catch{}) para chamadas destes métodos.
 Estruturas de Controle de Erros
• Quando você for estruturar seu código, haverão duas ações básicas que
devem ser tomadas: levantar (ou jogar) uma exceção e tratar uma
exceção. Uma exceção será levantada quando for verificada uma
condição anormal de funcionamento do programa, então o método que
esta sendo executado é imediatamente terminado e o controle passa
para o método que o chamou, onde pode ocorrer um tratador da
exceção ou não. Se ocorrer um tratador, na maioria dos casos a
exceção para de se propagar ali mesmo. Se não ocorrer um tratador
outras chamadas de métodos são “desfeitas”, encerradas, podendo
culminar no término do programa se toda a cadeia de chamada de
métodos for desfeita até chegar em main sem que se ache um tratador
para esta exceção. Existem vários modelos de tratamento de exceções,
o modelo adotado por Java recebe o nome de: “termination model”,
justamente por essas terminações de métodos.
• Jogar uma exceção é suspender a execução do método atual e passar
um objeto para o bloco catch mais próximo na cadeia de chamadas de
métodos atual. Isto é feito através da declaração:
• throw nomedoobjeto; //ou
• throw new nomedaclassedoobjeto(argumentos do construtor)
 Estruturas de Controle de Erros
• Como exceções são objetos, você pode definir hierarquias
de classes de exceções, que mapeiem em termos de
informações as condições anormais de seu programa
contendo as mensagens de erro e as possíveis soluções
• As exceções geradas pela linguagem pertencem a uma
hierarquia cujo topo é a classe Throwable, imediatamente
estendida por Error e Exception. Por exemplo:
– try{ /*algo que possa gerar uma excecao*/}
– catch (Exception erro) { /* acoes de tratamento do erro
com possivelmente nova tentativa de execução dos
métodos chamados*/ }
• Este exemplo seria capaz de tratar todas as exceções que
estejam abaixo de Exception (na hierarquia) geradas em try
{ }.
Sobrecarga, Herança e Polimorfismo
• Os métodos em Java podem ser sobrecarregados, ou seja,
podem-se criar métodos com o mesmo nome, mas com
diferentes assinaturas (parâmetros) e diferentes definições.
Quando se chama um método em um objeto, o Java casa o
nome do método, o número de argumentos e o tipo dos
argumentos e escolhe qual a definição do método a
executar.
• Para criar um método sobrecarregado, é necessário criar
diferentes definições de métodos na sua classe, todos com
o mesmo nome, mas com diferentes parâmetros (número
de argumentos ou tipos).
• Podemo, por exemplo, criar a definição da classe
Retangulo, a qual define um retângulo plano. A classe
Retangulo têm quatro variáveis para instanciar, as quais
definem o canto superior esquerdo e o canto inferior direito
do retângulo: x1, y1, x2 e y2.
Sobrecarga, Herança e Polimorfismo
• Por exemplo:
class Retangulo {
int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;
}
Sobrecarga, Herança e Polimorfismo
• Quando uma nova instância da classe Retangulo for criada,
todos as suas variáveis são inicializadas com 0. Definindo
um método constRetang (), este método recebe quatro
inteiros e faz um “resize” do retângulo de acordo com as
novas coordenadas e retorna o objeto retângulo resultante (
note que os argumentos possuem o mesmo nome das
variáveis instanciáveis, portanto deve-se usar o this para
referenciá-las ).
– Retangulo constRetang ( int x1, int y1, int x2, int y2 ){
– this.x1 = x1;
– this.y1 = y1;
– this.x2 = x2;
– this.y2 = y2;
– return this;}
Sobrecarga, Herança e Polimorfismo
• Querendo-se definir as dimensões do retângulo de outra
forma, por exemplo pode-se usar o objeto Point ao invés
de coordenadas individuais. Faremos a sobrecarga do
método construaRetang (), passando agora como
parâmetro dois objetos Point:
Retangulo constRetang (Point superiorEsquerdo, Point
inferiorDireito) {
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = inferiorDireito.x;
y2 = inferiorDireito.y;
return this;}
Sobrecarga, Herança e Polimorfismo
• Porém querendo-se definir um retângulo usando somente o
canto superior esquerdo e uma largura e altura do retângulo
pode-se ainda definir mais um método construaRetang ()
Retangulo constRetang (Point superiorEsquerdo, int
largura, int altura) {
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = (x1 + largura);
y2 = (y1 + altura);
return this;}
Sobrecarga, Herança e Polimorfismo
• Para finalizar o exemplo temos um método
para imprimir as coordenadas do retângulo
e um main para fazer o teste:
import java.awt.Point;
class Retangulo {
int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;
Retangulo constRetang ( int x1, int y1, int x2, int y2 ) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
return this;}
Sobrecarga, Herança e Polimorfismo
Retangulo constRetang (Point superiorEsquerdo, Point inferiorDireito) {
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = inferiorDireito.x;
y2 = inferiorDireito.y;
return this;}
Retangulo constRetang (Point superiorEsquerdo, int largura, int altura) {
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = (x1 + largura);
y2 = (y1 + altura);
return this;}
void imprimaRetangulo () {
System.out.print ( “Retângulo: < “ + x1 + “, “ + y1 );
System.out.println ( “, “ + x2 + “, “ + y2 + “>”);}
 Sobrecarga, Herança e Polimorfismo
public static void main ( String args[] ) {
Retangulo retang = new Retangulo();
System.out.println ( “Chamando constRetang com coordenadas 25, 25, 50, 50 :” );
retang.constRetang ( 25, 25, 50, 50 );
retang.imprimaRetangulo ();
System.out.println ( “--------------------------------------------“);
System.out.println ( “Chamando constRetang com os pontos
(10, 10) , (20, 20) :” );
retang.constRetang ( new Point (10,10) , new Point (20, 20) );
retang.imprimaRetangulo ();
System.out.println ( “--------------------------------------------“);
System.out.println ( “Chamando constRetang com os pontos (10, 10) ,
largura (50) e altura (50) :” );
retang.constRetang ( new Point (10,10) , 50, 50);
retang.imprimaRetangulo ();
System.out.println ( “--------------------------------------------“);}
}