1.1.1-Quanto á atribuição de valores:
Devemos levar em conta que uma variável é um nome associado a uma posição (endereço hexadecimal) de memória.Na sua declaração, o compilador "arranja" (aloca) um espaço para ela. A variável tem um tipo associado, por vezes conhecido como "tipo em tempo de compilação", que possui um dos tipos anteriormente citados.Uma variável de um tipo primitivo sempre armazena um valor de seu tipo exato.Em uma variável de tipo referência, deve-se ter uma atenção especial:
-Se ela é uma variável de referência do tipo Classe:
Considerando uma classe Guj, ela pode armazenar uma referência a null ou uma referência a uma instância de Guj, ou qualquer subclasse de Guj.
-Se ela é uma variável de referência do tipo Interface:
Ela pode armazenar uma referência a null ou uma referência a qualquer instância de qualquer classe que implementa essa interface.
-Se ela é referência do tipo Objeto:
a) Se ela é pertencente a um Array:
Se x é de um tipo primitivo então uma variável do tipo Array de x, pode armazenar uma referência a null ou uma referência a qualquer Array do tipo "Array de x"; se x é do tipo referência, então a variável do tipo "Array de x" pode armazenar uma referência a null, ou uma referência a qualquer Array de um tipo y, considerando que y tem tipo atribuível à x.
b) Se ela é um Objeto:
Uma variável do tipo Object pode armazenar uma referência a null ou uma referência a qualquer Objeto; seja instância de uma Classe, Interface ou Array. Nunca é demais lembrar que Object é a superclasse de todas as outras classes.Portanto, qualquer classe que o leitor crie, já é herdeira (é uma subclasse) de Object e seus respectivos 11 métodos.
1.1.2-tipos identificáveis em uma classe:
Existem 7 tipos de variáveis identificáveis em uma classe Java.São eles:
1-Variável de Classe:
É um campo declarado com a palavra-chave static dentro de uma declaração de classe, ou com (ou sem) static dentro de uma declaração de interface.
2-Variável de Instância:
É um campo declarado dentro de uma declaração de classe sem a palavra-chave static.
3-componentes de um Vetor(Array):
São variáveis sem nome que são criadas e inicializadas com valores padrão sempre que um novo objeto que é um array é criado.
4-parâmetros para método:
São nomes de argumentos cujos valores são passados para um método.Para cada parâmetro declarado em uma declaração de método, uma nova variável de parâmetro é criada cada vez que um método é invocado.
5-parâmetros para Construtor:
São nomes de argumentos em que seus valores são passados para um construtor. Para cada parâmetro declarado em uma declaração de um construtor, uma nova variável de parâmetro é criada cada vez que uma instância é criada ou uma chamada explícita ao construtor é executada.
6-parâmetro para tratar uma exceção:
É criado cada vez que uma exceção é capturada por uma cláusula catch em um bloco try-catch. A nova variável é inicializada com o Objeto associado com a exceção.
7-variáveis locais:
São variáveis locais aquelas limitadas ao escopo (alcance) de uma instrução ou método. Quando um fluxo de controle entra em um bloco ou uma instrução for, uma nova variável é criada para cada variável local declarada nessas instruções ou campos. Uma instrução de declaração de uma variável local pode conter uma expressão que inicializa a variável. Uma variável local com uma expressão de inicialização não é inicializada, entretanto, até a sua instrução de declaração que a declara ser executada. Se não fosse uma excepcional situação, poderíamos dizer que uma variável local é sempre criada quando uma instrução ou bloco a qual foi declarada é executada. Uma excepcional condição ocorre quando em uma instrução switch, aonde é possível o controle de entrada no bloco pular a execução de uma instrução que declara uma variável local.Seu ciclo de vida é no máximo o método a qual está inserida.
Vejamos um simples código para reforçar o que foi escrito:
import java.io.*;
public class Variaveis{
private float sal; //1
private static String nome; //2
private final static int ID=10; //3
Variaveis(){ //4
} Variaveis(float x,String y){ //5
this.sal=x;
this.nome=y; }
public static void main(String []args){
Variaveis v = new Variaveis(); //6 v é local a main
v.sal=5000; nome="Paulo"; Object o[] = new Object[]{"J","U","G"}; //7
exibir(o);//8
System.out.println(+v.sal); //9
System.out.println(nome); //10
System.out.println(id); //11
try{ //12
PrintWriter grava = new PrintWriter(new FileWriter("c:\\entrada.txt"));
grava.println("Registro :"+id);
grava.println("Nome :"+nome); grava.println("Salario :"+v.sal);
grava.close(); } catch(Exception erro){ //13
erro.printStackTrace();
System.err.println("Erro de Arquivo!");
}
} protected static void exibir(Object []object){ //14
for(int i=2;i>=0;i--){System.out.print(object[i]); }
System.out.println();
}
} //fim da classe Variáveis
Nessa classe temos a presença de vários tipos de variáveis.Vamos analisar cada trecho (siga os comentários numerados):
Em (1), temos uma variável de instância sal do tipo float;
Em (2), temos uma variável de classe (repare o static) chamada nome do tipo String;
Temos em (3) uma outra variável de classe (ID) com a palavra-chave final.Isso indica que a ela só pode ser atribuído um valor uma única vez.E uma vez atribuído, ela terá sempre esse mesmo valor (é uma constante).
Temos em (4) e (5) um construtor vazio (sem parâmetros) e um recebendo os parâmetros de construtores x e y respectivamente.Esse trecho de código referentes a construtores é totalmente desnecessário (é apenas para ilustrar o tipo de variável), pois nenhuma variável é passada na criação da instância de classe em (6). Poderia deixar sem construtor nenhum, pois java proveria um vazio para classe. Mas jamais poderia deixar somente o construtor com parâmetros -em (5)-, pois daria um erro de compilação, uma vez que em (6):
Variaveis v=new Variaveis();
Nenhum valor é passado a instância da classe criada no método main!
Nota:v é uma instância de classe, mas é local a main, ela pode acessar variáveis de classe e de instância, mas não pode ser acessada de lugar algum senão o próprio método em que é criada.
Continuando:
Em v.sal=5000; atribuímos a variável de instância sal o valor 5000
repare que é necessário utilizar uma instância da classe (v) para acessar sal.Isso ocorre porque ela não é estática (static).Em nome= "Paulo"; podemos atribuir diretamente porque ela é de classe.Esse modificador(static) garante á variável que só haverá uma instância dela em memória.
Em (7), criamos um array do tipo Object cujos índices receberam J, U e G como parâmetros.
Em (8), fazemos uma chamada ao método exibir() passando a variável de referência o como parâmetro.
Em (9), (10) e (11) passamos parâmetros ao método println() para mostrá-los na tela.Repare que as duas variáveis de classe (com o static) são passadas diretamente (sem a variável de referência v), sal, que é de instância, precisa ser acessada da forma objeto.variável;
Em (12), temos o início de um bloco try-catch, try tenta executar o código para gravar um arquivo de texto em disco. Para isso usamos um reescritor de caracteres da classe java.io.FileWriter (por isso é necessário dar um import java.io.*; e uma instancia chamada grava de java.io.PrintWriter que através das chamadas ao método println(parametro) nos permite gravar em disco os dados.Logo depois fechamos o recurso utilizado através de grava.close();
Colocando o programa para executar( javac Variaveis.java ) Será visto na tela:
GUJ
5000.0
Paulo
10
E, no seu drive C: será criado o arquivo entrada.txt com os dados:
Registro :10
Nome: Paulo
Salario :5000.0
Nota-se que na tela e no arquivo o numero inteiro 5000 passado a float sal foi convertido para 5000.0. Isso ocorre porque a conversão do tipo float para int é permitida.Veremos uma tabela de conversão de tipos primitivos no final desse tópico.
Em (13), temos uma cláusula catch com o parâmetro erro (do tipo Exception).Se um erro ao tentar gravar esse arquivo entrada.txt ocorrer, a execução do programa será desviada para catch,e a chamada a erro.printStackTrace(); exibirá na tela a pilha de erros a partir do ponto em que ocorreram.A chamada a System.err.println() é somente para tornar mais explícita (e personalizado)ao programador que um erro ocorreu.
E temos, finalmente em (14), o corpo do método exibir() que recebe um array de Object como parâmetro, conta seus índices do final para o início, para mostrá-los na tela(transformará J,U,G em GUJ).
Nesse exemplo( Variaveis.java) vimos vários tipos de variáveis, mas devemos observar que isso é apenas um humilde pedaço do poderoso mundo que é Java.
No que tange a variáveis vale a pena salientar que:
-Quando instanciamos uma variável com um Objeto associado, essa variável não guarda o próprio objeto, e sim um endereço (uma “referência”) para esse objeto ser acessado na memória.
-Uma dada variável não pode ser declarada mais de uma única vez, ou ocorreria um erro de compilação. Ela pode ser inicializada uma única vez, e escrita/lida quantas vezes for necessário.
-O custo de declarações locais é NULO em termos de instruções utilizadas pela CPU para alocação de espaço. Já o custo de inicializar essas variaveis deve ser considerado.
-variáveis locais também são chamadas de variáveis de pilha, temporárias e ou de método.
-Variáveis de instância também são chamadas de atributos, propriedades ou campos.
-Uma variável de instância e uma variável de método podem possuir o mesmo nome; nesse caso uma referência this deve ser usada dentro do método a onde está localizada a variável local para chamar a variável de instância.(this faz referencia ao objeto "classe" a qual está inserido).
-Toda variável local tem que ser inicializada antes de ser usada.
-Variáveis de Instância são inicializadas com valores padrão caso não seja feito explicitamente pelo Programador assim que um objeto da classe a qual está inserida é instanciado.
-Variáveis de um tipo mais restritivo (por exemplo int) não podem receber um conteúdo de um tipo mais abrangente(por exemplo double), pois dará erro de compilação!Será necessário uma coerção (ou casting) para permitir isso. Ex: double d=(double)i; //onde i é um inteiro
Vejamos uma tabela de valores default de variáveis não explicitamente inicializadas:
short=0
int=0
long=0l
float=0.0f
double=0.0d
char='\u0000'(caracter null)
boolean=false
O número de conversões e tipos são tão grandes em Java, que esse assunto merece um tutorial á parte só para isso.Por hora, mostraremos uma tabela com as conversões permitidas entre os tipos primitivos (as que ocorrem com mais frequência) em seus programas Java, só a título de curiosidade:
Comversão de ampliação de tipo primitivo(são 19 possíveis):É permitido de:
byte para short,int,long, float ou double
short para int,long,float ou double
char para int,long, float ou double
int para long,float ou double
long para float ou double
float para double
Nota: Conversões de Ampliação de um tipo numérico primitivo não causam perda no valor da ordem de grandeza da variável, desde que ela(a classe ou método) esteja com o modificador strictfp, que força todos os métodos a aderirem as regras IEE754, tornando possível saber o comportamento de números double ou float, independente da plataforma.Caso não esteja com esse modificador, poderão ocorrer perdas em números float e double.Em números int e long, o uso de strictfp evita uma perda de valores na sua conversão para float ou double arredondando para um valor válido mais próximo possível.
byte para char
short para byte ou char
char para byte ou short
int para byte,short ou char
long para byte,short,char ou int
float para byte,short,char,int ou long
double para byte,short,char,int,long ou float
Nota: Conversões de Redução de um tipo numérico primitivo podem causar perdas na ordem de grandeza da variável e perder a precisão quanto ao seu valor real.
Obs: Variáveis de instância e métodos, também são chamados de membros de classe e podem fazer uso de modificadores de acesso, ao contrário das variáveis locais.Veremos mais sobre o assunto no próximo tópico.
No comments:
Post a Comment