Você está na página 1de 47

Java Básico

Marcelo Gomes Carvalheiro


Apresentação
Marcelo Gomes Carvalheiro.
Desenvolvedor do NATI – UNIFOR.
Mais de dez anos de experiência em
desenvolvimento de softwares.
Aplicações para web e dispositivos
móveis.
email: mgcarvalheiro@gmail.com
blog: http://mgcarvalheiro.wordpress.com/
twitter: http://twitter.com/mgcarvalheiro
Agenda
● Introdução à Linguagem Java
● Introdução à Orientação a Objetos
● Identificadores e Keywords
● Controle de Acesso e Variáveis
● Classes Abstratas e Interfaces
● Tratamento de Exceções
● Arrays e Coleções
● Threads
● Javadoc
Bibliografia
Na Internet
● http://developers.sun.com/
● http://www.cejug.org/
● http://www.guj.com.br/
E é claro
● http://www.google.com.br/
Introdução à Linguagem Java
O que é Java?

Será um tipo de café ?


O que é Java ?

Será uma ilha da


Indonésia ?
O que é Java ?

Não !!!
Não !!!

Java é uma linguagem de programação


desenvolvida pela SUN com o objetivo de
manter o poder computacional de C++,
agregando características de segurança,
robusteza e portabilidade
Um pouco de História
● Patrick Naughton, engenheiro da
Sun, estava cansado e iria sair
● Scott McNealy, CEO da Sun, pediu
para que ele escrevesse o que estava
errado
● Naughton não poupou palavras, mas
achou que não ia dar em nada
● McNealy enviou a mensagem para
outros e Naughton recebeu uma
enxurrada de mensagens de apoio,
inclusive de Bill Joy (fundador da Sun)
e James Gosling (seu mentor), que
colocaram “lenha na fogueira”
Um pouco de História
● A Sun, então, fez sua contra-proposta: criou o projeto Green para desenvolver
algo inovador
● Reclusos e sem contato com a Sun, os melhores desenvolvedores analisavam e
debatiam sobre tecnologias existentes
● A sacada: como aparelhos eletrônicos (jogos, TVs, VCRs, etc.) poderiam
comunicar-se uns com os outros?
● Logo notaram que estes aparelhos todos possuíam hardware diferente e
limitado
● Depois de 18 meses, a Sun transformou um projeto Green em uma empresa,
chamada “First Person”e tirou seu time da reclusão
● A empresa tinha uma boa idéia, mas não tinha mercado
● Em 1993 foi lançado o Mosaic, primeiro navegador para a World Wide Web
● O projeto muda de rumo e aposta no sucesso da Internet, que se encaixava
perfeitamente com as idéias do grupo
● O projeto muda de rumo e aposta no sucesso da Internet, que se encaixava
perfeitamente com as idéias do grupo
Um pouco de História
● A linguagem Oak se tornaria o produto. Naughton sugere que seja distribuída
gratuitamente na web
● O time desenvolve o navegador WebRunner, mais tarde HotJava Browser.
Nascem as Applets
● Sun concorda em disponibilizar Oak, mas antes troca seu nome para Java
(outros mais cotados: Neon, Lyric, Pepper e Silk)
● A Netscape anuncia seu novo navegador com suporte a Java e a tecnologia
dispara
Apresentando o Java
Apresentando o Java
● Orientada à objetos ;
● Independente de plataforma: Linux – Mac – Windows – PDA –
Torradeiras (?);
● Sem ponteiros (Ufa!);
● Performance – bytecodes – JVM;
● Multithreading: assobia e chupa cana ao mesmo tempo;
● Fortemente tipada e estática;
● Vasto conjundo de bibliotecas (API's)
● Segura Robusta;
● Gerenciameno de memória (Garbage Collector);
● Semelhante as linguagens C/C++
● Write once, run anywhere.
A evolução do Java
A evolução do Java
● Java 1.0a
● Java Development Kit 1.1
● Java 2 Platform 1.2
● Java 2 Platform 1.3
● Java 2 Platform 1.4
● Java 2 Platform 5.0 (Tiger)
● Java 6 (Mustang)
● Próxima: Java 7 (Dolphin)
Plataforma Java

I. Java Virtual Machine – JVM


II.Java Application Progamming Interface (Java API)
Máquina ? Virtual ?
● Uma máquina imaginária que é implementada via software ou
hardware.
● Um código para ser executado por essa máquina deve ser
gravado em um arquivo com extensão .class. e possuir um
código compatível com as instruções Java.
API
● A API Java é uma coleção de componentes de software prontos
● Incluem desde estruturas para manipulação de arquivos até a
construção de aplicativos gráficos
● É organizada como um grupo de bibliotecas com classes e
interfaces; essas bibliotecas são chamadas de pacotes.
Como Java funciona?
O que é preciso para um
programa Java funcionar?
Meu primeiro programa
/** Meu primeiro programa em Java */ comentário
public class HelloWorld {
nome da classe

public static void main(String[] args) {

declaração do método declaração do argumento

System.out.println("Hello, world!");

argumento
}
classe variável método

}
Instalando e configurando o Java
● Baixar o JDK em:
http://java.sun.com/javase/downloads/index.jsp;
● Escolha o JDK para a plataforma Windows;
● Instalar o arquivo baixado;
● Criar a váriável do sistema JAVA_HOME;
● Testando a instalação: javac -version.

EM CASA
JDK x JRE
● JDK: Java Devopment Kit;
● Kit de desenvolvimento para java;
● Compilador, interpretador e utilitários;
● JRE: Java Runtime Enviroment;
● contém um conjunto de ferramentas que
permitirão a execução de aplicativos
desenvolvidos com a tecnologia Java em sua
máquina.
O método main
● Em Java tudo ocorre em classes.
● Quando executamos um programa estamos na verdade executando uma
classe.
● Executar um programa significa informar a JVM: “Carregue a classe
HelloWorld e execute o método main, continue executando até o final
do método.
● Não importa o tamanho do programa (número de classes) deverá existir
um método main.
● É no método main onde tudo inicia.
Executando o progama
Code Conventions
● A Sun criou o code conventions, documento padrão que a
Sun segue e recomenda que outros programadores o sigam
● É uma boa prática a seguir ele cobre: nomes de arquivo,
organização, indentação, comentários, declarações, etc
● Você pode consultar o documento completo em:
http://java.sun.com/docs/codeconv/
Code Conventions
● As principais regras são:
● Notação camelo: minhaIdade, BolaFutebol;
● Interfaces e Classes: primeira letra maiúscula;
● Membros de classe: primeira letra minúscula.
Mão na massa
● Abra o Eclipse;
● Digite o programa Hello World e salve
com o nome de HelloWorld.java
Operadores de Atribuição
➔ =
➔ +=, -=, *=, /=
Exemplos:
● valor = 10; //atribui 10 a valor
● valor += 2; //atribui 10 somando 2 a valor
● valor -= 2; //atribui 12 subtraindo 2 a valor
● valor *= 3; //atribui 10 multiplicando 3 a valor
● valor /= 10; //atribui 30 dividindo 10 a valor
Operadores Relacionais
➔ > maior que
➔ >= maior ou igual que
➔ < menor que
➔ <= menor ou igual que
Exemplos:
● x > 1 //retorna verdadeiro caso x seja maior que 1
● x >= 1 //retorna verdadeiro caso x seja maior ou igual a 1
Operadores de Igualdade
➔ == (não confundir com o operador “=“)
➔ != (não igual – diferente)
Exemplos:
● x == 10 //retorna verdadeiro caso x seja igual a 10
● x != 10 retorna verdadeiro caso x seja diferente de 10
Operadores Aritméticos
➔ +, –, *, /
➔ %
➔ ++, – –
Exemplos
● x = 3 % 2; //atribui a x o resto da divisão de 3 por 2
● x++; //incrementa 1 a x
Opa ! Parecem iguais mas não são !
● ++x; //incrementa 1 a x
➔ x ++ primeiro usa a variável para depois
incrementar, enquanto ++x incrementa para
depois usar a variável.
Operadores Aritméticos
● Você pode usar o operador “+“ para fazer concatenação de
textos;
● Ex.: System.out.println(“Nome: “ + nome);
● Você também pode concatenar um texto com um inteiro, nesse
caso ele é automaticamente convertido para texto (String);
● Ex.: System.out.println(“Idade: “ + idade);

idade é uma variável do tipo int,


ou seja é um número inteiro.
Operador Condicional
➔ x = expressão ? Valor caso verdadeiro : valor caso falso
Exemplo:
➔ x = (idade >= 18) ? “maior de idade“: “menor de idade“;
//se a idade for maior ou igual a 18 é atribuído a x o valor
“maior de idade“, senão é atribuído “menor de idade“

• Este operador também é conhecido como operador ternário.


Operadores Lógicos
➔ && (and) e || (or) - short-circuit
➔ & (and) e | (or) - non-short-circuit
➔ ^ - or exclusivo (retorna verdadeiro se somente uma das expressões
for verdadeira
➔ ! - inversor booleano
Exemplos
● if (x > 10) && (x < 12) //se a primeira expressão for false não faz o
segundo teste
● if (x > 10) & (x < 12)//sempre faz os dois testes
● if (x > 10) || (x < 12)//se a primeira expressão for verdadeira não
realiza o segundo teste
● if (x > 10) | (x < 12)//sempre faz os dois teste
● if (!(x >10) //inverte o valor da expressão para false no teste
● if (2 < 3) ^(4 >3) //retorna false, pois as duas expressões são
verdadeiras
Mão na massa
● Digite o programa e complete as lacunas para obter os resultados esperado.
public class Operators {

public static void main(String[] args) {


int x = 10;
int y = 12;
int z = 13;

if (_______) {
System.out.println("y é maior que x");
}

if (_______) {
System.out.println("x não é igual a y");
}

if (__________) {
System.out.println("y é maior que x e menor que z");
}

if (_________) {
System.out.println("O valor de x agora é 11");
}

int w = ________;

System.out.println("O resto da divisão de y por x é " + w);


}
}
Controle de Fluxo
● if
● swith
● while
● do...while
● break
● continue
Controle de Fluxo - if
● Teste condicional
Sintaxe:
if (expresssão condicional) {
//bloco de comandos
} else {
//bloca alternativo de comandos opcional
}
Exemplo:

if (x >= 10) { O Ministério da Tecnologia adverte:


w = 20; não respeitar a identação faz mal
} else { ao código.
w = 21;
}
Controle de Fluxo - switch
● É semelhante ao if, mas que usa valores inteiros para a tomada
de decisões ao invés de expressões booleanas.
Sintaxe: Exemplo:
switch ((int) expressão) { int x = 3;

case ((int) valor_1): switch (x) {


//bloco de comandos case 1:
break; System.out.println("x é igual a 1");
break;
case ((int) valor_2):
//bloco de comandos case 2:
break; System.out.println("x é igual a 2");
break;
case ((int) valor_n):
//bloco de comandos case 3:
break; System.out.println("x éi gual a 3");
break;
default:
break; default:
} System.out.println("nenhum valor para x");
}
Controle de Fluxo - while
É utilizada para definir que um bloco de comandos deve ser
executado enquanto a expressão condicional for verdadeira.
Sintaxe:
while (expresssão condicional) {
//bloco de comandos
}

Exemplo:
while (x < 10) {
x++;
}
Controle de Fluxo - do...while
Muito semelhante ao while, porém o bloco de comandos é
executado pelo menos uma vez, e até que a condição seja falsa.
Sintaxe:
do {
//bloco de comandos
} while (expresssão condicional)

Exemplo:
do {
x++;
} while (x < 10)
Controle de Fluxo - for
A declaração for é utilizada para definir que um bloco de
comandos deve ser executado 'n' vezes, onde 'n' é um número
inteiro.
Sintaxe:
for ( inicialização ; expressão condicional ; iteração ){
//bloco de comandos
}

Exemplo:
for ( int i = 0 ; i < 10 ; i++ ){
//bloco de comandos
}

Existem outras formas de se utilizar o for, estaremos vendo-as em


aulas posteriores.
Controle de Fluxo - break
Faz com que um laço seja interrompido.
Exemplo:
for (int i = 0 ; i < 10 ; i++) {
if (i > 5) {
break;
}
}

Quando i atingir um valor maior que 5 o laço é interrompido e a


execução do programa vai para a linha logo após o for.
Controle de Fluxo - continue
É usado para "pular" uma execução e continuar a partir da
próxima.
Exemplo:
for (int i = 0 ; i < 10 ; i++) {
if (i == 5) {
continue ;
}
System.out.println("valor de i :" + i);
}
Quando i atingir um valor igual a 5 o laço volta para o início e a
linha que imprime o valor de i não é executada nessa iteração.
Mão na massa
● Faça um programa que conte de 1 a 100, exibindo dizendo se o número é par ou
ímpar.

public class Contador {

public static void main(String[] args) {

//Entre com o código aqui

}
Solução
● Uma das possíveis soluções:

public class Contador {

public static void main(String[] args) {

for (int i = 1; i <= 100; i++) {


if ((i % 2) == 0 ) {
System.out.println("O número " + i + " é par");
} else {
System.out.println("O número " + i + " é ímpar");
}