Como funciona a linguagem java

Variáveis

Todos os programas utilizam variáveis para guardar, temporariamente, alguns dados . Por exemplo, se você pedir um número de um usuário em alguma parte do programa, vai armazená-lo em uma variável para que possa utilizar depois. As variáveis devem ser definidas (ou declaradas) em um programa antes que você possa usá-las, e além disso, é necessário atribuir um tipo específico a cada variável. Mais um exemplo: você pode definir uma variável para ter um tipo que permita armazenar números, e definir outra para ter um tipo que a deixe armazenar o nome de uma pessoa. (Como o Java requer que você defina as variáveis antes de usá-las e diga o tipo de valor que deseja armazenar nelas, ela é chamada de uma linguagem de tipagem forte. Como você deve estar se perguntando, há linguagens que não requerem isso, são as linguagens de tipagem fraca. No geral, ao criar programas grandes, a tipagem forte costuma reduzir o número de erros de programação que você pode cometer).

  import java.awt.Graphics;
    import java.awt.Color;
      public class FirstApplet extends java.applet.Applet
    {
          public void paint(Graphics g)
        {
            int width = 200;
            int height = 200;
            g.drawRect(0, 0, width, height);
            g.drawLine(0, 0, width, height);
            g.drawLine(width, 0, 0, height);
        }
    }  

Neste programa, declaramos 2 variáveis chamadas width (largura) e height (altura). E também declaramos que o tipo delas é int. Este é o tipo de variável capaz de armazenar um número inteiro (por exemplo, 1, 2, 3). E, finalmente, inicializamos ambas com o valor de 200. Outra forma de dizer a mesma coisa seria:

          int width;
            width = 200;
            int height;
            height = 200;  

A primeira forma é um pouquinho mais rápida de ser digitada. O ato de definir o primeiro valor de uma variável é chamado de inicialização da variável. Um erro de programação comum acontece quando você esquece de inicializá-la. Para ver esse bug, experimente eliminar a parte da inicialização no código (a parte "= 200") e recompile o programa para ver o que acontece. Você vai ver que o compilador reclama desse problema e essa é uma característica bem legal porque vai ajudá-lo a economizar muito tempo.
Há dois tipos de variáveis em Java: as variáveis simples (primitivas) e as classes.
O tipo int é uma variável simples. Ela é capaz de armazenar um número e nada mais do que isso. Basta declarar uma int, definir um valor e usá-la. As classes, por outro lado, podem conter partes múltiplas e têm métodos que facilitam seu uso. Um exemplo bom e direto de uma classe é a Rectangle (retângulo), e vamos começar por ela.
Uma das limitações do programa no qual trabalhamos até agora é o fato de que ele presume que a janela tem um tamanho de apenas 200 pixels x 200 pixels. E se quiséssemos perguntar para a janela: "Qual é o seu tamanho?," e criar nosso retângulo e diagonais nos baseando neste tamanho? Se você voltar um pouco e olhar a página da documentação referente à classe Graphics (java.awt.Graphics.html, o arquivo que lista todas as funções de desenho disponíveis), vai ver que uma das funções se chama getClipBounds. Clique nesse nome de função para ver a descrição completa. Na verdade, essa função não aceita nenhum parâmetro. Em vez disso, ela retorna um valor do tipo Rectangle. O retângulo que ela retorna contém a largura e a altura da área disponível para desenho. Se você clicar em Rectangle nessa página da documentação, vai ser levado para a página referente à classe Rectangle (java.awt.Graphics.html). Ao olhar na seção Variable Index (Índice de Variáveis) na parte superior da página, vai descobrir que essa classe contém 4 variáveis chamadas de x, y, width (largura) e height (altura), respectivamente. Sabendo isso, o que queremos fazer é saber o tamanho do maior retângulo possível usando getClipBounds, pegar a largura e a altura desse retângulo e salvar esse valores nas variáveis width e height que criamos no exemplo anterior, assim:

  import java.awt.Graphics;
    import java.awt.Color;
    import java.awt.Rectangle;
      public class FirstApplet extends java.applet.Applet
    {
          public void paint(Graphics g)
        {
            int width;
            int height;
            Rectangle r;
              r = g.getClipBounds();
            width = r.width - 1;
            height = r.height - 1;
              g.drawRect(0, 0, width, height);
            g.drawLine(0, 0, width, height);
            g.drawLine(width, 0, 0, height);
        }
    }  

