MindView Inc.

Pensando em Java, 3ª ed. Revisão 4.0


[ Viewing Hints ] [ Book Home Page ] [ Free Newsletter ]
[ Seminars ] [ Seminars on CD ROM ] [ Consulting ]

Anterior Próximo Página Inicial Índice Conteúdo

2: Tudo
é um Objeto



Embora seja baseada em C++, Java é mais do que uma “pura” linguagem orientada a objeto.



Ambos C++ e Java são linguagens híbridas, mas em Java seus criadores sentiram que a hibridação não foi tão importante como foi para o C++. Uma linuagem híbrida permite múltiplos estilos de programação; A razão de C++ ser híbrida é para suportar compatibilidade com a línguagem C. Porque C++ é um superconjunto da línguagem C, este introduz várias características indesejáveis, o que pode fazer em alguns aspectos C++ demasiadamente complicada.Comentários (em inglês)



A linguagem Java assume que você quer fazer programação orientada a objeto somente. Isto significa que antes de começar, você tem que mudar de atitude para um mundo orientado a objeto (a menos que já esteja lá). O benefício deste esforço inicial é a habilidade para programar em uma linguagem que é mais simples de aprender e usar comparado a muitas outras linguagens de OOP. Neste capítulo nós veremos os componentes básicos de um programa de Java e nós aprenderemos que tudo em Java é um objeto, até mesmo um programa de Java. Comentários (em inglês)

Você manipula objetos com referências



Cada lingüagem de programação tem seus próprios meios de manipular dados. Algumas vezes o programador deve estar constantemente ciente de que tipo de manipulação está acontecendo. Você está manipulando o objeto diretamente, ou você está lidando com algum tipo de representação indireta (um ponteiro em C ou C++) que tem que ser tratado com uma sintaxe especial?Comentários (em inglês)



Tudo isso é simplificado no Java. Você trata tudo como um objeto, usando uma única sintaxe consistente. Embora você trate tudo como um objeto, o identificador que você manipula é, na verdade, uma "referência" para um objeto.[10]Você pode imaginar esta cena como uma televisão (o objeto) com seu controle remoto (a referência). Já que você está com esta referência em mãos, você tem uma conexão com a televisão, mas quando alguém diz "mude o canal" ou "abaixe o volume", o que você está manipulando é a referência, que por sua vez modifica o objeto. Se você quer se mover pela sala e ainda controlar a televisão, você leva o controle/referência com você, não a televisão.Comentários (em inglês)



Também, o controle remoto pode ficar sozinho, sem televisão. Ou seja, só porque você tem uma referência não quer dizer que há necessariamente um objeto conectado a ela. Então se você quer manter uma palavra ou sentença, você cria uma referência do tipo String.Comentários (em inglês)



String s;




Mas você criou apenas a referência, não um objeto. Se você dicidiu enviar uma mensagem para s neste momento, você receberá um erro (em tempo de execução) porque s não está realmente anexado a nada (não há televisão). Uma prática mais segura, então, é sempre inicializar uma referência quando você criá-la:Comentários (em inglês)



String s = "asdf";




Entretanto, este (acima) usa uma vantagem especial do Java: strings podem ser inicializadas com texto entre aspas. Normalmente, você tem que usar um tipo de inicialização mais geral para objetos.Comentários (em inglês)

Você tem que criar
todos os objetos



Quando você cria uma referência, você quer conectá-la com um novo objeto. Você faz isso, em geral, com a palavra-chave new. A palavra-chave new quer dizer "Faça de mim um novo desses objetos". Então, no exemplo seguinte, você pode dizer:Comentários (em inglês)



String s = new String("asdf");




Isto não significa simplesmente “Crie uma nova String,” mas também contém informaçoes de como criá-la pelo fornecimento de uma string inicial. Comentários (em inglês)



É claro, String não é o único tipo que existe. Java vem com um monte de tipos já prontos. O que é mais importante é que você pode criar seus próprios tipos. De fato, esta é a atividade fundamental na programação Java, e é sobre isso que você estará aprendendo no resto deste livro.Comentários (em inglês)

Onde o armazenamento vive



It’s useful to visualize some aspects of how things are laid out while the program is running—in particular how memory is arranged. There are six different places to store data: Comentários (em inglês)

  1. Registers. This is the fastest storage because it exists in a place different from that of other storage: inside the processor. However, the number of registers is severely limited, so registers are allocated by the compiler according to its needs. You don’t have direct control, nor do you see any evidence in your programs that registers even exist. Feedback
  2. The stack. This lives in the general random-access memory (RAM) area, but has direct support from the processor via its stack pointer. The stack pointer is moved down to create new memory and moved up to release that memory. This is an extremely fast and efficient way to allocate storage, second only to registers. O compilador conhece muito Java, até que ele é, criado o programa, ,no exato tamanho e por toda vida de todo o dado ,que é a armazenagem em pilha, , porque ele precisa gerar o código para [move] a pilha indicador de cima para baixo. Essa restrição instala [limits] para a flexibilidade em seu programa, assim até que de uma certa forma Java na armazena a pilha exitenti ;em particular, objeto pesquisa --Java e o objeto,eles mesmos não instala em pilha references—Java objects themselves are not placed on the stack. Feedback
  3. The heap. This is a general-purpose pool of memory (also in the RAM area) where all Java objects live. The nice thing about the heap is that, unlike the stack, the compiler doesn’t need to know how much storage it needs to allocate from the heap or how long that storage must stay on the heap. Thus, there’s a great deal of flexibility in using storage on the heap. Whenever you need to create an object, you simply write the code to create it by using new, and the storage is allocated on the heap when that code is executed. Of course there’s a price you pay for this flexibility. It takes more time to allocate heap storage than it does to allocate stack storage (if you even could create objects on the stack in Java, as you can in C++). Feedback
  4. Static storage. “Static” is used here in the sense of “in a fixed location” (although it’s also in RAM). Static storage contains data that is available for the entire time a program is running. You can use the static keyword to specify that a particular element of an object is static, but Java objects themselves are never placed in static storage. Feedback
  5. Constant storage. Constant values are often placed directly in the program code, which is safe since they can never change. Sometimes constants are cordoned off by themselves so that they can be optionally placed in read-only memory (ROM), in embedded systems. Feedback
  6. Non-RAM storage. If data lives completely outside a program, it can exist while the program is not running, outside the control of the program. The two primary examples of this are streamed objects, in which objects are turned into streams of bytes, generally to be sent to another machine, and persistent objects, in which the objects are placed on disk so they will hold their state even when the program is terminated. The trick with these types of storage is turning the objects into something that can exist on the other medium, and yet can be resurrected into a regular RAM-based object when necessary. Java provides support for lightweight persistence, and future versions of Java might provide more complete solutions for persistence. Feedback

Special case: primitive types



