Utilizamos o comando JAVAC para chamar o
compilador Java. Ele irá transformar o código fonte (arquivo com a extensão .java em byte- code (arquivo com a extensão .class).
Utilizamos o comando JAVA para chamar a
JVM, que irá interpretar o byte-code (arquivo
Erros de compilação
Durante a compilação, o compilador irá listar 1
ou mais erros (caso eles existam).
Caso isso aconteça, devemos sempre olhar e
corrigir sempre o primeiro erro desta lista.
Um erro simples de sintaxe (por exemplo esquecer
o “ponto-e-vírgula”) pode fazer o compilador entender que existam vários outros erros.
Após corrigir este erro, compilar de novo e verificar
Erros de compilação – erros comuns
Erros que externos ao código fonte
O PATH não está configurado corretamente e o sistema
operacional não consegue achar o compilador e a jvm.
Solução: configurar corretamente a variável de ambiente
PATH.
‘javac' não é reconhecido como um comando interno ou externo, um programa operável ou um arquivo em lotes.
‘java' não é reconhecido como um comando interno ou externo, um programa operável ou um arquivo em lotes.
Erros de compilação – erros comuns
O compilador não está achando o arquivo fonte.
Possíveis causas:
o nome foi digitado incorretamente
o arquivo fonte não está no diretório atual
o CLASSPATH não está configurado corretamente
Soluções:
verificar se o nome do arquivo foi digitado corretamente verificar se o arquivo está no diretório atual
verificar se o CLASSPATH está configurado com o diretório atual (.)
error: cannot read: Teste.java
Erros de compilação – erros comuns
Para localizarmos a maioria dos erros que pertencem
ao código fonte, o compilador avisa em qual arquivo o erro está localizado, e em qual linha. Em seguida
mostra qual o erro cometido.
Teste.java:4: ';' expected
^
1 error
Na linha 4
Erro no arquivo Teste.java
O compilador esperava (expected) achar um “ponto-e-vírgula” no final da linha
O mesmo tipo de erro (<simbolo> expected) acontece quando no código está faltando algum símbolo de parênteses ou chaves.
Formato de uma classe class <nome> { } int x; char c; Atributos do objeto funcao <nome>() { ... } Métodos
Fundamentos da Linguagem
Java é sensível a letras maiúsculas e
minúsculas (case-sensitive)
Ex: maria ≠ Maria ≠ MAria ≠ MARIA
Formatação livre de código
Os dois exemplos abaixo produzem o mesmo efeito:
x = 1 + 5; x =
1 + 5
Ao final de cada comando é obrigatório o uso
do ponto-e-vírgula
Ex: x = 1 + 5;
Blocos de código são colocados entre chaves
Fundamentos da Linguagem
int soma() {
x = a + b;
return x;
Fundamentos da Linguagem
Identificadores – nomes de classes, variáveis e funções – devem:
iniciar com os seguintes caracteres:
A até Z (maiúscula ou minúscula) _ (undescore)
$ (cifrão)
os próximos caracteres podem ser qualquer um dos
Fundamentos da Linguagem
Comentários – são textos colocados dentro de um código
fonte apenas como forma de identificar trechos do código,
como um lembrete. No momento da compilação o compilador ignora os trechos que estão em comentário
Java suporta os seguintes tipos de comentários
Dentro de uma mesma linha (inline): // comentário
Várias linhas (multi-line): /* comentário */
Multi-line com Javadoc: /** comentário */
Javadoc são comentários colocados em uma formatação
específica dentro do código que depois podem ser extraídos em formato HTML, o que torna desnecessária a escrita da
Fundamentos da Linguagem
Palavras reservadas – palavras que não podem
ser utilizadas como nome de variáveis, nome de classes, etc
Em Java:
abstract, boolean, break, byte, byvalue, case,
catch, char, class, continue, default, do, double, else, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int,
interface, long, native, new, null, package,
private, protected, public, return, short, static, super, switch, synchronized, this, threadsafe,
Fundamentos da Linguagem
Um programa Java é composto por uma ou
mais classes.
Cada classe deve estar em um arquivo
diferente (em princípio).
Este arquivo deve ter o exatamente o mesmo
nome da classe (inclusive maiúsculas e minúsculas) com a extensão .java
Fundamentos da Linguagem
Uma aplicação stand-alone em Java precisa ter em
sua classe principal um método também principal, que indica onde o programa começa.
Este é o método main (principal em português)
A classe principal é a classe que será chamada pela
JVM:
java ClassePrincipal
public static void main(String[] args) {
//inicialização
Variáveis em Java
Para declararmos uma variável, utilizamos a seguinte
instrução:
<tipo da variável> <nome da variável>
Exemplo:
int media; char teste;
A variável também já pode ser inicializada durante sua
declaração, o que sempre é um bom modo de programar.
Exemplo:
Variáveis em Java
Variáveis para números inteiros:
Obs: não temos o tipo unsigned como em C++
8 bytes -922.337.203.685.475.808 até +922.337.203.685.475.807 long 4 bytes -2.147.483.648 até +2.147.483.637 int 2 bytes -32.768 até +32.767 short 1 byte -128 até +127 byte Espaço em memória Variação Tipo
Variáveis em Java
Variáveis para números decimais (ou ponto
flutuante):
O Java possui 2 tipos de variáveis para números
decimais. A diferença entre elas é a sua precisão.
8 bytes -1.7 x 10 308 até +1.7 x 10 308 double 4 bytes -3.4 x 10 38 até +3.4 x 10 38 float Espaço em memória Variação Tipo
Variáveis em Java
Tipo caracter
Diferentemente de outras linguagens, o Java utiliza o padrão
Unicode ao invés do padrão ASCII.
Isso torna possível o suporte a línguas como árabe e
japonês.
Isso faz com que o tipo caracter em Java ocupe 2 bytes ao
invés de 1 byte como em outras linguagens.
Exemplo:
Variáveis em Java
Tipos booleanos
Utilizados para expressões lógicas, ocupam 1 bit, e
possuem somente dois valores:
true false
Exemplo:
Variáveis em Java
Todas as variáveis vistas até agora são ditas
“primitivas”. Ou seja, não é preciso declarar nenhum objeto para utilizá-las.
O tipo String (cadeia de caracteres) embora seja uma
classe é declarado como se fosse um tipo primitivo:
String nome = “Joao da Silva”;
Por ser uma classe, temos vários métodos já
embutidas (que serão vistos adiante).
Por ser um objeto, deve ser comparada usando o
método equals. Exemplo:
Literais
São os valores propriamente ditos, escritos no
código
Exemplo:
meuInt = 10; nome = "Maria";
meuInt é uma variável do tipo int, e nome é uma String 10 é uma literal
Literais
Literais para Inteiros
Toda literal inteira será tratada como:
int – caso o valor esteja dentro da capacidade do tipo int long – caso seja maior que a capacidade do int
Supondo as duas linhas de código abaixo:
se (x > 10)
se (x > 2147483638)
A literal 10 será tratada como tipo int
Literais
Para forçar um literal int a ser tratado como
long podemos utilizar os modificadores de tipo:
Exemplo de código:
se (x > (long) 10)
O mesmo serve para forçarmos uma literal int
a ser tratada como byte ou short:
Literais
Números com ponto flutuante
todos os números com ponto flutuante são tratados
como double
para utilizarmos o tipo float devemos utilizar os
Literais
Booleanos – somente dois valores possíveis
true
false
String – deve estar entre aspas duplas
Exemplo de linha de código:
String nome = "Maria";
Literais char – deve estar entre aspas simples
Exemplo de linha de código:
Literais
Para caracteres não expressáveis:
'\t' = tab
'\b' = backspace
'\n' = nova linha
'\r' = voltar ao começo da linha (retorno do carro)
Exemplo de linha de código:
System.out.println("Hoje o dia esta com\n Sol");
Sairia na tela como:
Hoje o dia esta com Sol
Constantes
Constantes são variáveis que possuem um valor fixo,
que não pode ser alterado.
Geralmente usamos constantes no lugar de uma literal
que é muito usada no código.
Para declarar uma constante devemos utilizar o
modificador de tipo final.
Para facilitar a identificação, as constantes devem ser
declaradas em letra maiúscula.
Exemplo:
Convenções
Convenções utilizadas
Nome de Classes: primeiro caracter de todas as palavras
maiúsculo e o restante minúsculo.
Ex.: HelloWorld, MeuProgramaEmJava, BancoDeDados
Variáveis e funções: idem as classes, porém o primeiro
caracter é minúsculo.
Ex.: minhaFuncao, minhaVariavelInt
Constantes: Tudo maiúsculo
Tabulações: devem ser abertas após a chave de abertura {
Escopo de Variáveis
Escopo de uma variável define em qual lugar
podemos acessar tal variável.
Uma variável que está definida dentro de um
método não pode ser acessada fora deste método.
Variáveis dentro de um método são conhecidas
como variáveis locais.
Variáveis locais devem ter um valor de
Escopo de Variáveis
Podemos ter dentro de um bloco de código
outro bloco de código. Exemplo:
{
int x = 0; x = 1;
{
// novo bloco de código
int y = 0; y = 2; x = 2; } y = 3; }
Acesso normal as variáveis do escopo
Acesso normal as variáveis do escopo principal
Operadores
Em Java temos os seguintes operadores:
+ Soma - Subtração / Divisão * Multiplicação % Resto da Divisão ++ Auto-incremento pré e pós-fixado -- Auto-decremento pré e pós-fixado
op= Pode ser utilizado com qualquer operador
Exemplo:
var = var + 1;
Pode ser representado como:
Operadores - Precedência
No exemplo abaixo:
x = 10 + r * 4 / 11 - 5;
Qual operação seria realizada primeiro?
Java possui uma tabela de precedência que indica
qual operação seria realizada primeiro.
Um bom código ignora esta tabela e coloca
parêntesis adequadamente, o que melhora a sua legibilidade:
Exercício
1. Criar uma classe chamada Calculo, que contenha um
método chamado expressao (void expressao()) que calcule a seguinte expressão e atribua o resultado a uma variável chamada Result:
87 + ((156 * 2) / 4)
Imprimir na tela o resultado utilizando a função System.out.println();
Criar uma classe chamada Principal, e dentro dela
criar o método principal da seguinte forma:
Execute o código. Altere o código para que 2 seja dividido por 4
antes de ser multiplicado por 156.
public static void main(String[] args){
Calculo calc = new Calculo();
calc.expressao();
Expressões Condicionais
Uma expressão condicional serve para controlar o
fluxo do nosso programa
Exemplo: Poderíamos imaginar um programa que calcule a
média dos alunos de uma sala e diga se o mesmo foi aprovado ou não:
Formato no Java:
Onde o uso do else não é obrigatório
se (notaAluno > 5) imprimaNaTela(“Aprovado!”); senão imprimaNaTela(“Reprovado!”);
if (<condicao>) <expressao1>
Expressões Condicionais
A condição da sentença acima geralmente envolve
Operadores Lógicos, que em Java são:
== é igual if (i == 1) != diferente if (i != 1) < menor <= menor ou igual > maior >= maior ou igual Operadores boleanos: && e if ((i == 1) && (g >= 6)) || ou ! negação if (!(i < 1))
Java também admite if na forma ternária:
Imprima( (media > 5) ? "Aprovado" : "Reprovado" ) if (<condicao>) <expressao1>
Exercício
1. Criar uma classe chamada Bissexto, com um método
chamado verifica que irá utilizar expressão condicional para verificar se um ano é bissexto ou não:
Um ano é bissexto caso seu valor seja divisível por 4. Copiar o código abaixo.
Preencher o conteúdo do if.
Criar uma classe chamada UsaBissexto, que irá conter um método main, e dentro deste método chamar o método
verifica.
class Bissexto {
void verifica() { int ano = 1999; if ()
System.out.println(“Ano “ + ano + “ eh bissexto”); else
System.out.println(“Ano “ + ano + “ nao eh bissexto”); }
Expressões Condicionais
Considere o seguinte código com if:
int diaSemana = 2; if (diaSemana==1) {
System.out.println(“Domingo"); }
else if (diaSemana==2) {
System.out.println(“Segunda-feira"); }
else if (diaSemana==3) {
System.out.println(“Terça-feira"); }
else if (diaSemana==4) {
System.out.println(“Quarta-feira"); }
else if (diaSemana==5) {
System.out.println(“Quinta-feira"); }
else if (diaSemana==6) {
System.out.println(“Sexta-feira"); }
else {
System.out.println(“Sábado"); }
Expressões Condicionais
Uma outra forma de expressão condicional é o
switch, que permite executar expressões
condicionalmente baseadas em um valor inteiro.
O switch executa a expressão case correspondente
ao valor de sua expressão (nesse caso, diaSemana).
int diaSemana = 7; switch (diaSemana) {
case 1: System.out.println("Domingo"); break;
case 2: System.out.println("Segunda-Feira"); break; case 3: System.out.println("Terça-Feira"); break; case 4: System.out.println("Quarta-Feira"); break; case 5: System.out.println("Quinta-Feira"); break; case 6: System.out.println("Sexta-Feira"); break; case 7: System.out.println("Sábado"); break;
Expressões Condicionais
No fim de cada case, se coloca um break para terminar o
switch, e o programa continuar a partir do fim do bloco do switch. Sem o break, o controle passa aos case
subseqüentes.
Se não houver um case correspondente, é executada a
expressão default caso esta exista, senão nada é executado. int diaSemana = 2;
switch (diaSemana) {
case 2: System.out.println("Segunda é um dia chato."); case 3:
case 4: case 5:
case 6: System.out.println("É dia de trabalho!"); break; case 1:
case 7: System.out.println("É dia de dormir!"); break; default: System.out.println("Dia inválido!");
Laços
Laços são códigos de bloco que queremos
repetir várias vezes.
Por exemplo, poderíamos querer que nosso
programa calcule todas as médias dos alunos enquanto ainda houverem alunos sem notas calculadas.
Isso torna o código mais legível e muito menor
do que ficar reescrevendo o mesmo código várias vezes para cada aluno.
Laços
Como na maioria das linguagens, em Java
temos 3 tipos de laços:
while
Em português, ENQUANTO. Executará o bloco de código
apenas se uma condição for verdadeira.
do-while
Semelhante ao while, com a diferença de que executará
o bloco de código pelo menos uma vez.
for
Executará o bloco de código um número de vezes
Laços Sintaxe: while (<condicao>) <codigo> do <codigo> while (<condicao>);
for (<valor inicial>; <condicao>; <atualizacao>)
<codigo>
int i = 0;
while (i < 5) {
System.out.println(i); i++;
}
int i = 0;
do {
System.out.println(i); i++;
} while(i < 5);
for (int i = 0; i < 5; i++) { System.out.println(i);
System.out.println("Teste de laço"); }
Exercício
1. Escrever um programa que utilize while para
inverter um número inteiro.
Utilizar a seguinte estrutura
class Inverte{
void inverteNumero(){ int numero=123456789; int numeroInvertido=0; while(<condicao>){
//Logica para inversao do numero }
System.out.println(numeroInvertido); }
Ramificações
Os comandos de ramificação permitem um
controle mais avançado do fluxo nos laços. O Java suporta 3 comandos:
break
Permite sair no meio de um laço (break significa quebrar)
continue
Permite pular para a próxima iteração de um laço
return
Ramificações
O comando break é utilizado para se sair de
um laço.
String palavra = "guarda-chuva";
boolean achou = false;
for (int i = 0; i < palavra.length(); i++) { if (palavra.charAt(i) == '-') { achou = true; break; } } if (achou)
System.out.println("Palavra composta"); else
Ramificações
O comando break pode ser utilizado com um
label (rótulo), para sair de laços aninhados.
String[] palavras = {"disco-voador", "ufo"};
boolean achou = false;
busca:
for (int j = 0; j < palavras.length; j++) {
for (int i = 0; i < palavras[j].length(); i++) { if (palavras[j].charAt(i) == '-') { achou = true; break busca; } } } if (achou)
System.out.println("Possui palavra composta"); else
Ramificações
O comando return é utilizado para sair de uma
função, retornando um valor (quando o tipo da função não for void).
Quando usado antes do fim da função, return a
interrompe, e não executa o resto. O controle volta para a linha seguinte à que chamou a função.
Classes
Objetos são definidos através de classes. Objetos possuem características e
funcionalidades, o que em OO chamamos de
atributos e métodos.
Uma aplicação é formada por um conjunto de
classes que desenvolvemos ou já estão desenvolvidas.
Cada classe deve estar em um arquivo
Classes
Uma aplicação stand-alone deve conter um
método main.
A classe que contiver o método main deverá
ser a classe compilada pelo javac e depois chamada pela JVM.
Quando o compilador encontrar uma classe que
referencie outra, primeiro ele procura um
arquivo .java da classe referenciada. Caso não haja, o compilador procura o arquivo compilado (.class). E, caso o .class não seja achado, o
Classes e atributos
Como exemplo vamos definir um objeto Carro através da classe Carro com os seguintes atributos:
class Carro {
String modelo;
String combustivel;
boolean arCondicionado; }
Para utilizarmos esta classe, ou seja, criarmos um objeto carro, devemos declarar na classe que irá utilizar o objeto Carro (em nosso caso, é a classe UsaCarro) a seguinte instrução:
Carro <nome do objeto> = new Carro();
Exemplo:
Classes e atributos
Utilizar um objeto é semelhante a declararmos uma
variável dentro do código.
Criar um objeto de um determinado tipo dentro do
código chama-se instanciar um objeto. Em nosso exemplo, instanciamos um objeto do tipo Carro.
Para acessarmos as variáveis (ou atributos) dentro da
classe UsaCarro utilizamos o nome do objeto seguido de ponto (.) e o nome da variável.
Em nosso exemplo:
Classes e atributos
Os atributos dentro da classe Carro podem ser:
privados - somente dentro da classe Carro as variáveis
privadas serão acessadas. Dentro da classe UsaCarro não podem ser.
públicos - tanto dentro do seu escopo (classe Carro) quanto
na sua instância (dentro da classe UsaCarro), a variável pública pode ser acessada.
Quando instanciamos uma classe, caso suas variáveis
não tenham valor de inicialização, os valores padrão são:
Numérica = 0 ou 0.0 boolean = false
char = ‘\u000’ = espaço String = null
Classes e métodos
Os métodos podem ou não conter parâmetros.
Exemplo:
mostrarLogotipo(); soma(int a, int b);
Os parâmetros podem ser variáveis primitivas ou
então Objetos.
No caso de variáveis primitivas, as variáveis são passadas
para o método por cópia (isso chama-se passagem por
valor).
No caso de Objetos, os próprios objetos são passados para
o método, e não uma cópia (isso chama-se passagem por
Classes e métodos
Um método pode ou não ter valor de retorno.
Caso possua valor de retorno, o método pode
retornar variáveis primitivas ou objetos.
Caso não possua valor de retorno, o método deve
conter em seu início a palavra void.
int soma(int a, int b) { int result = (a + b); return (result); } void mostrarLogotipo() { // codigo }
int soma(int a, int b) { return (a + b);
Classes e métodos
Assim como acontece com os atributos, os
métodos também podem ser:
privados - somente dentro da classe que os define
tais métodos poderão ser acessados;
públicos - tais métodos serão acessíveis de qualquer
Exercício
1. Criar uma classe chamada Carro e transferir
o código do próximo slide.
Criar uma classe chamada UsaCarro, o método
main, instanciar um objeto Carro e chamar os
métodos definidos em uma ordem aleatória para teste.
Instanciar outro objeto Carro e também testar.
class Carro {
String combustivel; boolean ligado; boolean andando;
public void ligar() { if(ligado)
System.out.println(“Erro: O carro ja esta ligado”); else{
ligado=true;
System.out.println(“OK! O carro foi ligado”); }
}
public void desligar() {
if(!ligado || andando)
System.out.println(“Erro: O carro ja esta desligado ou esta andando”); else{
ligado=false;
System.out.println(“OK! O carro foi desligado”); }
}
public void andar() {
if(!ligado || andando)
System.out.println(“Erro: O carro ja esta andando ou esta desligado”); else{
andando=true;
System.out.println(“OK! Agora o carro esta andando”); }
}
public void parar() { if(!andando)
System.out.println(“Erro: O carro ja esta parado”); else{
andando=false;
System.out.println(“OK! Agora o carro esta parado”); }
} }
Atributos estáticos
Quando criamos um atributo estático, este
atributo será único para todos os objetos instanciados dessa classe.
Para isso utilizamos o modificador static na
declaração do atributo.
Podemos acessar atributos estáticos
diretamente pela classe sem precisar instanciá- la.
Atributos estáticos
Exemplo:
class TesteStatic {
public static int contador = 0; }
class UsaStatic {
public static void main(String[] args) { TesteStatic t1 = new TesteStatic();
t1.contador++;
TesteStatic t2 = new TesteStatic();
t2.contador++;
System.out.println(t2.contador);
System.out.println(TesteStatic.contador); }
}
Variável contador sendo incrementada
Mesma variável contador sendo incrementada
Métodos estáticos
Métodos estáticos funcionam como os atributos
estáticos, ou seja, podemos chamá-los sem precisar instanciar um objeto de uma classe.
Um caso típico e que até agora usamos sem
perceber é o método println quando
chamamos System.out.println. Para usá-lo não criamos um objeto da classe System.
O método main também é estático, pois não
Métodos estáticos
Para criar um método estático indicamos o
modificador static em sua declaração.
Criamos métodos estáticos para realizar
funções geralmente não atribuídas a nenhum método do nosso programa, como funções que invertem uma String, por exemplo. Poderíamos chamar tal classe de Util.
Para chamar o método inverte de nossa
suposta classe Util, por exemplo:
Encapsulamento
Encapsulamento nada mais é do que
protegermos nossos atributos de acesso externo direto.
Em nosso exemplo da classe Carro, se a classe
UsaCarro (ou qualquer outra classe que
instanciasse nosso objeto) quisesse mudar o valor dos atributos ligado e andando para
false e true, respectivamente, nosso simulador de Carro ficaria logicamente incorreto.
Encapsulamento
Do mesmo modo, para o atributo que define o
tipo de combustível poderíamos atribuir um nome de empresa, ou qualquer outra String que não fizesse sentido.
Para encapsular os atributos de uma classe
primeiramente devemos torná-los privados, o que impede de qualquer instância ler e alterá- los.
Encapsulamento
class Carro { String modelo;
private String combustivel;
private boolean ligado, andando;
// Funções ligar, desligar, andar e parar acessando agora as // variáveis privadas
public void setCombustivel(String valor) {
if ( valor.equals(“Gasolina”) || valor.equals(“Alcool”) ) combustivel = valor;
else System.out.println(“Combustivel invalido!”); }
public String getCombustivel() { return combustivel; } } Atributos encapsulados Método para atribuição e validação
Variável this