1- Introdução à Linguagem Java

Introdução à Linguagem
Java
O que é JAVA?
Java é uma linguagem de programação
orientada a objetos e desenvolvida pela
Sun Microsystems na década de 90,
que atualmente, pertence a Oracle.
Instalando o JAVA
Java tem suporte para Windows, Mac e Linux.
http://www.oracle.
com/technetwork/pt/java/javase/downloads/ind
ex.html
Classe JAVA
Classe é a representação de um objeto, ela
possui atributos e comportamentos (métodos).
Uma classe pode ser utilizada para instanciar n
objetos
Classe JAVA
Atributos
Métodos
Tipos de dados primitivos
boolean
Possui os valores true ou false.
char
Unicode de 16 bits. Pode armazenar dados alfanúmericos.
byte
Inteiro de 8 bits. Possui o range entre -27 = -128 e 27 - 1 = 127.
short
Inteiro de 16 bits. Possui o range entre -215 = -32.768 e 215 - 1 = 32.767.
int
Inteiro de 32 bits. Possui o range entre -231 = -2.147.483.648 e 231 - 1 = 2.147.483.647.
long
Inteiro de 64 bits. Possui o range entre -263 e 263 - 1
float
Números de ponto flutuante de 32 bits
double
Números de ponto flutuante de 64 bits
Tipos de métodos e variáveis
Toda variável (incluindo atributos) e método em
Java é tipada.
O tipo pode ser primitivo ou um Objeto.
Os métodos podem ter tipos de retorno ou
serem void, quando não retornam nenhum
valor após serem executados.
Construindo classes
As classes possuem construtores que quando
invocados criam uma instância da sua classe.
Construindo classes
Construtor
Construindo classes
O linha new Carro() invoca o construtor da classe Carro, alocando
memória para o objeto e inicializando os seus atributos.
Construindo classes
A figura ao lado
mostra como o objeto
meuCarro é alocado
na memória.
meuCarro
Cor
Modelo
Preto
Gol
Pacotes
Toda classe em Java pertence a um pacote.
Um pacote é um grupo de classes que tem
funcionalidades similares no projeto.
Pacotes
Para utilizar classes de pacotes diferentes, é
preciso utilizar os comandos de import.
Ex: Para utilizar a classe Math do Java, devese importa-la com o comando:
import java.lang.math
Escopo
Toda classe tem um escopo, que é delimitado
por chaves {}. Isso siginifica que tudo que
estiver dentro das chaves da classe pertence a
ela.
O mesmo vale para métodos, laços e
condicionais.
Escopo
Inicio do
escopo da
classe
Inicio do
escopo do
método
Fim do
escopo do
método
Fim do
escopo da
classe
Expressões
Operador
Descrição
- (Unário)
Negativa um Valor. Ex: -x
*
Multiplicação
/
Divisão
+
Adição
-
Subtração
%
Módulo
Operadores ++ e -int x = 3;
x++; // incrementa x em uma unidade
x--; // decrementa x em uma unidade
Operador Ternário
(expressão booleana)? resultado se for true:
resultado se for false
int x = 10;
int y = 20;
System.out.println(”O maior número é:” + x > y
? x : y);
Atribuição de variáveis
int x = 10;
x += 10 // x = x + 10
x -= 10 // x = x - 10
x *= 10 // x = x * 10
x /= 10 // x = x / 10
Operadores Lógicos - And
And (&) ou (&&)
A
B
A&B
V
V
V
V
F
F
F
V
F
F
F
F
Operadores Lógicos - Or
And (|) ou (||)
A
B
A|B
V
V
V
V
F
V
F
V
V
F
F
F
Operadores Lógicos - XOr
And (^)
A
B
A^B
V
V
F
V
F
V
F
V
V
F
F
F
Operadores Lógicos - Not
Not (!)
A
!A
V
F
F
V
boolean isOpen = true;
isOpen := !isOpen; // inverte o valor de isOpen.
Estruturas condicionais
O Java possui estruturas de condição. São
elas: if, switch
Estruturas condicionais - if
if (expresão booleana) {
//ação executada quando a expressão é
verdadeira.
} else {
//Executada quando a expressão não é
verdadeira.
}
Estruturas condicionais - If
Estruturas condicionais - switch
switch(identificador) {
case 1:
//Ação para o caso 1;
break;
case 2:
//Ação para o caso 2;
break;
default:
//Ação executada quando nenhum caso é atendido
}
Estruturas condicionais - switch
Looping For
for (contador ; condição ; incremento ) {
//Ação executada
}
for (int i = 1; i < 10 ; i++ ) {
//código executado em loop
}
Looping while
while (condição ) {
//Ação executada
}
while (i < 10) {
//código executado em loop
}
Looping do while
do {
//Ação executada
} while (condição);
do {
//código executado em loop
} while (x > 10)
Looping for each
ArrayList carros = new ArrayList();
for (Carro carro : carros) {
}
Comando break
for (int i = 0 ; i < 10 ; i++) {
if (i == 4) {
break; // Finaliza todo o looping for.
}
System.out.println("i: " + i);
}
Comando continue
for (int i = 0 ; i < 10 ; i++) {
if (i == 4) {
continue; // Finaliza a iteração atual e vai para a
próxima
}
System.out.println("i: " + i);
}
Modificadores de Acesso
● Java possui quatro modificadores de acesso: public,
protected, private e default.
● Esses modificadores podem ser utilizados tanto para
métodos como para atributos
Modificadores de Acesso
● Quando um atributo ou método é privado (private),
apenas a própria classe consegue acessá-lo
Modificadores de Acesso
● Quando um atributo ou método é público (public),
qualquer classe do projeto pode acessá-lo.
Modificadores de Acesso
● É possível declarar métodos e variáveis sem definir o
seu modificador de acesso. Nesse caso, dizemos que o
modificador é default.
● Com o modificador default, o método ou atributo é
visível por todas as classes que estão no mesmo
pacote.
● Ex: void print(){ System.out.println(“Metodo com acesso default”);}
Modificadores de Acesso
● O modificador protected tem um comportamento similar ao
default, ou seja, todos os membros de um mesmo pacote
conseguem enxergar os atributos e métodos protected
● A diferença é relacionada a herança, quando um método ou
atributo é protected, as classes filhas da classe dona do
método ou atributo conseguem acessa-los, mesmo que as
classes estejam em pacotes diferentes
Classes e Subclasses
● A classe mãe de todas as classes do Java é a Object.
● Quando uma classe é subclasse de outra, ela herda os
atributos e métodos da classe mãe. E consegue
acessá-los diretamente se eles são protected.
● Crie uma subclasse basta usar a palavra chave extends
Classes e Subclasses
Classes e Subclasses
● Em qualquer lugar onde a classe Veiculo seria utilizada,
é possível utilizar a classe Carro, pois ao herdar de
Veiculo, Carro passa a ser uma classe especializada de
Veiculo.
● É possível instanciar um Veiculo com um objeto do tipo
Carro:
Veiculo veiculo = new Carro();
Classes e Subclasses
● Em um método que requer um Veiculo, é possivel
utilizar um carro como parametro:
int getNumeroRodas(Veiculo v){...}
Carro c = new Carro();
getNumeroRodas(c);
Classes e Subclasses
● Esse poder do Objeto de assumir várias formas através
de herança é chamado de Polimorfismo
● As classes herdeiras podem redefinir os métodos da
classe pai, desde que mantenham a assinatura. Isso é
chamado de sobrescrita (Override). Quando um
método redefinido for chamado, mesmo que a classe
filha esteja encapsulada, a sua implementação do
método é que será executada.
Polimorfismo
Classes e Subclasses
Classes e Subclasses
● Caso seja necessário, a implementação do método
original da classe pai também pode ser utilizado através
do comand super.
Classes e Subclasses
● O mesmo vale para construtores. Porém o construtor
de uma classe pai sempre deve executar primeiro.
Caso você não chame o construtor da classe pai
explicitamente, ele será chamado automaticamente.
Classes Abstratas
● É possível definir classes que não podem ser
instanciadas em Java. Essas classes são chamadas de
abstratas.
● Elas são utilizadas para definir métodos que sejam
comuns a qualquer classe que possam potencialmente
herdar dela. As classes abstratas também podem ter
atributos.
Classes Abstratas
Interfaces
● Interfaces são utilizadas para definir comportamentos.
● Elas funcionam como contratos, qualquer classe que
implementa uma interface deve criar os métodos com a
mesma assinatura que está definida na interface
● Ao contrário da classe abstrata a interface não pode ter
atributos e nem definir corpo de métodos
Exceções
Exceções em Java servem para indicar a
ocorrência de erros ou comportamentos
inesperados do sistema.
Existem dois tipos: Exceções de runtime e
Exceções checadas
Exceções
As exceções de runtime não devem ser
capturadas, pois quando ocorrem, o problema
está na codificação.
Ex: NullPointerException e
ArrayIndexOutOfBOundsException
Exceções
As exceções checadas devem ser tratadas.
Por exemplo ao lidar com arquivos, uma
exceção do tipo IOException pode ser lançada
e isso não ocorre por defeitos no código e sim
por erros que podem ocorrer no processo.
Exceções
Para tratar uma exceção, o trecho de código que pode
lançar uma exceção fica dentro do escopo do comando
try. Em seguida desse bloco, deve-se escrever um
comando catch para cada exceção que se quer tratar.
Exceções
Exceções
É possível ainda lançar a exceção para os métodos que
irão chamar o método atual. Através do comando
throws na assinatura do método.
Se um método tem o comando throws, qualquer método
que o chama deve tratar ou passar adiante a exceção.
Exceções
Exceções
Para lançar uma exceção de dentro do escopo de um
método, é necessário utilizar o comando throw e
instanciar uma nova classe de exceção.
Para criar uma nova exceção, bastar criar uma classe
que extenda da classe Exception.
Exceções