Um grupo de tipos, os quais você usará com bastante frequência em sua programação, recebe tratamento especial. Você pode pensar neles como tipos “primitivos”. A razão para o tratamento especial é que para criar um objeto com new—especialmente uma pequena variável simples—não é muito eficiente, porque new coloca objetos na pilha. Para estes tipos Java recuou na abordagem tomada por C e C++. Isto é, ao invés da criação da variavel pelo uso de new, uma variavel “automatica” é criada e não uma referência. A variavel mantem o valor, e é colocada no stack, assim é muito mais eficiente. Comentários (em inglês)



Java determina o tamanho de cada tipo primitivo. Esses tamanhos não se alteram de uma arquitetura de máquina para outra como acontece em muitas liguagens. Este tamanho não varia em razão de programas Java serem portáveis. Comentários (em inglês)

Tipo primitivo

Tamanho

Mínimo

Máximo

Wrapper type

boolean




Boolean

char

16-bit

Unicode 0

Unicode 216- 1

Character

byte

8-bit

-128

+127

Byte

short

16-bit

-215

+215—1

Short

int

32-bit

-231

+231—1

Integer

long

64-bit

-263

+263—1

Long

float

32-bit

IEEE754

IEEE754

Float

double

64-bit

IEEE754

IEEE754

Double

void




Void



Todos os tipos numéricos tem sinal, portanto não procure por tipos sem sinal. Comentários (em inglês)



O tamanho do tipo boolean não é especificado explicitamente; é somente definido para ser apto a tomar os valores literais true ou false. Comentários (em inglês)



As classes “wrapper” para o tipos de dados primitivos permitem que você faça um objeto não-primitido na pilha para representar aquele tipo primitivo. Por exemplo: Comentários (em inglês)



char c = 'x';
Character C = new Character(c);




Ou você pode também usar:



Character C = new Character('x');




A razão para fazer isto será mostrada num capítulo adiante. Comentários (em inglês)

Numero de alta-precisão



Java inclue duas classes para executar aritmética de alta precisão: BigInteger e BigDecimal. Embora aquelas aproximadamente se fixem na mesma cataregoria das classes “wrapper” , nenhuma delas tem um primitivo análogo. Comentários (em inglês)



Ambas as classes tem métodos que providenciam comparações para as operações que você executa em tipos primitivos. Isto é, você pode fazer qualquer coisa com um BigInteger ou BigDecimal que você pode fazer com um int ou float, só que você deve usar a chamada de métodos ao invés de operadores. Também, como há mais involvido, as operação serão mais lentas. Você está trocando velocidade por precisão. Comentários (em inglês)



BigInteger suporta inteiros de precisão arbitrária. Isto significa que você pode representar precisamente valores integrais de qualquer tamanho sem perder qualquer informação durante aos operações. Comentários (em inglês)



BigDecimal é para números de precisão arbitrária com ponto fixo; você pode usá-los para calculos monetários precisos, por exemplo. Comentários (em inglês)



Consulte a documentação do JDK para detalhes sobre os construtores e métodos que você pode chamar para essas duas classes. Comentários (em inglês)

Arrays (Arranjos) em Java



Virtualmente todas as linguagens de programação suportam arrays. Usar arrays em C e C++ é arriscado porque aqueles arrays são somente blocos de memória. Se um programa acessa além do bloco de memória do array ou usa a memória antes de sua inicialização (erros comuns de programação), haverão resultados imprevisíveis. Comentários (em inglês)



Um dos principais objettivos de Java é a segurança, assim muitos dos problemas que afligem programadores em C e C++ não são repetidos em Java. Um array Java é garantido para ser inicializado e não pode ser acessado além de seus limites. A checagem de limite veio com o preço de ter um pequeno montante de memória a mais em cada array apenas para verificar o índice em tempo de execução, mas a compreensão é que a segurança e a produtividade ampliadas cobrem o custo. Comentários (em inglês)



Quando você cria um array de objetos, você na realidade, está criando um array de referências, e cada uma destas referências é automaticamente inicializada com um valor especial com sua própria palavra chave: null. Quando Java vê null, reconhece que a referência em questão não está apontando para um objeto. Você precisa atribuir um objeto para cada referência antes de usá-la, e se você tentar usar uma referência que ainda é null, o problema será reportado em tempo de execução. Então, estes típicos erros de array são prevenidos em Java. Comentários (em inglês)



Você pode também criar um array de primitivos. Novamente, o compilador garante inicialização porque ele zera a memória para este array. Comentários (em inglês)



Array serão discutidos em detalhes em próximos capítulos. Comentários (em inglês)

Você nunca precisa
destruir um objeto



Na maioria das linguagens de programação, o conceito de duração de uma variável é parte importante no esforço de programação. Por quanto tempo a variável existe? Se você deve destruí-la, quando é o momento certo? Dúvidas sobre a duração de variáveis podem gerar muitos erros, e esta seção mostra como o Java simplifica drasticamente este assunto, realizando o trabalho de limpeza para você.Comentários (em inglês)

Definindo o Escopo



A maioria das linguagens procedurais têm o conceito de escopo. Isto determina a visibilidade e o tempo de duração dos nomes definidos naquele escopo. Em C, C++ e Java, o escopo é determinado pela utilização de chaves {}. Por exemplo: Comentários (em inglês)



{
  int x = 12;
  // Only x available
  {
    int q = 96;
    // Both x & q available
  }
  // Only x available
  // q “out of scope”
}




Uma variável definida dentro de um escopo está disponível somente até o final deste escopo.Comentários (em inglês)



Qualquer texto após ‘//’, até o final da linha, é um comentário.



Identação faz o código Java mais fácil de entender. Como Java é uma linguagem de forma livre, os espaços extra, tabulações, e entradas de nova linha não afetam o programa resultante.Comentários (em inglês)



Note que você não pode fazer o seguinte, mesmo sendo isto legal em C e C++:



{
  int x = 12;
  {
    int x = 96; // Illegal
  }
}




O compilador irá informar que a variável x já foi definida. Portanto, a habilidade do C e do C++ de "esconder" uma variável em um escopo maior não é permitida, porque os designers do Java acharam que isto podia levar a programas que geram confusão.Comentários (em inglês)

Escopo de objetos



Objetos Java não tem o mesmo tempo de vida como os primitivos. Quando você cria um objeto Java usando new, ele espera até passar o fim do escopo. Então se você usa:



{
  String s = new String("a string");
} // End of scope




a referência s desaparece no final do escopo. No entanto, o objeto String para o qual s estava apontando continua a ocupar memória. Neste exemplo não há como acessar o objeto, porque a única referência a ele está fora de escopo. Nos capítulos a seguir você verá como a referência ao objeto pode ser repassada para outros lugares e duplicada durante o curso de um programa.Comentários (em inglês)



Uma quantidade enorme de problemas com programação em C++ simplesmente desaparecem porque objetos criados com new duram por tanto tempo quanto você quiser. Os problemas mais difíceis parecem ocorrer em C++ porque você não tem nenhuma ajuda da linguagem em ter certeza de que os objetos estão disponíveis quando são necessários. E mais importante, em C++ você deve ter certeza de destruí-los quando eles não forem mais necessários.Comentários (em inglês)



