Como configurar a máquina .virtual java jdk7.0.1 no Windows 7

Amigos  vou fazer 60 anos no dia 14 de outubro. Hoje é dia 3 de outubro. Com essa idade resolvi estudar análise de sistemas. Um curso de nível superior da Estácio. O pessoal foge desse curso porque acham que  é coisa de maluco. Acham muito difícil. Realmente eu venho estudando bem. Já passei por barreiras bem difíceis, mas esse período está sendo para mim especialmente difícil. 

A faculdade resolveu colocar sete matérias no período em vez das três em média tradicionais. É bem verdade que aumentou também o tempo de curso que antes era três meses e agora é seis meses, mas o ritmo continuou o mesmo uma web aula por semana, mais uma aula teletransmitida por semana para cada matéria. 

Em menos de dois meses querem empurrar pela nossa cabeça a dentro linguagem de programação Java, para quem nunca programou, projeto de banco de dados, teste de software, medidas de esforço de software, entre outras matérias. É coisa para NERD.

Apesar de tudo eu resolvi adotar JAVA como a linguagem que eu pretendo estudar. Porque eu a vejo como a linguagem que realmente irá dominar no futuro. Portabilidade é a principal razão. Ela roda em tudo o que é sistema desde Mac OS até Open Solaris, passando logicamente pelos tradicionais LINUX e Windows.

Bem, essa matéria é para explicar como configurar seu sistema operacional Windows 7 para rodar a máquina virtual JAVA. Há vários tutoriais  sobre isso na Internet, mas eu vou colocar o meu porque a forma plenamente correta eu não encontrei. Sempre com uma ou outra diferença. Dessa forma fica registrado para minha própria consulta e irá atrair outros que tiverem a mesma dificuldade se estiverem dando seus primeiros passos com a linguagem JAVA.

Não é preciso dizer para o iniciante que é preciso instalar a jdk. No caso escolhi a mais recente  que é a versão "jdk1.7.0" .

Como ambiente de desenvolvimento todos os iniciantes estão escolhendo o NETBEANS, também na versão 7.

Primeiramente faça o Download e instale e deixe que sejam instalados nos diretórios (pastas) padrão.

No caso as pastas serão:

• Program Files/java/jdk1.7.0
• Program Files/java/jre7

A seguir no Windows 7 acesse:

INICIAR/PAINEL DE CONTROLE/SISTEMA E SEGURANÇA/SISTEMA/CONFIGURAÇÕES AVANÇADAS DE SISTEMA

Clique na ABA AVANÇADO. Clique no botão VARIÁVEIS DE AMBIENTE.

Em variaveis do sistema clique em "NOVA"
Coloque o nome da variavel como "ClassPath"
Em valor da variável coloque de acordo com as pastas padrão.

;C:\Program Files\Java\jdk1.7.0\src.zip;C:\Program Files\Java\jdk1.7.0\lib\tools.jar;.

Coloque do jeito que está acima, com os “;” e com o ponto final. Lembre-se que todas as variáveis de ambiente PATH devem ser separadas por um ponto e vírgula ";" e ao final não deixe de acrescentar também  o ";" (ponto e vírgula), e o ponto final.

Clique em Ok. Agora vamos configurar a variável Path que está em Variáveis do sistema também…



Você seleciona a variável Path e clica em Editar, em Valor da variável você vai ACRESCENTAR (nada de apagar valores) o seu endereço do jdk, se as pastas forem as padrão, ficará assim:



;C:\Program Files\Java\jdk1.7.0\bin



o “;” é necessário e o “bin” depois do
endereço também!

Em variaveis de usuário mais em cima  clicar em NOVO e depois em editar.

Em Variavel coloque JAVA_HOME. E em valor o seguinte:

c:\Program files\java\jdk1.7.0


Recomendamos reiniciar a máquina

Para testar, abra o prompt do DOS e digite "java -version"

A seguir digite "javac".

Se o resultado for esse ai abaixo, tudo bem.

Caso contrário revise as digitações. Um simples espaço põe tudo a perder.

a palavra reservada "static"

Não sou especialista em JAVA. estou aprendendo, e como aprendiz não tenho condições de postar nada como se soubesse. Portanto vou colocar aqui as minhas dúvidas e procurar discuti-las com os que se interessarem. Esse blog procura mostrar as dificuldades de um iniciante, e auxiliar os mais espertos a entender essas dificuldades.

