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:

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.

Como funciona a linguagem java

Fazendo o download do compilador Java

Para ter um ambiente de desenvolvimento Java configurado em sua máquina, você "desenvolve" ou "escreve", programas de computador usando um "ambiente de desenvolvimento". Você vai ainda ter de completar as seguintes etapas:

• fazer o download de um arquivo grande que contenha o ambiente de desenvolvimento Java (o compilador e outras ferramentas).;
• fazer o download de outro arquivo grande com a documentação sobre o Java;
• caso não tenha o WinZip (ou outro programa equivalente) na sua máquina, vai ter de fazer o download de um arquivo que contenha o WinZip e instalá-lo;
• instalar o ambiente de desenvolvimento Java;
• instalar a documentação;
• configurar algumas variáveis de ambiente;
• testar e verificar se está tudo bem.

Mas antes de começarmos, facilitaria um pouco se você criasse um novo diretório, no seu diretório temporário, para armazenar os arquivos que vai "baixar". Vamos chamar esta pasta de diretório de download.

Passo 1 - faça o download do ambiente de desenvolvimento Java
Acesse a página http://java.sun.com/javase/downloads/ (em inglês). Faça o download do programa SDK clicando no link "Download J2SE SDK". Em seguida, vai aparecer um contrato de licença. Clique em "Accept". Selecione o seu sistema operacional e faça o download do arquivo para o seu diretório de download. Esse arquivo é gigante e vai demorar algum tempo para terminar o processo. E se prepare, pois os 2 próximos arquivos também são grandes.

Passo 2 - faça o download da documentação do Java
Procure na página http://java.sun.com/javase/reference/index.jsp a documentação mais indicada para seu sistema operacional..

Passo 3 - faça o download e instale o WinZip
Se não tiver uma versão do WinZip ou algum programa equivalente no seu computador, acesse a página http://www.winzip.com/ (em inglês) e faça o download de uma cópia de teste do WinZip. Para instalá-lo, rode o arquivo EXE. Vamos usá-lo em alguns instantes para instalar a documentação.

Passo 4 - instale o kit de desenvolvimento
Execute o arquivo que você baixou no passo 1. Ele vai ser descompactado e instalado automaticamente.

Passo 5 - instale a documentação
Leia as instruções de instalação da documentação. Elas vão lhe dizer para mudar o arquivo de documentação para o mesmo diretório em que você acabou de instalar o arquivo de desenvolvimento. Descompacte a documentação e coloque-a no lugar correto.

Passo 6 - configure o seu ambiente
Como instruído nesta página (em inglês) é necessário mudar sua variável PATH. A maneira mais fácil de fazer isso é abrir uma janela do MS-DOS e digitar PATH para ver qual a sua configuração no momento. Aí, é só abrir o arquivo "autoexec.bat" no Bloco de Notas e fazer as alterações no PATH especificadas nas instruções.

Passo 7 - teste
Agora, já é possível abrir outra janela do MS-DOS e digitar javac. Se tudo foi configurado adequadamente, vai aparecer um texto de 2 linhas dizendo como usar o javac. Esse é o sinal de que tudo está pronto. Porém, se a mensagem "Bad Command or File Name" aparecer, é o sinal de que algo deu errado. Releia as instruções de instalação para descobrir o que você fez de errado. Certifique-se de que o PATH está configurado corretamente e funcionando. Volte, releia as instruções acima e seja persistente até conseguir resolver o problema.

Parabéns! Você tem o orgulho de ser o dono de uma máquina capaz de compilar programas em Java. Está na hora de começar a criar programas!

A propósito, uma das coisas que você descompactou é um diretório de demonstração cheio de exemplos legais do que dá para fazer com o Java. E o melhor, todos esses exemplos estão prontos para serem executados. Tire um tempinho para encontrar o diretório e brincar com alguns dos exemplos. Como há vários que fazem sons, veja se os seus alto-falantes estão ligados. Para rodar os exemplos, encontre as páginas com nomes como example1.html e as abra no mesmo programa que você usa para navegar na internet.

Seu primeiro programa

O seu primeiro programa vai ser simples e direto. Ele vai criar uma área de desenho e desenhar uma linha diagonal através dela. Para criar este programa, você terá de:

• abrir o bloco de notas e digitar (ou cortar e colar) o programa
• salvar o programa
• compilar o programa com um compilador Java para criar um applet Java
• corrigir problemas que aparecerem
• criar uma página da web (HTML) para "abrigar" o applet que você criou 
• executar o applet Java

O programa que vamos usar para essa demonstração é este aqui:

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

Passo 1 - digite o programa
Crie um novo diretório para ele. Abra o bloco de notas (ou qualquer outro editor de texto capaz de criar arquivos TXT). Digite ou corte e cole o programa na janela do Bloco de Notas. Preste atenção: a diferença entre maiúsculas e minúsculas é importante quando estiver digitando o programa. Por isso, é necessário digitar as maiúsculas e minúsculas exatamente como no nosso exemplo. Leia novamente o programa acima. Ele não vai funcionar a menos que você digite EXATAMENTE da mesma maneira.

