Guia Rápido Java
Variaveis
Existem 3 tipos de variaveis:
tipo primitivo;
referencia para objeto;
matriz.
Tipos primitivos
Os tipos primitivos são:
• byte: inteiro de um byte
• short: inteiro de 2 bytes
• int: inteiro de 4 bytes
• long: inteiro de 8 bytes
• char: caractere unicode de 2 bytes
• float: numero com virgula de 4 bytes
• double: numero com virgula de 8 bytes
• boolean: assumem apenas os valores true ou false
Quanto a float, deve ser adicionado um f no final do numero. Sem f é double. Ex.:
float f = 3.145f;
double d = 3.145;
Referencia a objetos
Para se criar um objeto de uma classe “Qualquer”, deve-se primeiro criar uma referencia a ele:
Qualquer obj;
O objeto é criado com o operador new <Nome_da_classe>(<Parametros_do_construtor>):
obj = new Qualquer();
Matrizes
A sintaxe é semelhante a de referencia de objetos. Exemplo de matriz de objetos da classe
Qualquer:
Qualquer[] mtx;
mtx = new Qualquer[3];
mtx[0] = 23;
mtx[1] = 8;
mtx[2] = 76;

O tamanho de uma matriz pode ser visto por:
mtx.lenght;
Classes
Uma classe “Qualquer” é definida como:
public class Qualquer{
//lista de atributos
//lista de metodos
}
Classes públicas podem ser acessadas por outras classes do mesmo diretório ou que acessem seu
pacote. Pode haver apenas uma classe publica em um arquivo .java
Classes não-publicas (sem o public) podem ser acessadas apenas por classes do mesmo arquivo
.java.
Acesso de atributos e métodos
Quanto as palavras de acesso, elas devem ser as primeiras palavras na declaração de um atributo e
método:
public: atributos e métodos de um objeto podem ser acessados por outras classes.;
private: atributos e métodos só podem ser acessados por métodos do objeto. Não podem ser
herdados. Classes com construtores private não podem ser estendidas;
protected: atributos e métodos só podem ser acessados por métodos do objeto. Podem ser
herdados.
Metodos e atributos estaticos e finais
Atributos e métodos estaticos não precisam de um objeto para serem usados, basta colocar o nome
da classe e chamar o atributo ou metodo da mesma forma que um objeto chama. Por exemplo:
Class Qualquer{
public static int num;
…
public static byte Somar(int a, int b);
…
}
…
Qualquer.num;
Qualquer.Somar(1, 45);
…
Atributos e métodos não-estaticos da classe não podem ser usados num método estatico.

Blocos estaticos servem para inicializar variaveis assim que a classe é carregada da memória:
Class Qualquer{
public static int num;
…
static{
num = 2;
}
…
}
Um atributo final não pode ter seu valor modificado depois de declarado, por isso ele é constante.
Um método final não pode ser sobreescrito por classes derivadas. Ex.:
Class Qualquer{
public final static int num;
…
public final byte Somar(byte a, byte b);
…
}
Construtores
Um construtor é um método especial chamado quando um objeto é instanciado. Tem o nome da
classe e não tem retorno algum. Se não for especificado, o compilador criará o seguinte:
public NomeDaClasse(){
}
Uma classe pode ter vários construtores, desde que os tipos das sequencias de parametros sejam
diferentes:
public NomeDaClasse(int a){...}
public NomeDaClasse(int b){...}// Não permitido. Mesmo tipo de
parâmetro q o anterior
public NomeDaClasse(int a, String b){...}
public NomeDaClasse(String b, int a){...} // Permitido. Ordem da
sequencia é diferente do anterior
Se um construtor for definido, o compilador não irá fazer o construtor default (sem parametros).
Dessa forma será preciso criar outro construtor default se necessário.
Construtores não são herdados.
Quando o construtor é private, a classe não pode ser instanciada. Isso serve para uma classe em q os
métodos devem apenas serem usados como funções.
O JDK
Cada arquivo .java pode conter no maximo a definição de uma classe. Um arquivo .java é
compilado em um arquivo .class atraves do comando:

$ javac <nome>.java
Um arquivo com o nome da classe definida é criada. Ex.: Qualquer.class.
Dentre as classes compiladas numa mesma pasta, uma deve conter o metodo estatico main, que será
o primeiro a ser executado pela maquina virtual java (JVM).
Class Qualquer{
…
public static void main(String args[]){
//corpo da função
}
…
}
Logo após o .class que contem o main, deve ser executado pela JVM, da seguinte maneira:
$ java <nome_da_classe>
Herança
Uma classe “Qualquer” herda de “Outra” da seguinte forma:
public class Qualquer extends Outra{
…
}
Classes final não podem ser estendidas:
public final class Ultima{
…
}
Caso se queira sobrepor um método, mas poder usar o antigo faz-se:
class Qualquer extends Outra{
…
public void MetodoDaSuperClasse(){
super.MetodoDaSuperClasse();
…
}
…
}
Quando um uma classe herda de uma classe que herda de outra e assim por diante, é chamado
primeiro o construtor da classe pai recursivamente. A chamada de um construtor do pai deve ser
chamado com o método super() e deve ser a primeira linha. Se o construtor do pai não for colocado
o compilador fará:
…