Isto levanta uma questão interessante. Se Java deixa os objetos por aí, o que os impede de consumir toda a memória e travar o seu programa? Este é exatamente o tipo de problema que ocorreria em C++. É aí que acontece um pouco de mágica. Java tem um coletor de lixo (garbage collector), que procura por todos os objetos que foram criados com new e descobre quais não estão sendo referenciados. Então ele libera a memória ocupada por eles, para que ela possa ser utilizada por outros objetos. Isto significa que você nunca precisa se preocupar em liberar memória. Você simplesmente cria os objetos e, quando você não precisar mais deles, eles serão apagados automaticamente. Isso elimina uma certa categoria de problemas: os tão conhecidos "vazamentos de memória" (memory leak), nos quais o programador esquece de apagar os objetos não utilizados.Comentários (em inglês)

Criando novos
tipos de dados: classe



Se tudo é um objeto, o que determina a forma como uma classe de objeto se parece e se comporta? Ou ainda, o que define o tipo de um objeto? Você deve imaginar que existe uma palavra-chave chamada "tipo", e isso realmente faria sentido. Historicamente, no entando, a maioria das linguagens orientadas a objeto têm usado a palavra-chave classe com o significado: "Eu vou lhe dizer como se parece um novo tipo de objeto". A palavra-chave classe (que é tão comum que não será colocada em negrito no decorrer do livro) é seguida pelo nome do novo tipo. Por exemplo: Comentários (em inglês)



class UmNomeDeTipo { /* O corpo da classe vai aqui */ }




Isto introduz um novo tipo, apesar de que o corpo da classe é composto somente por um comentário (os asteriscos, barras e o que há dentro, que será discutido mais tarde neste capítulo), portanto não há muito o que você possa fazer com ele. No entanto, você pode criar um objeto deste tipo usando new:



UmTipo a = new UmTipo();




Mas você não pode dizer para ele fazer praticamente nada (isto é, você não pode mandar para ele nenhuma mensagem interessante), até que você defina alguns métodos para ele. Comentários (em inglês)

Campos e métodos



Quando você define uma classe (e tudo o que você faz em Java é definir classes, instanciar objetos destas classes e enviar mensagens para estes objetos), você pode colocar dois tipos de elementos em suas classes: campos (às vezes chamados de dados membro), e métodos (às vezes chamados de funções membro). Um campo é um objeto de qualquer tipo com o qual você pode se comunicar através de sua referência. Ele também pode ser um dos tipos primitivos (que não é uma referência). Se ele é uma referência para um objeto, você deve inicializar esta referênca para conectá-lo a um objeto real (usando new, como visto antes) em um método especial chamado construtor (totalmente descrito no Capítulo 4). Se ele é um tipo primitivo, você pode inicializá-lo no ponto de definição na classe (como você verá mais tarde, referências também podem ser inicializadas no ponto de definição).Comentários (em inglês)



Cada objeto mantém a sua própria área de armazenamento para os seus campos; os campos não são compartilhados entre os objetos. Aqui está um exemplo de uma classe com alguns campos: Comentários (em inglês)



class DataOnly {
  int i;
  float f;
  boolean b;
}




Esta classe não faz nada, mas você pode criar um objeto com ela: Comentários (em inglês)



DataOnly d = new DataOnly();




Você pode definir valores para os campos, mas primeiramente você deve saber como acessar um membro de um objeto. Isto é feito informando o nome da referência ao objeto, seguido por um ponto e seguido pelo nome do membro dentro deste objeto: Comentários (em inglês)



objectReference.member




For example: Comentários (em inglês)



d.i = 47;
d.f = 1.1f; // ‘f’ after number indicates float constant
d.b = false;




Também é possível que o seu objeto contenha outros objetos que contenham dados que você queira modificar. Para isto, você simplesmente continua "conectando os pontos". Por exemplo: Comentários (em inglês)



myPlane.leftTank.capacity = 100;




A classe SomenteDados não pode fazer praticamente nada, a não ser armazenar dados, porque ela não tem métodos. Para entender como os métodos funcionam, você primeiramente deve entender argumentos e valores de retorno, que serão descritos brevemente. Comentários (em inglês)

Valores padrão para membros primitivos



Quando um tipo de dado primitivo é um membro de uma classe, este terá um valor default caso você não inicializá-lo:

Primitive type

Default

boolean

false

char

‘\\u0000’ (null)

byte

(byte)0

short

(short)0

int

0

long

0L

float

0.0f

double

0.0d



Note com cuidado que os valores default são o que JAVA garante quando a variável é usada como um membro de uma classe. Isto assegura que variáveis membro de tipos primitivos sempre serão inicializadas (isto C++ não faz), reduzindo uma fonte de bugs. De outra forma, este valor inicial pode não estar correto ou ainda apropriado para o programa que você está escrevendo. É melhor sempre inicializar explicitamente suas variáveis. Comentários (em inglês)



Esta garantia não se aplica a variáveis locais - esses não são campos de uma classe. Assim, se na definição de um método você tiver:



int x;




Então x terá alguns valores arbitrários (como em C e C++); Ele não será automaticamente inicializado com zero. Você é responsável por indicar um valor apropriado antes de usar x. Se você esqueceu, Java definitivamente supera C++: você recebe um erro de compilação informando que a variável não foi inicializada. (Muitos compiladores C++ advertem sobre variáveis não inicializadas, mas em Java isto é um erro.) Comentários (em inglês)

Métodos, argumentos,
e valores de retorno



Em várias linguagens (como C e C++), o termo function é usado para identificar uma subrotina. O termo que é mais comumente usado em Java é method, como em “uma forma de fazer algo.” Se você quiser, você pode continuar pensando em termos de funções. Isto é realmente apenas uma diferença sintática, mas este livro mostra o uso comum do termo “method” em Java.Comentários (em inglês)



Métodos em Java determinam as mensagens que um objeto pode receber. Nesta seção você aprenderá como é simples definir um método. Comentários (em inglês)



As partes fundamentais de um método são o nome, os argumentos, o tipo de retorno e o corpo. Esta é a forma básica:



returnType methodName( /* Argument list */ ) {
  /* Method body */
}




O tipo de retorno é o tipo de valor disparado fora do método após você chamá-lo. A lista de argumentos concedidos a tipos e nomes para a informação, você precisa para passar dentro do método. O nome do método e lista de argumentos juntos identificam o método.Comentários (em inglês)



Métodos em Java podem ser criados somente como parte de uma classe. Um método somente pode ser executado em um objeto,[11] e este objeto deve ser capaz de executar este método. Se você tentar executar em um objeto um método de forma errônea, você receberá uma mensagem de erro em tempo de compilação. Você chama um método em um objeto usando o seu nome, seguido de um ponto (.), seguido do nome do método e da lista de argumentos, desta forma:



objectName.methodName(arg1, arg2, arg3);




Por exemplo, suponha que você tem um método f( ) que não recebe argumentos e retorna um valor de tipo int. Então, se você tem um objeto chamado a para o qual f( ) pode ser chamado, você pode dizer isto:



int x = a.f();




O tipo do valor de retorno deve ser compatível com o tipo de x. Comentários (em inglês)



