diff options
Diffstat (limited to 'pt-br/java-pt.html.markdown')
| -rw-r--r-- | pt-br/java-pt.html.markdown | 435 |
1 files changed, 435 insertions, 0 deletions
diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown new file mode 100644 index 00000000..f922f6d9 --- /dev/null +++ b/pt-br/java-pt.html.markdown @@ -0,0 +1,435 @@ +--- + +language: java +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", "rene.douglas.bsi@gmail.com"] +lang: pt-br +filename: LearnJava.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 lina, 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; + } + +} + +``` + +## 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/) |