Linguagem de Programação Java

Prévia do material em texto

ESTUDO DA LINGUAGEM JAVA
O nome JAVA
Java tinha como nome inicial Oak (carvalho, em português). Por causa de problemas autorais o nome foi alterado para Java.
Java foi desenvolvida para ser uma linguagem portável, multiplataforma, ou seja, para rodar em qualquer aplicativo e navegador. 
Java é uma linguagem de programação orientada a objetos:
· O código está contido dentro de classes.
· Java suporta HERANÇA SIMPLES, mas não herança múltipla.
· A ausência de herança múltipla é compensada pelo uso de HERANÇA E INTERFACES, onde uma classe herda o comportamento de sua superclasse, além de oferecer uma implementação para uma ou mais interfaces.
Java é compilado e interpretado:
· Todo programa Java é compilado e interpretado.
· O desenvolvedor escreve o código em Java, o computador não entende esse código. Para ele entender, é preciso compilar o código fonte. 
· O compilador Java é chamado de JavaC. 
· O código gerado pelo compilador Java se chama Bytecode. 
· O computador não entende o Bytecode. 
· O bytecode (que é independente de máquina) é interpretado pela JVM em linguagem de máquina.
· Por isso, temos a máquina virtual (JVM).
· A JVM vai INTERPRETAR o código para o computador entender.
· A COMPILAÇÃO de um código acontece SOMENTE UMA VEZ, assim, o código fonte vai funcionar em qualquer plataforma.
· A INTERPRETAÇÃO acontece SEMPRE que o programa é executado.
WORA 
Write Once Run Anywhere – escreva uma vez e execute em qualquer lugar.
Resumo WORA: é o processo de escrever o código em um sistema operacional, e esse código compilado funciona em qualquer outro sistema operacional.
O Java tem um conjunto de ferramentas que permitem ao desenvolvedor trabalhar com a linguagem: 
· O compilador (JavaC); 
· O interpretador (JVM); 
· O gerador de documentação (javadoc); 
· A ferramenta de compactação de arquivos (jar); 
· Diversas outras ferramentas instaladas no diretório bin da distribuição.
Java é uma linguagem robusta:
Ela foi pensada para o desenvolvimento de softwares confiáveis, provendo verificações tanto em tempo de execução quanto compilação, o coletor de lixo faz a limpeza da memória quando houver necessidade;
Em muitas das linguagens de programação, inclusive C e C++, a responsabilidade de liberar espaço que não será utilizado é do programador, entretanto, nem sempre é fácil gerenciar o que está e o que não está sendo utilizado. 
Na linguagem de programação Java, a responsabilidade pela gerência da memória é do Coletor de lixo (Garbage Collector), desta forma, programadores Java ficam livres da preocupação de alocação e desalocação da memória.
Garbage Collector: O Coletor de lixo é um processo que roda em segundo plano, e faz a liberação de memória alocada por variáveis que não estão sendo utilizadas pela aplicação.
Java é uma linguagem Segura: 
Aplicações Java são executadas em ambiente próprio (JRE), o que inviabiliza a intrusão de código malicioso;
HOTSPOT E JIT
HotSpot é o nome que a Sun passou a dar para sua implementação da JVM a partir do J2SE 1.3. 
O HotSpot possui dois compiladores JIT distintos: C1 e C2 (algumas vezes chamados de "cliente" e "servidor").
Quando se executa a aplicação pela primeira vez, ela é executada em modo interpretado, ou seja, não é feita nenhuma otimização inicial. 
Durante a utilização da aplicação, são feitas estatísticas de runtime (durante a execução). 
Com essas estatísticas é verificado os pontos quentes (os trechos de códigos mais executados do programa).
Esses trechos são otimizados, utilizando técnicas bem parecidas com as dos compiladores tradicionais, mas, lembrando que isso tudo é feito em tempo de execução (runtime). 
O HotSpot utiliza a ideia de que apenas 10% do código é executado em 90% do tempo, então a otimização destes pontos isolados permite um ganho de performance e em até algumas vezes maior do que a compilação tradicional, pois os dados são obtidos diretos da execução real do programa.
JIT Compiler
Em compiladores tradicionais (nativos), as otimizações são feitas em tempo de compilação (reordenação de instruções, otimização para a máquina que está compilando etc). Isso, para linguagens como C++, etc.
No Java, isso não funciona, pois as classes são compiladas em arquivos separados. 
O compilador JIT pega o bytecode e traduz tudo de uma vez para a linguagem de máquina antes da execução.
Esta é a estratégia utilizada pela maioria das VMs.
RESUMO HOTSPOT E JIT: 
· Hotspot: A ideia é detectar trechos quentes (partes mais executadas) e compilar usando o compilador JIT, otimizando os trechos.
· JIT: Se refere a uma técnica. HotSpot é um software.
VERSÕES DO JAVA
Quem quer somente usar um programa Java, vai usar o JRE (Java runtime environment – ambiente de execução Java).
Quem quer desenvolver em Java vai usar o JDK (Java Development Kit – Kit de desenvolvimento Java).
· JRE só execução.
· JDK desenvolvimento.
JRE é composto por JVM e bibliotecas. Dentro da JVM existem componentes, dentre eles: Loader, interpretador e JIT.
Figura - JRE é composto por JVM e bibliotecas 
O JDK é composto pelo JRE, JavaLang e JavaTools. Dentro do JavaTools existem várias ferramentas, entre elas: 
· JavaC.
· Debugger
· APIs (JavaFX, etc.)
Ao instalar o JDK, podemos instalar junto a IDE (ambiente de desenvolvimento).
JRE = JVM + Bibliotecas 
JDK = JRE + Java Lang + Java Tools
PRIMEIRO PROGRAMA EM JAVA
package primeiroprograma; //pacote primeiro programa
public class PrimeiroPrograma{ //classe PrimeiroPrograma
	public static void main(String[] args){ //método principal
		System.out.println("Olá, mundo!");
	}
}
· Uma classe em Java, é um bloco.
· Dentro do bloco da classe, temos métodos.
· Classes são compostas de métodos.
· Classes fazem parte de um pacote de classes.
· Pacotes contém -> classes 
· Classe contém -> métodos
Em Java, tudo são classes.
· Um projeto em Java contém pacotes
· Pacotes contém classes
· Classes contém métodos
· Métodos contém variáveis
Observação: Podemos ter variáveis dentro das classes também. 
VARIÁVEIS
As variáveis são usadas para armazenar um valor na memória. Sempre devemos declarar a variável antes de utilizá-la.
Características das variáveis - Toda variável possui:
· Um Nome
· Um tipo
· Um tamanho
· Valor
Java é case sentitive. 
Uma variável não pode começar o seu nome com um número. 
Variáveis não podem conter em seu nome espaços em branco. 
Importação de pacotes em JAVA:
import java.net.*; -> importa todas as classes do pacote .net (com exceção dos subpacotes).
import java.net.URL; -> importa somente a classe URL do pacote java.net. 
Entrada e saída de dados:
Todo programa tem três características:
· Entrada de dados
· Processamento de dados
· Saída de dados (teclado, impressora, etc.)
CONSTANTES:
Uma constante é definida pela alocação de espaço na memória para guardar um valor durante a execução de um programa ou bloco de instrução.
Uma constante é semelhante a uma variável, porém, a constante deve assegurar que a informação não será alterada em nenhuma hipótese. 
Uma constante não mudará, por isso, ela não deve ser declarada como uma variável. 
CARACTERÍSTICAS de uma constante:
· Dados não podem ser alterados durante o tempo de execução.
· Um constante tem seu endereço de memória na qual foi alocada protegido.
· Uma constante nunca será desalocada.
· Declaramos uma única vez, e usamos quantas vezes forem necessárias.
Exemplo:
VARIÁVEIS
O Java herdou os tipos primitivos do C e C++, por essa razão, o Java é fortemente TIPADO. Em linguagens como PHP, Python ou Javacript, basta atribuirmos um valor, que o compilador identifica o tipo da variável.
FORTEMENTE TIPADO = significa que em Java é preciso declarar sempre o tipo da variável.
	TIPOS DE DADOS
	Tamanho Byte reservado para cada variável pela máquina virtual
	Faixa
	char
	2
	UNICODE
	boolean
	1
	TRUE/FALSE
	byte
	1
	+/-128 a 128(2^8=256)
	short
	2
	+/-32768(2^16=65536)
	int
	4
	+/-2147483648(2^32=4294967296)
	long
	8
	+/-9223372036854775808
	float
	4
	P.flutuante: +/-3.4E-38
	double
	8
	P.flutuante: +/-1.7E-308