Ao executar este exemplo, vai notar que o retângulo e as diagonais cabem direitinho dentro da área de desenho. E mais: se alterar o tamanho da janela, o retângulo e as diagonais são desenhadas novamente de maneira automática e de acordo com o novo tamanho. Há 5 novos conceitos introduzidos nesse código, vamos ver quais são eles:

1. em primeiro lugar, por estarmos usando a classe Rectangle, precisamos importar java.awt.Rectangle na terceira linha do programa;
2. neste programa, declaramos 3 variáveis, 2 (width e height) são do tipo int e uma (r) é do tipo Rectangle;
3. usamos a função getClipBounds para descobrir o tamanho da área de desenho. E como ela não aceita parâmetros, não lhe demos nenhum ("( )"). Mas ela retorna um "Rectangle". Escrevemos a linha "r = g.getClipBounds();" como uma maneira de dizer: "Por favor, coloque o retângulo retornado na variável r";
4. essa variável r, pelo fato de pertencer à classe Rectangle, contém 4 variáveis: x, y, largura e altura (leia a documentação da classe Rectangle para aprender esses nomes). Se você quiser ter acesso a elas, use o operador "." (ponto). Por isso, a frase "r.width" quer dizer: "Dentro da variável r, pegue o valor chamado width". Este valor vai ser colocado na nossa variável local que também tem o nome de width. Repare que subtraímos 1 no processo. Faça um teste para ver o que acontece se não fizer isso. Aproveite e também tente subtrair 5 em vez de 1;
5. por último, usamos width e height nas funções de desenho;

Uma questão que costuma ser feita nesse ponto é: "É obrigatório declarar variáveis com o nome de width e height?" A resposta é não. Poderíamos ter digitado r.width - 1 diretamente na função de desenho. Mas criar variáveis facilita na hora da leitura e é recomendado que você crie este hábito. A linguagem Java é compatível com muitos tipos de variáveis simples. Estas 3 são as mais comuns:

• int - valores inteiros (1, 2, 3...)
• float - valores decimais (3,14159, por exemplo)
• char - caracteres (a, b, c...)

Dá para realizar operações matemáticas com os tipos simples. Entre as operações que a linguagem Java entende, estão + (soma), - (subtração), * (multiplicação) e / (divisão). Aqui vai um exemplo de como você poderia usar essas operações em um programa. Digamos, por exemplo, que você quer calcular o volume de uma esfera com um diâmetro de 10 metros. Este código faria exatamente o que você quer:

  float diameter = 10;
    float radius;
    float volume;
      radius = diameter / 2.0;
    volume = 4.0 / 3.0 * 3.14159 * radius * radius * radius;  

O primeiro cálculo diz: "Divida o valor da variável chamada diameter (diâmetro) por 2,0 e coloque o resultado na variável chamada radius (raio)". Perceba que o sinal "=" significa "Coloque o resultado do cálculo à direita dentro da variável cujo nome está à esquerda".

Dando voltas

Uma das coisas que os computadores fazem muito bem é realizar cálculos e operações repetitivas. Nas seções anteriores, vimos como escrever "blocos seqüenciais de código", o que, automaticamente nos leva a falar sobre as técnicas para fazer um bloco destes acontecer repetidamente. Por exemplo, digamos que eu lhe peça para desenhar a seguinte figura:
Um bom começo seria desenhar as linhas horizontais assim:
Uma maneira de desenhar as linhas seria criar um bloco seqüencial de código:

  import java.awt.Graphics;
        public class FirstApplet extends java.applet.Applet
      {
            public void paint(Graphics g)
          {
              int y;
              y = 10;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
          }
      }  