Passo 2 - salve o arquivo
Salve o arquivo com o nome FirstApplet.java no diretório que criou no passo 1, a diferença entre maiúsculas e minúsculas também importa na hora de escrever o nome do arquivo. Certifique-se de que 'F' e 'A' estejam em maiúsculas e todos os outros caracteres estejam em minúsculas.

Passo 3 - compile o programa
Abra uma janela do MS-DOS. Mude o diretório ("cd") para o diretório que contém o FirstApplet.java. Digite:

       javac FirstApplet.java   

Maiúsculas são diferentes de minúsculas! Agora, há duas possibilidades: ou ele vai funcionar, e não aparecerá nada na janela, ou vão aparecer alguns erros. No caso de não aparecerem erros, será criado um arquivo com o nome de FirstApplet.class logo após o FirstApplet.java, no mesmo diretório.

Certifique-se de que o arquivo foi salvo com o nome FirstApplet.java em vez de FirstApplet.java.txt. A maneira mais fácil de fazer esta verificação é digitar dir na janela do MS-DOS e olhar o nome do arquivo. Caso ele tenha uma extensão .txt, renomeie o arquivo para retirar esta extensão. Outra maneira de fazer essa verificação é executar o Windows Explorer e selecionar Opções no menu Exibir. Certifique-se de que a opção "Ocultar as extensões dos tipos de arquivos conhecidos" NÃO está selecionada e olhe o nome do arquivo no próprio Explorer. Modifique se for necessário.

Passo 4 - corrija quaisquer problemas
Se houver erros, corrija-os. Compare o seu programa com o programa acima e faça com que sejam exatamente idênticos. E vá recompilando até sumirem todos os erros. Se o javac não estiver funcionando, volte à seção anterior e corrija sua instalação.

Passo 5 - crie uma página HTML
Chegou a hora de criar uma página HTML para "abrigar" o applet. Para isso, abra mais uma janela do bloco de notas e digite o seguinte:

<html>
<body>
<applet code=FirstApplet.class width=200 height=200>
</applet>
</body>
</html>

Salve esse arquivo no mesmo diretório e com o nome de applet.htm.    O código do passo anterior é o modo de acessar o applet Java, a paritr de uma página web.

Passo 6 - execute o applet
Na janela do MS-DOS, digite:

appletviewer applet.htm

Deve surgir uma linha diagonal sendo traçada do canto superior esquerdo ao canto inferior direito:

Aumente um pouco a janela de visualização do applet para conseguir ver a linha toda. Além disso, também dá para abrir a página HTML em qualquer navegador moderno como o Netscape Navigator ou o Microsoft Internet Explorer e ver quase a mesma coisa.

É isso aí! Você acabou de criar se primeiro programa!!!

Como funciona a linguagem java

Introdução

Já parou para imaginar como funcionam os programas de computador? Já quis aprender como criar seus próprios programas? Se você tem 14 anos de idade e gostaria de aprender a criar seu primeiro jogo, ou se tem 70 e faz 20 anos que está curioso sobre programação de computadores enfim não importa a idade, este artigo foi feito especialmente para você. Nesta edição, ensinaremos como os programas de computador funcionam. Vamos começar com a linguagem de programação Java.

E para ensiná-lo, vamos supor várias coisas:

• presumiremos que você não saiba nada sobre programação. No entanto, se já conhece um pouco sobre isso, a primeira parte deste artigo vai parecer fácil demais para você. Sinta-se à vontade para pular as seções até chegar algo que você não conheça;
• presumiremos que você conhece um pouco sobre o computador que está usando, ou seja já sabe editar, copiar, apagar e renomear arquivos, encontrar informações no seu sistema e outras coisas do tipo;
• para simplificar as coisas, vamos supor também que você está usando uma máquina com Windows 95, 98, 2000, NT ou XP, e para aqueles que não estão usando um desses sistemas operacionais, já sabem que terão de transpor os conceitos para o sistema que estiverem usando, certo?
• e, por último, mas não menos importante, vamos supor que você tem vontade de aprender.

Todas as ferramentas de que precisa para começar a programar em Java estão disponíveis na internet, de graça. Também há uma grande quantidade de material educativo sobre o assunto, o que significa que dá para continuar a aprender mais mesmo depois que terminar de ler este artigo. É possível aprender a programação em Java sem gastar dinheiro com compiladores, ferramentas de desenvolvimento, material para leitura, etc. E depois que tiver aprendido Java, fica fácil aprender outras linguagens. Por isso, não se preocupe pelo fato de ser um iniciante no assunto, você veio para o lugar certo.

Bem, considerando tudo isso, estamos prontos para continuar. Mãos à obra!

Alguns termos

Lembre-se vamos supor que você não sabe nada sobre programação. Aqui vão alguns termos para deixar as coisas mais compreensíveis:

• programa de computador - um programa de computador é um conjunto de instruções que diz ao computador exatamente o que deve fazer. Estas instruções podem dizer ao computador para somar alguns números ou comparar 2 números. E, também, tomar uma decisão dependendo do resultado da comparação ou o que quer que você consiga imaginar! Mas um programa de computador não é nada mais do que um conjunto de instruções para o computador, assim como uma receita é um conjunto de instruções para um cozinheiro ou notas musicais são um conjunto de instruções para um músico. O computador segue suas instruções à risca e acaba fazendo algo que você precisa (como calcular o seu orçamento mensal, exibir um jogo na tela ou executar um processador de textos).
• linguagem de programação - para que o computador consiga reconhecer as instruções que você deu, elas precisam ser escritas em um idioma que ele entenda: uma linguagem de programação. Da mesma maneira que há vários idiomas diferentes, também há muitas linguagens de programação por aí (Fortran, Cobol, Basic, Pascal, C, C++, Java, Perl). No fundo, todas elas expressam mais ou menos os mesmos conceitos, mas de maneiras diferentes.
• compilador - um compilador traduz um programa de computador escrito em uma linguagem que pode ser lida por humanos (como o Java) para uma forma que o computador possa entender e executar. Sabe aqueles arquivos EXE que existem no seu computador? Então! Eles são os arquivos que os compiladores geram e contêm programas executáveis, programas em linguagem de máquina que foram traduzidos a partir de programas escritos em linguagem de humanos.

Para que você possa começar a escrever programas na linguagem de programação chamada de Java, vai precisar de um compilador específico para essa linguagem. A próxima seção vai guiá-lo por todo o processo de download e instalação de um compilador. Depois de ter obtido um compilador, estaremos prontos para começar. Mas, dependendo da sua conexão Internet, esta parte do processo vai levar algum tempo, com uma grande parte dele sendo usada para fazer o download de vários arquivos grandes. E, além disso, você também vai precisar de cerca de 40 megabytes de espaço livre em disco rígido (certifique-se de que tem esse espaço disponível antes de começar!)

Como funcionam as portas eletrônicas

Construindo o regulador

Para construir o regulador, você precisará de três peças:

• um regulador de 5 volts 7805 em um encapsulamento TO-220
  
  
• dois capacitores eletrolíticos de qualquer valor entre 100 e 1.000 microfarads

Um capacitor eletrolítico

O 7805 recebe uma tensão entre 7 e 30 volts e a regula para exatamente 5 volts. O primeiro capacitor elimina qualquer ruído proveniente do transformador, de modo que o 7805 receba uma tensão de entrada regular, e o segundo capacitor atua como um equilibrador de carga para assegurar uma saída consistente do 7805.

O 7805 possui três pinos. Se você olhar pela frente (o lado com a gravação), os três pinos serão, da esquerda para a direita, a tensão de entrada (7 a 30 volts), o terra e a tensão de saída (5 volts).

Para conectar o regulador ao transformador, você pode usar esta configuração:

Os dois capacitores são representados por linhas paralelas. O sinal "+" indica que os capacitores eletrolíticos são polarizados: um capacitor eletrolítico apresenta um terminal positivo e um terminal negativo (um dos quais é identificado). Você precisa se assegurar quanto à polaridade correta quando instalar o capacitor.

Você pode construir este regulador em sua placa de montagem. Para isso, precisará entender como é feita a fiação interna da placa de montagem. A figura a seguir mostra essa fiação:

Nas bordas externas da placa de montagem há duas linhas de terminais que percorrem toda a extensão da placa. Todos esses terminais são conectados internamente. Você passará +5 volts através deles e aterrará os outros. No centro da placa existe um canal. Em qualquer lado do canal há conjuntos de cinco terminais interconectados. Você pode usar seu multímetro para ver as interconexões. Coloque o dial do multímetro em seu ajuste de ohms e, em seguida, introduza fios em diferentes pontos da placa de montagem (as pontas de prova do multímetro provavelmente serão muito largas para se encaixarem nos orifícios da placa de montagem).

No ajuste de ohms, o multímetro mede a resistência. A resistência será zero se houver uma conexão entre dois pontos (encoste uma ponta de prova na outra para ver isso) e será infinita se não houver conexão. Você descobrirá que os pontos na placa realmente estão interconectados conforme é mostrado no diagrama. Outra maneira de ver as conexões é puxar o adesivo na parte posterior da placa de montagem um pouco para trás e ver os conectores metálicos.

Agora conecte as peças para seu regulador:

1. conecte o fio-terra do transformador a uma das tiras externas longas da placa de montagem;
2. encaixe o 7805 em três das fileiras de cinco orifícios;
3. conecte o terra da barra de terminais ao pino central do 7805 com um fio: simplesmente corte um pedaço de fio, desencape ambas as extremidades e encaixe-as;
4. conecte o fio positivo do transformador ao pino esquerdo (entrada) do 7805;
5. conecte um capacitor a partir do pino esquerdo do 7805 ao terra, prestando atenção à polaridade;
6. conecte o pino de 5 volts do 7805 à longa barra de terminais externa na placa de montagem;
7. Conecte o segundo capacitor entre as barras de 5 volts e de aterramento.

Você criou seu regulador. Ele poderá se parecer com este quando estiver pronto:

Em ambas as figuras acima, as linhas provenientes do transformador entram pelo lado esquerdo. Você pode ver a linha do terra do transformador conectada diretamente à barra de aterramento que passa pelo comprimento da placa, na parte inferior. A barra superior fornece +5 volts e está conectada diretamente ao pino +5 do 7805. O capacitor esquerdo filtra a voltagem do transformador, enquanto o capacitor direito filtra os +5 volts produzidos pelo 7805. O LED se conecta entre as barras +5 e de aterramento, através do resistor, e permite que você veja quando a alimentação de energia é "ativada".

Encaixe o transformador e meça a tensão de entrada e saída do 7805. Você deverá ver exatamente 5 volts saindo do 7805, independente da tensão fornecida pelo seu transformador. Caso isso não ocorra, desconecte imediatamente o transformador e faça o seguinte:

• remova os capacitores. Encaixe o transformador de volta por um momento e veja se ocorreu alguma mudança;
• assegure-se de que o fio terra e o fio positivo provenientes do transformador não estejam invertidos (se estiverem, é provável que o 7805 esteja muito quente e, possivelmente, queimado);
• assegure-se de que o transformador esteja produzindo qualquer tensão, desconectando-o e verificando-o com seu voltímetro. Veja a página anterior para aprender como fazer isso.

Assim que constatar 5 volts saindo do regulador, você poderá fazer novos testes e comprovar que ele está ativado conectando um LED a ele. Você precisa conectar um LED e um resistor em série: isso é fácil de fazer em sua placa de montagem. Você precisa usar o resistor, caso contrário o LED irá queimar imediatamente. Um bom valor para o resistor é 330 ohms, apesar de que qualquer valor entre 200 e 500 ohms funciona perfeitamente. Os LEDs, sendo diodos, possuem uma polaridade. Então, se ele não acender, tente inverter as pontas e ver se isso ajuda.

Pode parecer que deu muito trabalho apenas para fazer a fiação da fonte de alimentação e colocá-la em funcionamento. Mas você já aprendeu algumas coisas nesse processo. Agora podemos experimentar as portas booleanas.

Brincando com portas booleanas

Se você usasse a tabela na página anterior para fazer o pedido de suas peças, teria seis chips diferentes contendo seis tipos de portas:

• 7400 - NAND (quatro portas por chip)
• 7402 - NOR (quatro portas por chip)
• 7404 - NOT (seis portas por chip)
• 7408 - AND (quatro portas por chip)
• 7432 - OR (quatro portas por chip)
• 7486 - XOR (quatro portas por chip)

No interior dos chips, as coisas são assim:

Vamos começar com um chip AND 7408. Se você olhar para o chip, haverá normalmente um ponto no pino 1, ou uma marca na extremidade deste pino. Também pode haver alguma outra marcação para indicar o pino 1. Pressione o chip na placa de montagem de modo que ele se encaixe no canal central. Você pode ver nos diagramas que, em todos os chips, o pino 7 deve se conectar ao terra e o pino 14 deve se conectar a +5 volts. Assim, conecte estes dois pinos de maneira apropriada. Se você os conectar invertidos, queimará o chip: tome muito cuidado para não invertê-lo. Caso queime um chip acidentalmente, jogue-o fora para não confundi-lo com suas peças boas. Agora conecte um LED e o resistor entre o pino 3 do chip e o terra. O LED deve acender. Caso contrário, inverta o LED para que ele acenda. Seu CI deve se parecer com este:

Nesta figura, o chip está recebendo +5 volts no pino 14 (fio vermelho) e o terra no pino 7 (fio preto). O resistor deixa o pino 3 e se conecta ao LED, o qual também está conectado ao terra. Conecte os fios de +5 e terra às entradas A e B da porta para exercitá-la.

Eis o que está acontecendo: em TTL, +5 representa um binário "1" e o terra representa um binário "0". Se um pino de entrada de uma porta não está conectado a nada, ele "flutua alto", o que significa que a porta assume haver um "1" no pino. Assim, a porta AND deve estar vendo "1s" nas entradas A e B, o que significa que a saída no pino 3 está fornecendo 5 volts. Então o LED se acende. Se você aterrar o pino 1 ou 2 no chip, o LED se apagará. Esse é o comportamento padrão para uma porta AND, conforme descrito em Como funciona a lógica booleana.

Experimente as outras portas conectando-as em sua placa de montagem e veja que todas se comportam de acordo com as tabelas lógicas apresentadas no artigo sobre a lógica booleana. Então, tente fazer a fiação de algo mais complicado. Por exemplo, faça a fiação para a porta XOR ou bit Q do adicionador completo, e veja que o comportamento é o esperado.

Como funcionam as portas eletrônicas

Montando seu equipamento

Para brincar com as portas TTL, você deve ter vários equipamentos. Eis uma lista do que você precisará comprar:

• uma placa de montagem
• um multímetro
• uma sonda lógica (opcional)
• uma fonte de alimentação regulada de 5 volts
• uma coleção de chips TTL para experimentar
• diversos LEDs (diodos emissores de luz) para ver as saídas das portas
• diversos resistores para os LEDs
• um pouco de fio (bitola 20 a 28) para conectar as coisas

Vamos ver alguns detalhes sobre esses componentes para familiarizá-lo com eles:

• Conforme descrito na página anterior, uma placa de montagem é um dispositivo que facilita a confecção de seus circuitos.
• Um multímetro permite que você meça a voltagem e a corrente com facilidade. Nós o usaremos para garantir que nossa fonte de alimentação esteja produzindo a voltagem correta.
• A sonda lógica é opcional. Ela facilita testar o estado (1 ou 0) de um fio, mas você pode fazer a mesma coisa com um LED.
• Das peças descritas acima, todas são fáceis de obter, exceto a fonte de alimentação de 5 volts. Parece que ninguém vende uma fonte de alimentação regulada de 5 volts simples e barata. Portanto, você tem duas escolhas. Pode comprar uma fonte de alimentação mais potente da Jameco (por exemplo, para um vídeo game) e usar a fonte de 5 volts para isso, ou pode usar um pequeno transformador retificador power-cube e então construir o regulador você mesmo. Falaremos das duas opções a seguir.
  

  Um resistor e um LED

• Um LED (diodo emissor de luz) é uma mini lâmpada. Você usa LEDs para ver a saída de uma porta.
• Usaremos os resistores para proteger os LEDs. Se você deixar de usar os resistores, os LEDs queimarão imediatamente.

Não se encontra este equipamento em qualquer loja. Entretanto, não é difícil obter essas peças. Você tem algumas escolhas ao tentar comprar os componentes listados acima.

1. Radio Shack.
2. Uma loja local de componentes eletrônicos - a maioria das cidades possui suas lojas de componentes eletrônicos e muitas delas têm produtos eletrônicos excedentes.
3. Uma loja de encomendas pelo correio.

A fonte de alimentação

Definitivamente, você precisará de uma fonte de alimentação regulada de 5 volts para trabalhar com chips TTL. Como mencionado anteriormente, nenhuma loja parece oferecer uma fonte de alimentação regulada de 5 volts padrão e de baixo custo. Essa é uma fonte de alimentação de 5 volts de um antigo vídeo game da Atari. Algumas lojas têm disponíveis mais de 20 fontes de alimentação diferentes, produzindo todos os tipos de tensão e correntes. Você precisa de 5 volts com pelo menos 0,3 ampères (300 miliamperes). Você não precisa de 2 ampères, portanto, não compre uma fonte de alimentação mais potente do que precisa. O que você pode fazer é adquirir a fonte de alimentação, cortar o conector e obter acesso aos 5 volts e fios de aterramento. Isso funcionará muito bem e, provavelmente, será o caminho mais fácil. Você pode usar seu voltímetro (veja abaixo) para se assegurar de que a fonte de alimentação produz a tensão de que precisa.
Sua alternativa é construir uma fonte de 5 volts a partir de um pequeno transformador retificador power-cube. O que você precisa é de um transformador que produza 7 a 12 volts CC com 100 miliampères ou mais. Observe que:

• o transformador PRECISA produzir tensão CC
• ele PRECISA produzir de 7 a 12 volts
• ele PRECISA produzir 100 miliampères (0,1 ampère) ou mais

Você pode ter um desses guardado em casa que poderá usar: leia a gravação na tampa e se assegure de que ele atenda aos três requisitos.
Há disponível no mercado um modelo de 7,5 volts e 300 miliampères. Desencaixe o conector do transformador e separe os dois fios. Desencape cerca de um centímetro da isolação de ambos os fios. Agora encaixe o transformador (depois de encaixado, NUNCA deixe que os dois fios do transformador encostem um no outro). Use seu voltímetro (veja abaixo) para medir a voltagem. Você deve se assegurar de que o transformador esteja produzindo aproximadamente a tensão mencionada (ela poderá ser alta, mas não haverá problema). Seu transformador retificador atua como uma bateria para você, de modo que você pode determinar qual é o fio negativo e qual é o positivo. Encaixe as pontas de prova preta e vermelha do voltímetro nos fios do transformador retificador, aleatoriamente, e veja se a tensão medida é positiva ou negativa. Se for negativa, inverta as pontas de prova. Agora você sabe que o fio ao qual a ponta de prova preta está conectada é o fio negativo (terra), enquanto o outro é positivo.

Um multímetro mede voltagem, corrente e resistência. Ele possui duas "pontas de prova" (fios), uma preta e outra vermelha. O que queremos fazer com o medidor agora é aprender a medir voltagem. Para isso, encontre uma bateria AA, C ou D (que não esteja descarregada). Ela será usada como fonte de voltagem. Cada aparelho é diferente, mas, em geral, aqui estão as etapas para a preparação da medição da voltagem da bateria: Pegue a ponta de prova preta e introduza-a no orifício marcado (depende do medidor) como "Common", "Comum", "Com", "Ground", "Gnd", "Terra" ou "-" (menos). Pegue sua ponta de prova vermelha e introduza-a no orifício marcado (depende do medidor) como "Volts", "V", "Pos", "Positivo" ou "+" (mais). Alguns medidores possuem múltiplos orifícios para a ponta de prova vermelha. Assegure-se de usar a correta para a medição de volts. Gire a chave seletora para a seção "DC Volts" ou "Volts CC". Geralmente, há múltiplas faixas de voltagem disponíveis nessa seção. No meu medidor, as faixas são de 2,5, 50, 250 e 1.000 volts (medidores modernos com auto-ajuste podem ajustar a faixa automaticamente para você). Seu medidor terá faixas similares. A bateria terá uma voltagem de 1,25 volt, portanto, encontre a voltagem superior mais próxima a 1,25 volt. Neste caso, será a de 2,5 volts. Encoste a ponta de prova preta no terminal negativo da bateria e a ponta de prova vermelha no terminal positivo. Você deverá ler algo próximo a 1,25 volt no medidor. É importante que você prenda a ponta de prova preta ao negativo e a ponta de prova vermelha ao positivo e adquira o hábito de fazer isso. Agora você pode usar o medidor para testar sua fonte de alimentação. Mude a faixa de voltagem, se necessário, e então conecte a ponta de prova preta ao terra e a ponta de prova vermelha ao que você supõe que seja o fio positivo de 5 volts. O medidor deverá ler 5 volts. Usando um multímetro

Como funcionam as portas eletrônicas

Introdução

Se você leu o artigo sobre a lógica booleana, então sabe que os dispositivos digitais dependem de portas booleanas. Você também leu no artigo que uma maneira de implementar portas envolve o uso de relés. No entanto, nenhum computador moderno usa relés, eles usam "chips".

Que tal fazer experiências com portas booleanas e chips? E se você quisesse construir seus próprios dispositivos digitais? Isso não é tão difícil. Neste artigo, você verá como é possível experimentar todas as portas analisadas no artigo de lógica booleana. Vamos falar sobre onde obter componentes, como você pode fazer sua conexão e como ver o que eles estão fazendo. No processo, você abrirá as portas para todo um novo universo de tecnologia.

Preparando o cenário

No artigo Como funciona a lógica booleana, vimos as sete portas fundamentais. Essas portas são os blocos de montar de todos os dispositivos digitais. Também vimos como combinar essas portas em funções de nível cada vez mais elevado, como adicionadores completos. Se você quiser fazer experiências com essas portas, a maneira mais fácil é adquirir algo chamado chips TTL e fazer rapidamente a fiação de circuitos em um dispositivo chamado placa de montagem sem solda. Vamos falar um pouco sobre a tecnologia e o processo, para que você possa conhecer o assunto.

Se você analisar a história da tecnologia de computadores, descobrirá que todos eles são projetados ao redor de portas booleanas. Entretanto, as tecnologias usadas para implementar essas portas mudaram drasticamente ao longo dos anos. As primeiras portas eletrônicas foram criadas usando relés. Essas portas eram lentas e volumosas. Em pouco tempo, as válvulas a vácuo substituíram os relés. As válvulas eram muito mais rápidas, mas também eram volumosas e, além disso, eram perseguidas pelo problema da queima (parecido com o das lâmpadas). Assim que os transistores foram aperfeiçoados (eles foram inventados em 1947), os computadores começaram a usar portas feitas de transistores discretos. Os transistores possuíam muitas vantagens: alta confiabilidade, baixo consumo de energia e tamanho pequeno comparado às válvulas ou relés. Esses transistores eram componentes discretos, o que significa que cada transistor era um dispositivo independente. Cada um era montado em uma pequena cápsula metálica com, aproximadamente, o tamanho de uma ervilha com três fios presos a ela. Poderiam ser necessários três ou quatro transistores, diversos resistores e diodos para criar uma porta.

No início dos anos 60 foram inventados os circuitos integrados (CIs). Transistores, resistores e diodos podiam ser fabricados juntos com "chips" (pastilhas) de silício. Essa descoberta deu origem aos CIs SSI (de small scale integration, integração em pequena escala). Um CI SSI consiste de uma pastilha de 3 milímetros quadrados de silício onde talvez 20 transistores e vários outros componentes foram gravados. Um chip comum poderia conter de quatro a seis portas individuais. Esses chips encolheram o tamanho dos computadores por um fator aproximado de 100 e tornou sua fabricação muito mais fácil.

À medida que as técnicas de fabricação das pastilhas melhorava, mais e mais transistores podiam ser gravados em um único chip. Isso levou aos chips MSI (de integração de média escala) que contêm componentes simples, como adicionadores, feitos de múltiplas portas. Então a LSI (integração em larga escala) permitiu que os projetistas encaixassem todos os componentes de um microprocessador simples em um único chip. O processador 8080, lançado pela Intel em 1974, foi o primeiro microprocessador montado em um único chip bem sucedido comercialmente. Ele era um chip LSI que continha 4.800 transistores. Desde então, a tecnologia VLSI tem aumentado constantemente o número de transistores. O primeiro processador Pentium foi lançado em 1993 com 3,2 milhões de transistores. Chips atuais como o Intel Core2 Duo tem quase 300 milhões de transistores.

Para fazer experimentos com as portas, vamos voltar um pouco no tempo e usar CIs SSI. Esses chips ainda são amplamente disponíveis, extremamente confiáveis e baratos. Os CIs específicos que usaremos são de uma família chamada TTL (de Transistor Transistor Logic, lógica de transistor a transistor, que recebeu este nome devido à fiação específica das portas no CI). Os chips que usaremos são da série TTL mais comum, chamada série 7400 . Há talvez cerca de 100 diferentes chips SSI e MSI na série, que abrangem desde portas AND simples até completas ULAs (unidades lógicas aritméticas).

Os chips da série 7400 são alojados em DIPs (de dual inline packages, cápsulas duplas em linha). Como ilustrado à direita, um DIP é uma pequena cápsula plástica com 14, 16, 20 ou 24 pequenas pontas metálicas protuberantes para possibilitar as conexões até portas em seu interior. A maneira mais fácil de construir algo a partir dessas portas é colocar os chips em uma placa de montagem sem solda. A placa de montagem permite que você faça a fiação dos componentes simplesmente encaixando pedaços de fios nos orifícios de conexão existentes na placa.

Uma placa de montagem sem solda

Todas as portas eletrônicas necessitam de uma fonte de energia elétrica. As portas TTL usam 5 volts para sua operação. Os chips são bastante exigentes quanto a essa voltagem, então, é recomendável usar uma fonte de alimentação de 5 volts regulada e sem ruídos sempre que trabalhar com chips TTL. Outros modelos de chips, como a série 4000 de chips CMOS, são bem menos específicos quanto às voltagens utilizadas. Os chips CMOS possuem a vantagem adicional de usar muito menos energia. No entanto, eles são muito sensíveis à eletricidade estática e isso os torna menos confiáveis, a menos que você possua um ambiente de trabalho livre de estática. Assim, ficaremos com o TTL para esta aplicação.

Como funciona a algebra booleana

Implementação de portas

Nas seções anteriores, vimos que, com o uso de portas booleanas simples, podemos implementar somadores, contadores, latches e assim por diante. É um avanço e tanto pois, até pouco tempo atrás, só os seres humanos sabiam somar dois números. Sem muito trabalho, é possível projetar circuitos Booleanos que implementem subtração, multiplicação, divisão... veja que estamos próximos de uma calculadora de bolso. A partir dela, não é longo o caminho até as CPUs usadas nos computadores.

E como implementar essas portas na vida real? O Sr. Boole as concebeu no papel e no papel elas parecem ótimas. No entanto, precisamos implementá-las fisicamente para que as portas possam executar sua lógica efetivamente. Feita a transição, teremos nos lançado à criação de verdadeiros dispositivos computacionais.

O modo mais simples de se entender a execução física da lógica booleana é com o uso de relés. Essa é a forma pela qual foram implementados os primeiros computadores. Atualmente, os relés foram substituídos pelos sub-microscópicos transistores criados em chips de silício. Esses transistores são incrivelmente pequenos e rápidos, e consomem bem pouca energia se comparados a um relé. No entanto, os relés são incrivelmente fáceis de se entender, e podem implementar lógica booleana de forma muito simples. Por causa dessa simplicidade, você será capaz de ver que o mapeamento, desde as "portas na teoria" até "ativar portas implementadas em realidade física", é algo possível e simples. Realizar o mesmo mapeamento com transistores é tão fácil quanto.

Vamos começar com um inversor. É fácil implementar uma porta NOT com um relé: iremos usar voltagens que representam estados de bit. Atribuímos ao binário 1 o valor de 6 volts, e ao binário 0 o valor de zero volts (terra). Usamos uma bateria de 6 volts para prover os circuitos de energia. A porta NOT, portanto, terá a seguinte aparência:

Se esta figura não faz sentido para você, leia Como funciona o relé para obter uma explicação.

Neste circuito, você verá que, se atribuirmos zero volts a A, Q receberá 6 volts; e se atribuirmos 6 volts a A, Q receberá zero volts. É muito fácil de se implementar um inversor com um relé.

Também é fácil implementar uma porta AND com dois relés:

Aqui, note que, se atribuirmos 6 volts para A e B, Q receberá 6 volts. Do contrário, Q receberá zero volts. Este é exatamente o comportamento que se espera de uma porta AND. A porta OR é ainda mais simples: é só juntar dois fios, A e B, para criá-la. Você também poderá utilizar dois relés paralelos, se assim o desejar.

Partindo desse axioma, é possível criar três portas básicas: E, OU ou NÃO (são mais comuns os seus equivalentes em inglês: AND, OR e NOT), a partir dos relés. Podemos juntar estas portas físicas usando os diagramas lógicos acima para criar um somador físico de 8 bits (ripple-carry adder). Se usarmos chaves simples (interruptores) para aplicar entradas A e B ao somador e juntarmos todas as oito linhas Q a lâmpadas, poderemos somar quaisquer dois números e ler os resultados nas lâmpadas ("acesas" = 1, "apagadas" = 0).

A lógica booleana sob a forma de portas simples é bastante direta. A partir delas, criam-se funções mais complexas, como a soma. A implementação física dessas portas é fácil e possível. Desses três fatores, obtemos o coração da revolução digital e podemos entender, em profundidade, como funcionam os computadores.

Como funciona a algebra booleana

Flip-flops

Uma das coisas mais interessantes que podemos fazer com portas booleanas é criar memória. Se as portas forem dispostas corretamente, elas vão se lembrar do valor de entrada. Este conceito simples é a base da RAM (memória de acesso randômico) dos computadores, e também possibilita a criação de uma ampla variedade de circuitos úteis.

A memória é baseada em um conceito chamado realimentação (feedback), o que significa que o valor de saída de uma porta retorna à sua entrada. O mais simples circuito com realimentação com o uso de dois inversores está exemplificado abaixo:

Ao acompanhar o caminho da realimentação, nota-se que, se o valor de Q for igual a 1, ele sempre será 1. Se por acaso for 0, sempre será 0. Embora esse circuito em particular não tenha muito uso, é possível ver como a realimentação funciona.

Em circuitos "reais", o uso dessa abordagem simples de realimentação do inversor é perfeitamente possível. Um circuito com realimentação de mais utilidade com o uso de duas portas NAND está exemplificado abaixo:

Esse circuito tem duas entradas (R e S) e duas saídas (Q e Q'). Por causa da realimentação, sua tabela lógica fica um pouco incomum se a compararmos àquelas vistas anteriormente:

R	S	Q	Q'
0	0		Inválida
0	1	1	0
1	0	0	1
1	1		Retém

O que a tabela lógica mostra é que:

• se R e S tiverem valores opostos, Q acompanha S e Q' é o inverso de Q;
• se tanto R quanto S recebem valor 1 simultaneamente, então o circuito retém o que foi apresentado anteriormente em R e S.

Há ainda o estado inválido. Nesse estado, tanto R quanto S valerão 0, o que não tem significado em aplicação de memória, enquanto memória, nada vale. Para prevenir esse estado ilegal, costuma-se acrescentar uma pequena lógica condicional no lado da entrada, conforme abaixo:

Neste circuito, há duas entradas (D e E). Podemos pensar em D como "Data" (dado) e E como "Enable" (habilitar). Se E valer 1, Q acompanhará D. Se E mudar para 0, no entanto, Q lembrará do que tiver sido visto por último em D. Um circuito com este comportamento costuma ser conhecido como flip-flop.

Um flip-flop bastante comum é o flip-flop J-K. Não está claro de onde veio o nome "J-K", mas ele costuma ser representado em um quadro como este:

Neste diagrama, P significa "Preset" (pré-definido), C significa "Clear" (limpar) e Clk significa "Clock" (relógio). A tabela lógica fica assim:

P	C	Clk		J	K	Q	Q'
1	1	1-para-0		1	0	1	0
1	1	1-para-0		0	1	0	1
1	1	1-para-0		1	1		Alterna
1	0	X		X	X	0	1
0	1	X		X	X	1	0

A tabela informa que: primeiro, Preset e Clear ignoram J, K e Clk completamente. Se o valor de Preset for modificado para 0, então o valor de Q será modificado para 1; e se o valor de Clear for modificado para 0, então o valor de Q será modificado para 0, não importando o que J, K e Clk estiverem fazendo. No entanto, se Preset e Clear tiverem valor igual a 1, então J, K e Clk poderão operar. A notação 1-para-0 significa que, quando o relógio mudar de 1 para 0, os valores de J e de K, caso sejam opostos, serão memorizados. J e K ficam armazenados na borba da descida do relógio (a transição de 1 para 0). Porém, se tanto o valor de J quanto o de K equivalerem a 1 borba da descida do relógio, então Q simplesmente alterna, ou seja, muda de seu estado atual para o estado oposto.

Agora, você deve estar se perguntando: "e para que serve isso?". Na verdade, o conceito de "disparo por borda" é muito útil. O fato de o flip-flop J-K apenas "armazenar" (latching) as entradas J-K em uma transição de 1 para 0 faz com que ele seja muito mais útil como dispositivo de memória. Os flip-flops J-K também são bastante úteis em contadores (muito usados na criação de relógios digitais). Aqui está o exemplo de um contador de 4 bits usando flip-flops J-K:

As saídas para este circuito são A, B, C e D, que representam um número binário de 4 bits. Na entrada do relógio do flip-flop, mais à esquerda, aparece um sinal mudando de 1 para 0 e de volta para 1 repetidamente (um sinal oscilatório). O contador contará com as bosrdas de descida que vê neste sinal, ou seja, a cada vez que este sinal que chega mudar de 1 para 0, o número de 4 bits representado por A, B, C e D será incrementado em 1. Então, o contador irá de 0 a 15 e retornará a 0. Podemos acrescentar quantos bits quisermos a este contador e contarmos o que quisermos. Por exemplo, com o uso de uma chave magnética em uma porta, o contador registrará o número de vezes que a porta se abre e se fecha. Com um sensor ótico colocado na estrada, o contador poderá registrar o número de carros que passarem.

Outro uso do flip-flop J-K é na criação de um latch disparado por borda, conforme abaixo:

Neste arranjo, o valor de D é armazenado quando o nível do clock vai de baixo para o alto. Os latches têm extrema importância no projeto de unidades centrais de processamento (CPUs) e periféricos em computadores.