JAVA SE

INTRODUO:

Nome do arquivo fonte deve ser o mesmo da classe principal.

Nome de classes devem sempre comear com letra maiscula.
Nome de mtodos, variveis e objetos sempre comeam com letra minscula.

SADA:
package testes; //o pacote sempre deve ser especificado.
public class Teste {
public static void main(String[] args) {
System.out.print("Hello World !");
}
}

Pode ser tambm:

System.out.println(); //imprime com \n no final.
System.out.printf(); //funciona igual ao printf em c.

Caracteres de escape:
\t tabulao.
\ imprimi uma aspa dupla.
\\ - imprimi uma barra.
\n - quebra de linha.

VARIVEIS:

Tipos primitivos:
int
float
double
char boolean
void
long short
byte
Todos os tipos no primitivos so tipos por referncia.
Ex: String e outras classes.
Casting:
int x, y;
double a = (double)x/y; //fora 'x' ser do tipo 'double'.

MODIFICADOR final e constante:

final double PI = 3.141592; //o valor de 'PI' no pode ser alterado.

OBS: nomes de constantes devem ser em letra maiscula.

ENTRADA COM Scanner:
import java.util.Scanner; //importa a classe Scanner.

...
Scanner input = new Scanner(System.in); //instancia a classe 'Scanner' em 'input'.
int a = input.nextInt(); //'a' recebe o retorno do mtodo 'nextInt'.
// Ou:
System.out.println(input.nextFloat()); //imprimi o retorno de 'nextFloat'.

OPERADORES:

Aritmticos: * + - / %
Incremento e decremento: ++ -Condicionais:
&& || == != !
Relacionais: < > <= >=

ESTRUTURAS DE CONTROLE E REPETIO:

Condicionais:
if else
switch
operador condicional(?)
Repetio:
while
do while
for

-- Todos iguais na linguagem C.

VETORES OU ARRAYS:
double[] notas = new double[20]; //cria um vetor de 20 posies em 'notas'.
String[] cores = {"azul", "verde", "vermelho", "preto"};
//cria um vetor de strings de 4 posies.

VETORES MULTIDIMENSIONAIS:
double[][] x = new double[3][3]; //cria uma matriz de 2 dimenses.
double[][] x = {
{10, 2.3, 5.6},
{4.7, 1.3, 6.123},
{17, 5.698, 12.7}
}; //cria e inicializa uma matriz de 2 dimenses.

ESTRUTURA ArrayList:

Consiste em uma classe do pacote java.util que permite a criao de uma

lista de tipos no primitivos e aceita alocao dinmica.
Podem-se colocar tipos primitivos convertendo esses em objetos utilizando as
classes Wrapper.
ArrayLists comeam no ndice 0.
Criao e operaes:
ArrayList <String> nome = new ArrayList<>(); //cria a lista de 'String'.
nome.add(novo); //adiciona um elemento no final da lista.

nome.add(1, novo); //adiciona um elemento na posio especificada.

nome.size(); //retorna a quantidade de elementos.
nome.get(2); //retorna o elemento da posio 2.
nome.indexOf(elemento); //retorna o ndice do elemento especificado.
nome.remove(elemento); //remove o elemento especificado.
nome.contains(elemento); //verifica a existncia do elemento especificado.
nome.clear(); //remove todos os elementos da lista.

ITERAO COM foreach (for aprimorado):

int[] vet = {1, 7, 9, 13};
for(int i : vet) //percorre 'vet' e a cada ciclo coloca um elemento em 'i'.
System.out.println(i);
//pode-se percorrer ArrayList tambm.

RTULOS:

Utilizados juntamente com os comandos: break e continue, servem para

controlar os fluxos de repetio.
int i,j;
primeiroFor:
for(i=0;i<10;i++){
for(j=0;j<10;j++){
if(j==4)
break primeiroFor; //encerra o primeiro for.
}
}

CLASSES Wrapper:

Pode-se criar invlucros de tipos primitivos com essas classes, que permitem
vrias operaes.
Double preco = new Double("12.45"); //cria um objeto 'Double' e inicializa.
int i = preco.intValue(); //converte o valor de 'preco' para int.
byte b = preco.byteValue(); //converte para 'byte'
//converso esttica...
double d = Double.parseDouble("123.5"); //converte a string para 'double'.
int i2 = Integer.parseInt("123");
//converso de bases...
int i3 = Integer.valueOf("10011", 2); //converte a string que est na base 2.

CLASSES ORIENTAO A OBJETOS:

Uma classe apenas um projeto de objeto, onde so declarados seus

atributos e implementados seus mtodos.
Ao instanciar um objeto com o operador new, um espao na memria
alocado para esse objeto e o seu endereo retornado. Portanto, uma
instncia de uma classe apenas uma referncia.

MTODOS:

Possuem sempre: modificadores de acesso, tipo de retorno, nome e uma lista

de parmetros se necessrio.
So blocos de instrues que podem ser chamados na mesma classe ou em
outras atravs do operador ponto, dependendo dos seus modificadores de
acesso.

MODIFICADORES DE ACESSO:

Podem ser usados em classes, mtodos, variveis, objetos e etc.

private
package
protected
public

:
:
:
:

pode ser acessado apenas na prpria classe.

no mesmo pacote(se no tiver nenhum ele padro).
na prpria classe e nas subclasses (herana).
em qualquer lugar.

MODIFICADOR static:

Pode ser usado em variveis, objetos e mtodos.

Torna-o global, ou seja, permite que no seja criado toda vez que se instanciar
um novo objeto da mesma classe.
No pode ser acessado com o operador this j que no pertence a um objeto
em especfico, mas sim a todos daquele tipo. Da mesma forma que mtodos
static no podem acessar variveis locais.
Na utilizao de mtodos static por outras classes no necessrio um
objeto, apenas informar:
NomeClasse.metodo;

MTODOS COM ARGUMENTOS VARIVEIS:

double soma(double...numeros){ //transforma os args em vetor.
double total = 0;
for(double n : numeros){
total+=n;
}
return total;
}

Pode ser utilizado apenas como ltimo argumento na lista de args.

MTODOS SOBRECARREGADOS:

So mtodos que possuem o mesmo nome, mas possuem assinaturas

diferentes, ou seja, possuem listas de parmetros diferentes ou tipos de
retorno.

CONSTRUTORES:

Construtores sempre tem o mesmo nome da classe.

Servem para inicializar os atributos do objeto. No so mtodos por no

possuir um tipo de retorno.
Se nenhum construtor for declarado na classe os atributos sero inicializados
com valores padro.
Pode se declarar mais de um construtor para a mesma classe, por exemplo,
outro que recebe parmetros.
NomeClasse novo = new NomeClasse();
//ou:
NomeClasse novo = new NomeClasse("Novo", 2);

COMPOSIO:

Objetos podem ser compostos de outros objetos, ou seja, um objeto declarado

dentro de outra classe chama-se de relao de composio.

ENUMERAES CLASSES enum:

Um tipo enum uma lista de constantes enum (so automaticamente static

e final). Podem-se incluir construtores ou mtodos.
Cada constante na verdade uma instancia da classe que tem seus prprios
atributos.
No so criados objetos enum usando o operador new.
As constantes declaradas contm atributos que podem ser inicializados no
projeto da classe, como uma chamada ao construtor.
public enum Medida{
MM("Milmetro"), CM("Centmetro"), M("Metro"); //lista de constantes.
private String nome; //atributo das constantes.
Medida(String nome1){
nome = nome1;
}
public String retornarNome(){ //mtodo que retorna o nome da constante.
return nome;
}
}

Para cada enum gerado automaticamente um mtodo static chamado

values que retorna um vetor das constantes do enum.
Para exibir todos os nomes das constantes do exemplo acima seria:
for(Medida m : Medida.values())
System.out.println(m + " : " + m.retornarNome());

Para acessar diretamente uma das constantes ou seu nome:

System.out.println(Medida.MM);
System.out.println(Medida.CM.retornarNome());

O mtodo range (java.util.EnumSet) retorna um intervalo de constantes:

for(Medida m : EnumSet.range(Medida.CM, Medida.M)) //retorna o intervalo.
System.out.println(m + " : " + m.retornarNome());

HERANA:

Uma classe pode herdar os atributos e mtodos de outra classe, nesse caso, a
classe que herda chamada de subclasse e a classe pai de superclasse.
A palavra-chave extends seguida do nome da classe pai faz com que a
subclasse possa utilizar todos os componentes da superclasse.

- superclasse:
public class Funcionario{
String nome;
double salario;
int horasTrabalho;
public void receberPagamento(double salario){
this.salario = salario;
}
public double calcularSalario(){
//cdigo...
}
}