Para alguns programadores iniciantes, a frase "y = y + 25;" pode parecer estranha na primeira vez que a virem, mas o que ela significa é: "Pegue o valor que está na variável y, some 25 e coloque o resultado de volta na variável y." Por exemplo, se y contiver 10 antes da linha ser executada, ele terá 35 imediatamente após a linha ter sido executada.
Não é difícil perceber logo de cara que esse código contém 2 linhas iguais sendo repetidas várias vezes. O que acontece é que, neste caso, a repetição não é tão trabalhosa, mas imagine se você quisesse criar uma tabela com milhares de linhas e colunas. Ia ser muito cansativo escrever o programa usando este método de repetição. A solução para esse problema é um loop, como você pode ver abaixo:

  import java.awt.Graphics;
        public class FirstApplet extends java.applet.Applet
      {
            public void paint(Graphics g)
          {
              int y;
              y = 10;
              while (y <= 210)
              {
                  g.drawLine(10, y, 210, y);
                  y = y + 25;
              }
          }
      }  

Ao executar este programa, vai ver que ele desenha 9 linhas horizontais com 200 pixels de comprimento.
A expressão while é uma expressão de loop na linguagem Java. Ela manda o Java agir da seguinte maneira: na frase em que pode ler while, o Java observa a expressão entre parênteses e pergunta, "O y é menor ou igual a 210?":

• caso a resposta seja positiva, o Java insere o bloco de código colocado entre chaves, "{" e "}". A parte do loop acontece ao final do bloco de código. Quando o Java chega à chave final, volta à frase com o while e faz a mesma pergunta novamente. Pode ser que essa seqüência de loop ocorra várias vezes.
• mas se a resposta for negativa, ele pula o código colocado entre as chaves e segue em frente.

Quando executar esse programa, vai ver que o valor inicial de y é 10. Como dez é menor do que 210, o Java bloqueia as chaves, desenha uma linha de (10,10) a (210,10), define y como 35 e volta à frase while. E como 35 é menor do que 210, o Java bloqueia as chaves mais uma vez, desenha uma linha de (10,35) a (210,35), define y como 60 e retorna à frase while. E isso vai se repetindo até que y seja maior do que 210, a única condição em que o programa pára. E podemos completar nossa grade adicionando um segundo loop ao programa, veja só:

  import java.awt.Graphics;
        public class FirstApplet extends java.applet.Applet
      {
            public void paint(Graphics g)
          {
              int x, y;
              y = 10;
              while (y <= 210)
              {
                  g.drawLine(10, y, 210, y);
                  y = y + 25;
              }
              x = 10;
              while (x <= 210)
              {
                  g.drawLine(x, 10, x, 210);
                  x = x + 25;
              }
          }
      }  

Acho que você percebeu que a frase while tem 3 partes:

• há um passo de inicialização que define y como 10;
• depois vem um passo de avaliação dentro dos parênteses da frase while;
• e por último, em algum lugar da frase, há um passo de acréscimo, que aumenta o valor de y.

Além disso, o Java também suporta uma outra maneira de fazer a mesma coisa de um jeito mais compacto do que a frase com while. Basta usar o comando for. Se você tiver um comando while, da seguinte forma:

          y = 10;
              while (y <= 210)
              {
                  g.drawLine(10, y, 210, y);
                  y = y + 25;
              }  

Então, a frase equivalente a for vai ter a seguinte aparência:

          for (y = 10; y <= 210; y = y + 25)
              {
                  g.drawLine(10, y, 210, y);
              }  

Dá para ver que tudo o que esse novo tipo de programa faz é condensar as linhas de inicialização, avaliação e acréscimo em uma só linha. Não passa de uma maneira de reduzir o tamanho do programa que você escreveu.
E já que estamos aqui, lá vão 2 pontos rápidos a respeito dos loops:

• em muitos casos, também seria fácil inicializar y como 210 e subtrair 25 a cada passagem pelo loop. A avaliação iria perguntar: "o y é maior ou igual a 10?" A escolha é só sua, mas o que posso dizer é que a maioria das pessoas acha mais fácil somar do que subtrair. E você, o que acha?
• o passo de acréscimo é muito importante. Um exemplo disso é o seguinte: digamos que você deixou de fora, sem querer, a parte que diz "y = y + 25;" dentro do loop. O que iria acontecer é que o valor de y nunca mudaria (ficando sempre em 10), o que não o deixaria ficar maior do que 210 e o loop continuaria para sempre (ou até que você o parasse, desligando o computador ou fechando a janela). Essa condição é chamada de loop infinito e é um bug bem comum.

Para praticar um pouco o loop, tente escrever programas que desenhem as seguintes figuras: