mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
649 lines
22 KiB
Markdown
649 lines
22 KiB
Markdown
---
|
|
|
|
contributors:
|
|
- ["Jake Prather", "http://github.com/JakeHP"]
|
|
- ["Madison Dickson", "http://github.com/mix3d"]
|
|
translators:
|
|
- ["Victor Kléber Santos L. Melo", "http://victormelo.com.br/blog"]
|
|
- ["Renê Douglas N. de Morais", "mailto:rene.douglas.bsi@gmail.com"]
|
|
filename: LearnJava-pt.java
|
|
|
|
---
|
|
|
|
Java é uma linguagem de programação de propósito geral, concorrente, baseada em classes e orientada a objetos.
|
|
[Leia mais aqui](http://docs.oracle.com/javase/tutorial/java/index.html)
|
|
|
|
```java
|
|
// Comentários de uma linha começam com //
|
|
/*
|
|
Comentários de várias linhas são feitos dessa forma.
|
|
*/
|
|
/**
|
|
Comentários JavaDoc são feitos assim. São usados para descrever a Classe ou os atributos da Classe.
|
|
*/
|
|
|
|
// Importa a classe ArrayList que está dentro do pacote java.util
|
|
import java.util.ArrayList;
|
|
// Importa todas as classes que estão dentro do pacote java.security
|
|
import java.security.*;
|
|
|
|
// Cada arquivo .java contém uma classe pública, com o mesmo nome do arquivo.
|
|
public class LearnJava {
|
|
|
|
// Um programa precisa ter um método main como um ponto de entrada.
|
|
public static void main (String[] args) {
|
|
|
|
// O System.out.println é usado para imprimir no console
|
|
System.out.println("Olá Mundo!");
|
|
System.out.println(
|
|
"Integer: " + 10 +
|
|
" Double: " + 3.14 +
|
|
" Boolean: " + true);
|
|
|
|
// Para imprimir sem inserir uma nova linha, use o System.out.print
|
|
System.out.print("Olá ");
|
|
System.out.print("Mundo");
|
|
|
|
|
|
///////////////////////////////////////
|
|
// Tipos & Variáveis
|
|
///////////////////////////////////////
|
|
|
|
// Declara-se variáveis usando <tipo> <nome> [
|
|
// Byte - inteiro de 8 bits com sinal complementado a dois
|
|
// (-128 <= byte <= 127)
|
|
byte fooByte = 100;
|
|
|
|
// Short - inteiro de 16 bits com sinal complementado a dois
|
|
// (-32,768 <= short <= 32,767)
|
|
short fooShort = 10000;
|
|
|
|
// Integer - inteiro de 32 bits com sinal complementado a dois
|
|
// (-2,147,483,648 <= int <= 2,147,483,647)
|
|
int fooInt = 1;
|
|
|
|
// Long - inteiro de 64 bits com sinal complementado a dois
|
|
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
|
|
long fooLong = 100000L;
|
|
// L é usado para indicar que o valor da variável é do tipo Long;
|
|
// sem o L, tudo é tratado como inteiro por padrão.
|
|
|
|
// Nota: Java não tem tipos sem sinal
|
|
|
|
// Float - Ponto Flutuante 32-bits, de precisão simples no padrão IEEE 754
|
|
float fooFloat = 234.5f;
|
|
// f é usado para indicar que o valor da variável é do tipo float;
|
|
// caso contrário, ela é tratada como double.
|
|
|
|
// Double - Ponto Flutuante 64-bits, de precisão dupla no padrão IEEE 754
|
|
double fooDouble = 123.4;
|
|
|
|
// Boolean - true & false
|
|
boolean fooBoolean = true;
|
|
boolean barBoolean = false;
|
|
|
|
// Char - Um caractere Unicode de 16 bits
|
|
char fooChar = 'A';
|
|
|
|
// Usa-se o final para fazer com que a variável seja imutável.
|
|
final int HORAS_QUE_TRABALHEI_POR_SEMANA = 9001;
|
|
|
|
// Strings
|
|
String fooString = "Aqui está minha String!";
|
|
|
|
// \n é um caractere de escape que inicia uma nova linha
|
|
String barString = "Imprimir em uma nova linha?\nSem problemas!";
|
|
// \t é um caractere de escape que adiciona um caractere de tabulação
|
|
String bazString = "Você quer adicionar tabulação?\tSem problemas!";
|
|
System.out.println(fooString);
|
|
System.out.println(barString);
|
|
System.out.println(bazString);
|
|
|
|
// Arrays
|
|
//O tamanho do array precisa ser determinado na sua declaração
|
|
//O formato para declarar um array é:
|
|
//<tipo de dado> [] <nome da variável> = new <tipo de dado>[<tamanho do array>];
|
|
int [] intArray = new int[10];
|
|
String [] stringArray = new String[1];
|
|
boolean [] booleanArray = new boolean[100];
|
|
|
|
// Outra maneira de declarar e inicializar um array
|
|
int [] y = {9000, 1000, 1337};
|
|
|
|
// Indexando um array - Acessando um elemento
|
|
System.out.println("intArray no índice 0: " + intArray[0]);
|
|
|
|
// O primeiro termo de um array é o 0 e eles são mutáveis.
|
|
intArray[1] = 1;
|
|
System.out.println("intArray no índice 1: " + intArray[1]); // => 1
|
|
|
|
// Outras estruturas que devem ser vistas
|
|
// ArrayLists - São parecidos com os arrays, porém oferecem mais funcionalidades
|
|
// e o tamanho é mutável.
|
|
// LinkedLists
|
|
// Maps
|
|
// HashMaps
|
|
|
|
///////////////////////////////////////
|
|
// Operadores
|
|
///////////////////////////////////////
|
|
System.out.println("\n->Operadores");
|
|
|
|
int i1 = 1, i2 = 2; // Forma abreviada de escrever múltiplas declarações.
|
|
|
|
// Aritmética é feita da forma convencional
|
|
System.out.println("1+2 = " + (i1 + i2)); // => 3
|
|
System.out.println("2-1 = " + (i2 - i1)); // => 1
|
|
System.out.println("2*1 = " + (i2 * i1)); // => 2
|
|
System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 arredondado para baixo)
|
|
|
|
// Módulo
|
|
System.out.println("11%3 = "+(11 % 3)); // => 2
|
|
|
|
// Operadores de comparação
|
|
System.out.println("3 == 2? " + (3 == 2)); // => false
|
|
System.out.println("3 != 2? " + (3 != 2)); // => true
|
|
System.out.println("3 > 2? " + (3 > 2)); // => true
|
|
System.out.println("3 < 2? " + (3 < 2)); // => false
|
|
System.out.println("2 <= 2? " + (2 <= 2)); // => true
|
|
System.out.println("2 >= 2? " + (2 >= 2)); // => true
|
|
|
|
// Operadores bit-a-bit!
|
|
/*
|
|
~ Complemento de um
|
|
<< Deslocamento a esquerda com sinal
|
|
>> Deslocamento a direita com sinal
|
|
>>> Deslocamento a direita sem sinal
|
|
& E bit-a-bit
|
|
| OU bit-a-bit
|
|
^ OU exclusivo bit-a-bit
|
|
*/
|
|
|
|
// Incrementações
|
|
int i = 0;
|
|
System.out.println("\n->Inc/Dec-rementação");
|
|
System.out.println(i++); //i = 1. Pós-Incrementação
|
|
System.out.println(++i); //i = 2. Pre-Incrementação
|
|
System.out.println(i--); //i = 1. Pós-Decrementação
|
|
System.out.println(--i); //i = 0. Pre-Decrementação
|
|
|
|
///////////////////////////////////////
|
|
// Estruturas de Controle
|
|
///////////////////////////////////////
|
|
System.out.println("\n->Estruturas de Controle");
|
|
|
|
// Os comandos If são parecidos com o da linguagem C
|
|
int j = 10;
|
|
if (j == 10){
|
|
System.out.println("Eu serei impresso");
|
|
} else if (j > 10) {
|
|
System.out.println("Eu não");
|
|
} else {
|
|
System.out.println("Eu também não");
|
|
}
|
|
|
|
// O Loop While
|
|
int fooWhile = 0;
|
|
while(fooWhile < 100)
|
|
{
|
|
//System.out.println(fooWhile);
|
|
//Incrementando o contador
|
|
//Iteração feita 99 vezes, fooWhile 0->99
|
|
fooWhile++;
|
|
}
|
|
System.out.println("Valor do fooWhile: " + fooWhile);
|
|
|
|
// O Loop Do While
|
|
int fooDoWhile = 0;
|
|
do
|
|
{
|
|
//System.out.println(fooDoWhile);
|
|
//Incrementando o contador
|
|
//Iteração feita 99 vezes, fooDoWhile 0->99
|
|
fooDoWhile++;
|
|
}while(fooDoWhile < 100);
|
|
System.out.println("Valor do fooDoWhile: " + fooDoWhile);
|
|
|
|
// O Loop For
|
|
int fooFor;
|
|
//estrutura do loop for => for(<operação_de_início>; <condição>; <passo>)
|
|
for(fooFor=0; fooFor<10; fooFor++){
|
|
//System.out.println(fooFor);
|
|
//Iteração feita 10 vezes, fooFor 0->9
|
|
}
|
|
System.out.println("Valor do fooFor: " + fooFor);
|
|
|
|
// O Loop For Each
|
|
// Itera automaticamente por um array ou lista de objetos.
|
|
int[] fooList = {1,2,3,4,5,6,7,8,9};
|
|
//estrutura do loop for each => for(<objeto> : <array_de_objeto>)
|
|
//lê-se: para cada objeto no array
|
|
//nota: o tipo do objeto deve ser o mesmo do array.
|
|
|
|
for( int bar : fooList ){
|
|
//System.out.println(bar);
|
|
//Itera 9 vezes e imprime 1-9 em novas linhas
|
|
}
|
|
|
|
// Switch
|
|
// Um switch funciona com os tipos de dados: byte, short, char e int
|
|
// Ele também funciona com tipos enumerados (vistos em tipos Enum)
|
|
// como também a classe String e algumas outras classes especiais
|
|
// tipos primitivos: Character, Byte, Short e Integer
|
|
int mes = 3;
|
|
String mesString;
|
|
switch (mes){
|
|
case 1:
|
|
mesString = "Janeiro";
|
|
break;
|
|
case 2:
|
|
mesString = "Fevereiro";
|
|
break;
|
|
case 3:
|
|
mesString = "Março";
|
|
break;
|
|
default:
|
|
mesString = "Algum outro mês";
|
|
break;
|
|
}
|
|
System.out.println("Resultado do Switch: " + mesString);
|
|
|
|
// Condição de forma abreviada.
|
|
// Você pode usar o operador '?' para atribuições rápidas ou decisões lógicas.
|
|
// Lê-se "Se (declaração) é verdadeira, use <primeiro valor>
|
|
// caso contrário, use <segundo valor>".
|
|
int foo = 5;
|
|
String bar = (foo < 10) ? "A" : "B";
|
|
System.out.println(bar); //Imprime A, pois a condição é verdadeira.
|
|
|
|
|
|
///////////////////////////////////////
|
|
// Convertendo tipos de dados e Casting
|
|
///////////////////////////////////////
|
|
|
|
//Conversão de Dados
|
|
|
|
//Convertendo String para Inteiro.
|
|
Integer.parseInt("123");//retorna uma versão inteira de "123".
|
|
|
|
//Convertendo Inteiro para String
|
|
Integer.toString(123);//retorna uma versão String de 123.
|
|
|
|
// Para outras conversões confira as seguintes classes
|
|
// Double
|
|
// Long
|
|
// String
|
|
|
|
// Casting
|
|
// Você pode também converter objetos java, há vários detalhes e
|
|
// lida com alguns conceitos intermediários
|
|
// Dê uma olhada no link:
|
|
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
|
|
|
|
|
|
///////////////////////////////////////
|
|
// Classes e Métodos
|
|
///////////////////////////////////////
|
|
|
|
System.out.println("\n->Classes e Métodos");
|
|
|
|
// (segue a definição da classe Bicicleta)
|
|
|
|
// Use o new para instanciar uma classe
|
|
Bicicleta caloi = new Bicicleta(); // Objeto caloi criado.
|
|
|
|
// Chame os métodos do objeto
|
|
caloi.aumentarVelocidade(3); // Você deve sempre usar métodos para modificar variáveis
|
|
caloi.setRitmo(100);
|
|
|
|
// toString é uma convenção para mostrar o valor deste objeto.
|
|
System.out.println("informações de caloi: " + caloi.toString());
|
|
|
|
} // Fim do método main
|
|
} // Fim da classe LearnJava
|
|
|
|
|
|
// Você pode incluir outras classes que não são públicas num arquivo .java
|
|
|
|
|
|
// Sintaxe de declaração de Classe.
|
|
// <public/private/protected> class <nome da classe>{
|
|
// // atributos, construtores e todos os métodos.
|
|
// // funções são chamadas de métodos em Java.
|
|
// }
|
|
|
|
class Bicicleta {
|
|
|
|
// Atributos/Variáveis da classe Bicicleta.
|
|
public int ritmo; // Public: Pode ser acessada em qualquer lugar.
|
|
private int velocidade; // Private: Apenas acessível a classe.
|
|
protected int catraca; // Protected: Acessível a classe e suas subclasses.
|
|
String nome; // default: Apenas acessível ao pacote.
|
|
|
|
// Construtores são uma forma de criação de classes
|
|
// Este é o construtor padrão.
|
|
public Bicicleta() {
|
|
catraca = 1;
|
|
ritmo = 50;
|
|
velocidade = 5;
|
|
nome = "Bontrager";
|
|
}
|
|
|
|
// Este é um construtor específico (ele contém argumentos).
|
|
public Bicicleta (int ritmoInicial, int velocidadeInicial, int catracaInicial, String nome) {
|
|
this.catraca = catracaInicial;
|
|
this.ritmo = ritmoInicial;
|
|
this.velocidade = velocidadeInicial;
|
|
this.nome = nome;
|
|
}
|
|
|
|
// Sintaxe de um método:
|
|
// <public/private/protected> <tipo de retorno> <nome do método>(<args>) //
|
|
|
|
// Classes em Java costumam implementar métodos getters e setters para seus campos.
|
|
|
|
// Sintaxe de declaração de métodos
|
|
// <escopo> <tipo de retorno> <nome do método>(<args>) //
|
|
public int getRitmo() {
|
|
return ritmo;
|
|
}
|
|
|
|
// Métodos do tipo void não requerem declaração de retorno.
|
|
public void setRitmo(int novoValor) {
|
|
ritmo = novoValor;
|
|
}
|
|
|
|
public void setEquipamento(int novoValor) {
|
|
catraca = novoValor;
|
|
}
|
|
|
|
public void aumentarVelocidade(int incremento) {
|
|
velocidade += incremento;
|
|
}
|
|
|
|
public void diminuirVelocidade(int decremento) {
|
|
velocidade -= decremento;
|
|
}
|
|
|
|
public void setNome(String novoNome) {
|
|
nome = novoNome;
|
|
}
|
|
|
|
public String getNome() {
|
|
return nome; // retorna um dado do tipo String.
|
|
}
|
|
|
|
//Método para mostrar os valores dos atributos deste objeto.
|
|
@Override
|
|
public String toString() {
|
|
return "catraca: " + catraca +
|
|
" ritmo: " + ritmo +
|
|
" velocidade: " + velocidade +
|
|
" nome: " + nome;
|
|
}
|
|
} // fim classe Bicicleta
|
|
|
|
// Velocipede é uma subclasse de bicicleta.
|
|
class Velocipede extends Bicicleta {
|
|
// (Velocípedes são bicicletas com rodas dianteiras grandes
|
|
// Elas não possuem catraca.)
|
|
|
|
public Velocipede(int ritmoInicial, int velocidadeInicial){
|
|
// Chame o construtor do pai (construtor de Bicicleta) com o comando super.
|
|
super(ritmoInicial, velocidadeInicial, 0, "PennyFarthing");
|
|
}
|
|
|
|
// Você pode marcar um método que você está substituindo com uma @annotation
|
|
// Para aprender mais sobre o que são as annotations e sua finalidade
|
|
// dê uma olhada em: http://docs.oracle.com/javase/tutorial/java/annotations/
|
|
@Override
|
|
public void setEquipamento(int catraca) {
|
|
catraca = 0;
|
|
}
|
|
|
|
}
|
|
|
|
// Interfaces
|
|
// Sintaxe de declaração de Interface
|
|
// <nível de acesso> interface <nome-da-interface> extends <super-interfaces> {
|
|
// // Constantes
|
|
// // Declarações de método
|
|
//}
|
|
|
|
// Exemplo - Comida:
|
|
public interface Comestivel {
|
|
public void comer(); // Qualquer classe que implementa essa interface, deve
|
|
// implementar este método.
|
|
}
|
|
|
|
public interface Digestivel {
|
|
public void digerir();
|
|
// Em Java 8, interfaces podem ter métodos default.
|
|
// public void digerir() {
|
|
// System.out.println("digerindo ...");
|
|
// }
|
|
}
|
|
|
|
|
|
// Agora podemos criar uma classe que implementa ambas as interfaces.
|
|
public class Fruta implements Comestivel, Digestivel {
|
|
|
|
@Override
|
|
public void comer() {
|
|
// ...
|
|
}
|
|
|
|
@Override
|
|
public void digerir() {
|
|
// ...
|
|
}
|
|
}
|
|
|
|
// Em Java, você pode estender somente uma classe, mas você pode implementar muitas
|
|
// interfaces. Por exemplo:
|
|
public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
|
|
InterfaceDois {
|
|
|
|
@Override
|
|
public void InterfaceUmMetodo() {
|
|
}
|
|
|
|
@Override
|
|
public void InterfaceDoisMetodo() {
|
|
}
|
|
|
|
}
|
|
|
|
// Classes abstratas
|
|
|
|
// Sintaxe de declaração de classe abstrata
|
|
// <Nível de acesso> abstract <nome-da-classe-abstrata> extends <estende super-abstratas-classes> {
|
|
// // Constantes e variáveis
|
|
// // Declarações de método
|
|
//}
|
|
|
|
// Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem
|
|
// ser definidos em uma classe filha. Semelhante às interfaces, classes abstratas não podem
|
|
// ser instanciadas, ao invés disso devem ser estendidas e os métodos abstratos
|
|
// definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de
|
|
// métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo,
|
|
// a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um
|
|
// classe abstrata. Classes abstratas também PODEM ter o método "main".
|
|
|
|
public abstract class Animal
|
|
{
|
|
public abstract void fazerSom();
|
|
|
|
// Método pode ter um corpo
|
|
public void comer()
|
|
{
|
|
System.out.println("Eu sou um animal e estou comendo.");
|
|
//Nota: Nós podemos acessar variáveis privadas aqui.
|
|
idade = 30;
|
|
}
|
|
|
|
// Não há necessidade de inicializar, no entanto, em uma interface
|
|
// a variável é implicitamente final e, portanto, tem
|
|
// de ser inicializada.
|
|
protected int idade;
|
|
|
|
public void mostrarIdade()
|
|
{
|
|
System.out.println(idade);
|
|
}
|
|
|
|
//Classes abstratas podem ter o método main.
|
|
public static void main(String[] args)
|
|
{
|
|
System.out.println("Eu sou abstrata");
|
|
}
|
|
}
|
|
|
|
class Cachorro extends Animal
|
|
{
|
|
|
|
// Nota: ainda precisamos substituir os métodos abstratos na
|
|
// classe abstrata.
|
|
@Override
|
|
public void fazerSom()
|
|
{
|
|
System.out.println("Bark");
|
|
// idade = 30; ==> ERRO! idade é privada de Animal
|
|
}
|
|
|
|
// NOTA: Você receberá um erro se usou a
|
|
// anotação Override aqui, uma vez que java não permite
|
|
// sobrescrita de métodos estáticos.
|
|
// O que está acontecendo aqui é chamado de "esconder o método".
|
|
// Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
|
|
public static void main(String[] args)
|
|
{
|
|
Cachorro pluto = new Cachorro();
|
|
pluto.fazerSom();
|
|
pluto.comer();
|
|
pluto.mostrarIdade();
|
|
}
|
|
}
|
|
|
|
// Classes Finais
|
|
|
|
// Sintaxe de declaração de classe final
|
|
// <nível de acesso> final <nome-da-classe-final> {
|
|
// // Constantes e variáveis
|
|
// // Declarações de método
|
|
//}
|
|
|
|
// Classes finais são classes que não podem ser herdadas e são, portanto, um
|
|
// filho final. De certa forma, as classes finais são o oposto de classes abstratas,
|
|
// porque classes abstratas devem ser estendidas, mas as classes finais não podem ser
|
|
// estendidas.
|
|
public final class TigreDenteDeSabre extends Animal
|
|
{
|
|
// Nota: Ainda precisamos substituir os métodos abstratos na
|
|
// classe abstrata.
|
|
@Override
|
|
public void fazerSom();
|
|
{
|
|
System.out.println("Roar");
|
|
}
|
|
}
|
|
|
|
// Métodos Finais
|
|
public abstract class Mamifero()
|
|
{
|
|
// Sintaxe de Métodos Finais:
|
|
// <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
|
|
|
|
// Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
|
|
// e são, portanto, a implementação final do método.
|
|
public final boolean EImpulsivo()
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
// Tipo Enum
|
|
//
|
|
// Um tipo enum é um tipo de dado especial que permite a uma variável ser um conjunto de constantes predefinidas. A
|
|
// variável deve ser igual a um dos valores que foram previamente definidos para ela.
|
|
// Por serem constantes, os nomes dos campos de um tipo de enumeração estão em letras maiúsculas.
|
|
// Na linguagem de programação Java, você define um tipo de enumeração usando a palavra-chave enum. Por exemplo, você poderia
|
|
// especificar um tipo de enum dias-da-semana como:
|
|
|
|
public enum Dia {
|
|
DOMINGO, SEGUNDA, TERÇA, QUARTA,
|
|
QUINTA, SEXTA, SABADO
|
|
}
|
|
|
|
// Nós podemos usar nosso enum Dia assim:
|
|
|
|
public class EnumTeste {
|
|
|
|
// Variável Enum
|
|
Dia dia;
|
|
|
|
public EnumTeste(Dia dia) {
|
|
this.dia = dia;
|
|
}
|
|
|
|
public void digaComoE() {
|
|
switch (dia) {
|
|
case SEGUNDA:
|
|
System.out.println("Segundas são ruins.");
|
|
break;
|
|
|
|
case SEXTA:
|
|
System.out.println("Sextas são melhores.");
|
|
break;
|
|
|
|
case SABADO:
|
|
case DOMINGO:
|
|
System.out.println("Finais de semana são os melhores.");
|
|
break;
|
|
|
|
default:
|
|
System.out.println("Dias no meio da semana são mais ou menos.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
EnumTeste primeiroDia = new EnumTeste(Dia.SEGUNDA);
|
|
primeiroDia.digaComoE(); // => Segundas-feiras são ruins.
|
|
EnumTeste terceiroDia = new EnumTeste(Dia.QUARTA);
|
|
terceiroDia.digaComoE(); // => Dias no meio da semana são mais ou menos.
|
|
}
|
|
}
|
|
|
|
// Tipos Enum são muito mais poderosos do que nós mostramos acima.
|
|
// O corpo de um enum pode incluir métodos e outros campos.
|
|
// Você pode ver mais em https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
|
|
```
|
|
|
|
## Leitura Recomendada
|
|
|
|
Os links fornecidos aqui abaixo são apenas para ter uma compreensão do tema, use o Google e encontre exemplos específicos.
|
|
|
|
Outros tópicos para pesquisar:
|
|
|
|
* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
|
|
* [Modificadores de acesso do Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
|
|
* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
|
|
* [Herança](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
|
|
* [Polimorfismo](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
|
|
* [Abstração](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
|
|
* [Exceções](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
|
|
* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
|
|
* [Tipos Genéricos](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
|
|
* [Conversões de código Java](http://www.oracle.com/technetwork/java/codeconv-138413.html)
|
|
|
|
Livros:
|
|
|
|
* [Use a cabeça, Java](http://www.headfirstlabs.com/books/hfjava/)
|
|
|
|
Apostila:
|
|
|
|
* [Java e Orientação a Objetos](http://www.caelum.com.br/apostila-java-orientacao-objetos/)
|
|
* [Java para Desenvolvimento Web](https://www.caelum.com.br/apostila-java-web/)
|