- subclasse:
public class Gerente extends Funcionario{
public void pagarFuncionario(Funcionario f){

f.salario += f.calcularSalario();
}

A classe Gerente estende de Funcionario que uma classe mais geral.

Se algum atributo ou mtodo de Funcionario estiver duplicado em Gerente
a prioridade ser do mais prximo.
Vantagens: elimina o cdigo duplicado e generaliza um comportamento a um
grupo de classes facilitando alteraes.
Gerente novo = new Gerente();
novo.receberPagamento(valor);
//ou:
Funcionario f = new Gerente();//j que tambm Funcionario.

Para referenciar-se a atributos, mtodos e construtores da superclasse, utilizase a referencia super:

super.nome = "Gerente";
super(); //chamada ao construtor.

Diferente da palavra this que referencia a prpria classe.

Para tirar o acesso a um atributo ou mtodo para as subclasses utiliza-se o
modificador private. Diferente do modificador protected que disponibiliza
apenas para as subclasses.
Para verifica o tipo de um objeto utiliza-se o operador instanceof:
Gerente novo = new Gerente();
if(novo instanceof Gerente && novo instanceof Funcionario)
System.out.println(" Gerente e Funcionario");

Todas as classes, por padro, estendem da classe Object que possui alguns
mtodos como:
novo.equals(outro); //compara as informaes de dois objetos.

novo.hashCode(); //gera um nmero serial para o objeto.

novo.getClass(); //retorna o tipo da classe do objeto.
novo.toString(); //retorna a representao em string do objeto.

POLIMORFISMO:

Pode-se modificar o comportamento natural de uma herana, por exemplo,

sobrescrever um mtodo para torn-lo mais especfico para a classe.
O mtodo teria o mesmo nome (sobrecarregado), mas seria o mais prximo
classe.
Se criarmos uma nova classe que herda de Funcionario, por exemplo:
public class Contador extends Funcionario{
public void calcularBalanoMensal(){

//cdigo...
}

Ao implementar um mtodo genrico no main, por exemplo:

public static void calcularSalario(Funcionario f){

//poderia ser qualquer um que estenda da classe'Funcionario'.

f.calcularSalario();

//seria mais eficiente que...

public static void calcularSalario(Funcionario f){
if(f.equals("Gerente")){
//calcularSalario do gerente.
}else if(f.equals("Contador")){
//calcularSalario do contador.
}
}

CLASSES E MTODOS abstract:

So classes que no podem ser instanciadas apenas herdadas, ou seja, so

rascunhos para outras classes.
Mtodos abstratos so mtodos que devem ser implementados pelas
subclasses, ou seja, no possuem corpo na classe abstrata. Podem existir
apenas em classes abstratas, estas tambm podem conter mtodos no
abstratos (concretos).
Todas as classes que herdarem de classes de classes abstratas precisam
implementar os mtodos abstratos da sua superclasse, a menos que seja
tambm uma classe abstrata.
public abstract class NomeClasse{
}

abstract void nomeMetodo();

Classes abstratas, assim como seus mtodos abstratos, servem para ganhar
em polimorfismo, j que existe a garantia de que toda classe concreta que
estender dela ter seus mtodos abstratos implementados.

Uma classe abstrata no necessariamente precisa ter ao menos um mtodo

abstrato.
Classes abstratas podem estender de classes concretas.
Uma classe filha de uma classe que estende uma classe abstrata no precisa
implementar seus mtodos abstratos, j que ela herda da sua classe pai, mas
poderia.

CLASSES E MTODOS final:

So classes que no podem ser herdadas e mtodos que no podem ser

sobrescritos.
public final class NomeClasse{
}

final void nomeMetodo(){}

POLIMORFISMO interfaces:

Interfaces padronizam como objetos podem interagir entre si, ela especifica
quais operaes devem ser realizadas, mas no como devem ser realizadas.
como um contrato que uma classe assume para ter um determinado status,
e para cumpri-lo ter que especificar todos os mtodos pr-definidos.
Uma interface utilizada em classes no relacionadas torna mtodos e
constantes
comuns
a
elas,
permitindo
que
sejam
processadas
polimorficamente.
public interface Pagavel{
double valor;
}

double calcularPagamento();

Todos os mtodos em uma interface so automaticamente abstratos, ou seja,

toda classe que implementar esta interface ter que implementar os seus
mtodos de forma especfica.
Todos os atributos so automaticamente constantes.
redundante declarar atributos com os modificadores: public, static e final,
assim como, declarar mtodos com: public e abstract.
Uma classe que no implementa todos os mtodos da interface utilizada deve
ser declarada como classe abstrata.
Para utilizar uma interface a classe concreta deve implement-la utilizando a
palavra implements:
public class NomeClasse implements NomeInterface{
//implementar todos os mtodos da interface.
}

Ao implementar uma interface ela ser herdada.

Pode-se implementar mais de uma interface em uma classe utilizando
vrgulas entre os nomes das interfaces. (herana mltipla)

A diferena entre as outras classes que evita mtodos ou atributos

desnecessrios para as quem implementa.
Assim como as classes abstratas, elas tambm do garantia ao polimorfismo
entre as classes que implementam.

TRATAMENTO DE EXCEES:

O bloco try catch trata possveis erros como: entradas invlidas e

operaes mal sucedidas.
O cdigo que vai tentar (try) executar o bloco perigoso e, caso o problema
seja do tipo exceo especificada , ele ser pego (caught).
try{
//execuo normal...
}catch(TipoExceo nome){
//tratamento...
}
finally{
//algo imprescindvel de ser executado, caso tenha havido
//exceo ou no.
}

Podem existir vrios catch para diferentes tipos de erros, ou usar o multi
catch (para excees com o mesmo tratamento):
try{

//execuo normal...
}catch(Exceo1 | Exceo2 | Exceo3 nomeExcees){
//tratamento...
}

Usados juntamente a um do-while pode-se forar uma entrada vlida ou

uma operao.
A partir do momento que uma exception foi catched (pega, tratada, handled),
a execuo volta ao normal a partir daquele ponto fora do try.
No tratamento dos erros pode ser includo o atributo err da classe System
para dar destaque em vermelho a mensagem de erro.
System.err.println("ERRO");

stackTrace: Pilha de erros, ou seja, uma lista de todos os erros que podem se
propagar durante a execuo de um bloco de instrues. Permite algumas
operaes como:
nome.printStackTrace(); //imprimi a pilha de erros.
nome.getStackTrace(); //retorna uma array de erros.
nome.getMessage();//retorna a msg passada no construtor da exceo.

Um ArrayIndexOutOfBoundsException ou um NullPointerException poderia ser

facilmente evitado. por esse motivo que o java no te obriga a dar o
try/catch nessas exceptions e chamamos essas excees de unchecked.
Excees checked devem ser tratadas ou lanadas pra quem chamou o
mtodo. Para isso utiliza-se o throws que retornar as excees:
Quando uma exceo lanada (throw), a JVM entra em estado de alerta e
vai ver se o mtodo atual toma alguma precauo ao tentar executar esse
trecho de cdigo.
public void nomeMetodo() throws NomeExceo1, NomeExceo2{
//bloco de instrues...
throw new NomeExceo(); //lana a exceo.
}

Excees mais comuns:

NullPointerException
: tentar acessar um objeto nulo.
ArithmeticException
: operaes aritmticas invlidas.
ArrayIndexOutOfBoundsException : tentar acessar uma posio invlida de
uma array.
ClassCastException
: erro em um casting de tipos.
NumberFormatException
: converses de tipos invlidos (classes
Wrapper).
Todas as excees so classes que devem estender da classe Exception
tornando-se uma exceo verificada, ou seja, para criar classes de exceo
seria:
public class NomeException extends Exception{
public NomeException(String msg){

super(msg); //chamada ao construtor de 'Exception'.

}

//chamada em um mtodo...
public static void nomeMetodo() throws NomeException{

if(...){
//normal
}else
throw new NomeException(); //lana a exceo.

Podem ser tratadas vrias execees, ou tratar algumas e lanar outras.

Excees do tipo unchecked estendem de RuntimeException e as checked
estendem de Exception.

desnecessrios declarar no throws as excees unchecked, porm permitido e

pode facilitar a leitura do cdigo.

STRINGS:

So referncias a conjuntos de caracteres, ou seja, so classes que permitem

diversas operaes:
String s1 = "texto";
String s2 = "texto2" + s1; //concatenar String.
char[] array = {'J', 'a', 'v', 'a'};
String s4 = new String(array); //construir a partir de uma array de caracteres.

s1.length(); //retorna o nmero de caracteres.

s1.charAt(2); //retorna o caractere da posio '2'.
s1.toString(); //retorna a string.
s4.indexOf('a'); //retorna a posio de 'a'.
s3.lastIndexOf('a'); //retorna a posio da ltima ocorrncia de 'a'.
s3.isEmpty(); //retorna se a lista est vazia.
s3.equals("texto"); //compara duas strings.
s4.equalsIgnoreCase("java"); //compara sem diferenciar maisculas.
s4.startsWith("a"); //retorna se comea com um caractere especifico ou uma string.
s4.endsWith("v"); //retorna se termina com um caractere especifico ou uma string.
s3.compareTo(s2); //compara em ordem alfabtica: -1 se maior, 1 se menor e 0 igual.

s3.regionMatches(...); //existe uma regio especifica (pesquisar parmetros).

s3.substring(4); //retorna a substring a partir de da posio especificada.
s3.substring(2, 4); //retorna a substring do intervalo.
s3.concat("texto"); //concatena.
s3.replaceAll("a", "b"); //troca todos os 'a' por 'b'.
s3.replaceFirst("a", "b"); //troca a primeira ocorrncia de 'a' por 'b'.
s3.toUpperCase(); //converte para maisculo.
s3.toLowerCase(); //converte para minsculo.
s3.trim(); //remove espaos antes e depois da string.
s3.split(";"); //quebra em tokens de acordo com o delimitador especificado.

ARQUIVOS:

Arquivos de caracteres simples:

importar:
java.nio.file,
java.io.IOException.

java.nio.file.Path,

java.nio.file.Paths

//definio do caminho em 'p'...

Path p = Paths.get("C:/.../texto.txt");
p.toAbsolutePath(); //retorna o caminho do arquivo.
p.getParent(); //retorna o caminho pai do arquivo.
p.getRoot(); //retorna a raiz do sistema.
p.getFileName(); //retorna o nome do arquivo.
try{

Files.createDirectories(p.getParent()); //cria o diretrio pai.

//escrevendo...
byte[] bytes = "Texto".getBytes(); //retorna um array de bytes.
Files.write(p, bytes); //cria, limpa, escreve e fecha o arquivo.
//lendo...

byte[] retorno = Files.readAllBytes(p); //ler e retorna um array de bytes.

System.out.println(new String(retorno)); //imprimi 'retorno'.
}catch(IOException e){
e.printStackTrace();
}

Arquivos grandes de caracteres:

importar:
java.nio.Files,
java.nio.file.Path,
java.nio.file.Paths,
java.io.IOException,
java.io.BufferedWriter,
java.io.BufferedReader,
java.nio.charset.Charset e java.nio.charset.StandardCharsets.
//definio do caminho em 'p'...
Path p = Paths.get("C:/.../texto.txt");
Charset utf8 = StandardCharsets.UTF_8; //define a codificao.
BufferedWriter w = null;
try{

w = Files.newBufferedWriter(p, utf8);
w.write("Texto"); //escreve no arquivo.
w.flush(); //passa o contedo do buffer para o arquivo.
}catch(IOException e){
e.printStackTrace();
}finally{

if(w != null)
w.close(); //fecha o arquivo.

//Ou a partir do Java 7...

//definio do caminho em 'p'...
Path p = Paths.get("C:/.../texto.txt");
Charset utf8 = StandardCharsets.UTF_8; //define a codificao.
try(BufferedWriter w = Files.newBufferedWriter(p, utf8)){ //inicializa aqui.
w.write("Texto"); //escreve no arquivo e fecha.
}catch(IOException e){
e.printStackTrace();
}
//leitura...
try(BufferedReader r = Files.newBufferedReader(p, utf8)){
String linha = null;
while((linha = r.readLine()) != null){ //ler at o final.
System.out.println(linha);
}
}catch(IOException e1){
e1.printStackTrace();
}

Outras operaes:
Path path = Paths.get("C:/.../texto.txt");
Files.exists(path); //retorna se o caminho existe.
Files.isDirectory(path); //retorna se o caminho um diretrio.
Files.isRegularFile(path); //se um arquivo regular.
Files.isReadable(path); //se o arquivo pode ser lido.
Files.isExecutable(path); //se o arquivo pode ser executado.
Files.size(path); //retorna o tamanho do arquivo.
Files.getLastModifiedTime(path); //retorna a ltima vez que foi modificado.
Files.getOwner(path); //retorna o dono do arquivo.
Files.probeContentType(path); //retorna o tipo do arquivo.
//delete...
Path path = Paths.get("C:/.../texto.txt");
Files.delete(path);
/* pode lanar a exceo 'NosuchFileException' se o arquivo no existir
* ou a exceo 'DirectoryNotEmptyException' se o arquivo no estiver vazio.
*/
Files.deleteIfExists(path); //s deleta se o arquivo existir.
//create..
Files.createFile(path); //cria um arquivo vazio.
Files.write(path, "Texto".getBytes());
//copy...
Path copia = Paths.get("C:/.../texto.txt");
Files.copy(path, copia, StandardCopyOption.REPLACE_EXISTING);
//copia se o arquivo existir.
//move...
Path mover = Paths.get("C:/.../texto.txt");
Files.createDirectories(mover.getParent());

Files.move(path, mover, StandardCopyOption.REPLACE_EXISTING);

//remove do diretrio atual e copia no novo diretrio.
//importar tambm e java.nio.file.StandardCopyOption.

SERIALIZAO DE OBJETOS:

No so arquivos de caracteres, mas sim de bytecodes.

importar:
java.io.FileInputStream,
java.io.FileOutputStream,
java.io.ObjectInputStream, java.io.ObjectOutputStream, java.util.Arrays.
Para serializar uma classe preciso implementar a interface
java.io.Serializable,
caso
contrrio
ser
lanada
a
exceo
NotSerializableException.
String[] cores = {"azul", "vermelho", "preto"};
//escrita...
//definir o caminho...
FileOutputStream fos = new FileOutputStream("C:/.../texto.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(cores); //escreve um objeto.
oos.close(); //fecha o arquivo.
//leitura...
FileInputStream fis = new FileInputStream("C:/.../texto.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
String[] cores2 = (String[])ois.readObject(); //ler um objeto.
ois.close();
System.out.print(Arrays.toString(cores2)); //exibi o array de strings.

Variveis static no so serializadas. Utiliza-se o modificador transient para

evitar a serializao de um atributo.

CLASSE Math:

Realizar algumas operaes matemticas:

double PI = Math.PI; //constante 'PI'.(double)
Math.pow(a, b); //potncia de 'a' elevado a 'b'.
Math.sqrt(a); //calcula raiz quadrada.
Math.cbrt(a); //calcula a raiz cbica.
Math.log(a); //retorna logaritmo de 'a'.
Math.round(a); //arredonda 'a'.
Math.signum(d); //retorna -1 se negativo, 0 se igual zero e 1 se positivo.

BANCO DE DADOS COM JDBC:

Connection con;

/* para mysql */
con = DriverManager.getConnection("jdbc:mysql://localhost/bdteste", "root", "");
Statement st = con.createStatement(); //cria a statement.
String cmd = "COMANDO SQL";
st.executeUpdate(cmd); //pra comandos que alteram os dados.
st.executeQuery(cmd); //para comandos de pesquisa.
st.close(); //fecha a statement.
OBS.: adicionar o conector do SGBD na build path do projeto.

- Modo padro de criao da conexo(Classe externa):

import java.sql.DriverManager;
import java.sql.Connection;import javax.swing.JOptionPane;
public class Conexao {
static Connection con;
private Conexao(){
try{
con=DriverManager.getConnection("jdbc:mysql://localhost/bdteste",
"root", "");
}catch(Exception e){
e.printStackTrace();
}
}
public static Connection getConnection(){
if(con == null){ //se ainda no tiver sido criada.
new Conexao();
}
return con; //retorna sempre a msm conexo.
}
}

//em outro arquivo:

Statement st = Conexao.getConnection().createStatement(); //cria a statement.
String cmd = "COMANDO SQL";
ResultSet rs = st.executeQuery(cmd);

while(rs.next()){ //enquanto tiver registro no resultado.

sysout(rs.getInt("nome_coluna"));
sysout(rs.getDouble("nome_coluna"));
}
rs.close();
st.close();

/* Outra forma de inserir no banco (usando PreparedStatement)*/

Connection con = new Conexao.getConnection();
String sql = "insert into tabela" +
" (coluna_1, coluna_2, coluna_3)" +
" values (?,?,?)";
// cria um preparedStatement com o comando.
PreparedStatement stmt = con.prepareStatement(sql);
// preenche os valores
stmt.setString(1, "valor1"); //recebe posio da interrogao no cmd e o valor.
stmt.setString(2, "valor2");
stmt.setString(3, "valor3");
stmt.execute();
stmt.close();

- Casos bsicos de cardinalidade:

1 para N : chave estrangeira no lado do N
N para N : tabela intermediria com as chaves primrias de cada tabela.
Composio(listas) : retorna primeiro o objeto principal e retorna a lista apenas na
chamada de um metodo get interno.
Herana simples : uma tabela para a superclasse e tabelas para as subclasses com
chaves estrangeiras para a superclasse.
Herana mltipla : tabelas para as superclasses e tabelas para as subclasses com
chaves estrangeiras para as suas superclasses.