Observações:
· 1 byte tem8 bits. Exemplo, um char ocupar 2 bytes (16bits).
· O BOOLEAN tem como padrão o valor false (se não declararmos um valor para ela, ela será false).
· Variável char, devemos usar aspa simples ‘ ’. Exemplo:
char c = 'a';
char d = '1';
· Ao declarar variável bit, ela deve receber valores entre -128 e +127. Fora desses valores, ocorre erro.
· Uma variável do tipo short tem por padrão o valor zero.
· Float e Double aceitam números fracionados / flutuantes.
· A diferença de float e double, é que o valor flutuante float deve ser acompanhado de f. Exemplo:
float valor = 4.4f;
double valor2 = 4.4;
VARIÁVEIS PRIMITIVAS
Variáveis primitivas é a variável que guarda seu real conteúdo, ou seja, uma variável de tipo primitivo armazena exatamente um valor de seu tipo declarado.
 Exemplos:
int i = 5; // i recebe uma cópia do valor 5;
int j = i; // j recebe uma cópia do valor de i;
i = i + 1; // i vira 6, j continua 5.
Variáveis primitivas: podem ser do tipo byte, short, int, long, float, double, char ou boolean.
CASTING E PROMOÇÃO
O cast é uma conversão, é quando convertemos um valor de um tipo para outro tipo. 
Existem dois tipos de conversão (Cast): implícitas e explícitas
Conversões implícitas:
São as conversões que ocorrem sem nenhum cast, como, por exemplo, passar um valor de um tipo menor para dentro de um tipo maior.
short a = 10;
int b = a; // Jogamos a variavel short dentro de um int aqui.
Também funciona de tipos inteiros para tipos flutuantes (float flutuante = inteiro), mas não o contrário (int inteiro = flutuante).
Conversões explícitas:
São as conversões feitas pelo desenvolvedor, utilizando os comandos de cast como: (int), (byte), (double), ou métodos de conversão.
double d = 5; // ok, o double pode conter um número inteiro.
int i = d; // NÃO COMPILA.
Apesar de 5 ser um valor válido para int, o compilador não tem como saber qual valor estará dentro de double no momento da execução.
Já no caso a seguir é o contrário:
int i = 5;
double d2 = i; //COMPILA.
long x = 10000;
int i = x; // não compila, pois pode estar perdendo informação.
EXEMPLOS DE CASTING:
CONVERTER FRAÇÃO EM INTEIRO:
long x = 10000;
int i = (int) x;
double d3 = 3.14;
int i = (int) d3;
CONVERTER STRING EM INTEIRO:
String s = "30";
int i = Integer.parseInt(s);
OBSERVAÇÃO: O único tipo primitivo que não pode ser atribuído a nenhum outro tipo é o BOOLEAN.
Tipos de casting em Java: 
Impl. (Indica que é cast implícito – feito automaticamente)
OBSERVAÇÃO: ao declarar variável, double, por exemplo, ela deve começar por minúscula. Maiúscula representa a classe, Double, Float, etc. 
Cada tipo primitivo tem uma classe correspondente (Como Char, Float e Double) provenientes do pacote java. lang.
ASSOCIATIVIDADE DE OPERADORES:
Em Java, alguns operadores têm prioridade sobre outros: 
· a+b*c vai multiplicar primeiro, para depois somar
· Se quiser somar primeiro, temos que fazer: (a+b) * c
Ordem de precedência:
Primeiro nível: ()
Segundo nível: *, /, %
Terceiro nível: +, -
Quarto nível: <, <= , >, >=
Quinto nível: ==, !=
Observação: Se houver vários operadores do mesmo nível, os operadores serão avaliados da esquerda para a direita.
Observação 2: somente o operador de atribuição “=” associa da direita para a esquerda.
INCREMENTO E DECREMENTO
	OPERADOR
	SIGNIFICADO
	Pós-fixo
	x++
	Primeiro atribui