Comumente se referem a este chamado de método como envio de mensagem a um objeto. No exemplo anterior, a mensagem é f( ) e o objeto é a. Programação orientada a objeto é frequentemente resumida como simplesmente “envio de mensagens a objetos.” Comentários (em inglês)

A lista de argumentos



A lista de argumentos do método especifica qual informação você passa para o método. Como você pode perceber, esta informação—como tudo mais em Java—toma a forma de objetos. Assim, o que você deve especificar na lista de argumentos são os tipos dos objetos para passar e o nome para usar em cada um. Como em qualquer situação em Java onde você parece estar manuseando objetos, você está realmente passando referências.[12] Contudo, o tipo da referência deve estar correto. Se o argumento é suposto para ser uma String, você deve passar uma String ou o compilador dará um erro. Comentários (em inglês)



Considere um método que toma uma String como seu argumento. Aqui está a definição, a qual deve ser colocada dentro da definição da classe para que seja compilada:



int armazenamento(String s) {
  return s.length() * 2;
}




Este método mostra a você quandos bytes são necessários para manter a informação em uma particular String. (Cada char em uma String tem 16 bits, ou dois bytes, para suportar caracteres Unicode.) O argumento é do tipo String e é chamado s. Uma vez que s é passado para o método, você pode tratá-lo como qualquer outro objeto. (Você pode mandar mensagens a ele.) Aqui, o método length( ) é chamado, o qual é dos métodos de Strings; ele retorna o número de caracteres na string. Comentários (em inglês)



Você pode também ver o uso da palavra chave return , que faz duas coisas. Primeiro, ela significa “deixe o método, eu terminei.” Segundo, se o método produz um valor, este valor é colocado imediatamente após a declaração return . Neste caso, o valor de retorno é produzido pela avaliação da expressão s.length( ) * 2. Comentários (em inglês)



Você pode retornar o tipo que quiser, mas se não quiser retornar nada, você deve indicar que o método retorna void. Aqui estão alguns exemplos:



boolean flag() { return true; }
float naturalLogBase() { return 2.718f; }
void nothing() { return; }
void nothing2() {}




Quando o tipo de retorno é void, então a palavra chave return é usada apenas para sair do método, e é portanto desnecessária quando você alcança o fim do método. Você pode retornar de qualquer ponto do método, mas se você tiver dado um retorno de tipo não-void , então o compilado forçará você (com mensagens de erro) a retornar o tipo apropriado de valor sem levar em consideração onde você retorna. Comentários (em inglês)



Neste ponto, parece que um programa é só feixe de objetos com métodos que tomam outros objetos como argumentos e enviam mensagens para aqueles outros objetos. Este é o fato mas a coisa segue, e no próximo capítulo você aprenderá como fazer o trabalho detalhado de baixo nível tomando decisões dentro de um método. Para este capítulo, enviar mensagens será o suficiente. Comentários (em inglês)

Construindo um programa Java



Há diversos outros assuntos que você precisa compreender antes de ver seu primeiro programa Java. Comentários (em inglês)

Visibilidade do nome



Um problema em qualquer linguagem de programação é o controle de nomes. Se você usa um nome em um módulo do programa, e outro programador usa o mesmo nome em outro módulo, como você distingue um nome do outro e previne os dois nomes do “conflito?” Em C este é um problema particular porque um programa é frequentemente um inadministravel mar de nomes. As classes C++ (nas quais Java está baseada) aninham funções dentro de classes assim elas não conflitam com nomes de funções aninhadas dentro de outras classes. Contudo, C++ ainda permite dados globais e funções globais, assim conflitos ainda são possíveis. Para resolver este problema, C++ introduziu escopos usando palavras chaves adicionais. Comentários (em inglês)



Java foi habilitada para evitar tudo isto tomando um abordagem nova. Para produzir um nome não ambíguo para uma biblioteca, o especificador usado é nada menos que o nome de domínio na Internet. De fato, os criadores Java querem que você use seu nome de domínio da Internet ao contrário pois este assegura que é único. Como meu nome de domínio é BruceEckel.com, minha biblioteca de utilidades de pontos fracos poderia ser chamada com.bruceeckel.utility.foibles. Depois de seu nome de domínio reservado, os pontos são convencionados para representar sub-diretórios. Comentários (em inglês)



Na Java 1.0 e Java 1.1 as extensões de domínio com, edu, org, net, etc., foram colocadas em maiúsculo por convenção, assim a biblioteca poderia aparecer como: COM.bruceeckel.utility.foibles. Em parte através do desenvolvimento da Java 2, contudo, foi descobero que isto causou problemas, assim agora o nome inteiro da package é em minúsculas. Comentários (em inglês)



Este mecanismo significa que todos os seus arquivos automaticamente vivem em seu próprio escopo, e cada classe dentro de um arquivo deve ter um identificador único. Assim você não precisa aprender artifícios especiais de linguagem para resolver este problema—a linguagem toma conta disto por você. Comentários (em inglês)

Usando outros componentes



A qualquer momento em que você quiser usar uma classe pre-definida em seu programa, o compilador deve saber como localizá-la. É claro, a classe pode já existir no mesmo arquivo (source code) do qual ela está sendo chamada. Neste caso, você simplesmente usa a classe mesmo que a classe esteja sendo referenciada antes de sua definição no arquivo (Java elimina o problema da "forward referencing", então você não precissa se preocupar com isto).Comentários (em inglês)



E que tal uma classe que existe em um outro arquivo qualquer? Você pode pensar que o compilador deve ser esperto o suficiente para simplismente achar esta classe, mas há um problema. Imagine que você queira usar uma classe com um nome em particular, entretanto existem mais de uma definição para aquela classe (presumidamente estas são definições diferentes). Ou pior, imagine que você está escrevendo um programa, e a medida que você está construindo o mesmo você adiciona uma nova classe à sua biblioteca que entra em conflito com o nome de uma classe existente. Comentários (em inglês)



Para resolver este problema, você deve eliminar todas as potenciais ambiguidades. Isto é feito falando para o compilador Java exatamente quais as classes você quer usar através da palavra chave import. import informa ao compilador para disponibilizar um pacote, que é uma biblioteca de classes. (Em outras palavras, uma biblioteca pode ser constituída de funções e dados assim como de classes, mas lembre-se todo e qualquer código em Java deve ser escrito dentro de classes.)Comentários (em inglês)



A maior parte do tempo você estara usando componentes da biblioteca padrão de Java (Java API) que vem junto com seu compilador. Com isto, você não precissa se preocupar com a localização das classes; você apenas diz, por exemplo:



import java.util.ArrayList;




para dizer ao compilador que você quer usar a classe ArrayList de Java. Entretanto, java.util contém várias classes e você pode querer usar algumas delas sem ter que declarar o import para cada uma delas explicitamente. Isto é facilmente alcançado usando '*' para indicar um curinga:



import java.util.*;




É mais comum importar uma coleção de classes desta maneira do que importas classes individualmente.Comentários (em inglês)

A palavra chave static