Os posts aqui colocados poderão ser tirados da Internet e nesse caso eu citarei as fontes.

Veja que eu gosto de entender o que está sendo programado. Cada virgula, cada palavra. e quando encontro algo que não entendo, eu paro. Não vou adiante, até entender o raio daquela palavra ou virgula ou seja lá o que for.
Foi quando me deparei com a seguinte linha:

 public static void main(String[] args) {


para quem está acostumado a programar, essa expressão está para lá de manjada, e eu entendo quase tudo, senão vejamos.

public - Refere-se a um método public, ou seja aquele método que dá acesso a tudo, completamente desnudo vamos dizer assim.
void - significa que é um método sem retorno. Se tivesse retorno iria executar um processamento e retornar alguma coisa. Um valor ou uma string. Se não retorna nada é VOID..
 main - É a função principal. A função raiz de onde todas as outras derivam.

Coisa que não entendi.

static e (String[] args) {

Ato contínuo ==> GOOGLE e colocamos na busca static + java.

De primeira encontrei essa excelente explicação.

ENTENDI TUDO

Entendendo static

em 14/02/2003 , por Rafael Steil 

Quando e porquê usar static? static é uma das palavras-chave do Java, e é também motivo de muita confusão e dúvidas entre o pessoal que esta começando. Aliás, mesmo os mais experienciados confundem-se às vezes em usar ela. O método static mais famoso de todos é o main. É através dele que vimos nosso primeiro programa em Java nascer, e é sempre via main que nossos programas criam vida. Por definição da linguagem Java, o métodomain precisa necessariamente ter acesso public, ser static, não retornar coisa alguma ( void ) e receber como argumento um array de String ( String args[] ): 

view plainprint?

1. public static void main(String args[])  

Entendendo static

Como regra geral, tenha isso em mente: dentro de métodos static somente é possível pode acessar outros métodos e variáveis que também sejam static. Dentro do método pode-se definir qualquer tipo de variável, static ou não. Caso seja necessário acessar algum método ou membro não-static, é necessário criar uma instância da classe e então chamar o que quiser. Já o contrario é um pouco diferente: dentro de membros não-static, é possível acessar tanto propriedades static quanto as não-static. O fato de ser preciso primeiramente criar uma instância da classe para só então chamar algum método não-static ou acessar uma variável comum dentro de um métodostatic deve-se ao fato que dentro dele não existe uma referência para o ponteiro this. O ponteiro this é utilizado para referenciar propriedades da classe em que estamos trabalhando. Por exemplo: 

view plainprint?

1. ...  
2. // Variável simples, para guardar o nome  
3. private String nome;  
4.   
5. // Algum método comum  
6. public void meuMetodo()  
7. {  
8.     this.nome = "Fulano";  
9. }  

No exemplo acima, this.nome = "Fulano" diz que estamos atribuindo ao membro da classe chamado nome o valor "Fulano". O uso de this é automático, portando o exemplo acima poderia ser escrito simplesmente da forma 

view plainprint?

1. ...  
2. // Variável simples, para guardar o nome  
3. private String nome;  
4.   
5. // Algum método comum  
6. public void meuMetodo()  
7. {  
8.     nome = "Fulano";  
9. }  

Note que agora não mais usamos this, e funciona da mesma maneira. Se o método meuMetodo fosse static, o código acima não funcionaria, pois como foi dito antes, métodos static não possuem this. Ao contrário do que o nome soa, static não significa que a variável ou método sera estática do ponto de vista que seu valor não pode mudar ( final é usado para estes casos ). static nos garante que somente haverá uma, e não mais que uma, referência para determinada variável ou método disponível em mémoria. Em outras palavras, declarando alguma coisa como static, todas as instâncias da classe irão compartilhar a mesma cópia da variável ou método. Declarar algo como static também permite você acessar as coisas diretamente, ou seja, sem precisar criar uma instância da classe. Existe inclusive um Design Patter baseado no uso de static: Singleton.

Exemplificando

Para entender melhor tudo o que foi dito, nada melhor que alguns exemplos práticos para ver com os próprios olhos o funcionamento. O primeiro exemplo consiste em uma classe com 2 variáveis, uma static e outra não-static. A cada novo objeto criado, incrementados ambas variáveis e imprimimos o resultado na tela. Digite o seguinte código em um arquivo chamado "TesteStatic.java": 

view plainprint?

1. // TesteStatic.java  
2. class Classe1  
3. {  
4.     // Variavel static  
5.     public static int contador = 0;  
6.   
7.     // Variavel nao-static  
8.     public int outroContador = 0;  
9.   
10.     public Classe1() {}  
11.   
12.     // Precisa ser static porque "contador" é static  
13.     public static void incrementaContador()  
14.     {  
15.         contador++;  
16.   
17.         System.out.println("contador agora é "+ contador);  
18.     }  
19.   
20.     public void incrementaOutroContador()  
21.     {  
22.         outroContador++;  
23.   
24.         System.out.println("outroContador agora é "+ outroContador);  
25.     }  
26. }  
27.   
28. public class TesteStatic  
29. {  
30.     public static void main(String args[])  
31.     {  
32.         Classe1 c1 = new Classe1();                       
33.         c1.incrementaContador();  
34.         c1.incrementaOutroContador();  
35.   
36.         Classe1 c2 = new Classe1();  
37.         c2.incrementaContador();  
38.         c2.incrementaOutroContador();  
39.           
40.         Classe1 c3 = new Classe1();  
41.         c3.incrementaContador();  
42.         c3.incrementaOutroContador();  
43.   
44.         Classe1 c4 = new Classe1();  
45.         c4.incrementaContador();  
46.         c4.incrementaOutroContador();  
47.     }  
48. }  

A saida gerada por este programa será 

view plainprint?

1. contador agora é 1  
2. outroContador agora é 1  
3. contador agora é 2  
4. outroContador agora é 1  
5. contador agora é 3  
6. outroContador agora é 1  
7. contador agora é 4  
8. outroContador agora é 1  

Note que a variavel "contador", que é static, não teve seu valor zerado a cada novo objeto criado da classe Classe1, mas sim incrementado, enquando "outroContador", que é uma variável comum, ficou sempre em 1, pois a zeramos o valor no construtor da classe.

Acesso direto

Ao contrário de tipos de dados não-static, qualquer variável ou método static podem ser acessado diretamente, sem necessitar de uma instância da classe criada: 

view plainprint?

1. // TesteStatic2.java  
2. class Classe2  
3. {  
4.     // Escreve alguma frase na tela  
5.     public static void escreve(String msg)  
6.     {  
7.         System.out.println(msg);  
8.     }  
9.       
10.     // Retorna a multiplicação de dois números int  
11.     public static int multiplica(int n1, int n2)  
12.     {  
13.         return (n1 * n2);  
14.     }  
15.       
16.     // Construtor, apenas para mostrar que  
17.     // ele nem chega ser chamado  
18.     public Classe2()  
19.     {  
20.         System.out.println("Construtor de Classe2");  
21.     }  
22. }  
23.   
24. public class TesteStatic2  
25. {  
26.     public static void main(String args[])  
27.     {  
28.         Classe2.escreve("Multiplicando 3 vezes 3:");  
29.         int resultado = Classe2.multiplica(3, 3);  
30.         Classe2.escreve("Resultado: "+ resultado);  
31.     }  
32. }  

Rode este programa e repare no resultado. Veja que o construtor da classe não foi chamado, pois não aparece na tela a string "Construtor de Classe2". Repare também que não criamos instância alguma de Classe2 para chamar seus métodos. Caso os métodos escreve e multiplica não fossem static, seria necessário fazer 

view plainprint?

1. public class TesteStatic2  
2. {  
3.     public static void main(String args[])  
4.     {  
5.         Classe2 c2 = new Classe2();  
6.         c2.escreve("Multiplicando 3 vezes 3:");  
7.         int resultado = c2.multiplica(3, 3);  
8.         c2.escreve("Resultado: "+ resultado);  
9.     }  
10. }  

Note que o código acima funciona perfeitamente mesmo com os métodos static. Isso funciona porque apesar de podermos chamar diretamente as coisas quando elas são static, não é obrigatório, podendo perfeitamente ser criada uma instância da classe e então chamar os métodos. O uso de static depende muito do caso, e conforme você vai pegando mais experiência, irá naturalmente identificar os lugares que precisam - ou que são mais convenientes - ao uso de tal palavra-chave. Caso tenha alguma dúvida, não hesite em postar no fórum do GUJ. Abraços e até a próxima.