Como funciona a linguagem java

Entendendo o que acabou de acontecer

Mas o que foi que eu fiz? Em primeiro lugar, você escreveu um código para um  applet Java extremamente simples. Um applet é um programa Java que pode ser executado dentro de um programa de navegação na internet (browser), ao contrário de um aplicativo Java, que é um programa independente executado em um computador local (os aplicativos Java são um pouco mais complicados e não tão populares, por isso estamos começando com os applets). Depois, compilamos o applet usando o javac. O passo seguinte foi criar uma página da internet extremamente simples cuja função era somente "abrigar" o applet. Rodamos o applet usando o appletviewer, embora também dê para executá-lo, facilmente, em um programa de navegação.

O programa em si tem cerca de 10 linhas:

  import java.awt.Graphics;
      public class FirstApplet extends java.applet.Applet
    {
        public void paint(Graphics g)
        {
            g.drawLine(0, 0, 200, 200);
        }
    }  

Este é um dos applets mais simples que você pode criar. Para entendê-lo por completo, será necessário aprender bastante, especialmente no que diz respeito às técnicas de programação orientadas a objetos. E já que estou presumindo que você não tem a mínima noção sobre programação, gostaria que nos concentrássemos em só uma só linha deste programa no momento:

          g.drawLine(0, 0, 200, 200);   

Esta é a linha do programa que faz todo o trabalho. É ela que desenha a linha diagonal. O resto do programa, por sua vez, é a armação que dá suporte àquela linha, e vamos nos permitir ignorar a armação no momento. O que você fez nesse programa foi mandar o computador desenhar uma linha do canto superior esquerdo (0,0) ao canto inferior direito (200, 200). E o computador, obediente que é, desenhou exatamente como mandamos. Essa é a essência da programação de computadores!

(Repare também que, na página HTML, configuramos o tamanho da janela do applet (no passo 5 acima) para ter largura e altura iguais a 200.)

Neste programa, nós usamos um método (ou função) chamada drawLine e passamos 4 parâmetros para ela (0, 0, 200, 200). A linha termina com um "ponto e vírgula". Ele atua como o ponto final no fim de uma frase. A linha começa com g., o que significa que queremos usar a função chamada de drawLine no objeto específico g (que, como você pode conferir uma linha acima, é da classe Graphics, ou gráfico, em Português. Não se preocupe, ainda vamos entrar nos detalhes sobre classes e suas funções neste artigo).

Um método não é nada mais do que um comando, ou seja, ele manda o computador fazer algo. No nosso caso, drawLine manda o computador desenhar uma linha entre os pontos especificados: (0, 0) e (200, 200). Imagine a janela tendo sua coordenada 0,0 no canto superior esquerdo, com os eixos positivos X e Y se estendendo para a direita e para baixo. Cada ponto na tela (cada pixel) representa um incremento na escala.

Experimente o mesmo programa com números diferentes para os 4 parâmetros. Altere um número ou 2, salve suas modificações, recompile usando o javac e execute novamente o applet após cada mudança feita. Vamos ver o que você consegue descobrir.

E que outras funções posso usar além de drawLine? Para descobrir isso, temos de olhar a documentação da classe Graphics. Ao instalar o kit de desenvolvimento Java e descompilar a documentação, um dos arquivos descarregados no processo se chama java.awt.Graphics.html. É ele que explica essa classe específica. Na minha máquina, o caminho exato para este arquivo é o D:jdk1.1.7docsapijava.awt.Graphics.html. Na sua, porém, o caminho deve ser um pouco diferente (mas não tão diferente assim), tudo depende de onde você instalou o kit. De qualquer maneira, encontre o arquivo e o abra. Lá em cima no arquivo há uma seção chamada "Method Index" (Índice de métodos). Ela nada mais é do que uma lista de todas as funções dessa classe. A função drawLine é uma delas, mas existem várias outras. Alguns exemplos do que você pode desenhar:

• linhas
• arcos
• ovais
• polígonos
• retângulos
• seqüências 
• caracteres

Leia a respeito e teste algumas dessas funções diferentes para descobrir o que é possível fazer. Por exemplo, experimente este código:

          g.drawLine(0, 0, 200, 200);
            g.drawRect(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);

Ele vai desenhar uma caixa com 2 diagonais (lembre-se de deixar a janela grande o bastante para conseguir ver tudo). Agora, tente desenhar outras formas. Aproveite e leia sobre como alterar a cor com a função setColor. Por exemplo:

  import java.awt.Graphics;
    import java.awt.Color;
      public class FirstApplet extends java.applet.Applet
    {
          public void paint(Graphics g)
        {
            g.setColor(Color.red);
            g.fillRect(0, 0, 200, 200);
            g.setColor(Color.black);
            g.drawLine(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);
        }
    }  

Repare que foi adicionada uma nova linha import na segunda linha do programa. O resultado deste programa fica assim:

Uma coisa que pode estar passando pela sua cabeça neste momento é: "Como é que ele sabia que tinha de usar Color.red em vez de somente red (vermelho), e como ele sabia que tinha de adicionar uma segunda linha import?" Bom, esse é o tipo de coisa que você aprende com exemplos. Como lhe mostrei um exemplo de como usar o método setColor, agora você sabe que sempre que quiser mudar a cor, terá de usar Color. seguido por um nome de cor como parâmetro para o método setColor; também vai lembrar de adicionar a linha import apropriada no começo do programa. Se for olhar o setColor na documentação, vai ver que tem um link que fala sobre a classe Color, e dentro dele há uma lista de todos os nomes de cores válidos e técnicas para criar novas cores (sem nome). É só ler, guardar na cabeça e agora já sabe como alterar as cores em Java. Essa é a essência de se tornar um programador: aprender novas técnicas e lembrar delas no próximo programa que você for criar. E para aprender essas novas técnicas, você lê um exemplo (como fizemos aqui) ou lê a documentação. Ou, ainda, olha um código de exemplo (como os que estão no diretório de demonstração). Se o seu cérebro gosta de explorar, aprender e lembrar de coisas, você vai adorar programação!

Nesta seção, você aprendeu como escrever códigos lineares e seqüências, ou seja, blocos de códigos que consistem em métodos começando na parte superior e vão descendo (experimente desenhar uma das linhas antes de desenhar o retângulo vermelho e veja o que acontece. Ela será coberta pelo retângulo e ficará invisível, o que nos ensina que a ordem das linhas na seqüência do código é importante). Linhas de código em seqüência formam o núcleo básico de qualquer programa de computador. Agora, antes de irmos para a próxima seção, faça testes com todos os diferentes métodos de desenho e veja o que acontece.

Bugs e depuração

Uma coisa que você vai notar enquanto aprende sobre programação é que você costuma cometer um certo número de erros e suposições que fazem com que o seu programa: 1) não possa ser compilado; ou 2) produza resultados inesperados na execução. Esses problemas são conhecidos como bugs (erros), e a ação de removê-los chama-se depuração. Os programadores costumam passar metade do seu tempo fazendo isso.

Eu sei que você é capaz e vai ter tempo e oportunidade de sobra para criar os seus próprios bugs, mas vou criar alguns para deixá-lo mais familiarizado com as possibilidades. No seu programa, apague um dos "ponto e vírgula" do final de uma linha e tente compilar o programa com o javac. O compilador vai lhe mostrar uma mensagem de erro. Isso se chama erro de compilador e temos de eliminar todos eles antes de poder executar o programa. Outra possibilidade é cometer um erro de digitação no nome de uma função. Experimente esquecer de digitar um "{" ou eliminar uma das linhas import para ficar acostumado com os diferentes erros de compilador. A primeira vez que você vir um certo tipo de erro de compilador, pode ficar bem frustrado. No entanto, se fizer experiências assim (com erros conhecidos criados de propósito), vai se sentir mais familiarizado com vários dos erros comuns.

Um bug, também conhecido como erro de execução ou erro em tempo de execução, acontece quando o programa é compilado, normalmente e consegue ser executado, mas não produz o resultado planejado durante a programação. Por exemplo, este código produz um triângulo vermelho com duas linhas diagonais que o cruzam:

          g.setColor(Color.red);
            g.fillRect(0, 0, 200, 200);
            g.setColor(Color.black);
            g.drawLine(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);  

O código a seguir, por outro lado, produz apenas o retângulo vermelho (ele cobre as 2 linhas):

          g.setColor(Color.black);
            g.drawLine(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);
            g.setColor(Color.red);
            g.fillRect(0, 0, 200, 200);  

Embora o código seja quase idêntico, o resultado é completamente diferente na execução. E se o resultado esperado for visualizar 2 linhas diagonais, o código do segundo exemplo contém um bug.

Lá vai outro exemplo:

          g.drawLine(0, 0, 200, 200);
            g.drawRect(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);

Este código produz uma caixa com uma moldura em preto e 2 diagonais. Já este próximo pedacinho de código produz apenas uma diagonal:

          g.drawLine(0, 0, 200, 200);
            g.drawRect(0, 0, 200, 200);
            g.drawLine(0, 200, 0, 200);  

Novamente, se o que você queria era ver 2 diagonais, o segundo código contém um bug (examine-o até descobrir o que há de errado). Este é o tipo de bug que, por ser muito sutil, pode levar tempo para ser encontrado.

E não se preocupe, pois você vai ter bastante tempo para praticar a "arte" de encontrar seus próprios bugs. O programador comum gasta cerca de metade de seu tempo procurando, encontrando e eliminando esses erros. Então, tente não ficar frustrado quando ocorrerem, eles fazem parte da vida de um programador.