Geralmente, quando você cria uma classe você está descrevendo como serão os objetos dessa classe e como se comportarão. Você não tem realmente qualquer coisa até que crie um objeto dessa classe com a palavra chave new, e neste ponto o armazenamento de dados(memória) está criado e os métodos tornam-se disponíveis.new, and at that point data storage is created and methods become available. Comentários (em inglês)



Mas há duas situações nas quais esta característica não é suficiente. Uma é se você quer ter apenas uma região de memória para um dado particular, sem levar em consideração quantos objetos são criados, ou se nenhum objeto foi criado. O outro é se você precisa de um método que não está associado a um objeto particular de uma classe. Quer dizer, você precisa de um método que você pode chamar ainda que nenhum objeto esteja criado. Você pode alcançar ambos objetivos com a keyword static. Quando você diz que algo é static, isto significa que aquele dado ou método não está ligado a qualquer uma das instancias daquela classe. Então mesmo que você nunca tenha criado um objeto daquela classe você pode chamar um método static ou acessar uma região de memória static. Com os normais, dados e métodos não-static você deve criar um objeto e usá-lo para acessar os dados e métodos, uma vez que dados e métodos não-static devem conhecer o objeto particular aos quais eles estão associados. É claro que, uma vez que os métodos static não precisam que um objeto seja criado antes de serem usados, eles não podem diretamente acessar os dados ou métodos não-static simplesmente chamando os mesmos sem referenciar a um objeto declarado (uma vez que membros e métodos não-static devem ser ligados a um objeto particular).Comentários (em inglês)



Algumas linguagens orientadas a objetos usam o termo dados de classe e métodos de classe , indicando que os dados e os métodos existem para a classe como um todo, e não para um objeto expecífico da classe. Às vezes as literaturas Java usam este termo em demasia. Comentários (em inglês)



Para tornar um dado ou método static, você deve simplismente colocar a keyword antes das definições dos mesmos. Por exemplo, o código sequinte produz um campo(dado) static e inicializa o mesmo.Comentários (em inglês)



class StaticTest {
  static int i = 47;
}




Agora caso você construa dois objetos StaticTest, haverá apenas uma área de armazenamento para StaticTest.i. Ambos os objetos irão compartilhar o mesmo i. Considere:Comentários (em inglês)



StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();




Neste momento, ambos st1.i e st2.i possuem o mesmo valor 47, uma vez que eles referenciam a mesma localização de memória. Comentários (em inglês)



Há duas maneiras de referenciar uma variável static. Como o próximo exemplo indica, você pode referenciá-la através de um objeto, por exemplo, st2.i. Ou você pode referenciá-lo diretamente com o nome da classe onde a mesma está declarada, algo que você não pode fazer com um membro não-static. (Esta é a maneira mais indicada para referenciar uma variável static uma vez que enfatiza a natureza static da mesma.)Comentários (em inglês)



StaticTest.i++;




O operador ++ incrementa a variável i. Neste momento, ambos st1.i e st2.i terão o valor 48. Comentários (em inglês)



De forma similar à lógica aplicada aos dados statics. Você pode referenciar métodos statics através de um objeto da classe como com qualquer outro método, ou com uma sintax adicional especial ClassName.method( ). Você define um método static de forma similar: Comentários (em inglês)



class StaticFun {
  static void incr() { StaticTest.i++; }
}




Você pode ver que o método StaticFun incr( ) incrementa o dado static i usando o operador ++ . Você pode chamar incr( ) da forma típica, através de seu objeto: Comentários (em inglês)



StaticFun sf = new StaticFun();
sf.incr();




Ou, porquê incr( ) é um método static, você pode chamá-lo diretamente através de sua classe: Comentários (em inglês)



StaticFun.incr();




Quando aplicada a um campo, o static definitivamente muda a maneira com que os dados são criados (um para cada classe versus um para cada objeto quando não-static ), quando aplicado a um método a diferença não é assim tão dramática. Um uso importante do static para métodos é para permitir que você chame um método sem criar um objeto. Isto é essencial, como veremos, para definir o método main( ) que é o ponto de entrada(entry point) para a execução de uma aplicação.Comentários (em inglês)



Como todo método, um método static de Java. Entretanto, static static é usado frequentemente como um "pastor" para um conjunto de exemplares de seu próprio tipo.Comentários (em inglês)

Seu primeiro programa Java



Finalmente, aqui está o primeiro programa completo. O mesmo começa imprimindo uma string, e então seque imprimindo a data atual, usando a classe Date da biblioteca padrão de Java (API Java). Comentários (em inglês)



// HelloDate.java
import java.util.*;

public class HelloDate {
  public static void main(String[] args) {
    System.out.println("Hello, it's: ");
    System.out.println(new Date());
  }
}




No inicio de cada arquivo de programa (source file), você deve colocar as linhas de import para tornar disponível qualquer classe extra que você precisará ao longo do código. Note que eu disse "extra". Isto porquê há uma certa biblioteca de classes que é automaticamente colocada à disposição em todo arquivo Java: java.lang. Inicie seu web browser (um navegador da internet qualquer) e veja a documentação no site da Sun para maiores detalhes. (Se você ainda não baixou a documentação do JDK a partir de java.sun.com, faça isso agora[13]). Se você olhar na lista de pacotes, você verá todas as diferentes bibliotecas de classes que vem com Java. Selecione java.lang. Isto trará uma lista com todas as classes que fazer parte deste pacote. Uma vez que java.lang é implicitamente incluído em todo arquivo de código Java, estas classes estão automaticamente disponíveis. Não há um classe Date listada em java.lang, o que significa que você terá que importar uma outra biblioteca para tê-la disponível. Se você não sabe qual a biblioteca onde uma classe especifica se encontra, ou se você quer ver todas as classes, você pode selecionar "Tree" na sua documentação Java. Agora você pode encontrar todas as classes que vem com Java. Então você pode usar a função "find" do browser para encontrar Date. Quando você fizer isto, você verá a mesma listada como java.util.Date, o que lhe diz que ela está na biblioteca java.util e que você deve importar java.util.* ou java.util.Date para poder usar Date. Comentários (em inglês)



Se você retornar ao inicio, selecione java.lang e então System, você verá que a classe System tem vários campos, e se você selecionar out, você descobrirá que este é um objeto static PrintStream . Uma vez que este é static, você não precisará criar nada para usá-lo. O objeto out está sempre lá, e você pode simplesmente usar o mesmo. O que você pode fazer com este objeto out é determinado pelo seu tipo: um PrintStream. Convenientemente, PrintStream é exibido na descrição como um hyperlink, então se você clicar nele, você verá uma lista com todos os métodos que você pode chamar com PrintStream. Há alguns poucos, e estes serão tratados mais tarde neste livro. Por enquanto tudo em que nós estamos interessados é no método println( ), o qual seu efeito significa "imprima o que eu estou lhe passando no console e finalize com uma nova linha." Assim, em qualquer programa Java que você escrever você pode dizer System.out.println("things"); em qualquer momento que você quer imprimir algo no console.Comentários (em inglês)



