Valores Booleanos, Blocos, Estruturas de Seleção

Voltar

Para o desenvolvedor iniciante programar pode parecer um pouco de magia. Especialmente quando, ao se pesar a energia necessária para produzir um aplicativo funcional e “a prova de idiotas”.  É muita energia, que muitas vezes se apresenta como muitas e muitas linhas código. Não existe um limite para quantas linhas um aplicativo pode ter. Basta baixar programas de código aberto, ou observar repositórios para começar a entender a magnitude do trabalho. Mas não é algo que deve desanimar, pois o sucesso está ligado a planejamento, disciplina e perseverança.


Valores Booleanos

Vamos expandir um pouco o conceito de variáveis para abranger valores booleanos. Um tipo booleano é um espaço que armazena apenas dois valores, geralmente antagônicos, ou melhor opostos. Diversas linguagens usam representações como SIM/NÃO, VERDADEIRO/FALSO ou algo simples como 0/1. Independente da representação textual escolhida é importante lembrar que são opostos.

Para declarar um variável do tipo boleada em processing basta declara o tipo booleano e depois nomear a variável:

boolean v;

Caso queira declara e atribuir basta usar as palavras true e false. Assim:
boolean v = true; // Caso queira o valor como verdadeiro.
boolean w = false; // Caso queira iniciar como falso.

Existem dois operadores muito comuns para trabalhar com variáveis do tipo booleana, eles são o E e OU. Antes de ver em código, observe a seguinte representação abaixo:

  • considere que A = Verdadeiro, B = Falso, C = ? indeterminado. Assim, analise a operação E:
    C = A e B ===> Nesse caso C = Falso, pois A = V e B = F…. então V e F => F

Para dois valores booleanos resultarem em Verdadeiro utilizando o E, é necessário que os dois sejam verdadeiros. Caso qualquer um (ou dois) sejam falso(s) o resultado será falso.

  • Agora vamos imaginar uma situação parecida, mas trocaremos e pelo OU.
    C = A ou B ===> Nesse caso C = Verdadeiro, pois V ou F => V

Para dois valores booleanos resultarem em verdadeiro utilizando o OU, é necessário que apenas um (ou os dois) seja(m) verdadeiro(s).  Apenas no caso de ambos serem falsos é que o resultado do OU será falso.

Considere que A = V, B = V, C = F e resolva a seguinte expressão:

D = (A e B) ou C;

Para determinar o valor final de D precisamos observar qual operação tem precedência na expressão acima. Nesse caso é (A e B), como A = V e B = V, então V e V = V. Assim podemos concluir que o valor entre os parênteses é V. Atualize a expressão (já substituindo o C pelo seu valor):

D = (V) ou F;

Assim analisando V ou F, apenas um precisa ser verdadeiro para o resultado da expressão ser Verdadeiro. Assim V ou F = V. Portanto podemos concluir que D = Verdadeiro.

Existe mais uma expressão que é muito comum em expressões booleanas, que é o NÃO. O operação NÃO inverte o valor de qualquer resultado booleano. Assim:

NÃO(Verdadeiro) = Falso , NÃO(Falso) = Verdadeiro

Voltando as expressões anteriores e acrescentando o NÃO teríamos:

A = V, B = F;
C = NÃO(A e B);

Observando (A e B) temos (V e F) que resulta em F. No entanto, temos NÃO(F) que em consequência resulta em V. Portanto o valor final de C será V.

Uma forma que entender melhor o funcionamento dessas operações é observar a tabela lógica abaixo. Nela são abordados diversas combinações e seus resultados:Screen Shot 2015-08-24 at 12.17.03

Agora vamos ver como essas expressões são representadas em código:

e       ===> &&       ====> A e B seria A && B
ou    ===> ||         ====> A ou B seria A || B
não  ===> !            ====> NÃO(A) seria !A….   NÃO(A e B) seria !(A && B)

Além de declarar diretamente valores booleanos é possível cria-los a partir de testes booleanos entre valores. Nesse caso é possível gerar resultados booleanos utilizando outros tipos, por exemplo: inteiros. Para isso vamos utilizar símbolos conhecidos como >, <, >=, <=, !=, ==…

Considere as variáveis declaradas abaixo:

int a = 2;
int b = 5;
boolean c =  a > b;

O valor de c será falso, pois 2 > 5 (2 não é maior que 5). Continue analisando as expressões abaixo
3 > 6; // verdadeiro
3 == 6; // falso
3 == 3; // verdadeiro
3 > 3; // falso
3 >= 3; // verdadeiro
3 != 3; // falso
e assim por diante…

agora podemos juntar os operadores com simbolos comparativos e formar expressões ainda mais elaboradas, observer:

boolean c = !(3 > 5) && ((4 == 6) || (7 < 10));
// Qual será o valor de c?


Blocos

Esta seção irá apresentar um elemento estrutural conhecido como bloco. O bloco representa um pedaço de código. De forma mais prática é quando se agrupa um conjunto de código que realiza uma tarefa especifica. Blocos formam contextos que possuem um certo tipo de hierarquia e ajudam a organizar o programa.

A simbologia adotada pelo processing é {  }, cada par representa um bloco. A hierarquia dos blocos permite que se declare variáveis dentro dele e assim esses valores só poderão ser vistos pelo próprio ou seus filhos. Observe o código abaixo:

B1 {
  int a = 2;
  int b = 3;
   B2 {
    int c = a + b;
  } // fim de B2
} // fim de B1

Esse trecho possui 3 valores (a,b,c). O valor a e b são declarados e atribuídos no bloco B1, enquanto o valor c é declarado no bloco B2. O bloco B2 sendo filho de B1 permite ver e usar as variáveis disponíveis em B1. Já o inverso não é verdadeiro. Caso se tenha a seguinte situação:

B1 {
  int a = 2;
  int b = 3;
   B2 {
    int c = a + b;
  } // fim de B2
  int d = 2*c;
} // fim de B1

Nesse caso, a variável d não será capaz de ler c, pois c está em um bloco fora do seu escopo de atuação. Não se deixe levar pela simplicidade do conceito, pois blocos, assim como variáveis são elementos estruturais importantes para o paradigma de programação do processing (e muitas outras linguagens). O bloco geralmente é acompanhado de palavras no início (onde é visto B1 e B2), antes da demarcação do seu começo ( { ) que identifica seu comportamento. Blocos podem receber tipos e nomes, assim como variáveis e podem ser utilizados para estruturar um código de forma não linear, criar ramificações entre múltiplas opções de códigos baseado em estruturas de seleção ou realizar operações repetitivas (como aquelas usadas em somatórios).


Estrutura de Seleção

Vamos pegar carona no conceito de blocos para identificar um uso aplicado. Geralmente um programa a partir de dados iniciais irá processar e gerar novos resultados, que são desconhecidos pelo programador. Por exemplo: o resultado de um somatório, apesar de todo o programar descrever como calcular, o resultado ainda é desconhecido até o momento em que o código é executado. Em situações que um resultado pode alterar o curso do programa podemos utilizar um estrutura de seleção. Essa estrutura permite através de um pergunta de resultado booleano determinar qual bloco de código executar. Observe o código a seguir:

size(400,400);
int s = second(); // Comando second() retorna o valor em segundos atual.
fill(0,0,4*s);
eclipse(200,200,100,100);

Esse código irá produzir a imagem abaixo:

Screen Shot 2015-08-23 at 21.03.36

A cor da elipse no centro é determinada pela variável “s”, que por sua vez é determinada pelo comando second(). O comando second() retorna um numero inteiro igual ao numero de segundos atual do sistema. Então se o relógio do computador marca 23:30:55, o valor de s será 55. Veja mais informações e exemplos sobre second() seguindo o link para o manual do processing. O valor de “s” entra no comando fill(0,0,4*s), que determina a cor que será utilizada para desenhar, como o “s” ocupa o terceiro parâmetro de fill(R,G,B), então o circulo será sempre um tom de azul. Já que o terceiro parâmetro representa a intensidade de cor Azul (Blue). A faixa de valores para expressar cada cana de cor é de 0 a 255.

Caso s = 0  ====> a cor final será preta pois R = 0, G = 0, B = 0
Caso s = 59  ===> a cor final será um azul intenso pois R = 0, G = 0, e B = 236 (4*59).

Agora que conhece bem o código, vamos propor uma mudança. Caso o “segundo atual” seja um numero par o “s” deve ser utilizado no parâmetro azul, senão “s” deve ser usado no vermelho. Assim com “s” par: fill(0,0,s), e quando “s” for impar fill(s,0,0); Observe o código abaixo:

01|   size(400,400);
02|   int s = second()*4;
03|   if (s % 2 == 0) {
04|      fill(0,0,s);
05|   } else {
06|      fill(s,0,0);
07|   }
08|   ellipse(200,200,100,100);

*** bloco 01 —- *** bloco 02

Para facilitar, as linhas foram numeradas. Observe a linha 03, o bloco possui um prefixo:  if (s % 2 == 0). Primeiro podemos identificar duas expressões dentro do parênteses. Uma é s % 2  que significa o resto da divisão de s por 2. A outra é a comparação booleana entre o resultado da operação % e 0. Nesse caso se s for 3, então 3 % 2 será 1, em seguida 1 == 0 será falso. A palavra if (se) é uma chave para código e significa: somente execute o bloco seguinte caso a expressão entre parênteses for verdadeira. Caso seja falso e exista um bloco chamado else (senão) rode esse, caso não exista esse bloco simplesmente continue o programa. 

Vamos ler a operação de seleção: se (o resto da divisão de s por 2 for igual a 0) { execute o primeiro bloco} senão { execute o segundo bloco}.

Uma vez que conhecemos blocos e estruturas podemos começar a ver aplicações como fluxogramas. Repare como o programa acima pode ser representado:

Screen Shot 2015-08-27 at 15.41.13