Certificação Java SE 7 Programmer I

Defina o escopo de variáveis - Defina o escopo de variáveis

Nessa sessão da prova, será cobrado do aluno definir o escopo de existência de uma variável. A variável existe a partir de quando até quando?

Se falarmos de escopo de variáveis, o primeiro escopo que falaremos é o escopo de uma variável local, a variável local existe, é declarada dentro de um método ou de um construtor. E ela vai existir dentro do bloco que foi criada. O que é o bloco que ela foi criada?

São as chaves, as últimas chaves que criaram aquela variável, basicamente é isso. Vamos ver os vários exemplos de variável local e de onde e até onde ela existe?

Então aqui dentro da minha classe de teste eu vou instanciar a minha classe de teste Teste t = new Teste();. E vou chamar o método m1 t.m1();. Dentro desse método m1, eu vou escrever o código que eu quiser, public void m1() {.

Claro que toda variável que eu definir aqui dentro vai ser uma variável local. Se eu declarar uma variável int x = 10, eu consigo imprimir ela aqui dentro porque a variável x existe dentro desse método, que é o bloco dentro deste bloco int x =10; System.out.printIn(x), essa variável x existe.

Vamos testar? Vou ao terminal, javac Teste..java "Enter", java Teste "Enter". 10. Dentro desse bloco dentro desse método eu posso ter outros blocos como, por exemplo, um if(x >= 10), que é verdadeiro, sabemos disso, eu declaro a variável y int y = 50. Dentro desse bloco vai existir a variável System.out.printIn(y);.

Vamos testar? No terminal javac Teste.java "Enter", compilo e rodo java Teste "Enter". A variável y existe, a variável x existe.

A variável y não existe fora desse bloco, por quê? Porque ela foi definida dentro do bloco do if, ela não existe fora do bloco do if, ela morre logo depois Teste.java "Enter".

Vamos tentar compilar e dá o erro na linha 11. Não foi capaz de achar a variável y, o símbolo y. Linha11, o símbolo y não existe, ele só existe dentro deste bloco.

Uma variável local é definida dentro de um bloco e ela só existe dentro daquele bloco. Muito cuidado também no caso do for, se eu fizer um for, eu posso fazer um for clássico que é for(int i=0;i<=10;i++).

Mas vamos supor que eu quero colocar uma variável a mais aqui, eu declaro outra variável j=0. E eu vou somar essa variável como j++. Essa variável j está disponível fora do meu for? System.out.println(i); "Enter". E a variável i está disponível fora do meu for? System.out.println(j);

Salvo e tento compilar, Teste.java "Enter". Quando eu tento compilar ele fala que nem a variável i e nem a variável “j” existem fora do meu for. Por quê? Porque nesse meu caso, apesar de eu não ter usado as chaves, lembra que as variáveis foram declaradas dentro do for, tanto o i quanto o “j” foram declarados dentro do meu for.

O meu escopo é o escopo do for, por mais que as chaves não estejam definidas, não estejam explicitas, as chaves do for estavam implícitas, elas estavam aqui, tanto a variável i quanto a variável j só poderiam ser usadas aqui dentro e não fora.

Cuidado com o caso do for que é um caso especial. Mesmo sem as chaves temos que lembrar que a variável só vai existir dentro do escopo do for. Se você só tiver uma linha, essa linha é o escopo do meu for, não consigo acessar ele fora.

Além do for, do if e outros blocos que eu posso ter dentro de um método, eu posso ter também diversos métodos, por exemplo, o método 1 que recebe uma string e um parâmetro public void m1(String nome) {, System.out.pintln(nome);.

Um parâmetro também é uma variável local, se ele também é uma variável local, ele só vive, essa variável só existe dentro deste bloco, dentro deste método. Quando eu chamar o método t.m1("guilherme");, essa variável existe. Vamos testar? Compilo Teste.java "Enter" Teste "Enter" e rodo.

Mas se eu tiver outro método, agora um public void m2() {}. E dentro do método m2, eu tento imprimir o meu nome System.out.println(nome);. Eu chamo o m1 com essa variável, t.m1("guilherme"); e chamo o m2 sem nada t.m2();. Quando eu tento compilar Teste.java "Enter", nome não existe.

Por que o nome não existe aqui dentro? Porque uma variável local só existe dentro do bloco que ela foi acessada. Uma variável parâmetro foi definida dentro do método, só existe dentro deste método. Então eu não posso acessar essa variável aqui dentro do outro método, não tenho mais acesso a essa variável.

Mesmo que o método m1 chamasse o método m2, m2(); aqui dentro, eu não tenho acesso à variável. Vamos testar? Teste.java "Enter". Tento compilar, mesmo erro, nome não está acessível.

Por quê? Porque a variável nome só pode ser acessada aqui dentro, m2 é outro método. Dentro do m2 quais são os locais que eu tenho? Nenhuma. Não tenho parâmetro, não tenho definição de variável local nenhuma, eu não tenho acesso à variável nome aqui dentro.

Uma variável local, parâmetro ou definida dentro do método só pode ser acessada ali dentro, no momento em que você chamou outro método variáveis locais não pode mais ser acessadas. É claro, a variável nome continua existindo após chamar o método m2, ela existe tanto antes quanto depois, mas quando eu chamo o método eu não posso mais acessá-la.

Ela só pode ser acessada dentro do escopo em que ela foi definida, ela foi definida dentro do método m1, ela só pode ser acessada dentro do método m1. Na hora em que eu chamo o método m2, eu já estou dentro do método m2, outro escopo, não posso mais acessar aquelas variáveis locais. Tento compilar de novo Teste.java "Enter", compila. Tento rodar Teste "Enter". E ele imprime.

Dentro do método m1 posso acessar as variáveis definidas? Dentro do método m1. Dentro do método m2 posso acessar as variáveis definidas? Dentro do método m2.

A mesma coisa vai valer para os construtores, se void m1 é um construtor, public Teste(String nome). Dentro do método m2 eu não posso chamar a variável. Quando eu chamar o construtor Teste, eu passo um nome e ele imprime.

Quando eu chamar o método m2, não posso acessar. Tento compilar, Teste.java "Enter". Está ok. Teste "Enter". Roda bonito.

Se eu tentar aqui dentro acessar uma variável que não foi definida aqui dentro Teste.java "Enter". Não compila.

Recapitulando, variável local é a variável que foi definida dentro de um método ou construtor e essas variáveis locais só poderão ser acessadas dentro daquele escopo em que elas foram definidas, se o escopo é o próprio método ou o próprio construtor, através de um parâmetro, ou definidas, jogadas naquele método ou construtor, é aquele método ou construtor inteiro

Se é dentro de um if, dentro de um for, dentro de um io é só naquele escopo do if, do for ou do io, não posso acessar depois.

O segundo tipo de variável em que temos que nos preocupar com escopo é a variável de instância, ou variável de objeto, às vezes também chamada de atributo, ou variável membro.

A variável de instância e objeto é declarada dentro da classe, isso é, aqui dentro String nome;. Quando eu tenho uma variável de instância, ela pode ser acessada em qualquer lugar dentro do meu objeto, dentro da minha classe desde que eu tenha um objeto instanciado porque ela é uma variável do meu objeto.

Por exemplo, se eu defino que a string tenha o valor guilherme, String nome = "guilherme". Quando eu crio ele, dentro do meu construtor, eu posso acessar essa variável de objeto, System.out.println(nome).. Variável de instância ou de objeto.

Não só dentro do meu construtor, dentro de um método da minha classe, um método da minha instância, eu posso também acessar essa variável de instância, variável de objeto e imprimir o meu nome, System.out.println(nome);.

Quando eu tenho variáveis de instância, variáveis membro, variáveis do meu objeto, atributos, eu posso acessar tanto dentro do construtor quanto dentro de métodos normais.

Eu posso chamar t.m2(); que ele deve imprimir o meu nome também. Vamos testar esse código? Vou ao terminal e compilo Teste.java "Enter". E rodo a minha classe Teste "Enter". Rodo o meu programa, guilherme, guilherme. Variável de instância eu posso acessar nos dois lugares.

Posso referenciar também a minha variável de instância através de outra variável de instância, por exemplo, String nomeCompleto =nome + "silveira";. Eu tenho o meu nome completo. Vou imprimir System out.printLn(nomeCompleto);. E eu tenho que a minha variável de instância, minha variável de objeto referencia outra variável de instância, outra variável de objeto.

Posso acessar, ela foi definida dentro de uma classe como uma variável de instância, ela pode ser acessada basicamente em qualquer método ou construtor do meu objeto, exceto em métodos estáticos como veremos quando falarmos de static.

Métodos de instância e no meu construtor eu posso acessar as variáveis de instância. Vamos testar? Teste.java "Enter", compilo de novo. A variável que é o meu atributo pode acessar a minha outra variável membro, que também é atributo. Teste "Enter", vou lá e rodo.

Nomes comuns para variáveis de instância são: variável de instância, variável de objeto, atributo ou membro.

Posso acessar também a minha variável de instância através da minha instância, se eu tenho uma instância de teste eu posso chamar t.nome = "joao";. Por quê? Porque eu estou falando que a minha variável de instância é João. Eu tento imprimir um novo nome, System. out.print.ln(t.nome); que deve ser João. Guilherme, Guilherme Silveira, João.

Vou compilar Teste.java "Enter". E vou rodar Teste "Enter". “guilherme, guilherme silveira, joao”. Variável de instância nos 3 casos, posso acessar dentro do construtor, dentro do método de instância ou através da instância.

Temos também as variáveis estáticas, variáveis de classe. Nesse caso, nas variáveis de classe, vamos dar um exemplo diferente, uma classe pessoa que tem um static int id = 1;.

Aqui dentro eu vou instanciar uma Pessoa p =new Pessoa. E agora vem a dúvida, quando eu posso acessar uma variável estática, uma variável de classe? Eu posso acessar uma variável estática ou de classe através de uma instância p.id, System out.println(p.id).

Lembrando que uma variável estática, uma variável de classe, existe uma única para todos os objetos daquela classe, existe uma única para aquela classe, se eu criar 5 pessoas diferentes é uma única variável de instância, uma única variável estática que eu tenho, um único ID que eu teria. Nesse caso, eu estou acessando p.id, System.out.println(p.id);.

Posso acessar através da instância? Posso acessar a variável estática através da instância, não tem problema nenhum. Posso acessar também através da classe, já que é uma variável de classe, uma variável estática, eu posso acessar através de System.out.println(pessoa.id);.

Se eu tenho um objeto eu posso acessar através daquele objeto, através da instância. Se eu não tenho o objeto, posso acessar através da minha classe pessoa.id. Vamos testar? Eu compilo Teste.java "Enter". E eu testo, Teste "Enter".

Legal. Quer dizer que eu posso acessar variáveis estáticas através de qualquer escopo dentro de um método local, dentro de um construtor, dentro de outro método, através da referência da classe, pessoa.id, através da referência da instância, p.id.

Todos eles estão referenciando o mesmo ID, a minha variável estática que está lá na minha classe, a variável de classe, variável estática.

É claro, para acessar uma variável estática eu não preciso de uma referência para aquele objeto, uma referência para uma pessoa, eu posso diretamente acessar através da classe. Claro, eu tenho que respeitar as regras de modificadores de acesso, public, private, default, protected, que veremos na seção que cobra modificadores de acesso.

Posso acessar variáveis estáticas também através de um método estático. Se eu tenho um método estático, o meu static void metodo() {}, eu posso acessar a minha variável estática. Então System.out.println(id);, posso acessar diretamente.

Aqui eu vou chamar direto, Pessoa.metodo(). Chamo o meu método estático, um método estático pode acessar variáveis estáticas. Vamos testar? Teste.java "Enter", compilo e testo Teste "Enter".

Legal. A regra geral é: variáveis estáticas podem ser acessadas a partir de qualquer lugar desde que sejam respeitados os modificadores de acesso, você pode acessar ela através do nome da classe, nome do tipo diretamente, ou através de uma instância daquela classe, de uma instância daquele tipo. Essa é a regra das variáveis estáticas.

Se eu tenho esses diversos escopos para acessar as variáveis, será que eu posso ter duas variáveis com o mesmo nome? E duas variáveis em escopos diferentes com o mesmo nome? Existem alguns cuidados a serem tomados, cuidados que vão ser cobrados na prova, a sacada está aí, os cuidados que teremos que tomar.

O primeiro deles é: se eu tenho uma variável local com um nome eu não posso ter outra variável local naquele mesmo escopo com o mesmo nome, isso é, se eu declarar uma variável int a = 0; e outra int a = 10;, a variável a já existe como variável local nesse escopo.

Vamos ver a mensagem de erro? Teste.java "Enter". Ele tem que dar a mensagem de erro na segunda linha, quando eu tento redeclarar a variável int a.

“Variável a já foi definida dentro do método main”. Não posso. E se eu tenho um parâmetro, será que eu consigo declarar aqui uma variável local se eu tenho um parâmetro args? String args[] = null;, só para ter um valor qualquer. Será que eu posso? Vou tentar, Teste.java "Enter". Também não posso.

Afinal, a variável args já foi definida dentro do método main. Quer dizer que eu não posso ter duas variáveis locais com o mesmo nome.

Vamos ver alguns outros casos em que é proibido? Por exemplo, se eu criar uma classe Bla {, e dentro dessa classe eu ter uma variável estática static int a;, e uma variável int a;.

Não pode ter uma variável estática e uma variável membro, uma variável de instância, com o mesmo nome na mesma classe, proibido, não compila. Vamos testar? Teste.java, eu tento compilar e não pode. Já foi definida a variável a dentro da classe Bla. Mesmo que uma seja estática e a outra de instância. Eu ficaria perdido sem saber qual das duas ele está chamando.

O que mais? Não posso declarar variável local com parâmetro, como eu mostrei para vocês. E variável local com variável local.

Apesar de ser estranho, eu posso definir uma variável local e uma variável membro com o mesmo nome, isso é, se eu tenho uma classe pessoa que tem um static int x =0;. E um int y = 0;, eu posso ter um método public static void setX(, que recebe um x) {.

Eu posso ter um parâmetro, uma variável local que tem o mesmo nome que uma variável que eu já tenha de instância, ou uma variável estática.

E eu posso ter um método que receba um parâmetro ou que tenha uma variável local com o mesmo nome de uma variável de instância ou de uma variável estática, public void setY(int y) {.

Posso ter parâmetro com variável de instância, parâmetro com variável membro. Variável local com variável membro, ok. Variável local com variável de instância, ok. Variável local com variável local, não pode.

Nesse caso, por que acabamos fazendo isso? this.y = y;. Porque queremos setar essa variável, é comum termos isso, esse shadowing, a capacidade de esconder o acesso a uma das variáveis, Pessoa.x =x;.

Porque se eu acessar x diretamente eu estou acessando o parâmetro, se eu acessar y diretamente eu estou acessando o parâmetro. Se eu quero acessar a variável membro, quero acessar a variável de instância this.y. Se eu quero acessar a variável de classe, quero acessar a variável estática, Pessoa.x.

Quando temos o shadowing, quando escondemos uma das variáveis porque colocamos duas variáveis com o mesmo nome, uma de instância e uma local, uma de estática e uma local, eu vou usar o nome da classe, ou this, para dizer que eu quero referenciar essa variável.

Dessa maneira, eu consigo acessar essas variáveis. Eu posso ter variáveis locais e “variáveis membro” com o mesmo nome, posso ter variáveis locais e variáveis de instância com o mesmo nome. Vou compilar essas classes, Teste.java "Enter", e elas devem compilar.

E o que é o shadowing? O shadowing é justamente essa capacidade de esconder, se eu tenho uma classe x e dentro dessa classe x eu tenho uma variável a com valor 10, class X { > int a = 10;. Eu posso ter um método, public void metodo() {, e dentro desse método se eu fizer int a = 20; > System.out.println(a):. Quer dizer, eu escondi a variável membro “a” quando eu criei a variável local “a”.

Quer seja uma variável local como essa, quer seja uma variável local parâmetro, tanto faz, eu fiz o shadowing, eu escondi a variável membro, escondi a variável de instância. Vou testar aqui, new X().metodo();.

Ele tem que imprimir 20 porque é a variável que eu declarei por último no meu escopo local e escondi a variável membro. Vamos testar? Teste.java "Enter", compilo. java Teste "Enter". Ele roda.

Recapitulando, quando escrevemos uma nova variável com o mesmo nome, quais são os casos que eu não posso? Duas variáveis locais com o mesmo nome não pode. Variável membro e variável de instância com o mesmo nome não pode. Combinar uma variável de instância com uma variável local pode. Combinar uma variável estática com um variável local pode.

Nesses casos, temos o shadowing, que foi o que vimos nessas 3 situações. No shadowing, se acessarmos o nome daquela variável diretamente estamos sempre acessando a variável local, nunca de instância ou a de classe.

Se eu quiser forçar acessar a de instância ou a de classe, variável de instância eu uso this., variável classe usamos o “Pessoa”.

Veremos esses casos nos casos específicos de variáveis de instância e de classe mais para frente. O importante é lembrar que o shadowing faz você acessar a variável local.

Recapitulando, vimos variáveis locais, que podem ser definidas dentro de um método ou de um construtor, e elas vivem somente dentro daquele bloco, pode ser dentro de um if ou dentro de um for. Cuidado.

Vimos variáveis de instância ou “variáveis membro”, também chamadas de atributo ou variáveis de objeto. Vimos variáveis estáticas ou variáveis da classe, podem ser acessadas de qualquer lugar desde que sejam referenciadas através do objeto de uma instância ou através do nome da classe.

E vimos conflito de nomes em escopos distintos, no mesmo escopo não pode, e no escopo static e de instância não pode. Só pode no escopo de static e local ou membro e local.

Defina a estrutura de uma classe Java - Estrutura da classe Java

Nessa seção da prova seremos cobrados qual estrutura de um arquivo e de uma classe Java. Para isso, teremos um arquivo dentro desse diretório “br > com > caelum > certificação”, que eu vou chamar de “Pessoa.Java”, eu vou colocar uma class Pessoa {}.

Aqui dentro desse arquivo a primeira coisa que um arquivo Java pode ter é o pacote package br.com.caelum.certificacao;. Falaremos mais de cada um desses itens no ponto da prova que cobra cada um desses itens.

Esse ponto cobra a estrutura, o que aparece dentro de um arquivo .java e de uma classe Java. Primeira coisa, o pacote, o pacote é opcional, package e o nome do pacote, só pode ter um pacote. O pacote, que é opcional, é a primeira coisa.

Depois disso eu posso ter os imports, diversos imports, pode ter import java.util.Date;, import java.io.*;. Diversos tipos de imports que eu posso ter, porém, ele sempre vem depois do package, o package sempre é a primeira informação, opcional, mas sempre a primeira informação.

Depois dos imports, diversos imports, um import, zero import. Não importa quantos imports, mas vem os imports. E por fim, vem as minhas classes e interfaces, interface Figura {}.

Classes, interfaces, enums, e quaisquer outras coisas que teremos dentro do Java, cobradas ou não cobradas na prova, vem depois do package e dos imports.

Aonde entram os comentários? Comentários entram em qualquer lugar, inclusive antes do package, por exemplo, declaração do pacote. Um comentário desnecessário, mas para mostrar o exemplo de que o comentário pode vir antes do package.

Onde mais? Comentário pode vir antes do import? Claro, comentário antes do import. Pode vir à direita do import, direita do import. Não tem problema nenhum.

E sabemos, existem dois tipos de comentário no Java, existe o comentário de uma linha, que é o “barra barra”, tudo à direita do “barra barra” é um comentário. E o comentário do “barra asterisco”, tudo que estiver entre barra asterisco e asterisco barra é um comentário, /* tudo que estiver aqui */.

Uma variação especial do “barra asterisco”, asterisco barra é aquele que chamamos de Javadoc, que começa com “barra asterisco asterisco”. Ele é o Javadoc, /**Javadoc. Que vai servir para documentar a minha classe, os meus pacotes, as minhas interfaces, os meus métodos, etc.

Não vai ser cobrado nada específico do Javadoc na prova, só é importante saber que podemos comentar com “barra barra” em qualquer lugar, tudo que estiver a direita está comentado. Barra asterisco, que é “barra asterisco” até “asterisco barra”. E por vezes vemos “barra asterisco asterisco”. Não precisa de “asterisco asterisco” para fechar.

Comentário pode estar em qualquer lugar, inclusive, eu poderia colocar um comentário feio, mas poderia colocar na linha 10 que é a linha da classe, /* nome da classe */.

Um comentário feio, que parece estar mais atrapalhando do que ajudando, porém, ele pode aparecer em qualquer lugar.

Lógico, ele não pode aparecer no meio da palavra, mas em qualquer lugar que eu tenha uma série de espaços em branco eu vou lá e coloco o meu comentário.

Vamos compilar esse arquivo para mostrar que todos esses comentários são compiláveis? Vamos ao terminal, Javac br/com/caelum/certificacao/, temos lá dentro o arquivo Pessoa.java. Compilei esse arquivo, tudo ok.

Repara que todas essas informações podem estar contidas dentro de um arquivo .java, porém todas são opcionais, todas, sem exceção.

Por exemplo, os imports são opcionais, se eu tiver um arquivo com import ou sem import, tanto faz, posso ter com, posso ter sem. Compilo e está ok.

Classe e interface, preciso ter? Opcional, você ter como pode não ter. Estranho não ter, para que eu vou compilar um arquivo sem isso? É estranho, mas é opcional.

E o nome do pacote é obrigatório? Não é obrigatório. Tudo compila, inclusive, um arquivo vazio.

Essas 3 partes, pacote, imports e tipos, são todos opcionais. O pacote só pode ter um, mas imports e tipos, podemos ter vários. Nessa ordem especificamente, pacote, import, tipos. Comentários entram em qualquer lugar do meu código.

Quando eu não estou falando nada sobre o pacote é porque ele está no pacote padrão, o pacote sem nome, o pacote padrão. Isso é importante, package deafult, pacote padrão. Ele está no diretório raiz.

Quando eu vou colocar um arquivo dentro de um pacote, ele tem que estar dentro do diretório específico, isso é, se o meu pacote é o pacote default, pacote padrão, ele está no diretório em que eu vou compilar os meus arquivos.

Se ele está no pacote “br”, ele tem que estar dentro do diretório “br”. Se ele está no pacote “br.com”, tem que estar no diretório “br/com”.

Se ele está dentro do pacote “br.com.caelum”, tem que estar no diretório “br/com/caelum”.

E se ele está no pacote “br.com.caelum.certificacao”, ele tem que estar dentro do diretório “br/com/caelum/certificação”, porque é nesse diretório que o Java em runtime vai procurar os nossos arquivos .class.

Quando eu compilo o meu arquivo, javac br/com/caelum/certificacao/Pessoa.java. Eu já coloquei o meu .java dentro porque ele já compila os meus arquivos, isso é, o Pessoa.class e a Figura.class dentro do diretório certificação, ls br/com/caelum/certificacao "Enter".

Essa parte, a parte em que eu falo o pacote é a primeira do meu arquivo. Se eu não falar o pacote, é o pacote default, o pacote sem nome. E se eu falar o nome do pacote, eu tenho que colocar o meu arquivo.class nesse diretório, no diretório “br/com/caelum/certificação”.

Se eu tenho que colocar nesse diretório, é normal que coloquemos, quando estamos escrevendo os arquivos também nesse diretório.

E o que eu posso ter dentro de uma classe? Vou tirar os comentários e vou colocar algumas coisas dentro da minha classe, String nome;. Posso ter variáveis membro, atributos, variáveis de instância, variáveis de objeto, que são essas variáveis que eu declarei aqui dentro.

Posso ter construtores com variáveis que são parâmetros, Pessoa(String nome) { > this.nome = nome;. Posso ter métodos public String getNome () {.

Nesse meu método, eu posso ter variáveis locais, String sobrenome = "Silveira"; > return nome + sobrenome;. Eu posso ter variáveis, posso ter métodos, construtores, tudo isso dentro da minha classe.

Um cuidado que temos que ter com os nomes das classes variáveis e dos métodos é que eu posso ter uma classe chamada class B, por exemplo, que tem uma variável chamada int b; lá dentro. Não tem problema, não existe conflito entre o nome de uma variável e nome de uma classe. Mesmo que o nome da variável seja b maiúsculo, int B;.

Fugindo do padrão do Java que é uma maldade aqui nesse caso, no padrão do Java o nome de variável é minúsculo, estou fugindo do padrão de propósito para tentar fazer com que isso não compile. Mas compila. Vamos lá no terminal, eu compilo, javac br/com/caelum/certificacao/Pessoa.java "Enter". E está lá, o nome da variável com o nome da classe. Não tem problema.

E método, eu poderia ter um método chamado b também com o B maiúsculo de maldade aqui? void B(). No terminal javac br/com/caelum/certificacao/Pessoa.java "Enter". Compilo. Posso ter um nome, uma variável e a classe, tipo com o mesmo nome, não tem problema, ele compila. Não há conflito entre o nome da variável membro, o nome do método e o nome da classe.

E o construtor, como eu colocaria aqui? B() {. Repara a diferença entre o construtor e o método, muito importante. O método está falando que devolve void, o construtor não faz nada. Uma “pegadinha”, seria ter um construtor e um método com o mesmo nome, ou não colocar o construtor e fazer parecer que o método é o construtor, void B ().

Não é o construtor, está escrito void, é o método. No terminal javac br/com/caelum/certificacao/Pessoa.java "Enter". Eu também compilo, não há nenhuma interferência entre esses nomes.

Repara, o package falamos que é opcional, posso ter 1 ou 0. O import eu posso ter 0, 1 ou mais. E classes, enums, interfaces e seja lá o que for que eu posso ter aqui embaixo, quantos eu posso ter? 0 ou mais, já tive 1, já tive 2, já tive 3. Um arquivo Java pode ter vários tipos definidos lá dentro, várias classes, várias interfaces, etc.

Um cuidado importante a ser tomado é que dentro de um arquivo .java eu só posso ter uma interface, ou classe, ou tipo público. Aqui eu tive duas classes e uma interface, nenhum público, tudo padrão. Se for público, só pode ter um.

E tem mais uma regra, se ele é público ele tem que ter o mesmo nome que o arquivo, por quê? Para ficar fácil de achá-lo.

Se ele pode ser acessado em outro pacote, se ele é público, eu tenho que deixá-lo com o mesmo nome do arquivo para ser fácil de descobrir onde ele está. A regra é: eu posso ter vários e se eu tiver um público, eu só posso ter um, e o nome tem que ser igual ao do arquivo.

Os tipos das variáveis que aparecem dentro de uma classe são as variáveis de instância, que é a variável de objeto, é o atributo, é a variável membro, que precisa de uma instância de uma classe, isso é, precisa de um objeto para poder ter algum valor. Uma pessoa precisa existir para poder ter um nome.

Agora, o total de pessoas, static int totalDePessoas = 0, que começa com zero, não precisa de uma pessoa para existir, inclusive, não importa a quantidade de pessoas que você tenha, a variável total de pessoas é uma só, a variável é uma só, com valor 14, 2, 3, 4, 5, 6. Mas a variável é uma só. Essa variável é a variável estática, variável de classe.

A variável local é a variável que definimos dentro de um método ou de um construtor, inclusive, um parâmetro é uma variável local, só vai existir dentro daquele escopo.

E os métodos, que tipo de método eu tenho? Eu posso ter o meu método de instância, meu método de objeto, método normal. Quando falamos método costumamos referenciar esse tipo de método, que eu preciso de uma pessoa para poder fazer algo.

E eu posso ter o método estático, por exemplo, o que temos na classe teste que é o método main. Ele é um método estático, você não precisa criar um objeto do tipo teste para chamar o método main, você simplesmente chama o método main, teste.main.

Eu tenho também os construtores, os construtores vão ter o mesmo nome que a classe, classe e o nome dela. Eu vou ter o mesmo nome que a classe, Pessoa, Pessoa, B, B.

Mas eu não falo tipo de retorno nenhum, construtor não retorna, eu não retorno algo. Por quê? Porque o próprio construtor já está retornando uma pessoa, a pessoa que está sendo criada.

E eu posso colocar um return sem nada? Afinal, eu já estou devolvendo uma pessoa. No terminal javac br/com/caelum/certificacao/Pessoa.java "Enter". Eu posso colocar um return sem nada, o que seria interessante no caso de eu fazer um if, por exemplo, if(nome ==null). nome = "Guilherme" e um return;. Se não this.nome = nome;.

Poderia fazer isso, não tem problema o return sem valor, mas isso não significa que quando eu chamar a pessoa = newPessoa, Pessoa.p = newPessoa não vai devolver nada. Vai sempre devolver uma nova pessoa.

Cuidado, o construtor tem sempre o mesmo nome que a nossa classe e quando temos o código lá dentro do nosso construtor, não definimos retorno, não coloca que ele devolve uma pessoa, não. É como se ele fosse um método sem nome, você pode ver dessa maneira, pode olhar dessa maneira. Mas no construtor você simplesmente define o nome da classe e os parâmetros que você quer receber.

Lá dentro, se você for retornar, só pode return vazio, não pode retornar alguma coisa.

E as interfaces? Eu coloquei uma interface figura, eu poderia colocar aqui agora uma interface A {. O que uma interface pode ter? Variáveis e métodos.

Na certificação o que é cobrado que pode ter dentro de uma interface são as variáveis constantes, isso é, uma variável que é final, por exemplo, final int TAMANHO = 5;. Essa variável final não pode ter o seu valor ou a sua referência alterada.

Ou eu posso ter definição de métodos abstratos públicos, tanto essa variável quanto este método são públicos, void autentica()(String nome, String senha);. Ambos são públicos queira eu digite ou não que eles são públicos, eles são públicos.

Não só isso, a variável por padrão é estática, e o método por padrão é abstrato. Se eu não coloco abstrato, se eu não coloco abstract, se eu não coloco public, por padrão eles são tudo isso. Vou colocar e vou compilar, javac br/com/caelum/certificacao/Pesso.java "Enter".

Repare que eu posso ter variáveis finais, públicas, estáticas dentro da interface e, a prova vai cobrar isso. Mesmo que eu não coloque aqui que ela é pública e estática, ela é pública e estática. E se eu não colocar que é final? Ela também é final e a prova pode te pegar aí.

Se eu tentar alterar o valor do A.TAMANHO = 15;. No terminal javac br.com.caelum.certificacao/Pesso.java "Enter". Não deveria compilar porque eu não posso alterar o valor de uma variável final. Não compila.

E a “pegadinha” pode ser se a variável for definida com letra minúscula tentando te pegar, A.tamanho = 15;. Dizendo que é uma variável normal de instância, não é, é uma variável estática, pública, final. Não pode alterar o valor.

E o método? O método é um método abstrato por padrão, público, abstrato. Compilei, dá o mesmo erro, eu não posso alterar essa variável. Vou comentar a linha 15, //. Estou compilando e está tudo bonito. Lembrando que eu posso ter várias interfaces e várias classes dentro de um arquivo .java.

As regras do pacote e dos imports serão aplicadas para todas as interfaces e todas as classes que forem definidas, todos os tipos que forem definidos dentro desse meu arquivo .java. E isso é muito importante lembrar.

O primeiro, esse A, está dentro desse pacote. O B está dentro desse pacote. A pessoa está dentro desse pacote. A figura está dentro desse pacote. E o teste está em um pacote separado.

Um cuidado importante a ser tomado é que dentro de um arquivo .java eu só posso ter uma interface ou classe, ou tipo, público. Aqui eu tive duas classes e uma interface, nenhum público, tudo padrão. Se for público só pode ter um. E tem mais uma regra, se ele é público, ele tem que ter o mesmo nome que o arquivo.

Por quê? Para ficar fácil de achá-lo. Se ele pode ser acessado em outro pacote, isso é, ele é público, eu tenho que deixar ele com o mesmo nome do arquivo para ser fácil de descobrir onde ele está.

A regra é: eu posso ter vários, e eu se eu tiver algum público eu só posso ter um e o nome tem que ser igual ao do arquivo.

Crie aplicações Java executáveis com um método main - Aplicações Java executáveis

Nessa seção, discutiremos qual a diferença entre uma classe normal e uma classe que pode ser executada pela linha de comando. Uma aplicação Java que tem o método main. Create executable java applications with a main method. Criar aplicação Java executáveis que tenham o método main. Para ser executável tem que ter o metódo main, é a primeira coisa.

Toda classe que for chamada na linha de comando tem que ter esse método main. Vamos criar ela? A primeira coisa, vou criar uma classe, “New file”, esse arquivo vai ser uma classe chamada class HelloWorld. E dentro dela eu vou colocar um métodomain, o padrão quando costumamos colocar a classe e o método main é fazer tudo público, public.

Classe pública, método público, public static void main(String [] args). Perfeito. Aqui dentro eu coloco o meu programa, System.out.println("rodando o programa");.

Esse é o método main tradicional. Vou chamar ele de “HelloWorld.java”. E vou à linha de comando para compilar javac HelloWorld.java "Enter". Compila e java HelloWorld "Enter".

Roda. Lembrando que quando eu compilo, o básico é: javac, o nome do arquivo, .java. E para rodar é: java, o nome da classe, não o nome do arquivo, não é HelloWorld.java ou HelloWorld.class. HelloWorld, o nome da classe, que tem o método main.

O padrão tradicional que encontraremos nos programas é: classe pública com public static void main(String [] args). É claro, o método tem algumas regras que tem que ser seguidas, por exemplo, o método tem que ser público, se o método não é público, ele compila, claro, você pode ter um método chamado main que não é público. E se eu tentar rodar? java HelloWorld "Enter". Não achei o método main na minha classe, por favor, defina o método como public static void main.

Dá um erro na hora de tentar rodar sua aplicação falando que o método public static void main(String [] args não existe.

O método tem que ser público. O que mais? O método tem que ser estático, óbvio, ele acabou de nos falar que tem que ser estático. Se eu tentar compilar de novo, HelloWorld.java "Enter". Compila. Se eu tentar rodar de novo, java HelloWorld "Enter", dá o mesmo erro. Public static void main, por favor. public static void main(String [] args.

void, será que eu posso devolver um int? Será que isso faz diferença? Afinal, quando eu chamo um método eu posso ignorar o retorno dele, int. No terminal javac HelloWorld "Enter" java HelloWorld "Enter". Javac compila, na hora que eu rodo, não dá certo, tem que devolver void. E ele fala que o main tem que devolver void.

Vou voltar para o void. E o string args? Será que tem alguma coisa aqui? Sim, tem que ser um array de args, um array pode ser definido assim [] ou varargs, o varargs também pode definir um array que eu estou recebendo através de varargs, e você tem uma validação válida (String... args). Vamos tentar compilar, HelloWorld.java "Enter". E vamos rodar, java HelloWorld "Enter". Funciona.

As duas variações aceitáveis varargs ou array. Lembrando que o array, veremos em uma seção de array, pode ser definido de diversas maneiras, na frente, atrás, ponta cabeça, etc., as diversas maneiras que array pode ser definida, veremos na seção de arrays.

Estou definindo array de outra maneira e está rodando bem. O que mais? O nome do array tem que ser args? Será que eu posso chamar de params? Eu vou tentar compilar, claro, eu posso sempre compilar javac HelloWorld.java "Enter". E na hora de rodar, beleza, java HelloWorld "Enter".

Por quê? Porque o nome de uma variável local, de uma variável que é um parâmetro nesse caso, não influencia a chamada do método no Java tradicional, não influencia. Eu posso receber qualquer nome de variável para esse parâmetro que eu quero, desde que seja uma array de strings.

Agora, lembrando que para executar esse programa lá no terminal, então javac HelloWorld.java "Enter" para compilar. E java HelloWorld "Enter" para rodar.

Quando eu rodo o que são aqueles parâmetros que eu recebo? Os parâmetros são os argumentos da linha de comando, se eu quiser, eu dou um System.out.println(params.length);, o tamanho da minha array.

Vou também fazer um for(int i=0;i < params.length; i++) {. E vou imprimir System.out.println(i + " => " + params[i]):. Para vermos todos os parâmetros que foram passados. Vou compilar o meu programa javac HelloWorld.java "Enter". Compilei. Vou rodar java HelloWorld "Enter".

Rodando o programa, 0. Por quê? Porque eu não passei nenhum parâmetro para o meu programa, mas o HelloWorld não é um parâmetro? Não, HelloWorld não é um parâmetro. Parâmetro é o que vem depois do nome da classe que está executando.

java HelloWorld primeiro segundo "Enter". Primeiro, segundo, lembra que é um array? Posição 0 primeiro, posição 1 segundo. Array recebe os parâmetros que eu passar na linha de comando de execução, compilação não tem nada a ver. Compilar é compilar, executar é executar.

Lembrando que essa primeira fase de compilação é feita pela compilador, o compilador que usamos é o Javac, é o compilador, por exemplo, da própria Oracle, que vem junto com o JDK, o Java Development Kit. O Javac é o JDK, Java Development Kit.

Para a prova da certificação, precisamos saber que o JDK, que é o Java Development Kit, contém o Javac, a linha de comando de compilação. Se eu quero compilar, tenho que baixar o JDK.

Se eu quero executar, eu posso baixar o Java Runtime Environment, a Virtual Machine do Java. A Virtual Machine do Java está no Java Runtime Environment, JRE.

Eu posso baixar só o JRE se eu quero executar um programa Java, se eu não quero compilar nada, eu baixo só o JRE, por exemplo, eu vou acessar um banco ou algo que tem uma aplicação Java, eu posso baixar só o JRE. Não preciso baixar o JDK para desenvolvimento.

É claro, quando eu baixo o JDK para desenvolvimento já vem a Java Virtual Machine e o JRE para eu executar porque eu estou compilando, eu já quero executar o meu programa e testar, etc.

Nesses casos, eu baixo o JDK que já vem com o JRE, tudo junto para eu baixar, compilar e rodar o meu programa.

Mas se eu sou o cliente final, só quero executar o programa eu baixo só o JRE, Java Runtime Environment, que vai ter só a Virtual Machine, só o Java e não o Javac, que é o compilador Java.

Lembrando que na hora que eu compilo um arquivo .java, tanto o diretório de saída quanto os nomes dos arquivos que serão gerados dependem do conteúdo da minha classe.

Se, por exemplo, dentro do meu projeto que se chama certificação eu ciar um diretório chamado “certificação” e lá dentro desse diretório certificacao eu criar um arquivo, "New Folder > certificacao > New File". E dentro dele definir a classe class Prova {. E a interface interface Exame {. Salvar esse arquivo como “Prova.java”. Eu posso compilar ele. Para compilar, javac certificacao/Prova.java "Enter". Se eu olhar o que foi criado, ls certificacao "Enter".

Eu vou ver que foi criado tanto o arquivo “Prova.class” quanto “Exame.class”. Foram criados os dois arquivos .class, um para a classe e um para a interface, os dois dentro do diretório “certificacao”.

Só que quando criamos dentro de diretórios, o que temos que lembrar de fazer? Trabalhar com os pacotes para organizar, esses arquivos estão, na verdade, no pacote “certificacao” dentro do diretório “certificacao”, package certificacao. Agora sim, eu recompilo, javac certificacao/Prova.java "Enter".

Eles ainda estão lá dentro, mas agora eles estão dentro de um pacote, eu estou falando para o Java que esses arquivos estão dentro do “pacote certificacao”, eles estão agrupados dentro do “pacote certificacao”.

Tem várias opções que eu posso passar para o meu compilador, por exemplo, eu posso passar para ele que a versão do meu bytecode, que a versão do meu código Java é a versão 1.3, -source 1.3. Ele vai ler conforme a versão 1.3 do Java, mesmo eu usando um compilador mais recente.

É claro, tem diversas opções de compilações, essas não serão cobradas na prova, mas você pode analisar segundo o que você quer fazer. Se eu compilar só com -source 1.3 ele pode falar que eu não configurei tudo direito para o 1.3, etc.

Dependendo do que você quer fazer na prática, no mundo real lá fora, não só na certificação, você pode querer passar diversos argumentos para o nosso compilador, para o Javac.

E se eu quiser rodar um programa que está dentro de um pacote? Afinal, eu estou falando do pacote toda hora e é uma boa prática no Java acabar utilizando pacotes para organizar as classes, os tipos dentro do seu projeto.

Se dentro do diretório “certificacao” eu tiver o meu arquivo Teste.java, vou criar outro arquivo “Teste.java” aqui dentro, public class Teste {. Com o método public static void main(String [] args). E vou imprimir aqui dentro, System.out.println("rodando o teste no pacote certificacao"); "Salvar > Teste.java". Dentro do diretório “certificacao”.

Para compilar, eu vou executar javac certificacao/Teste.java "Enter". Será que ele criou o meu arquivo .class? Vou lá ao diretório “certificacao”, ls certificacao. Criou o meu arquivo .class. E para rodar? Para rodar, lembra, Java e o nome da classe. java Teste "Enter".

Mas calma, Guilherme, ele não achou um método main ou a classe Teste, por quê? Ele até poderia achar se eu tivesse aquela classe Teste antiga no diretório raiz.

Mas, Guilherme, a classe Teste não está no diretório raiz, está no diretório certificacao. Ela tem que estar dentro do “pacote certificacao”. Eu esqueci no código, package certificacao;. Lembra, se eu estou dentro do diretório x eu estou no pacote x.

Vou compilar de novo, javac certificacao/Teste.java "Enter". Compilei a minha classe. Para rodar, o nome da classe. O nome da classe é Teste? Não, o nome da classe é java certificacao.Teste.

Se a classe estivesse no diretório “br.com.caelum.certificacao”, eu rodaria Java “br.com.caelum.certificacao.Teste”. O nome de uma classe inclui o pacote dela também. Então java certificacao.Teste. Rodando teste no “pacote certificacao”.

Quando eu rodo na linha de comando Java eu tenho que lembrar do pacote da classe e o nome da classe, tudo isso por inteiro, não só o nome simples, “Teste”, tenho que colocar o pacote. O nome simples, isto é, o nome inteiro da minha classe.

Por vezes, durante a execução de um programa, eu quero passar algumas propriedades na linha de comando, algumas propriedades mais avançadas que vão configurar algo dentro do meu programa.

Essa é uma característica importante saber, não é que eu estou passando um argumento para o meu programa como antes.

java certificacao.Teste, não é que eu estou passando um argumento como primeiro argumento, um args que vai ser recebido no método main, eu estou passando uma propriedade para o meu programa.

Quando eu passo propriedades para o meu programa, passamos com -D antes do nome da classe. - D e o nome da propriedade, por exemplo, sistema=producao. O nome da propriedade, sistema, o valor da propriedade, producao. -Dproduto=certificacao.

Estou passando propriedades e valores, isso é, propriedades, sistema, produção, propriedade, produto, valor, certificacao para o meu programa. O meu programa pode acessar isso através de variáveis de propriedades do meu sistema.

Agora, acessar isso não é necessário para a certificação, só é interessante saber. -D, o nome da propriedade, igual o valor. E eu passo essas propriedades para o meu programa.

Além disso, outra coisa muito importante para a certificação é saber como o Java encontra as minhas classes, como ele sabe que ele tem que procurar no diretório atual pelas minhas classes, no diretório certificacao, etc.

A sacada é que existe uma variável chamada CLASSPATH, tudo maiúsculo mesmo.

Essa variável CLASSPATH define aonde ele vai procurar as classes e onde el vai procurar os pacotes, por padrão o CLASSPATH é somente o diretório atual CLASSPATH=..

Somente o diretório atual, eu posso mudar isso tanto no Windows quanto no Linux com variáveis de ambiente, falando que o CLASSPATH é aquele diretório, é esse diretório, é um arquivo .java, diversas coisas, diversos diretórios, inclusive.

No Linux para separar diretórios eu vou usar dois pontos, é o diretório atual e o diretório CLASSPATH=.:/usr/libraries, por exemplo. E lá dentro eu posso ter diversos arquivos .class, ou posso ter um arquivo .jar, que tem as minhas classes lá dentro.

O CLASSPATH pode ser uma definição de uma sequência separada por dois pontos no Linux, separada pode ponto e vírgula no Windows, de diretórios ou arquivos .jar onde o Java vai procurar as minhas classes, interfaces e todos os meus tipos.

Por padrão, ele é somente CLASSPATH=., diretório atual. Se eu falar que eu estou procurando a classe Teste, ele vai procurar no diretório atual a classe Teste.

Se eu falar que estou procurando a classe certificacao.Teste, ele vai procurar no diretório atual um diretório chamado certificacao e um arquivo chamado Teste.class.

Lembrando que os Jars são somente arquivos .zip, poderia também passar um .zip aqui que é equivalente a um arquivo .jar.

Agora, a variável de ambiente.class, eu posso setar ela? Posso, só que não é uma boa prática, por quê? Porque se eu setar um CLASSPATH aqui, CLASSPATH= um diretório geral, toda a aplicação Java que eu rodar vai usar esse CLASSPATH, toda, mesmo que eu não queira ela vai usar esse CLASSPATH. Não é uma boa prática alterar a variável global de ambiente CLASSPATH.

É muito mais interessante que em vez de usar a variável CLASSPATH na hora que eu rodar o meu programa, eu falo que o -classpath . seja o diretório x, isso é, seja o diretório atual. Eu vou querer rodar a minha classe certificacao.Teste "Enter".

Beleza, rodou o programa. Além de -classpath, eu poderia colocar um atalho que é -cp . certificacao.Teste "Enter".Uso o diretório atual como classpath.

Se eu estivesse em outro diretório, por exemplo, no diretório anterior, o meu diretório, o diretório Guilherme, cd .. "Enter". Eu quero usar o classpath, não o diretório atual, eu quero usar o classpath, o diretório do meu projeto, -cp certificacao certificacao.Teste "Enter".

Eu rodo, beleza. Por quê? Porque ele procurou as classes dentro do diretório certificacao e não no meu diretório atual, se ele procurasse no diretório atual ele não acharia porque não existe essa classe aqui, não acharia, - cp . certificacao.Teste "Enter.

Lembrando que o diretório atual é o padrão do classpath, ele não acharia, java certificacao.Teste "Enter". Eu consigo mudar o classpath através de duas maneiras, variável global de ambiente, -classpath, -cp, que é bem mais interessante.

Lembrando que no -cp eu podia passar tanto Jar quanto diretório, ou um zip, e passar uma sequência separada com dois pontos no Linux ou com ponto e vírgula no Windows.

Dessa maneira, eu consigo acessar um classpath diferente do diretório atual, pode ser interessante como pode não ser interessante, dependendo do que você quer. Para certificação é importante saber que o Java em tempo de execução vai procurar as nossas classes no classpath.

Quem é o classpath? É o que você passar no -cp ou no -classpath.

Se você não passar nada no -cp ou no -classpath, ele vai usar o classpath variável de ambiente que é o padrão que, por padrão, é o diretório atual, mas pode ser outra coisa que você não sabe o que é. Por padrão, é o diretório atual.

Como não queremos misturar todos os projetos Java dentro de um computador, falamos para não mexer na variável de ambiente, simplesmente passar um java-cp com a lista de diretórios, de Jars e de zips que você quer para o seu projeto. Javac para compilar, Java para rodar.

E se a minha classe não for pública? O que acontece? Por padrão, eu consigo compilar, claro, compilar uma classe pública ou não pública, tanto faz, javac certificacao/Teste.java "Enter". Mas, e na hora de rodar? cd Enter". Vou voltar para o meu diretório certificacao, cd certificacao "Enter". E agora eu vou compilar minha classe javac certificacao/Teste.java "Enter".

Compilar uma classe não pública, beleza. Rodar uma classe não pública funciona? java certificacao/Teste. Também funciona. Eu posso rodar o método main de uma classe não pública, nas versões mais recentes do Java eu sempre posso rodar o método main mesmo que a classe não seja pública.

A classe não precisa necessariamente ser pública para o método public ser rodado. Um ponto importante.

Recapitulando tudo que vimos, temos que criar um método public static void main(String [] args). String args pode ser uma array, como pode ser um varargs, é a única variação aceita. A classe pode ser pública ou não, tanto faz, o Java vai deixar.

Para compilar nossas classes, sempre damos Javac e o nome do arquivo, não importa o diretório que ele está, javac certificacao/Teste.java "Enter". Ele vai gerar um arquivo por tipo que tem lá dentro, se eu tenho dois tipos definidos lá dentro, ele vai gerar dois arquivos.

Para rodar essa classe, Java e o nome da classe, isso é, java certificacao.Teste, com ponto e não barra para separar. Por quê? Porque ele tem que estar no pacote certificacao, se ele está no diretório certificacao e eu estou trabalhando com pacotes, package certificacao.

Para rodar, o nome da classe deixa de ser somente Teste, passar a ser certificacao.Teste, "Enter". E se eu estou em outro diretório, estou em um diretório maluco e quero pegar classes daqui, classes dali, classes que estão no zip, classes que estão dentro de um Jar.

Se eu quero fazer isso eu vou usar o classpath, que é onde o Java procura as nossas classes, é o path para as nossas classes, é o classpath.

Classpath pode ser setado com -classpath e pode ser setado com -cp, uma lista de diretório, Jars ou zips separados por dois pontos, ou ponto e vírgula. Dois pontos no Linux, ponto e vírgula no Windows. Ele vai procurar nesses diretórios, e nesses Jars e nesses zips.

Se eu quiser não passar o CLASSPATH manualmente na hora que eu dou o Java, eu posso usar a variável de ambiente CLASSPATH, que não é recomendada. CLASSPATH, tudo em maiúsculo.

Pode acontecer também de eu querer passar uma propriedade para o meu programa, para passar propriedades para o meu programa eu vou passar -D, maiúsculo, chave igual a valor, isso antes do nome do programa. java -Dnome=valor nomeDoPrograma, espaço, nome do meu programa, nome da minha classe ou pacote, etc. Lembrando, -D sem espaço, nome da chave, igual valor, espaço.

Vamos para os exercícios.

Sobre o curso Certificação Java SE 7 Programmer I

O curso Certificação Java SE 7 Programmer I possui 81 minutos de vídeos, em um total de 33 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Defina o escopo de variáveis
• Defina a estrutura de uma classe Java
• Crie aplicações Java executáveis com um método main
• Importe outros pacotes Java e deixe-os acessíveis ao seu código