O nome da classe é igual ao do arquivo. Quando você está criando um programa standalone como este que criamos, uma das classes no arquivo deve ter o mesmo nome que o arquivo. (O compilador reclamará se você não fizer isto.) Esta classe (com mesmo nome do arquivo) deve conter um método chamado main( )com esta assinatura:Comentários (em inglês)



public static void main(String[] args) {




A palavra chave public significa que o método está disponível para o mundo exterior ao da classe (descrito em detalhes no capítulo 5). O argumento para o método main( ) é um array de objetos String. O args não será usado neste programa, mas o compilador Java insiste que ele esteja lá porque ele contém os argumentos vindos da linha de comando.Comentários (em inglês)



The line that prints the date is quite interesting: Comentários (em inglês)



System.out.println(new Date());




O argumento é um objeto Date que está sendo criado apenas para enviar seu valor (que é automaticamente convertido para um objeto String) para println( ). Tão logo este comando terminar, onde o Date passa a ser desnecessário, o garbage collector (coletor de lixo) pode vir e recolhê-lo a qualquer momento. Nos não precisamos nos preocupar em limpá-lo da memória (cleaning it up).Comentários (em inglês)

Compilando e executando



Para compilar e executar este programa, bem como todos os outros programas neste livro, você precisa ter um ambiente de programação Java. Existem vários ambientes de desenvolvimento oferecidos por terceiros, mas neste livro assumiremos que você esteja usando o JDK (Java Developer’s Kit) da Sun, que é gratuito. Caso você esteja usando outro sistema de desenvolvimento,[14] você precisa procurar na documentação por esse sistema, para determinar como compilar e executar os programas. Comentários (em inglês)



Acesse a Internet e entre no site java.sun.com. Você encontrará informações e links que o instruirão no processo para fazer o download e instalar o JDK na sua plataforma particular.Comentários (em inglês)



Após ter instalado o JDK e configurado o caminho (path) do seu computador de modo que ele encontre javac e java, faça o download e descompacte o código fonte desse livro (você pode encontrá-lo em www.BruceEckel.com). Será criado um sub-diretório para cada capítulo do livro. Vá para o sub-diretório c02 e digite: Comentários (em inglês)



javac HelloDate.java




Este comando não produzirá uma resposta. Caso apareça alguma mensagem de erro, é provável que o JDK não foi instalado corretamente e você terá que investigar esses problemas. Comentários (em inglês)



On the other hand, if you just get your command prompt back, you can type:



java HelloDate




and you’ll get the message and the date as output. Comentários (em inglês)



Este é o processo que você pode usar para compilar e executar cada um dos programas apresentados neste livro. Porém, você verá que o código fonte deste livro também tem um arquivo chamado build.xml em cada capítulo e este contém comandos "ant" para gerar os arquivos deste capítulo automaticamente. Buildfiles e Ant (incluindo onde fazer o download) são descritos em detalhes no Capítulo 15, mas uma vez que você instalou o Ant (de http://jakarta.apache.org/ant) você pode simplesmente digitar ‘ant’ no prompt de comando para compilar e executar os programas em cada capítulo. Se você ainda não instalou o Ant, você pode digitar os comandos javac e java manualmente. Comentários (em inglês)

Comentários e documentação embutida



Existem dois tipos de comentários em Java. O primerio é o tradicional comentário no estilo C que foi herdado pelo C++. Estes comentários começam com um /* e continuam, possivelmente por várias linhas, até um*/. Note que muitos programadores começarão cada linha de um cumentário contínuo com um *, o que significa que você frequentemente verá:



/* This is a comment
 * that continues
 * across lines
 */




Lembre, contudo, que tudo dentro de /* e */ é ignorado, assim não há diferença em dizer: Comentários (em inglês)



/* This is a comment that
continues across lines */




A segunda forma de comentários vem do C++. É o comentário de uma única linha, que começa com // e continua até o final da linha. Este tipo de comentário é conveniente e geralmente usado porque é mais fácil. Você não precisa ficar procurando no teclado para encontrar uma / e depois o * (antes, você simplesmente pressiona a mesma tecla duas vezes), e você não precisa fechar o comentário. Portanto, você normalmente verá: Comentários (em inglês)



// This is a one-line comment



Documentação de Comentários



Uma das melhores idéias em Java é que escrever códigos não é a única atividade importante - documentá-lo também é importante. É provável que o maior problema em documentar o código seja manter a documentação atualizada. Se a documentação e o código estiverem separados, torna-se um problema alterar a documentação toda vez que você altera o código. A solução parece ser simples: lincar o código à documentação. A maneira mais fácil de se fazer isso é colocar tudo no mesmo arquivo. Para completar isso, porém, você precisa de uma sintaxe de comentário especial para marcar a documentação e uma ferramenta para extrair esses comentários e colocá-los em um formato que seja útil. E é isso o que Java tem feito. Comentários (em inglês)



A ferramenta para extrair os comentários chama-se javadoc, e ela faz parte da instalação do JDK. Ela usa alguma tecnologia do compilador Java para procurar por tags especiais de comentários que você colocou nos seus programas. Ela não apenas extrai as informações marcadas por essas tags, mas também traz o nome da classe ou o nome do método que une os comentários. Desta forma você fica com menos trabalho para gerar uma documentação descente dos programas. Comentários (em inglês)



A saída do javadoc é um arquivo HTML que você pode visualizar com o seu browser. Assim, javadoc permite que você crie e atualize um arquivo de código único e gere automaticamente uma documentação que seja útil. Devido ao javadoc temos um padrão para criar a documentação e é claro que podemos esperar ou mesmo exigir documentação com todas a bibliotecas Java. Comentários (em inglês)



Além do mais, você pode escrever seus próprios javadoc handlers, chamado doclets, caso você queira executar operações especiais nas informações processadas pelo javadoc (saída em formato diferente, por exemplo). Doclets são apresentados no Capítulo 15. Comentários (em inglês)



O que segue é apenas uma introdução e visão geral básica do javadoc. Uma descrição mais detalhada pode ser encontrado na documentação JDK que pode ser baixado do site java.sun.com (note que esta documentação não vem junto com o JDK; você precisa fazer um download separado para obtê-lo). Quando você abre ou descompacta a documentação, procure no sub-diretório “tooldocs” (ou siga o link “tooldocs”). Comentários (em inglês)

Sintaxe



Todos os comandos do javadoc ocorrem entre comentários /**. Comentários normalmente terminam com um */. Há duas maneiras básicas para se usar javadoc: inserindo-se comandos HTML ou pelo uso de “tags doc.” As tags doc independentes são comandos que iniciam com uma ‘@’ e são colocados no início de uma linha de comentário. (Qualquer ‘*’ adicional é ignorado.) As tags doc que são Inline podem aparecer em qualquer lugar dentro de um comentário javadoc e pode também começar com um ‘@’, porém aparecem entre chaves. Comentários (em inglês)



Existem três “tipos” de documentação de comentário, os quais correspondem ao elemento que o comentário antecede: classe, variável ou método. Ou seja, um comentário de classe aparece imediatamente antes da definição de uma classe; um comentário de variável aparece bem enfrente da definição de uma variável e o comentário de um método aparece bem enfrente da definição de um método. Como exemplo: Comentários (em inglês)



/** Comentário de classe*/
public class DocTest {
  /** Comentário de variável*/
  public int i;
  /** Comentário de método*/
  public void f() {}
}




Observe que o javadoc processará a documentação de comentário apenas para membros public e protected . Comentários para membros private e package-access (veja Capítulo 5) são ignorados e você não verá nenhuma saída. (Entretanto, você pode usar a flag private para incluir membros private .) Isto faz sentido, uma vez que apenas membrospublic e protected estão disponíveis fora do arquivo, que é a perspectiva do programador cliente. Entretanto, todos os comentários de classes são inseridos na saída. Comentários (em inglês)



A saída para o código precedente é um arquivo HTML que possui o mesmo formato padrão assim como todo o resto da documentação Java, de maneira que os usuários se sentirão confortáveis com o formato e poderão facilmente navegar nas suas classes. Vale apena digitar o código precedente, enviá-lo através do javadoc e observar os resultados no arquivo HTML gerado. Comentários (em inglês)

Inserindo HTML



O Javadoc passa os comandos HTML para a documentação HTML gerada. Isto permite que você use o HTML de maneira completa; contudo, o motivo primário é permitir que você formate o código como: Comentários (em inglês)



/**
* <pre>
* System.out.println(new Date());
* </pre>
*/




Você também pode usar HTML da mesma maneira como você usaria em qualquer outro document Web para formatar texto em suas descrições: Comentários (em inglês)



/**
* You can <em>even</em> insert a list:
* <ol>
* <li> Item one
* <li> Item two
* <li> Item three
* </ol>
*/




Observe que dentro do comentário da documentação, os asteriscos no início de uma linha, bem como os espaços são jogados fora pelo javadoc. O javadoc reformata tudo para estar em conformidade com a aparência da documentação padrão. Não use cabeçalhos HTML como <h1> ou <hr> , pois o javadoc insere os próprios cabeçalhos dele e os seus irá causar interferência. Comentários (em inglês)



Todos os tipos de comentários de documentação - classes, variáveis e métodos - podem suportar HTML encaixado. Comentários (em inglês)

Alguns exemplos de Tags



Aqui estão algumas tags do javadoc disponíveis para documentação do código. Antes de tentar fazer algo sério usando o javadoc, você deveria consultar a referência javadoc na documentação JDK (disponível para download) para obter uma cobertura completa sobre a forma de usar o javadoc. Comentários (em inglês) Comentários (em inglês)

@see: referenciando outras classes



A tag @see permite que você referencie a documentação de outras classes. O Javadoc gerará um arquivo HTML com as tags @see referenciando (por hipertexto) outra documentação. As formas são: Comentários (em inglês)



@see classname
@see fully-qualified-classname
@see fully-qualified-classname#method-name




Cada uma adiciona uma entrada de hiperlink “Veja Também” à documentação gerada. O Javadoc não verificará se os hiperlinks que você informou são válidos.Comentários (em inglês)

{@link pacote.classe#menbro rótulo}



Muito similar à @see, exceto que ela pode ser usada em linha e usa o rótulo como texto de hiperlink ao invés de “Veja Também.”

{@docRoot}



Gera o caminho relativo do diretório raiz da documentação. Útil para hiperligação explícita a páginas na árvore de documentação.

{@inheritDoc} 



Herda a documentação da classe base mais próxima desta classe, colocando-a no comentário da documentação corrente.

@version



Tem a seguinte forma:



@version version-information




Onde informação-da-versão é qualquer informação significante que você queira incluir. Quando a opção –version é informada na linha de comando do Javadoc, a informação de versão será destacada na documentação HTML gerada.Comentários (em inglês)

@author



Tem a seguinte forma:



@author author-information




Onde informações-do-autor é presumivelmente seu nome, mas também pode incluir seu endereço de e-mail ou qualquer outra informação apropriada. Quando a opção -author é informada na linha de comando do Javadoc a informação do autor será destacada na documentação HTML gerada. Comentários (em inglês)



Você pode ter várias tags de autor para registrar uma lista de autores, mas elas devem ser colocadas consecutivamente. Todas as informações do autor serão agrupadas em um parágrafo simples no HTML gerado.Comentários (em inglês)

@since



Esta tag permite que você informe a versão deste código que começou a utilizar uma característica em particular. Você a verá na documentação HTML Java indicando que versão do JDK foi usada.Comentários (em inglês)

@param



Esta tag é usada para a documentação de métodos e tem a seguinte forma:



@param parameter-name description




Onde nome-do-parâmetro é o identificador na lista de parâmetros do método e descrição é o texto que pode se estender pelas linhas seguintes. A descrição é considerada concluída quando uma nova tag de documentação é encontrada. Você pode ter quantas tags destas quiser, presumivelmente uma para cada parâmetro. Comentários (em inglês)

@return



Esta tag é usada para a documentação de métodos e tem a seguinte forma:



@return description




Onde descrição dá a você o significado do valor do retorno. Ela pode continuar nas linhas seguintes.Comentários (em inglês)

@throws



Exceções serão demonstradas no Capítulo 9. Resumidamente elas são objetos que podem ser lançados para fora de um método se este método falhar em sua execução. Embora apenas um objeto exceção possa ser lançado quando você chama um método, um determinado método pode produzir qualquer número de diferentes tipos de exceções, todas as quais necessitam de uma descrição. Então a forma da tag de exceção é:



@throws fully-qualified-class-name description




Onde nome-completo-da-classe fornece um nome não ambíguo de uma classe de exceção que é definido em algum lugar e descrição (a qual pode continuar nas linhas subseqüentes) informa a você porque este tipo particular de exceção pode emergir de uma chamada de método.Comentários (em inglês)

@deprecated



Esta tag é usada para indicar características que foram substituídas por uma característica melhorada. A tag deprecated é uma sugestão para você não mais utilizar uma característica em particular, considerando que em algum momento futuro ela provavelmente será removida. Um método que é marcado com a tag @deprecated instrui o compilador a emitir um aviso se ela for usada.Comentários (em inglês)

Exemplo de Documentação



Abaixo segue novamente o primeiro programa Java, desta vez com os comentários de documentação adicionados:



//: c02:HelloDate.java
import java.util.*;

/** The first Thinking in Java example program.
 * Displays a string and today's date.
 * @author Bruce Eckel
 * @author www.BruceEckel.com
 * @version 2.0
*/
public class HelloDate {
  /** Sole entry point to class & application
   * @param args array of string arguments
   * @return No return value
   * @exception exceptions No exceptions thrown
  */
  public static void main(String[] args) {
    System.out.println("Hello, it's: ");
    System.out.println(new Date());
  }
} ///:~




A primeira linha do arquivo utiliza minha própria técnica de colocar um ‘//:’ como uma marca especial para a linha de comentário, que contém o nome do arquivo fonte. Esta linha contém a informação do caminho para o arquivo (neste caso c02 indica o Capítulo 2) seguida pelo nome do arquivo.[15] A última linha também finaliza com um comentário e este (‘///:~’) indica o fim da listagem do código fonte, permitindo que o código seja automaticamente atualizado no texto deste livro após ser verificado com um compilador e executado.Comentários (em inglês)

Estilo de Codificação



O estilo descrito nas Convenções de Código para a Linguagem Java[16] é para colocar o nome de uma classe com a primeira letra maiúscula. Se o nome da classe consiste de várias palavras, elas são colocadas juntas (isto é, você não usa sublinhados para separar os nomes), e a primeira letra de cada palavra embutida é maiúscula, como por exemplo: Comentários (em inglês)



class AllTheColorsOfTheRainbow { // ...




Isso às vezes é chamado de “camel-casing”. Para praticamente todo o resto, métodos, campos (variáveis membros) e nomes de referência a objetos, o estilo aceito é o mesmo das classes exceto que a primeira letra do identificador é minúscula. Por exemplo: Comentários (em inglês)



class AllTheColorsOfTheRainbow {
  int anIntegerRepresentingColors;
  void changeTheHueOfTheColor(int newHue) {
    // ...
  }
  // ...
}




O usuário também deve digitar todos esses nomes longos, portanto seja piedoso. Comentários (em inglês)



O código Java que você vai ver nas bibliotecas da Sun também segue o posicionamento dos abre chaves e fecha chaves que você vê utilizado neste livro. Comentários (em inglês)

Sumário



O objetivo deste capítulo é mostrar apenas o suficiente de Java para entender como escrever um programa simples. Você também teve uma visão geral da linguagem e algumas de suas idéias básicas. Contudo, todos os exemplos até agora tiveram a forma “faça isso, então faça aquilo, então faça aquilo outro”. E se você quiser que o programa faça escolhas, como “se o resultado disso for vermelho, faça aquilo; senão, faça aquilo outro”? O suporte em Java para esta atividade fundamental de programação será coberto no próximo capítulo. Comentários (em inglês)

Exercícios



Soluções para os exercícios selecionados podem ser encontrados no documento eletrônico The Thinking in Java Annotated Solution Guide, disponível por um pequeno pagamento em www.BruceEckel.com.

  1. Seguindo o exemplo HelloDate.java neste capítulo, crie um programa “hello, world” que simplesmente exiba esta frase. Você precisa de apenas um método em sua classe (o “main”, que é executado quando o programa inicia). Lembre-se de torna-lo static e de incluir a lista de argumentos, mesmo que você não a use. Compile o programa com javac e execute com java. Se você está usando um ambiente de desenvolvimento diferente do JDK, aprenda como compilar e executar programas neste ambiente. Feedback
  2. Encontre os fragmentos de código envolvendo ATypeName e transforme-os em um programa que compila e executa. Feedback
  3. Transforme os fragmentos de código DataOnly em um programa que compila e executa. Feedback
  4. Modifique o Exercício 3 para que os valores dos dados no DataOnly sejam atribuídos e exibidos no main( ). Feedback
  5. Escreva um programa que inclua e chame o método storage( ) definido como um fragmento de código neste capítulo. Feedback
  6. Transforme os fragmentos de código StaticFun em um programa funcional. Feedback
  7. Escreva um programa que exiba três argumentos recebidos pela linha de comando. Para fazer isto, você vai precisar usar um índice para o vetor de Strings da linha de comando. Feedback
  8. Transforme o exemplo TodasAsCoresDoArcoIris em um programa que compila e executa. Feedback
  9. Encontre o código para a segunda versão do HelloDate.java, que é o exemplo de comentário simples de documentação. Execute o javadoc no arquivo e veja os resultados no seu navegador Web. Feedback
  10. Transforme o docTest em um arquivo que compila, então execute ele pelo javadoc. Verifique a documentação resultante com seu navegador Web. Feedback
  11. Adicione uma lista de ítens HTML na documentação no Exercício 10. Feedback
  12. Pegue o programa do Exercício 1 e adicione um comentário de documentação. Extraia este comentário de documentação para um arquivo HTML usando o javadoc e visualize com seu navegador Web. Feedback
  13. No Capítulo 4, localize o exemplo Overloading.java e adicione documentação javadoc. Extraia este comentário de documentação em um arquivo HTML usando o javadoc e visualize com seu navegador Web. Feedback



[10] Isto pode causar uma revolução. Existem aqueles que dizem “claramente, é um ponteiro,” mas isto presume uma implementação fundamental. Também, referências Java são muito mais parecidas com referências C++ que ponteiros em sua sintaxe. Na primeira edição deste livro, eu escolhi inventar um novo termo, “handle,” porque referências C++ e referências Java tem algumas diferenças importantes. Eu estava saindo do C++ e não queria confundir os programadores C++ os quais eu concluí que seriam a maior audiência para Java. Na 2ª edição, eu decidi que “referência” era o termo mais comumente usado, e que alguém mudando de C++ teria muito com que se deparar além da terminologia de referências, assim eles podem pular nisto com ambos os pés. Contudo, há pessoas que discordam sempre com o termo “referência.” Eu li em um livro onde estava “completamente errado dizer que Java suporta passagem por referência,” porque os identificadores de objeto Java (de acordo com aquele autor) são atualmente “referências a objetos.” E (ele continua) tudo é atualmente passado por valor. Assim você não está passando por referência, você está “passando uma referência a um objeto por valor.” Alguém poderia arguir a respeito da precisão de cada explanação convulsiva, mas eu penso que minha abordagem simplifica a compreensão do conceito sem ferir ninguém (Bem, os advogados da linguagem podem reclamar que eu estou mentindo para você, mas eu direi que estou providenciando um abstração apropriada.)



[11] static são métodos, sobre os quais você aprenderá em breve, que podem ser chamados pela classe, sem um objeto.



[12] Com a exceção comum dos já mencionados tipos de dados “especiais” boolean, char, byte, short, int, long, float, e double. Em geral, entretanto, você passa objetos, o que realmente significa que você passa referências a objetos.



[13] O compilador Java e a documentação da Sun não foram incluidas no CD deste livro porque eles tendem a trocar regularmente. Baixando você mesmo, obterá sempre a mais recentes versões.



[14] O compilador “jikes” da IBM é uma alternativa comum, como ele é significativamente mais rápido que o javac da Sun.



[15] Originalmente, eu criei uma ferramenta usando Python (ver www.Python.org), que usa esta informação para extrair os arquivos de código, colocá-os em subdiretórios apropriados, e cria os makefiles. Nesta edição, todos os arquivos estão armazenados em um Sistema de Versões Concorrentes (CVS) e automaticamente incorporados neste livro usando uma macro de Visual BASIC for Applications (VBA). Esta nova abordagem parece trabalhar muito melhor em termos de manutenção de código, principalmente por causa do CVS.



[16] http://java.sun.com/docs/codeconv/index.html. Para preservar espaço neste livro e nas apresentações de seminários, nem todas aquelas diretrizes seriam seguidas.


Anterior Próximo Página Inicial Índice Conteúdo