Daremos continuidade à série de documentos introdutórios à computação.
Continuaremos, por enquanto, com Java e orientação a objetos.
Conceitos esperados que o leitor compreenda: Máquina Virtual Java(JVM), Algoritmo, Classe, Objetos, Instância, Estados, Métodos, Campos, Variáveis, Atribuição, Argumentos, Parâmetros, Passagem por Valor e por Referência.
Conceitos apresentados: Variáveis, Tipos Primitivos, Vetores, Matrizes e String em Java.
Este documento é um resumo e uma tradução parcial do tutorial de iniciação Java da Oracle.
Language Basics: Variables
http://download.oracle.com/javase/tutorial/java/nutsandbolts/variables.html
Conceitos básicos da linguavem Java: Variáveis e Tipos Primitivos
Você aprendeu que objetos guardam seus estados em campos mas de qualquer forma a linguagem Java também adota o termo variável.
Variáveis de Classe/Class Variables (Campos Estáticos/Static Fields) são campos declarados com o modificador static, os quais avisão ao compilador onde está a única cópia de existência dessa variável, independentemente de quantas vezes a classe tenha sido instanciada. Um contador de instâncias, por exemplo, poderia ser marcado como sendo estático e auto-incrementável. Noutro exemplo, o número de rodas da classe Carros poderia ser:
static final int NUM_DE_RODAS = 4;
A palavra "final" transforma o valor numa constante, pois, o número de rodas de um automóvel nunca deveria mudar.
Variáveis de Instância/Instance Variables (Campos Não-Estáticos/Non-Static Fields) - Objetos guardam seus estados individuais em campos não-estáticos, ou seja, sem a precedência da palavra "static" em suas declarações. Isto garante independência dos valores presentes nestes campos em relação à todas outras instâncias da mesma classe. Por exemplo, se a classe Pessoa tem um campo não-estático "nome", cada pessoa.nome irá possir um valor independente.
Parâmetros/Parameters - Você já os utilizou em:
public static void main(String[] args){ }
A variável "args " é o parâmetro do método, o local responsável por armazenar os argumentos fornecidos. Parâmetros são variáveis, não são campos.
Variáveis Locais/Local Variables - Da mesma forma que um objeto quarda seus estados em campos, um método guarda seus estados nas variáveis locais. A declaração de uma variável local é idêntica à declaração de um campo:
int i = 0;
Sua natureza, portanto, é definida pelo seu escopo, pela localização de sua declaração - entre as chaves de um método, ou seja, dentro do corpo do método. Por isso, variáveis locais só são acessíveis dentro do método, no qual elas estão declaradas, e inacessíveis no restante da classe.
Membros/Members é o nome dado a um conjunto de campos e métodos.
// arquivo Variando.java
class Variando {
static float deClasse; // Static Field
float deInstancia; // Non-Static Field
public static void main(String[] args){ // args, acima, é parâmetro
soma(5, 11); // Passagem de 2 argumentos
double x; // Variável Local
} // fim main
static void soma(int a, int b){ // a e b são parâmetros
System.out.println("a + b = "+(a+b));
} // fim soma
} // fim Variando
Convenções de nomenclatura
Identificadores de variáveis/campos são sensíveis à caixa de texto, formados por seqüências ilimitadas de letras e dígitos Unicode, não permitem espaços, e apesar de poderem ser iniciados por "$" e "_", devem sempre começar com uma letra.
Quando escolher um nome para sua variável, use nomes longos ao invés de usar abreviações. Assim seu código será de fácil leitura e praticamente auto-comentado, desde que não se use uma palavra reservada.
abstract assert*** boolean
break byte case
catch char class
const* continue default
do double else
enum**** extends false
final finally float
for goto* if
implements import instanceof
int interface long
native new null
package private protected
public return short
static strictfp** super
switch synchronized this
throw throws transient
true try void
volatile while
* not used
** added in 1.2
*** added in 1.4
**** added in 5.0
Se o nome de sua escolha for apenas uma palavra, escreva-a em letras minúsculas. Se for uma união de palavras, escreva a primeira letra de cada palavra subseqüente em maiúsculo - camelCase: numerosPrimos, nomeCompleto.
Se a variável armazernar um valor constante, como em:
static final int NUM_DE_RODAS = 4;
a convenção muda. Capitalize todas as letras e separe as palavras por "_". Também por conveção, o "_" nunca mais é utilizado.
Tipos Primitivos
Java é uma linguagem de tipagem estática, ou seja, todas as variáveis devem ser declaradas antes de serem usadas.
// Tipo Nome Valor inicial
int primo = 7;
Java possui 8 tipos primitivos. Um tipo primitivo não é um objeto e portanto não pode compartilhar estados(campos) com otros tipos primitivos.
Data Type Range
-----------------------------------------------
|boolean | boolean, true/false ||--------- |------------------------------------|
|char | 16-bit, Unicode '\u0000' |
| | ... '\uffff' | |--------- |------------------------------------| |byte | 8-bit, -127 | | | ... 127 |
|--------- |------------------------------------| |short | 16-bit, -32.768 || | ... 32.767 |
|--------- |------------------------------------||int | 32-bit, -2.147.483.648 |
| | ... 2.147.483.647 |
|--------- |------------------------------------| |long | 64-bit, -9.223.372.036.854.775.808 |
| | ... 9.223.372.036.854.775.807 |
|--------- |------------------------------------||float | 32-bit, IEEE 754 floating point |
|--------- |------------------------------------||double | 64-bit, IEEE 754 floating point |
-----------------------------------------------
Além dos 8 tipos primitivos Java provê o tipo cadeia-de-caractere (corda/cordão/String) de modo tão intuitivo que você pode se sentir tentando a chama-lo de tipo primitivo, mas não é. String é um objeto imutável, ou seja, uma vez criado, seus valores não podem ser mudados.
String frase = "Java Language";
Valores Padrão/Default Values
Não é preciso fixar um valor na declaração de campos/fields. Todo campo declarado e sem inacialização explícita é inicializado pelo compilador com valores padrão. Entretanto, confiar neste recurso é considerado um mau estilo de programação.
Data Type Default Value(for fields)
--------- -------------------------
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char '\u0000'
boolean false
Object null
Atenção: O mesmo não ocorre com variáveis locais/parâmetros, já que o compilador nunca fixa um valor padrão para estes caso não tenham sido explicitamente inicializados. Por isso, o acesso à variáveis locais/parâmetros não inicializados gera um erro de compilação.
Inicialização
Você já deve ter notado que a palavra "new" não é usada para inicializar uma variável de tipo primitivo. Tipos primitivos são tipo de dados especiais construídos dentro da linguagem, eles não são objetos criado por classes. Um literal/literal (cuidado, não estou falando de String, apesar de ser uma cadeia de caracteres) é a representação em código fonte de um determinando valor.
//Keyword name literal
boolean result = true;
char letter = 'C';
byte b = 100;
short s = 10000
int i = 100000;
Literais inteiros
//Tipo nome literal-inteiro
long longo = 10000L; // Use L maiúsculo
// para não confunfiar com 1
int decVal = 26; // 26 em decimal
int hexVal = 0x1a; // 26 em hexadecimal
int binVal = 0b11010; // 26 em binário
Literais reais
//Tipo nome literal-real
float f1 = 123.4f;
double d1 = 123.4;
double d2 = 1.234e2; // Notação Científica
// mesmo valor de d1
Literais numéricos
Do Java SE 7 em diante, podemos usar o "_" para separar dígitos em literais numéricas, aumentando a legibilidade. Não podemos iniciar um literal numérico com "_", ou usá-lo adjacentemente à vírgula decimal ou a um prefixo/sufixo.
long cartao = 1234_5678_9012_3456L;
long cpf = 999_999_999_99L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;
Literais e caractere de escape
Literais do tipo "char" e "String" podem contar qualquer caractere Unicode (UTF-16). Use aspas simples para valores do tipo caractere/char e aspas duplas para Strings.
String s = "S\u00ED se\u00F1or"; // "Sí Señor"
char c = '\u0108'; // "C" com acento
String o = null; // Objeto nulo
/* // Estamos dentro de uma bloco de comentário
Escape Resultado
\b Backspace
\t Tab
\n Nova Linha
\f Form Feed*
\r Retorn de carro
\" Aspas duplas
\' Aspas simples
\\ \
*Form Feed não funciona no Prompt de Comando do Windows,
porém funciona normalmente em ambientes Unix e impressoras.
*/
Literal de classe
Sinceramente, não entendi muito bem... segue o trecho:
"Finally, there's also a special kind of literal called a class literal, formed by taking a type name and appending '.class'; for example, String.class. This refers to the object (of type Class) that represents the type itself."
Vetores/Vectors e Matrizes/Arrays
Um vetor é um objeto contêiner que armazena um número fixo de valores do mesmo tipo. O tamanho/length de um vetor é determinado no momento de sua criação.
int[] vetor;
vetor = new int[5];
vetor[0] = 1; // Primeiro Elemento
vetor[1] = 2;
vetor[2] = 4;
vetor[3] = 8;
vetor[4] = 16; // Último Elemento
int[] meuVetor = {2,3,5,7,11,13,17,19};
int[][] matriz = {{"Oi ","Olá "},{"Sr.","Sra."}};
String a = matriz[0,0] + matriz[1,0];
String b = matriz[0,1] + matriz[1,1];
System.out.println(a); // Oi Sr.
System.out.println(b); // Olá Sra.
int lista[]; // Outra declaração possível
// para um vetor, porém, de uso desencorajado.
É hora de revisão
Existem 4 tipos de variáveis em Java: de classe, de instância, de parâmetros e de métodos.
Variáveis de Classe/Static Fields são declaradas com o modificador "static", forçando sempre haver apenas uma região de memória comum a todas instâncias desta mesma classe-objeto.
Variáveis de Instância/Non-Static Fields são espaços únicos de memória para cada instância. Cada nova instância ganha novos espaços de memória.
Parâmetros são variáveis de escopo restrito a seus próprios métodos.
E por fim, Variáveis Locais existem da mesma forma que os parâmetros, só são visíveis no interior dos métods.
Links:
"Fear and Loathing in Typeland", by Robert Cooper in Opinion
http://www.oreillynet.com/onjava/blog/2007/01/fear_and_loathing_in_typeland.html
abraços
Nenhum comentário:
Postar um comentário