TA345/531 TP257 Informática Aplicada à Engenharia de Alimentos.


 

Aula 02: Variáveis, comentários e operadores

 

2.1. Variáveis e tipos de dados

Como qualquer linguagem, Java trabalha com variáveis.

Uma variável é um parâmetro do programa que vai possuir um valor inicial e esse valor pode mudar durante o processamento.

Quando criamos uma variável reservamos um espaço na memória da máquina na qual podemos guardar dados.

As variáveis têm um nome, correspondem a um tipo de variável e possuem um valor.

Se necessita usar uma variável, primeiramente terá que declará-la e so então poderá atribuir valores à mesma.

 

2.1.1. Como declarar variáveis

 Qualquer variável em Java tem de ser declarada antes que possa ser utilizada em um programa.

A forma geral de uma declaração de variável é: <tipo> <variável>;

Também é possível declarar uma lista de variáveis do mesmo tipo, separadas por vírgula:

 <tipo> <variável1, variável2, variável 3>;

Exemplos:

int idade;

double numero01,numero02,soma;

boolean existe;

String nome;

 

Os nomes de variáveis podem começar com uma letra, um sublinhado ( _ ), um traço ( - ) ou um cifrão ($).

Elas não podem começar com um número.
Depois do primeiro caractere, pode-se colocar qualquer letra ou número.

 

2.1.2. Tipos de variáveis

 Toda variável deve possuir um tipo. As possibilidades são:

[1] Tipos primitivos

[2] Classes

[3] Arrays (estrutura ordenada de dados de um mesmo tipo).

Estudaremos o uso de Classes e Arrays mais à frente em outras aulas.

 

Tipos primitivos

Os oito tipos de dados básicos são:

 

Tipo

Tamanho

Alcance

boolean

byte

short

int

long

float

double

char

8 bits

8 bits

16 bits

32 bits

64 bits

(32 bits, precisão simples)

(64 bits, precisão dupla)

16 bits

 true/false

-128 até 127

-32.768 até 32.767

-2.147.483.648 até 2.147.483.647

-9.223.372.036.854.775.808 até 9.223.372.036.854.775.807

-3,4E38 até 3,4E38

-1,7E308 até 1,7E308

  0 até 65535 (conjunto de códigos Unicode)

 

Em termos de utilização, podemos categorizar os tipos primitivos da seguinte forma:

[1] Para definição de valores lógicos: boolean;

[2] Para aritmética de inteiros: byte, short, int, long;

[3] Para aritmética de números reais: float, double;

[4] Para manipulação de caracteres: char.

 

Tipo boolean

Esse tipo de dado permite armazenar os valores lógicos, que são:

[1] verdadeiro (true) e

[2] falso (false).

Os valores true e false devem ser escritos com letras minúsculas.

Há duas coisas que você deve anotar sobre esse tipo de dado: em primeiro lugar, o tipo boolean não é baseado em inteiros, o que quer dizer que não suporta operações de incremento e decremento; em segundo lugar, não se pode converter um valor lógico para outro tipo de dado.

 

Tipo byte

Esse tipo de dado costuma ser usado para economizar espaço de armazenamento. Mas, devemos tomar cuidado com operações que envolvem tipos de dados byte porque os computadores modernos fazem todas as operações de números inteiros com precisão de 32 ou 64 bits, e não com precisão de 8 bits. Com isso, todas as atribuições de valores a variáveis do tipo byte devem ser “convertidas” para este tipo.

 

Tipo short

As mesmas regras aplicadas ao tipo byte se aplicam ao tipo short. As atribuições de valores a variáveis do tipo short sempre devem ser convertidas para este tipo de dado.

 

Tipo int

Int é o tipo de dado padrão para operações com inteiros em Java.

Uma característica do tipo int é que ele suporta “literais”. Literais são valores alfanuméricos.
Os literais inteiros podem ser atribuídos as variáveis de ponto flutuante, sem qualquer conversão. Entretanto, o compilador solicitará uma conversão se um literal inteiro for atribuído a uma variável menor (byte ou short, por exemplo) desde que o literal represente uma quantidade maior de bits do que a quantidade que o tipo byte ou short pode suportar.

 

Tipo long

Da mesma forma que o tipo int, o tipo long suporta a atribuição de literais.

A diferença é que o literal deve apresentar a letra “L” no final.

Nunca utilize a letra “l” minúscula para que não seja confundida com o dígito “1” (um).

 

Tipo float

Esse tipo de dado tem 6 ou 7 dígitos significativos de precisão, a precisão exata depende do número armazenado. Sempre que atribuirmos um valor a uma variável do tipo float, devemos utilizar um literal float, ou seja, um literal finalizado pela letra “F” ou “f”.

 

Tipo double

Esse tipo de dado tem 14 ou 15 dígitos significativos de precisão, a precisão exata depende do número armazenado.

O tipo Double é o tipo padrão em Java para atribuições de valores de ponto flutuante.

Não precisa de complemento (“D” ou “d”).

 

Tipo Char

Com esse tipo, podemos representar dados de caracteres ou máscaras de bit.

 Embora não pareça à primeira vista, o tipo char é baseado em inteiros, o que significa dizer que podemos fazer operações aritméticas com ele. Entretanto, nunca teremos um valor negativo para o tipo char. O tipo char foi construído para armazenar caracteres Unicode.

No exemplo a seguir, veja se consegue perceber como as variáveis foram declaradas e que tipo de variável usamos.

Exemplo 1: Soma de 2 números :

import java.applet.Applet;
import java.applet.*;
import java.awt.*;
import java.awt.event.*;

 

/* <APPLET CODE = "SomaNumerosReais.class" WIDTH=250 HEIGHT=200></APPLET> */

 

public class SomaNumerosReais extends Applet implements ActionListener
{
   Label   titulo, rotulo1, rotulo2, rotulo3;
   TextField   caixa1, caixa2, caixa3;
   Button   botao;
   double  num1,num2,soma;

 

    public void init()
    {   titulo = new Label("Soma de dois numeros reais: "); add(titulo);
         rotulo1 = new Label("Forneça o primeiro número: "); add(rotulo1);
         caixa1 = new TextField("",5); add(caixa1);
         rotulo2 = new Label("Forneça o segundo número: "); add(rotulo2);
         caixa2 = new TextField("",5); add(caixa2);
         botao = new Button("Soma"); add(botao);
         botao.addActionListener(this);

         rotulo3 = new Label("Resultado: "); add(rotulo3);
         caixa3 = new TextField("        ",5);   add(caixa3);
    }

 

    public void actionPerformed(ActionEvent e)
    {
        if (e.getSource() == botao)
        {
           num1=Double.valueOf(caixa1.getText()).doubleValue();

           num2=Double.valueOf(caixa2.getText()).doubleValue();

           soma=num1+num2;
           caixa3.setText(String.valueOf(soma));
        }
    }
}

 

Observou? Neste exemplo, usamos variáveis de ponto flutuante tipo double (precisão dupla).
Fizemos a declaração das variáveis da seguinte forma:
double num1,num2,soma;

 2.1.3. Atribuições a variáveis

 Depois de declarada uma variável, a atribuição é feita simplesmente usando o operador ‘=’:

 int idade = 18;

 boolean existe = true;

 

2.2. Comentários

Sempre utilize comentários em seus programas para identificá-los e explicar as partes essenciais do programa, isso facilitará a utilização dos mesmos por outros usuários sem grandes questionamentos.  Lembre-se que os comentários não aparecem na execução do programa, só podem ser visualizados no código fonte.

Existem duas formas de comentários:
// comentário
/* comentário */

No primeiro (duas barras), o comentário será apenas de uma linha e não é necessário colocar os sinais novamente para finalizar, ao mudar de linha já se entende que o comentário está encerrado.

Já o segundo tipo (barra asterisco), é necessário indicar o final do comentário (através de asterisco barra), neste caso o comentário pode ter várias linhas.

 

2.3. Caracteres especiais

Caractere

Significado

\n

\t

\b

\r

\f

\\

\’

\”

\ddd

\xdd

\uddd

Nova Linha

Tabulador (tab)

Retrocesso (backspace)

Retorno do Carro

“Formfeed” (avança uma página na impressora)

Barra invertida

Apóstrofe

Aspas

Octal

Hexadecimal

Símbolo unicode

 

 

2.4. Expressões e operadores

 

2.4.1. Operadores aritméticos

Operador

Significado

Exemplo

+

-

*

/

%

soma

subtração

multiplicação

divisão

módulo

3 + 4

5 - 7

5 * 5

14 / 7

20 % 7

 

No exemplo a seguir, observe como usamos os cinco operadores aritméticos.

           

Exemplo 2 - operador2:

import java.applet.Applet;

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

 

public class operador2 extends Applet implements ActionListener

{

    Label titulo, rotulo1, rotulo2, rotulo3, aviso;

    TextField caixa1, caixa2, caixa3;

    Button botaoSoma, botaoMultiplica, botaoSubtrai, botaoDivide, botaoResto, botaoLimpa;

    double num1, num2, soma, produto;

 

    public void init()

    {

        titulo = new Label("Operações com numeros reais: ");   add(titulo);

        rotulo1 = new Label("Forneça o primeiro número: ");   add(rotulo1);

        caixa1 = new TextField("3",5); add(caixa1);

        rotulo2 = new Label("Forneça o segundo número: "); add(rotulo2);

        caixa2 = new TextField("2",5); add(caixa2);

        botaoSoma = new Button("+"); add(botaoSoma); botaoSoma.addActionListener(this);

        botaoMultiplica = new Button("*");   add(botaoMultiplica); botaoMultiplica.addActionListener(this);

        botaoSubtrai = new Button("-"); add(botaoSubtrai); botaoSubtrai.addActionListener(this);

        botaoDivide = new Button("/"); add(botaoDivide); botaoDivide.addActionListener(this);

        botaoResto = new Button("%"); add(botaoResto); botaoResto.addActionListener(this);

        rotulo3 = new Label("Resultado: "); caixa3 = new TextField("        ",5); add(rotulo3); add(caixa3);

        botaoLimpa = new Button("Limpa"); add(botaoLimpa); botaoLimpa.addActionListener(this);

        aviso = new Label("Use ponto e não virgula"); add(aviso);

    }

 

    public void actionPerformed(ActionEvent e)

    {

        if (e.getSource() == botaoSoma)

        {

           num1=Double.valueOf(caixa1.getText()).doubleValue();

           num2=Double.valueOf(caixa2.getText()).doubleValue();

           soma=num1+num2;

           caixa3.setText(String.valueOf(soma));

        }

        if (e.getSource() == botaoMultiplica)

       {

                           num1=Double.valueOf(caixa1.getText()).doubleValue();

                           num2=Double.valueOf(caixa2.getText()).doubleValue();

                           produto=num1*num2;

                           caixa3.setText(String.valueOf(produto));

        }

        if (e.getSource() == botaoSubtrai)

        {

               num1=Double.valueOf(caixa1.getText()).doubleValue();

             num2=Double.valueOf(caixa2.getText()).doubleValue();

              produto=num1-num2;

               caixa3.setText(String.valueOf(produto));

        }

        if (e.getSource() == botaoDivide)

        {

               num1=Double.valueOf(caixa1.getText()).doubleValue();

               num2=Double.valueOf(caixa2.getText()).doubleValue();

               produto=num1/num2;

               caixa3.setText(String.valueOf(produto));

        }

        if (e.getSource() == botaoResto)

       {

               num1=Double.valueOf(caixa1.getText()).doubleValue();

               num2=Double.valueOf(caixa2.getText()).doubleValue();

               produto=num1%num2;

               caixa3.setText(String.valueOf(produto));

        }

        if (e.getSource() == botaoLimpa)

       {

                    caixa1.setText("0");

                    caixa2.setText("0");

                    caixa3.setText("");

        }

    }

}

 

 

O programa colocado a seguir é similar ao anterior, porém adicionamos cor de fundo no applet, e a opção “Resto” foi aprimorada colocando o valor da parte inteira da divisão e o valor inteiro do resto.  Veja como ficou:

Exemplo 3 – operador 3

import java.applet.Applet;

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

 

public class Operador extends Applet implements ActionListener

{

    Label titulo, rotulo1, rotulo2, rotulo3, rotulo4, aviso;

    TextField caixa1, caixa2, caixa3, caixa4;

    Button botaoSoma, botaoMultiplica, botaoSubtrai, botaoDivide, botaoResto, botaoLimpa;

    double num1, num2, soma, subtrai, produto, divide, resto;

 

    public void init()

    {

        setBackground(Color.magenta);

        titulo = new Label("Operações com numeros reais: ");

        add(titulo);

 

        rotulo1 = new Label("Forneça o primeiro número: ");

        caixa1 = new TextField("5",5);

        add(rotulo1); add(caixa1);

 

        rotulo2 = new Label("Forneça o segundo número: ");

        caixa2 = new TextField("3",5);

        add(rotulo2); add(caixa2);

 

        botaoSoma = new Button("+");

        add(botaoSoma);

        botaoSoma.addActionListener(this);

 

        botaoSubtrai = new Button ("-");

        add(botaoSubtrai);

        botaoSubtrai.addActionListener(this);

 

        botaoMultiplica = new Button("*");

        add(botaoMultiplica);

        botaoMultiplica.addActionListener(this);

 

        botaoDivide = new Button("/");

        add(botaoDivide);

        botaoDivide.addActionListener(this);

 

        botaoResto = new Button ("%");

        add(botaoResto);

        botaoResto.addActionListener(this);

 

        rotulo3 = new Label("        Resultado: ");

        caixa3 = new TextField("        ",5);

        add(rotulo3); add(caixa3);

 

        rotulo4 = new Label ("        Resto: ");

        caixa4 = new TextField("        ",5);

        add(rotulo4); add(caixa4);

 

        botaoLimpa = new Button("Limpa");

        add(botaoLimpa);

        botaoLimpa.addActionListener(this);

 

        aviso = new Label("Use ponto e não virgula");

        add(aviso);

    }

 

    public void actionPerformed(ActionEvent e)

    {

        if (e.getSource() == botaoSoma)

        {

            num1=Double.valueOf(caixa1.getText()).doubleValue();

            num2=Double.valueOf(caixa2.getText()).doubleValue();

            soma=num1+num2;

            caixa3.setText(String.valueOf(soma));

            caixa4.setText("0");

        }

 

        if (e.getSource() ==botaoSubtrai)

        {

           num1=Double.valueOf(caixa1.getText()).doubleValue();

           num2=Double.valueOf(caixa2.getText()).doubleValue();

           subtrai=num1-num2;

           caixa3.setText(String.valueOf(subtrai));

           caixa4.setText("0");

        }

 

        if (e.getSource() == botaoMultiplica)

        {

           num1=Double.valueOf(caixa1.getText()).doubleValue();

           num2=Double.valueOf(caixa2.getText()).doubleValue();

           produto=num1*num2;

           caixa3.setText(String.valueOf(produto));

           caixa4.setText("0");

        }

 

        if (e.getSource() == botaoDivide)

        {

          num1=Double.valueOf(caixa1.getText()).doubleValue();

          num2=Double.valueOf(caixa2.getText()).doubleValue();

          divide=num1/num2;

          caixa3.setText(String.valueOf(divide));

          caixa4.setText("0");

        }

 

        if (e.getSource() == botaoResto)

        {

          num1=Double.valueOf(caixa1.getText()).doubleValue();

          num2=Double.valueOf(caixa2.getText()).doubleValue();

          divide=num1/num2;

          caixa3.setText(String.valueOf((int)divide));

          resto=num1%num2;

          caixa4.setText(String.valueOf(resto));

        }

 

        if (e.getSource() == botaoLimpa)

        {

                    caixa1.setText("0");

                    caixa2.setText("0");

                    caixa3.setText("");

                    caixa4.setText("");

        }

    }

}

 

 

 No exemplo 4 usamos quatro operadores aritméticos. Mas, diferente dos dois exemplos anteriores, não temos um botão para cada operação, usamos apenas o botão “calcula” para que o programa imprima na tela aberta (objeto TextArea) o resultado das quatro operações.

 

Exemplo 4 - Clave8:

import java.applet.Applet;

import java.awt.*;

import java.awt.event.*;

 

/*

<APPLET CODE=Clave8.class WIDTH=400 HEIGHT=400></APPLET>

*/

 

public class Clave8 extends Applet implements ActionListener

{

  public Label legenda1, legenda2;

  public TextField caixa1, caixa2;

  public TextArea ta;

  public Button botao, botaoLimpa;

  double A,B;

 

  public void init( )

  {

         legenda1 = new Label ("A="); add (legenda1);

         caixa1 = new TextField("3", 2); add (caixa1);

         legenda2 = new Label ("B="); add (legenda2);

         caixa2 = new TextField("2", 2); add (caixa2);

         botao = new Button ("Calcula");  add(botao); botao.addActionListener(this);

         botaoLimpa = new Button ("Limpa");  add(botaoLimpa); botaoLimpa.addActionListener(this);

         ta = new TextArea("",10,40);   add(ta);

  }

 

  public void actionPerformed(ActionEvent e)

  {

      A=Double.valueOf(caixa1.getText()).doubleValue();

      B=Double.valueOf(caixa2.getText()).doubleValue();

 

      if (e.getSource() == botao)

      {

                 B=1;

                 ta.setText

                 (

                 "A+B = "+String.valueOf(A+B)+"\n"+

                 "A-B = "+String.valueOf(A-B)+"\n"+

                 "A*B = "+String.valueOf(A*B)+"\n"+

                 "A/B = "+String.valueOf(A/B)

                 );

        }

        if (e.getSource() == botaoLimpa)

        {

                 ta.setText(" ");

                 caixa1.setText(" ");

                 caixa2.setText(" ");

        }

    }

}

 

 

 

2.4.2. Mais sobre atribuições

Variáveis podem ser atribuídas em forma de expressões como:

int x, y, z;

x = y = z = 0;

Neste exemplo, as três variáveis recebem o valor 0.

 

Operadores de atribuição:

Expressão

Significado

x + = y

x - = y

x * = y

x / = y

x = x + y

x = x - y

x = x * y

x = x / y

 

 

2.4.3. Incrementos e decrementos

Como no C e no C++, o Java também possui incrementadores e decrementadores:

y = x++;

y = -x;

 

As duas expressões dão resultados diferentes, pois existe uma diferença entre prefixo e sufixo. Quando se usa os operadores ( x++ ou x- ), y recebe o valor de x antes de x ser incrementado; e usando o prefixo ( ++x ou -x ), acontece o contrario: y recebe o valor incrementado de x.

 

2.5. Comparações

Java possui várias expressões para testar igualdade e magnitude. Todas as expressões retornam um valor booleano (true ou false)

 

2.5.1. Operadores de comparação

Operador

Significado

Exemplo

= =

!=

< =

> =

Igual

Diferente

Menor que

Maior que

Menor ou igual a

Maior ou igual a

x = = 3

x != 3

x < 3

x > 3

x < = 3

x > = 3

  

2.5.2. Operadores condicionais ou lógicos

Operador

Significado

Exemplo

&&

||

!

Operação lógica E (AND)

Operação lógica OU (OR)

Negação lógica

op1 && op2: op1 e op2 são ambos verdadeiros

op1 || op2: ou op1 ou op2 é verdadeiro

!op: op é falso

 

2.5.3. Operadores de atribuição

Operador

Significado

Exemplo

=

+=

-=

*=

/=

op1 = op2

op1 += op2

op1 -= op2

op1 *= op2

op1 /= op2

Atribui o valor de op2 a op1

op1 = op1 + op2

op1 = op1 – op2

op1 = op1 * op2

op1 = op1 / op2

 

Até a próxima!



Tarefa de casa:
Veja os programas seguintes que são variações dos programas vistos em aula:

 

Na aula seguinte: Mostre os programas que você realizou.


Volta para a página principal

Última atualização: 16 de março de 2009