Depois incrementa
	
	x--
	Primeiro atribui
Depois decrementa
	
	
	
	Pré-fixo
	++x
	Primeiro incrementa
Depois atribui
	
	--x
	Primeiro decrementa
Depois abritui
Exemplo:
Int num=10;
Int result=0;
Result=num++; 
Primeiro atribui, ou seja, result vale 10
Depois incrementa, ou seja, num vale 11
OBSERVAÇÃO:
int num=10;
int result=0;
result += num;
ou
result -= num;
Os comandos acima, não realizam incremento e nem decremento, irá apenas realizar a soma ou subtração das variáveis, por exemplo:
· result +=num será 10+0=10;
· Pois result+= num é o mesmo que result = result + num;
BREAK E CONTINUE
O break faz o laço parar de executar quando atende a condição do IF.
O continue obriga o loop do for ou while a executar o próximo laço caso atenda a condição do if. Exemplo:
for(int i=x; i<y; i++) {
if(i % 19 ==0) { //se i for divisível por 19 mostra a mensagem
// o símbolo % pega o resto da divisão 
// Se resto da divisão for zero mostra msg.
System.out.println("Achei um número divisível por 19 entre x e y: " +i);
break; //FAZ PARAR QUANDO ACHAR O NÚMERO
}
}
for (int i = 0; i < 100; i++) {
if (i > 50 && i < 60) {
continue; //CONTINUA - o intervalo de 51 a 59 não será exibido por causa do if
}
System.out.println(i);
}
COMANDOS DE REPETIÇÕES – ESTRUTURAS DE CONTROLE
Os comandos de repetição e estruturas de controle em Java são:
· If, If-Else, For, While, Switch, Do-While
SWITCH
O switch case em java é uma estrutura de controle de fluxo que permite executar diferentes blocos de código com base em diferentes valores de entrada.
Quando usar? A declaração switch testa a igualdade de uma variável mediante múltiplos valores.
DO-WHILE
· O loop do while do java é usado para repetir uma parte do programa algumas vezes. 
· É recomendado o uso do loop do while quando o número de iterações não é fixo e você precisa executar o loop pelo menos uma vez.
O loop DO WHILE É EXECUTADO PELO MENOS uma vez porque a CONDIÇÃO É CHECADA DEPOIS do corpo do loop.
Exemplo:
Se você passar true em um loop do while, se tornará infinito.
Sintaxe:
do{
//código que será executado
} while(true);
Exemplo:
public class DoWhileExemplo2 {
public static void main(String[] args) {
do {
System.out.println("do while loop infinito");
} while(true);
}
}
Saída:
do while loop infinito
do while loop infinito
do while loop infinito
ctrl+c
Para sair do loop, aperte CTRL+C.
image3.png
image9.png
image8.png
image6.png
image4.png
image5.png
image2.png
image1.png
image7.png
image10.png