public Construtor(){
super();
…
}
VER MELHOR SOBRE O CONSTRUTOR THIS()
Polimorfismo
Uma subclasse pode ser referenciada por uma variavel de referencia de suas superclasses:
Outra x = new Qualquer();
Note que o compilador só irá permitir o uso de métodos herdados por Outra. Como parametro,
temos:
public Outra Metodo(Outra n){
…
b.Metodo(x); //x é a variavel de cima
Só serão aceitos dentro do método, métodos de x herdados de Outra. Note que devemos no método
de cima retornar um objeto da classe Outra. Podemos retornar um objeto derivado dessa classe
como x, mas o compilador irá interpretar que o objeto retornado é da classe Outra e não irá permitir
que um objeto da classe Qualquer seja atribuido ao retorno.
Então,
Qualquer x2 = new Qualquer();
…
x2 = b.Metodo(x); // isso não sera compilado
Então, para poder converter o objeto à sua classe real usa-se o operador cast:
x2 = (Qualquer) b.Metodo(x);
Para verificar se o objeto é realmente da classe desejada usa-se:
Object temp;
temp = b.Metodo(x);
if(temp instaceof Qualquer){
x2 = (Qualquer) temp;
}
intanceof retorna true se temp referencia objeto da classe Qualquer.
Sobrecarga
Sobrecarregar não é o mesmo que sobrepor! Um método sobreposto deve ter os mesmos
argumentos, retorno e permissoes de quem sobrepõe. Para um método ser sobrecarregado deve-se
mudar a lista de parametros.
Exemplos:

…
void Metodo( int a ){...}
…
int Metodo( int a ){...} // Sobreposição inválida! Mesmos
argumentos e retorno diferente.
…
double Metodo( double l ){...} // Sobrecarga! Argumentos
diferentes
A classe Object
Todas as classes em Java herdam diretamente ou indiretamente da classe Object. Seu método pode
ser o mais genérico possível usando Object como parametro:
public int Metodo(Object a){...}
Alguns métodos da classe Object:
String getClass(): retorna o nome da classe do objeto;
boolean equals(Object b): retorna true se o objeto que chamou é igual ao b.
Geralmente é sobreposto por quem cria a classe.
Classes abstratas
Classes abstratas não podem ser instanciadas. Servem apenas como molde. Ex.:
public abstract Qualquer{
…
}
Mas, note que isso é permitido:
Qualquer[] novo = new Qualquer(); // vetor de referencias
Já métodos abstratos não tem corpo. Só podem ser definidos em classes abstratas. Classes abstratas
podem conter métodos abstratos e concretos (não-abstratos):
public abstract Qualquer{
…
public void Metodo1(char a){...} // método concreto
…
public abstract int Metodo2(String d); //método abstrato. Usa-
se apenas dois pontos
…
}
Métodos abstratos devem obrigatóriamente serem implementados por classes concretas (não-
abstratas) que estendam a classe abstrata.
Interfaces

Intefaces são como classes abstratas onde todos os métodos são abstratos. Util quando se quer que
objetos com funções distintas possam usar funções semelhantes:
public interface Coisinha{
void Metodo1(int a);
double Metodo2(String s);
…
}
Todos os métodos são publicos e abstratos por padrão. Podemos implementar quantas interfaces
quisermos e ainda herdar de uma classe:
public Cachorro extends Animal implements Pet, Corredor{
…
}
VER DEPOIS: E se um objeto herdar de uma classe animal que tem um método
void Correr(){…}
E implementar uma classe Corredor que tem o método:
int Correr(){…}
Qual dos dois métodos será chamado?
Garbage Collector, Heap e Pilha
As variaveis locais, as que são declaradas dentro dos métodos ficam armazenadas na area de
memória chamada Pilha. Quando o método é encerrado as variaveis locais são excluidas da pilha.
Os objetos são armazenados no heap, quer dizer, seus atributos! Um objeto é sempre armazenado no
heap, mesmo que sua referencia seja declarada em um método.
Quando não há nenhuma variavel referenciando um objeto ele é marcado como “lixo”. Dessa
forma, o Coletor de Lixo (GC) irá exclui-lo do heap quando faltar memória.
Há 3 formas de eliminar referencia a um objeto:
• A referencia ao objeto é excluida porque o método em q esta inserido é terminado;
• Quando a referencia aponta para outro objeto, ou;
• A referencia recebe o valor null.
Empacotadores
As classes empacotadoras, são classes que servem para encapsular os tipos primitivos em classes.
Temos: Integer, Float, Character, etc. Ex.:
Character c = new Character('a');
Integer x = new Integer(2);

char c2 = c.charValue();
int x1 = x.intValue();
Auto-empacotamento
A partir do Java 5.0 é possível passar tipos primitivos para classes que esperam objetos Object. Usa-
se o nome do empacotador do tipo entre <> na declaração do objeto. Ex.:
ArrayList<Integer> lista = new ArrayList<Integer>(10);
lista.add(2);
O compilador irá substituir o inteiros adicionados pelas suas classes empacotadoras.
Sempre q um Integer for esperado em algum local, um int pode ser enviado, e vice-e-versa.
Métodos dos Empacotadores
A
Classe Math
As