Quais os objetivos de aprendizagem da Unidade 1? Confira:

● Compreender o funcionamento da Linguagem JAVA;

● Escrever programas em JAVA usando IDES de desenvolvimento;

● Trabalhar com comandos de condição em JAVA;

● Realizar fluxos de controle com comandos desta natureza em JAVA;

● Conhecer as estruturas de dados, funções e exceções na Linguagem JAVA.

‎Java é uma plataforma de linguagem de programação e computação lançada pela Sun Microsystems em 1995. Evoluiu de origens humildes para alimentar grande parte do mundo digital atual, fornecendo a plataforma confiável sobre a qual muitos serviços e aplicativos são construídos. Novos produtos inovadores e serviços digitais projetados para o futuro também continuam a depender do Java.‎

‎Embora a maioria dos aplicativos Java modernos combinem o tempo de execução java e o aplicativo juntos, ainda existem muitos aplicativos e até mesmo alguns sites que não funcionarão a menos que você tenha um Java desktop instalado. Java.com, este site, destina-se a consumidores que ainda podem precisar de Java para seus aplicativos de desktop – especificamente aplicativos voltados para Java 8. Desenvolvedores, bem como usuários que gostariam de aprender programação Java devem visitar o site ‎‎dev.java‎‎ em vez disso e os usuários de negócios devem visitar ‎‎oracle.com/java‎‎ para obter mais informações.‎

Que tal relacionar-se com os colegas por meio de um Fórum? Esse recurso favorece o diálogo, a troca de opiniões e de saberes, estimulando o debate e a reflexão em torno de temas, situações, problemas ou ideias encontradas em nossa vida acadêmica e pessoal.

Vamos  realizar um Objeto de Aprendizagem? Sugerimos o artigo "Java: história e principais conceitos", que serve para contextualizar brevemente sobre a Linguagem Java. 

Vamos à indicação de documentários e vídeos? Eles também servem a propósitos didáticos, complementando a educação formal.

Lógica computacional é o uso da lógica para executar ou raciocinar sobre computação. Ela tem uma relação com a ciência da computação e a engenharia semelhante à relação da lógica matemática com a matemática, ou à da lógica filosófica com a filosofia.

Tópico 1 - Linguagem de Programação JAVA

2 CARACTERÍSTICAS DA LINGUAGEM JAVA

Uma característica fundamental da língua Java é que seu código é traduzido pela primeira vez em um bytecode especial que é independente de plataforma. Este bytecode é então executado pela Máquina Virtual Java (JVM). A este respeito, Java difere de linguagens interpretadas padrão como PHP ou Perl, nas quais os códigos são imediatamente executados pelo interpretador. Ao mesmo tempo, Java não é uma linguagem puramente compilada como C ou C++.

Tal arquitetura fornece portabilidade entre plataformas e hardware de programas em Java, para que tais programas sem recompilação possam ser executados em diferentes plataformas — Windows, Linux, Mac OS, etc. Cada uma das plataformas pode ter sua própria implementação da máquina virtual JVM, porém, cada uma delas pode executar o mesmo código.

Java é uma linguagem com sintaxe semelhante a C e está próxima a C, C++ e C#. Portanto, se você está familiarizado com uma dessas línguas, será mais fácil compreender Java.

Java é uma língua orientada a objetos. Suporta polimorfismo, herança, digitação estática. A abordagem orientada a objetos permite resolver os problemas da construção de aplicações grandes, mas, ao mesmo tempo, flexíveis, escaláveis e extensíveis.

2.1 ORACLE JDK E OPEN JDK  

Para desenvolver usando a linguagem de programação Java, precisamos de um conjunto especial de ferramentas chamada JDK, ou “Java Development Kit”. No entanto, vale ressaltar que existem diferentes implementações do JDK, embora todas usem a mesma linguagem — Java. As duas implementações mais populares são Oracle JDK e OpenJDK. 

A diferença básica é que o Oracle JDK é totalmente desenvolvido pela Oracle, enquanto o OpenJDK está sendo desenvolvido tanto pela Oracle quanto por várias outras empresas juntas.

As maiores diferenças encontram-se em termos de licenciamento. Sob a licença Oracle, o JDK pode ser usado gratuitamente para uso pessoal, bem como para desenvolver, testar e demonstrar aplicativos. Em outros casos (por exemplo, para receber suporte), é necessária uma licença comercial na forma de uma assinatura. Já o OpenJDK é completamente gratuito.

Em termos de funcionalidade, o conjunto de recursos do Oracle JDK e OpenJDK deve ser praticamente o mesmo. Mas em desempenho, nota-se que o Oracle JDK é um pouco mais rápido que o OpenJDK. Além disso, alguns desenvolvedores notam que o  Oracle JDK é mais estável do que o OpenJDK.

Neste tutorial, usaremos o Oracle JDK, mas se estiver usando o OpenJDK, você também não deve encontrar nenhum problema.

2.2 INSTALAÇÃO DO JAVA 

Para desenvolver programas em Java, é necessário um JDK especial (Java Development Kit). O JDK inclui uma série de programas e utilitários que permitem compilar, executar programas em Java e executar uma série de outras funções.

O usuário pode baixar e instalar a versão apropriada do JDK no site oficial da Oracle: <https://www.oracle.com/java/technologies/javase-downloads.html>.

Nesta página encontraremos e baixaremos o kit de distribuição para o sistema operacional (Windows, macOS ou Linux), no caso da imagem em destaque, o Windows:

Para a maioria dos SO, há duas opções de download: como instalador ou como um arquivo que não precisa ser instalado. Por exemplo, meu SO é Windows, então selecione "x64 Installer" e baixe o arquivo que representa o instalador.

Uma vez baixado, execute o instalador. Clique no botão Seguinte. Na próxima tela, você precisa especificar em qual pasta a instalação será executada:

Deixe a pasta padrão, selecionada e clique em "Próximo" para concluir a instalação. 

Assim que a instalação do JDK estiver concluída, veremos esta janela: 

Então, após instalar o JDK, criaremos o primeiro programa Java.

3 O PRIMEIRO PROGRAMA 

Para criar nosso primeiro aplicativo em Java, precisamos escrever o código do programa, e para isso precisamos de um editor de texto. Você pode usar qualquer editor de texto, como o Bloco de Notas++.

Para transformar o código do programa em um aplicativo executável, você precisa de um compilador. Após instalar o JDK, todos os arquivos são colocados no diretório C:\Program Files\Java\jre-[version_number] por padrão (se estiver usando o Windows). Neste caso, este é o diretório C:\Program Files\Java\ jdk-18. Se abrirmos o subdiretório de lixo nele, podemos ver uma série de utilitários nele. Estamos interessados principalmente no utilitário compilador javac. Para compilar uma aula de programa, precisamos passar seu código para este compilador.

Também é de nota outro utilitário desta pasta - java.exe, que permite executar o programa compilado.

Então, vamos criar algum diretório no disco rígido onde os arquivos com o código-fonte no idioma Java serão localizados. Digamos que este é o diretório C:/Java. Em seguida, crie um arquivo de texto neste diretório, que vamos renomear para Program.java. Abra este arquivo em qualquer editor de texto e digite o seguinte programa nele:

public class Program{ 

    public static void main (String args[]){

        System.out.println("Hello Java!");

    }

}

Java é uma linguagem orientada a objetos, então todo o programa é representado como um conjunto de classes interativas. Neste caso, uma única classe de Programa é definida.

Ao definir uma classe, o modificador de acesso público vem em primeiro lugar, o que indica que esta classe estará disponível para todos, ou seja, podemos executá-la a partir da linha de comando. Em seguida vem a palavra-chave da classe, seguido pelo nome da classe. Ou seja, a classe se chama Programa. Após o nome, o conteúdo da classe é colocado em chaves.

Uma classe pode conter várias variáveis e métodos. Neste caso, declaramos um método principal. Este é o principal método em qualquer programa Java, é o ponto de entrada do programa e com ele toda a gestão começa, deste modo a Classe deve estar presente no programa.

O método principal também tem um modificador. A palavra indica que o método principal é estático, e a palavra indica que não retorna nenhum valor. Mais tarde, daremos uma olhada mais de perto no que tudo isso significa: public static void.

Em seguida, entre parênteses, temos os parâmetros do método: String args[] String — este é um conjunto de args que armazena valores de tipo, ou seja, cordas. Neste caso, nem precisamos ainda, mas em um programa real estes são os parâmetros de string que são passados quando você executa o programa a partir da linha de comando.

Após a lista de parâmetros em chaves está o corpo do método — estas são, na verdade, as instruções que o método executará. Neste caso, apenas uma instrução é realmente definida pela definição — a saída de uma determinada string para o console. Para sair para o console, use o embutido. A sequência de saída é passada para este método. Cada declaração termina com um ponto e vírgula.System.out.println()

Agora vamos compilar o programa escrito. Abra um prompt de comando (no Windows) ou um terminal no Linux/MacOS e digite os comandos apropriados lá. Em primeiro lugar, vamos ao diretório onde nosso arquivo com o programa está usando o comando:

Em seguida, compile o programa usando o comando: 

Observe que todo o caminho para o compilador javac está incluído entre aspas, e então o nome do nosso arquivo, que contém a classe do programa, passa por um espaço.

O programa é então compilado em bytecode, e um novo arquivo .class Programa pode ser encontrado no diretório C:\Java. Este será o arquivo com o bytecode do programa. Agora precisamos executá-lo usando o utilitário java:

Aqui, a extensão do arquivo não deve ser usada.

Para o Windows, todo o processo será assim:

3.1 ADICIONANDO JAVA ÀS VARIÁVEIS DE CAMINHO (WINDOWS) 

Para compilar, você tem que inserir o caminho completo para o compilador javac, que pode ser associado a erros ao digitar, e cada vez que você entra no caminho completo também é inconveniente. Para facilitar as coisas, vamos adicionar o caminho ao JDK à variável PATH nas variáveis do ambiente. Se trabalharmos no Windows, para adicionar uma variável de ambiente através da pesquisa encontraremos as variáveis de ambiente do sistema de alteração de opção. Para isso, digite no campo de pesquisa "Alterar variáveis do ambiente do sistema":

Selecione Variáveis de Ambiente. Primeiramente, abriremos a janela "Propriedades do Sistema", onde clicaremos no botão Variáveis de ambiente: 

Em seguida, veremos uma janela onde podemos ver todas as variáveis do ambiente. (Você também pode passar por Configurações e Sistemas -> Parâmetros do sistema -> Consertos viáveis). 

Aqui precisamos definir a variável JAVA_HOME. Se essa variável não existe, você deve criar uma. No entanto, se o java já foi instalado, separadamente ou como um componente necessário para outros programas, não é incomum criar uma variável de sistema "JAVA_HOME" quando instalada em variáveis de ambiente, o que pode indicar uma versão mais antiga do java. Então, neste caso, você só precisa redefinir seu valor para que ele aponte para o novo java sdk.

Sendo assim, digamos que não temos tal variável, neste caso, clique no botão "Criar" e na janela que aparece, digite o JAVA_HOME no campo de nome variável e no campo de valor variável - o caminho para sdk, ou seja, "C:\Program Files\Java\jdk-18\".

Se essa variável já existir, selecione-a e clique no botão "Editar" e também especifique o caminho para o novo SDK para ele. Em seguida selecione a variável Caminho para o usuário atual e clique no botão "Editar":

Em seguida, você verá uma janela com todos os caminhos adicionados à variável Path:

Nesta janela, clique no botão "Criar". Depois disso, uma nova linha será adicionada, na qual entraremos %JAVA_HOME%\bin. Neste caso, ele tomará o valor da variável JAVA_HOME, ou seja, o caminho para o Java SDK. E o componente adiciona o caminho para a pasta de lixo no diretório jdk. Assim, o caminho para o compilador javac e outras utilidades localizados nesta pasta serão adicionados às variáveis do ambiente. Depois disso, clique em OK.%JAVA_HOME%\bin.

Após definir a variável Caminho, passaremos para a linha de comando (em versões mais antigas do Windows, você pode precisar reescrever a linha de comando). Após isso, você pode inserir apenas os nomes dos utilitários sem caminhos completos:

Além disso, para ter certeza de que temos a versão correta do java habilitada, podemos inserir o comando no console: 

4 IDE DE DESENVOLVIMENTO

No último tópico, analisamos como criar o primeiro programa e depois executá-lo na linha de comando. No entanto, no mercado de trabalho, como regra geral, grandes programas são desenvolvidos não usando um simples editor de texto, mas usando ferramentas como IDEs ou ambientes de desenvolvimento integrados que simplificam e aceleram a escrita e a criação de aplicativos. No momento, um dos ambientes de desenvolvimento mais populares para Java é o IntelliJ IDEA da JetBrains. Vamos ver como usar esse ambiente.

4.1 INTELLIJ IDEA

Antes de mais nada, vamos baixar o kit de distribuição de instalação no site oficial da https://www.jetbrains.com/idea/download. Neste endereço você pode encontrar pacotes para Windows, macOS, Linux. Além disso, o ambiente está disponível em duas versões — Ultimate (pago com um período livre de teste) e Comunidade (gratuito). Neste caso, escolhemos a versão gratuita da Comunidade. 

Após a instalação, execute o IntelliJ IDEA e crie o primeiro projeto. Para fazer isso, na tela inicial, selecione Novo Projeto: 

Em seguida, a janela de criação do projeto será aberta. No lado esquerdo, selecione Java como o tipo de projeto: 

No campo Nome, especifique o nome do projeto. No meu caso, o projeto se chamará HelloApp.

No campo Localização, você pode especificar o caminho para o projeto se você não estiver satisfeito com o caminho padrão.

Uma vez que estaremos trabalhando com o idioma Java, no campo Language vamos selecionar Java.

Você também pode especificar o caminho para o Java SDK que será usado em seu projeto no campo JDK. Normalmente, este campo padrão já contém o caminho para o JDK que está instalado no computador local. Se este campo está vazio, deve ser definido.

Depois disso, clique no botão Criar. O ambiente então cria e abre o projeto.

Do lado esquerdo podemos ver a estrutura do projeto. Todos os arquivos de código-fonte são colocados na pasta src. Por padrão, esta pasta está vazia, ainda não temos nenhum arquivo de código no projeto. Portanto, vamos adicionar um arquivo de código-fonte. Para fazer isso, clique com o botão direito do mouse na pasta src e selecione Nova classe Java -> no menu de contexto: 

Depois disso, abriremos uma pequena janela na qual precisamos digitar o nome da classe. Que a classe se chame Programa: 

Após pressionar a tecla Enter, um novo arquivo com a classe java (no caso da classe Program acima) será adicionado à pasta src. E na parte central abrirá seu conteúdo — o próprio código-fonte: 

Vamos modificar o código de classe da seguinte forma: 

Usando o arqueiro verde na barra de ferramentas ou através do menu Run -> Run... vamos iniciar o projeto: 

E na parte inferior do IntelliJ IDEA exibirá uma janela de saída onde podemos ver o resultado do nosso programa. 

Tópico 2 - Noções Básicas de Programação JAVA

2 ESTRUTURA DO PROGRAMA

O bloco básico de construção de um programa Java é a declaração. Cada declaração realiza algumas ações, como chamar métodos, declarar variáveis e atribuir valores a eles. Quando uma instrução é concluída, Java coloca um ponto e vírgula (;). Este caractere aponta o compilador para o final da instrução. Por exemplo:

Esta string representa uma chamada para o método que imprime a string "Hello Java!" no console. Neste caso, a chamada do método é uma instrução, portanto, termina com um ponto e vírgula. 

Além das instruções individuais, uma construção comum é um bloco de código. O bloco de código contém um conjunto de instruções, é fechado em chaves e as instruções são colocadas entre as chaves de abertura e fechamento:

Há duas instruções neste bloco de código que expõem uma sequência específica para o console.

2.1 EXECUÇÃO DO PROGRAMA. MÉTODO PRINCIPAL

Java é uma linguagem orientada a objetos, de modo que todo o programa pode ser representado como um conjunto de classes e objetos interativos. No primeiro capítulo, ao criar o primeiro aplicativo, o programa foi definido da seguinte forma:

Ou seja, a base do nosso programa é a aula do Programa. Ao definir uma classe, o modificador de acesso público vem em primeiro lugar, o que indica que esta classe estará disponível para todos, ou seja, podemos executá-la a partir da linha de comando. Em seguida vem a palavra-chave da classe, seguido pelo nome da classe. O nome da classe é seguido por um bloco de código no qual o conteúdo da classe está localizado.

O ponto de entrada para um programa Java é o método principal, definido na classe Program. É com ele que começa a implementação do programa. Deve estar presente no programa. Neste caso, seu título só pode ser o seguinte:

Quando o aplicativo é iniciado, a Máquina Virtual Java procura um método principal na classe central do programa com um cabeçalho semelhante, e quando é detectado, ele inicia este método.

No início do cabeçalho do método está um modificador indicando que o método será acessível a partir do exterior. A palavra reservada “public static void String args[]” indica que o método principal é estático, e  que não retorna nenhum valor. Em seguida, entre parênteses, temos os parâmetros do método - este é um conjunto de args, que armazena valores do tipo String, ou seja, strings. Quando executamos o programa através deste array, podemos transferir vários dados para o programa. 

Após o título do método está o seu bloco, que contém um conjunto de instruções executadas.

2.2 COMENTÁRIOS 

O código do programa pode conter comentários. Os comentários permitem que você entenda o significado do programa, o que certas partes dele fazem. Quando compilados, os comentários são ignorados e não influenciam o funcionamento do aplicativo e sobre seu tamanho.

Existem dois tipos de comentários em Java: single-line e multi-line. Um comentário de uma linha é colocado em uma linha após uma barra dupla //. Abaixo segue o exemplo deste comentário:

Um comentário de várias linhas é fechado entre os caracteres /* texto de comentário */. Pode ser colocado em várias linhas. Por exemplo, como apresentado abaixo: 

3 VARIÁVEIS

As variáveis destinam-se ao armazenamento de dados no programa. Uma variável representa uma área de memória nomeada que armazena um valor de um tipo específico. Cada variável tem um tipo, um nome e um valor. Um tipo determina quais informações uma variável ou uma série de valores válidos podem armazenar.

As variáveis são declaradas da seguinte forma:

Por exemplo, vamos definir uma variável que será nomeada x e será de tipo:int 

Nesta expressão, declaramos uma variável x de tipo . Ou seja, x armazenará um número não maior que 4 bytes.int

Um nome variável pode ser qualquer nome arbitrário que satisfaça os seguintes requisitos:

• o nome pode conter quaisquer caracteres alfanuméricos, bem como um sublinhado, e o primeiro caractere no nome não deve ser um número;

• o nome deve estar livre de pontuação ou espaços;

• o nome não pode ser uma palavra-chave Java.

Além disso, ao declarar e posteriormente usar, deve-se ter em mente que Java é uma língua dependente de casos, de modo que as seguintes declarações representarão duas variáveis diferentes. Observe abaixo:

Declarando uma variável, podemos atribuir-lhe um valor: 

Você também pode atribuir um valor a uma variável ao declará-lo. Esse processo é chamado de inicialização: 

Se não atribuirmos um valor a uma variável antes de usá-lo, então poderemos obter um erro, por exemplo, no seguinte caso: 

Separado por vírgulas, você pode declarar várias variáveis do mesmo tipo e, ao mesmo tempo: 

Você também pode inicializá-los imediatamente: 

Uma característica distinta das variáveis é que podemos mudar seu significado durante o programa: 

3.1 PALAVRA RESERVADA VAR

Começando com Java 10, a palavra-chave var foi adicionada ao idioma, o que também permite definir uma variável: 

A palavra “var” é colocada no lugar do tipo de dados, e o próprio tipo da variável é inferido a partir do valor que é atribuído a ela. Por exemplo, para a variável x é atribuída o número 10, o que significa que a variável representará o tipo int.

Mas se uma variável é declarada usando o VAR, então devemos inicializá-la, ou seja, fornecê-la com um valor inicial, caso contrário teremos um erro, como, por exemplo, no seguinte caso:

3.2 CONSTANTES

Além das variáveis, a linguagem Java pode usar constantes para armazenar dados. Ao contrário das variáveis, as constantes só podem ser atribuídas uma vez. Uma constante é declarada da mesma forma que uma variável, apenas a palavra-chave final vem primeiro:

Normalmente, as constantes têm nomes maiúsculos.

As constantes permitem especificar variáveis que não devem mais ser alteradas. Por exemplo, se temos uma variável para armazenar o número pi, então podemos declarar ser uma constante por seu valor ser constante.

4 TIPOS DE DADOS

Uma das principais características de Java é a língua ser fortemente tipada. Isso significa que cada variável e constante representa um tipo específico e este tipo é estritamente definido. Um tipo de dados define uma gama de valores que uma variável ou constante pode armazenar.

Sendo assim, considere o sistema de tipo de dados base incorporado usado para criar variáveis em Java. E é representado pelos seguintes tipos.

boolean: armazena um valor ou true ou false 

byte: armazena um inteiro de 1 byte e ocupa -128127 

short: Armazena um inteiro de 2 bytes e ocupa -3276832767 

int: armazena um inteiro de 4 bytes e ocupa -21474836482147483647 

long: armazena um inteiro de 8 bytes e ocupa –9 223 372 036 854 775 8089 223 372 036 854 775 807 

double: armazena um número de ponto flutuante de 8 bytes e leva ±4.9*10-324±1.7976931348623157*10308 

float: armazena um número de 4 bytes ponto flutuante de e ocupa -3.4*10383.4*1038 

char: armazena um único caractere codificado UTF-16 e ocupa 2 bytes, de modo que a gama de valores armazenados é de 065535

Neste caso, a variável pode levar apenas os valores que correspondem ao seu tipo. Se uma variável é um tipo inteiro, ela não pode armazenar números fracionados.

5 OPERADORES

A maioria das operações em Java são semelhantes às usadas em outras linguagens,   como C. Há operações não realizadas (realizadas em um operando), operações binárias em dois operandos, e operações ternárias realizadas em três operações. Um operando é uma variável ou valor (como um número) envolvido em uma operação. Considere todos os tipos de operações.

Os números estão envolvidos em operações aritméticas. Em Java, há operações aritméticas binárias (realizadas em dois operandos) e operações unary (realizadas em um operando). As operações binárias incluem o seguinte:

(+) o funcionamento da adição de dois números:

(-) subtração de dois números: 

(*) operação de multiplicação de dois números 

(/) a operação de divisão de dois números: 

Ao dividir, vale a pena considerar que se dois inteiros estiverem envolvidos na operação, o resultado da divisão será arredondado para um inteiro, mesmo que o resultado seja atribuído ao flutuador ou à dupla variável: 

Para que o resultado represente um número de ponto flutuante, um dos operandos também deve representar um número de ponto flutuante: 

(%) obtendo o equilíbrio de dividir dois números: 

Há também duas operações aritméticas realizadas em um único número: ++ (incremento) e --(decréscimo ou decremento). Cada uma das operações tem duas variedades: prefixo e pós fixo:

(++) incremento do prefixo

Assume um aumento na variável por um, por exemplo (primeiro o valor da variável y é incrementado por 1, e então seu valor é atribuído à variável z)z=++y

(++) incremento pós-fixado

Também representa um aumento de uma variável por uma, por exemplo, (primeiro o valor da variável y é atribuído à variável z, e então o valor da variável y é aumentado por 1)z=y++

(--) decremento de prefixo

Reduzindo uma variável por um, por exemplo (primeiro o valor da variável y é reduzido por 1, e então seu valor é atribuído à variável z)z=--y

(--) decremento pós-fixado

z=y-- (primeiro o valor da variável y é atribuído à variável z, e então o valor da variável y é reduzido por 1)

5.1 PRIORIDADE DAS OPERAÇÕES ARITMÉTICAS

Algumas operações têm prioridade maior do que outras, portanto, são realizadas no início. Operações em ordem descendente de prioridade:

• ++ (incremento), -- (decremento)

• * (multiplicação), / (divisão), % (restante da divisão)

• + (adição), - (subtração)

A prioridade das operações deve ser considerada ao realizar um conjunto de expressões aritméticas:

Em primeiro lugar, será realizada uma operação de incremento, com maior prioridade — aumentará o valor da variável b e a devolverá como resultado. Em seguida, a multiplicação é realizada, e apenas a última adição é realizada ++b5 * ++ba + 5 * ++b

Os parênteses permitem que você substitua a ordem dos cálculos:

Embora a operação de adição tenha menor prioridade, a adição será realizada primeiro, não multiplicando, pois a operação de adição é fechada entre parênteses. 

5.2 ASSOCIATIVIDADE DAS OPERAÇÕES

Além da prioridade, as operações se distinguem por um conceito como a associatividade. Quando as operações têm a mesma prioridade, a ordem de cálculo é determinada pela associação dos operadores. Dependendo da associatividade, existem dois tipos de operadores:

• Operadores de associação de esquerda que correm da esquerda para a direita.

• Operadores de associação à direita que correm da direita para a esquerda.

Por exemplo, algumas operações, como multiplicação e operações de divisão, têm a mesma prioridade. O que, então, será o resultado na expressão:

Devemos interpretar essa expressão como (10 / 5) * 2 ou como 10 / (5 * 2)? Afinal, dependendo da interpretação, teremos resultados diferentes.

Todos os operadores aritméticos (exceto o incremento e o decréscimo do prefixo) são associativos à esquerda, ou seja, são executados da esquerda para a direita. Portanto, a expressão deve ser interpretada como, ou seja, o resultado será 4.10 / 5 * 2(10 / 5) * 2.

5.3 OPERAÇÕES DE PONTO FLUTUANTE

Deve-se notar que os números de pontos flutuantes não são adequados para cálculos financeiros e outros, onde erros de arredondamento podem ser críticos. Por exemplo:

Neste caso, a variável d não será 0,9, como se pode supor inicialmente, mas 0,899999999999999999999999999999999. Tais erros de precisão ocorrem porque um sistema binário é usado em um nível baixo para representar números de pontos flutuantes, mas não há representação binária para o número 0.1, nem para outros valores fracionados. Portanto, nesses casos, a classe BigDecimal é geralmente usada, o que permite contornar tais situações.

6 CONDICIONAIS

Um dos elementos fundamentais de muitas linguagens de programação são construções condicionais. Esses projetos permitem direcionar o trabalho do programa ao longo de um dos caminhos, dependendo de certas condições.

A língua Java usa os seguintes construtores condicionais: e if..else/switch.

6.1 IF/ELSE

A instrução IF/ELSE verifica a verdade de alguma condição e, dependendo dos resultados da verificação, executa determinado código:

Uma condição é colocada após a palavra-chave. E se essa condição for atendida, então o código é acionado, que é colocado no bloco se após as chaves. As condições são o funcionamento da comparação de dois números.if

Uma vez que, neste caso, o primeiro número é maior que o segundo, a expressão é verdadeira e retorna . Portanto, o controle se move para um bloco de código após chaves e começa a executar as instruções nele contidas, e especificamente o . Se o primeiro número fosse menor ou igual ao segundo, as instruções no bloco if não seriam executadas. num1 > num2 true System.out.println ("O primeiro número é maior que o segundo ");

Mas e se quiséssemos agir se a condição não fosse cumprida? Neste caso, podemos adicionar um bloco: else

Mas quando comparamos números, podemos contar três estados: o primeiro número é maior que o segundo, o primeiro número é menor que o segundo, e os números são iguais. Com a expressão, podemos lidar com condições adicionais:else if 

Também podemos conectar várias condições ao mesmo tempo, usando operadores lógicos: 

Aqui, o bloco se será executado se for igual e simultaneamente igual .num1 > num2truenum1>7true

6.2 SWITCH/CASE

A construção do switch/case é semelhante à IF/ELSE, pois permite que você manuseie várias condições ao mesmo tempo:

A palavra-chave do switch é seguida entre parênteses pela expressão que está sendo comparada. O valor desta expressão é sequencialmente comparado aos valores colocados após as declarações ver. E se uma correspondência for encontrada, ela executará o bloco de сase correspondente.

Uma declaração de quebra é colocada no final do bloco de сase para evitar a execução de outros blocos. Por exemplo, se você removeu o operador no seguinte caso:break.

Em seguida, o bloco seria executado (uma vez que a variável num é 8). Mas como não há nenhuma declaração de ruptura neste bloco, o bloco. case 8 case 9.

Se também quisermos lidar com uma situação em que não são encontradas correspondências, podemos adicionar um bloco padrão, como no exemplo acima. Embora o bloco padrão seja opcional.

Também podemos definir uma ação para vários blocos de casos seguidos:

6.3 OPERADOR TERNÁRIO

A operação ternária tem três operandos e estão envolvidos nesta operação em simultâneo. Dependendo da condição, a operação ternária retorna a segunda ou terceira operação: se a condição é “verdadeira ou true”, então o segundo operando é devolvido; se a condição é “Falsa ou false”, então a terceira é devolvida. Por exemplo:[primeiro operando - condição] ? [segundo operando] : [terceiro operando].

Aqui, o resultado da operação ternária é a variável z. Primeiro, a condição. E se for observado, então z será igual ao segundo operando - (x + y), caso contrário z será igual ao terceiro operando. x<y

7 CICLOS

Outro tipo de estruturas de controle são os ciclos. Os loops permitem que você execute uma determinada ação muitas vezes, dependendo de certas condições. A língua Java tem os seguintes tipos de loops:

• for

• while

• do...while 

7.1 CICLO FOR

O loop for tem a seguinte definição formal:

Considere o padrão para loop: 

A primeira parte da declaração do loop é criar e inicializar o contador i. O contador não precisa ser do tipo inteiro. Este pode ser qualquer outro tipo numérico, como ponto flutuante. Antes do loop correr, o contador será 1. Neste caso, é o mesmo que declarar uma variável int i = 1;

A segunda parte é a condição sob a qual o loop será executado. Neste caso, o loop funcionará até que se atinja o valor 9.

E a terceira parte é o incremento do contador por um. Mais uma vez, não temos que aumentar por um. Você pode reduzir: .i--

Como resultado, o bloco de ciclo disparará 8 vezes até que o valor de i se torne igual a 9. E cada vez que esse valor aumentar em 1.

Não precisamos especificar todas as condições ao anunciar o ciclo. Por exemplo, podemos escrever assim:

A definição do loop permaneceu a mesma, só que agora os blocos na definição que temos estão vazios: Agora não há uma contra variável inicializada, não há condição, então o loop funcionará sempre - um loop infinito.for (; ;)

Alternativamente, você pode omitir uma série de blocos:

Este exemplo é equivalente ao primeiro exemplo: também temos um contador, só que ele é criado fora do loop. Temos uma condição para a execução do ciclo. E há um incremento do contador já no próprio bloco para.

Um loop for pode definir e manipular várias variáveis ao mesmo tempo:

7.2 CICLO DO 

O loop do primeiro executa o código de loop e, em seguida, verifica a condição na instrução while. E enquanto essa condição for verdadeira, o ciclo se repete. Por exemplo:

Neste caso, o código de loop será acionado 7 vezes até j é zero. É importante notar que o loop “do” garante pelo menos uma ação, mesmo que a condição na declaração do tempo não seja verdadeira. Então, podemos escrever: 

Embora a variável “j” seja inicialmente menor que 0, o loop ainda será executado uma vez.

7.3 CICLO WHILE

O loop verifica imediatamente a verdade de alguma condição, e se a condição é verdadeira, então o código de loop é executado:while

7.4 CONTINUAÇÃO E/OU QUEBRA DE OPERADORES

A instrução de quebra permite que você saia do loop a qualquer momento, mesmo que o loop não tenha terminado seu trabalho:

Por exemplo:

Quando o contador é definido para 5, a declaração de quebra dispara e o loop termina.

Agora vamos fazer isso, para que se o número for 5, o loop não termine, mas simplesmente passe para a próxima iteração. Para isso, use o operador e continue:

Neste caso, quando a execução do loop atingir o número 5, o programa simplesmente pulará esse número e passará para o próximo. 

Tópico 3 - Estrutura de Dados e Funções

2 MATRIZES 

Uma matriz representa um conjunto de valores do mesmo tipo. Declarar uma matriz é semelhante a declarar uma variável regular que armazena um único valor, e há duas maneiras de declarar uma matriz:

Por exemplo, vamos definir uma matriz de números: 

Depois de declarar a matriz, podemos inicializá-la: 

A matriz é criada usando a seguinte construção: palavra reservada “new” + tipo de dados + [número de elementos], ou seja conforme esse exemplo, nums = new int[4]; onde a nova é a palavra-chave que aloca a memória para o número de elementos especificados entre parênteses. Por exemplo, nesta expressão, uma matriz de quatro elementos int é criada, e cada elemento terá um valor padrão — o número 0.

Você também pode inicializá-lo imediatamente quando você declarar uma matriz:

Com essa inicialização, todos os elementos da matriz têm um valor padrão. Para tipos numéricos (incluindo o tipo char), este é o número 0, para o tipo booleano é o valor , e para outros objetos é nulo. Por exemplo, para o tipo int, o valor padrão é 0, de modo que a matriz acima definida consistirá de quatro zeros. false nums

No entanto, você também pode definir valores específicos para os elementos da matriz quando você criá-lo:

Vale ressaltar que, neste caso, o tamanho da matriz não é indicado pelas chaves, uma vez que é calculado a partir do número de elementos em sua declaração no início.

Após criar uma matriz, podemos nos referir a qualquer um de seus elementos por índice, passado em colchetes quadrados após o nome da variável array:

A indexação dos elementos de uma matriz começa com 0, então, neste caso, para consultar o quarto elemento da matriz, precisamos usar a expressão.

E como temos uma matriz definida apenas para 4 elementos, não podemos nos referir, por exemplo, ao sexto elemento. Se tentarmos fazer isso, teremos um erro. 

2.1 COMPRIMENTO DA MATRIZ 

A propriedade mais importante que os arrays possuem é a propriedade de comprimento, que retorna o comprimento da matriz, ou seja, o número de seus elementos:

Não é incomum que o último índice seja desconhecido, e para obter o último elemento da matriz, podemos usar esta propriedade: 

2.2 MATRIZES MULTIDIMENSIONAIS

Anteriormente, olhamos para matrizes unidimensionais, que podem ser representadas como uma cadeia ou cadeia de valores semelhantes. Mas, além de matrizes unidimensionais, há também as multidimensionais. A matriz multidimensional mais famosa é uma tabela representando uma matriz bidimensional:

Visualmente, ambas as matrizes podem ser representadas da seguinte forma:

Matriz unidimensional nums1

Matriz bidimensional nums2. 

Como a matriz nums2 é bidimensional, é uma mesa simples. Também pode ser criado da seguinte forma: O número de suportes quadrados indicam a dimensão da matriz. Desta forma, os números entre parênteses são os números de linhas e colunas, usando índices, podemos usar os elementos da matriz no programa:int[][] nums2 = new int[2][3]; 

Declarar uma matriz tridimensional pode ser assim: 

2.3 MATRIZES IRREGULARES 

Matrizes multidimensionais também podem ser representadas como "matrizes irregulares". No exemplo acima, a matriz bidimensional tinha 2 linhas e três colunas, então temos uma mesa plana. Mas podemos atribuir a cada elemento em uma matriz bidimensional uma matriz separada com um número diferente de elementos:

3 MÉTODOS

Se variáveis e constantes armazenam alguns valores, os métodos contêm um conjunto de declarações que realizam ações específicas.

A definição geral dos métodos é a seguinte:

Modificadores e parâmetros são opcionais.

Por padrão, a classe principal de qualquer programa Java contém um método principal que serve como ponto de entrada para o programa:

Palavras-chave são modificadores. Em seguida é o tipo de valor de retorno. A palavra-chave “public static void” indica que o método não retorna nada. 

Em seguida, há o nome do método — principal e entre parênteses os parâmetros do método. E em chaves está o corpo do método — todas as ações que ele realiza.

Vamos criar mais alguns métodos:

Dois métodos adicionais são definidos aqui: olá e bem-vindo, cada um dos quais produz uma string para o console. Os métodos são definidos dentro de uma classe — neste caso, na classe do Programa onde o método principal é definido.

Mas se compilamos e executamos este programa, não veremos nada no console. No exemplo acima, definimos dois métodos, mas não os chamamos a lugar nenhum. Por padrão, um programa Java executa apenas o método principal e todo o seu conteúdo. Portanto, se queremos que outros métodos sejam executados também, devemos chamá-los no método principal.

O método é chamado na forma de:

O nome do método é seguido por parênteses que listam os argumentos — valores para os parâmetros do método.

Por exemplo, vamos definir e executar vários métodos:

O método principal chama o método de “olá” uma vez e o método de boas-vindas “duas vezes”. Essa é uma das vantagens dos métodos: podemos levar algumas ações gerais para um método separado e depois chamá-las repetidamente em diferentes lugares do programa. Como ambos os métodos não têm parâmetros, parênteses vazios são colocados após seu nome quando chamados.

Deve-se notar também que, para chamar outros métodos no método principal definidos na mesma classe, eles devem ter um modificador estático, indicada pela palavra reservada:  static.

Como resultado, após compilar e executar o programa, observaremos no console:

4 FUNÇÕES

Métodos podem devolver algum valor. Para fazer isso, use a declaração de retorno, neste caso, chamamos de retorno de uma função.

A declaração de retorno é seguida por um valor de retorno que é o resultado do método. Isso pode ser um valor literal, o valor de uma variável, ou alguma expressão complexa.

Por exemplo:

Em vez disso, o método usa qualquer outro tipo como tipo de retorno. Neste caso, o método de soma retorna um valor de tipo, de modo que esse tipo é especificado antes do nome do método. Além disso, se qualquer outro método que não seja “void” for definido como o tipo de retorno para o método, então o método deve necessariamente usar o operador de retorno para devolver o valor.

Neste caso, o valor de devolução deve ser sempre do mesmo tipo da definição da função. E se a função retornar um valor de tipo, então após a declaração de retorno há um valor inteiro que é um objeto do tipo int. Como neste caso, esta é a soma dos valores dos parâmetros do método.

Um método pode usar várias chamadas para a declaração de retorno para levantar valores diferentes dependendo de algumas condições:

Aqui, o método diurno retorna um valor de string, ou seja, uma sequência, e dependendo do valor do parâmetro de hora, a sequência retornada vai variar.

4.1 SAIR DA FUNÇÃO 

A declaração de retorno é usada para retornar um valor de um método, mas também para sair de um método. Nesta capacidade, o operador de retorno é usado em métodos que não retornam nada, ou seja, são do tipo:void: 

Se o valor passado para o método de daytime for maior que 24 ou menos de 0, então basta sair do método. Você não precisa especificar o valor de devolução após o retorno neste caso.

5 EXCEÇÕES

Muitas vezes, erros podem ocorrer durante a execução do programa, e não necessariamente devido à culpa do desenvolvedor. Alguns deles são difíceis de prever ou antecipar, e às vezes até impossíveis. Por exemplo, uma conexão de rede pode ser inesperadamente encerrada durante a transferência de um arquivo. Tais situações são chamadas de exceções.

A linguagem Java fornece ferramentas especiais para lidar com tais situações. Uma dessas ferramentas é a try…catch…finally. Quando uma exceção ocorre no bloco de tentativa, o controle se move para um bloco de captura que pode lidar com a exceção. Se nenhum desses blocos for encontrado, uma mensagem de exceção não manipulada será exibida ao usuário e uma execução adicional do programa será interrompida. E para que esse fato não ocorra, você precisa usar o bloco de try…catch. Por exemplo: 

Uma vez que temos uma matriz de números que pode conter apenas 3 elementos, o console lançará uma exceção quando a instrução for executada, e o programa será encerrado. Agora vamos tentar lidar com esta exceção: 

Ao usar a try... bloqueia-se e executa todas as declarações entre  declarações try e catch. Se uma exceção ocorrer de repente no bloco de tentativa, a ordem de execução normal pára e vai para a declaração do relógio. Portanto, quando a execução do programa chega à linha, o programa vai parar e passar para o bloco numbers[4]=45;catch

A expressão de catch tem a seguinte sintaxe: catch (tipo de exceção nome_variável) exException. Neste caso, você declara uma variável que é de tipo. No entanto, se a exceção que ocorre não for uma exceção ao tipo especificado na instrução catch, ela não é processada, e o programa simplesmente trava ou lança uma mensagem de erro.

Mas como o tipo é a classe base para todas as exceções, a expressão lidará com quase todas as exceções. Lidar com a exceção neste caso é produzir um erro no console da pilha de rastreamento usando o método definido na classe Exceção. Exceptioncatch (Exception ex).

Após o bloqueio de captura terminar de ser executado, o programa continua seu trabalho, executando todas as outras instruções após o bloco de captura.

Try… catch também pode ter um bloco. No entanto, este bloco é opcional e pode ser omitido ao manusear exceções. O bloco é executado em qualquer caso, independentemente de uma exceção ter ocorrido no bloco de tentativa ou não.

LEITURA COMPLEMENTAR

UMA BREVE INTRODUÇÃO AO ESTUDO E IMPLEMENTAÇÃO DE COMPILADORES 

Guido Aparecido Junior

Rodrigo Yoshio Tamae 

  RESUMO 

Este artigo tem o objetivo de demonstrar as etapas e os fundamentos necessários para a concepção de um compilador (parsers e gerador de código), bem como abordar, de forma introdutória, duas ferramentas baseadas em Java utilizadas na geração de projeto de compiladores: JavaCC e Jasmin. 

Palavras-chave: Parser, JavaCC e Jasmin.

 ABSTRACT

This paper has the objective to demonstrate the stages and the necessary beddings for the conception of a compiler (parsers and code generator), as well as approaching, in introductory form, two tools based on Java used in generation compilers project’s: JavaCC and Jasmin.

Keywords: Parser, JavaCC and Jasmin.

 1  – INTRODUÇÃO

Desde os primórdios da computação, desenvolver meios eficientes para obter o controle e otimizar o uso dos recursos computacionais disponíveis constituem-se em objetos de estudo dos cientistas da computação.

A concepção de uma linguagem pode ocorrer por meio das mais diversas justificativas, a exemplo da linguagem Java, que surgiu a partir da necessidade de se criar uma linguagem para atender a demanda de dispositivos embarcados, nos anos 90. Neste contexto, às vezes, necessidades como resolver problemas de limitação de hardware ou melhorar o desempenho dos recursos computacionais no nível do software ou mesmo para resolver algum problema em especial, fizeram surgir os compiladores.

Todo este esforço e a variedade de linguagens de programação e de compiladores disponíveis justifica-se pelo fato de que programar em linguagem de baixo nível tornou-se cada vez mais complicado, na mesma proporção em que surgem novos recursos computacionais.

Abordar os aspectos mais relevantes sobre o tema compiladores é o foco deste trabalho, que aponta para a concepção de um novo compilador através das ferramentas Java JavaCC e Jasmin. 

2  – PRINCÍPIOS DE UM COMPILADOR

 Um compilador é um software que traduz um programa descrito em uma linguagem de alto nível para um programa equivalente em código de máquina para um processador. Em geral, um compilador não produz diretamente o código de máquina, mas sim, um programa em linguagem simbólica (assembly) semanticamente equivalente ao programa em linguagem de alto nível. O programa em linguagem simbólica é, então, traduzido para o programa em linguagem de máquina através de montadores.

Para realizar esta tarefa, o compilador executa a análise léxica, sintática e semântica do código-fonte do programa que está sendo executada em linguagem abstrata para depois gerar o código de máquina.

Com o advento do computador de programa armazenado de John Von Neumann no final da década de 1940, tornou-se necessário escrever sequências de código (ou programas) para que os computadores efetuassem as computações desejadas. Inicialmente, estes programas foram escritos em linguagem de Máquina, ou seja, códigos numéricos representando as operações de máquina e serem efetivamente executadas (LOUDEN, 2004). Ao longo dos anos 50, os compiladores foram considerados programas notoriamente difíceis de escrever, pois, o primeiro compilador FORTRAN, por exemplo, consumiu 18 homens-ano para programar, levando a descobertas técnicas sistemáticas para o tratamento de muitas das mais importantes tarefas que ocorreram durante a compilação, e seguindo esta evolução, as técnicas de implementação em linguagens abstratas também se tornaram cada vez mais avançadas (AHO, 1996). 

O nome compilador faz referência ao processo de composição de um programa pela reunião de várias rotinas de bibliotecas, a tradução de linguagem abstrata para linguagem de baixo nível que é executada pelo compilador. O compilador tem duas tarefas básicas: Análise, que examina, verifica e compreende o texto de entrada (no código-fonte); Geração de código, em que o texto de saída (código de máquina) é gerado de forma correspondente ao texto de entrada (código-fonte da linguagem abstrata).

2.1   – ANALISADORES: LÉXICO, SINTÁTICO E SEMÂNTICO

 A análise léxica é o processo de analisar a entrada de linhas de caracteres (tal como o código-fonte de um programa de computador) e produzir uma seqüência de símbolos chamados "símbolos léxicos" (lexical tokens), ou somente "símbolos" (tokens), que podem ser manipulados mais facilmente por um parser (leitor de saída). A Análise Léxica é a forma de verificar determinado alfabeto, quando analisamos uma palavra podemos definir através da análise léxica se existe ou não algum carácter que não faz parte do nosso alfabeto, ou um alfabeto inventado por nós. O analisador léxico é a primeira etapa de um compilador, logo após virá a análise sintática (LOUDEN, 2004)..

O analisador sintático é considerado o coração do compilador, sendo responsável por verificar se a sequência de símbolos contida no código-fonte compõem um programa válido ou não. A sintaxe de uma linguagem de programação pode ser descrita por uma gramática independente de contexto e representada graficamente através da notação BNF (Backus-Naur Form ou Forma de Backus-Naur). Esta gramática descreve recursivamente a combinação de tokens possíveis de uma linguagem. Em termos práticos, pode também ser usada para decompor um texto em unidades estruturais para serem organizadas dentro de um bloco. O analisador sintático recebe do analisador léxico um grupo de tokens e usa um conjunto de regras para construir uma árvore sintática da estrutura. A vasta maioria dos analisadores sintáticos implementados em compiladores aceitam alguma linguagem livre de contexto para fazer a análise (LOUDEN, 2004).

A análise semântica é a terceira fase da compilação, que recebe este nome, pois requer a computação de informações que estão além da capacidade das gramáticas livres de contexto e dos algoritmos padrão de análise sintática, portanto estas informações não podem ser consideradas sintaxe. A informação computada também está fortemente relacionada com o significado, ou seja, a semântica do programa traduzido (LOUDEN, 2004). É neste analisador que se verifica os erros semânticos, (por exemplo, uma multiplicação entre tipos de dados diferentes) no código-fonte, ou seja, se não existem incoerências com os significados das construções utilizadas pelo programador, e coleta as informações necessárias para a próxima fase da compilação que é a geração de código-fonte. A verificação realizada pelo analisador semântico deve procurar por erros como: Se os tipos de operadores são compatíveis com os da linguagem; Variáveis não declaradas; Chamadas de funções ou métodos com um número incorreto de parâmetros; Comandos colocados fora de contexto.

Para que estas verificações sejam executadas o analisador depende de uma tabela de símbolos, onde estão armazenados informações de variáveis declaradas, funções ou métodos, tipos ou classes. Somente com a tabela de símbolos é possível realizar a validação semântica do programa.

2.2   – GERADORES DE CÓDIGO

Uma vez verificado que não existem erros sintáticos ou semânticos, o compilador pode realizar sua tarefa, que é a criação do código-objeto. Em geral, o código-objeto é armazenado num arquivo que pode ser posteriormente link editado com outros códigos-objeto ou simplesmente carregado na memória do computador e executado pelo sistema operacional (DELEMARO, 2004). Dentro do diversificado leque de categorias de ferramentas que prestam apoio às atividades da Engenharia de Software, uma específica vem ganhando cada vez mais destaque e, sobre ela, tem- se aplicado muito investimento nos últimos tempos: as Ferramentas de Geração de Código, ou simplesmente Geradores de Código. Dessa forma, Gerador de Código é aquela ferramenta que possui a capacidade de gerar código a partir de um determinado modelo de software. Inclusive, de acordo com alguns pontos de vista e a partir das características específicas do tipo de Gerador de Código, ele passa a ser conversor de códigos de linguagens distintas. Isso acontece, por exemplo, com o compilador, que transforma um código escrito através de uma linguagem de programação para código de máquina ou código-objeto . 

3  – AS ETAPAS PARA A CRIAÇÃO DE UM COMPILADOR

O objetivo de se criar um compilador vem da necessidade de se resolver um determinado problema através de uma nova linguagem abstrata (linguagem de alto nível) específica, identificar os propósitos desta linguagem, saber se esta vai ser utilizada para fins comerciais, científicos ou de propósitos gerais. Tendo definido isto, o próximo passo é a construção de uma gramática BNF para a nova linguagem e, consequentemente, escrever os analisadores e gerador de código.

Atualmente, um dos meios para se projetar um compilador é a utilização das ferramentas JavaCC (que é um gerador de analisador sintático que gera código em linguagem Java) e o Jasmim que gera o código de máquina semanticamente ao código-fonte das linguagens abstratas.

O JavaCC é um programa gerador de compiladores ou mais precisamente um gerador de analisador sintático. Ele toma como entrada uma gramática e transforma-a num programa descrito em linguagem Java capaz de analisar um arquivo e dizer se satisfaz ou não as regras especificadas nesta gramática. Oferece facilidades para a construção da árvore sintática. O programa gerado pelo JavaCC realiza um tipo de análise sintática chamada de top down ou análise descendente (DELAMARO, 2004). O Jasmin é uma interface de montagem para Java (Java ASseMbler INterface), que toma como entrada um arquivo ASCII com instruções JVM (Java Virtual Machine) e produz um arquivo executável para a JVM (arquivo “.class”). Assim pode-se verificar se o código gerado está correto ou não. Porém, para que possamos executar o código, precisamos executar mais uma tarefa, que é transformá-lo num arquivo executável Java, utilizando um programa Jasmin (DELAMARO, 2004). 

4  – CONSIDERAÇÕES FINAIS

Percebe-se que a construção de um compilador não é uma tarefa trivial, mas cujos estudos não geram apenas um conhecimento técnico em específico. A rigor, da nova tendência do uso de técnicas de programação linear nos ambientes corporativos como ferramentas de tomada de decisão que leva, não só ao apontamento da solução ótima de um problema, mas também a uma melhor compreensão do problema em questão, assim também ocorre com os estudos das técnicas de implementação de um compilador, pois além dos conhecimentos técnicos, leva a um entendimento apurado sobre as limitações de máquinas e como estas podem ser resolvidas pelo software.

Atualmente, existem diversas formas de se implementar um compilador, mas ressalta-se neste trabalho o uso de duas ferramentas Java: JavaCC e Jasmin. Dotadas de vasta biblioteca sobre a gramática de linguagens como C, SQL e Java, estas ferramentas possibilitam a uma imersão direta no mundo dos compiladores, abrindo novos horizontes, em nível de compreensão das arquiteturas computacionais, melhorando a qualidade de software produzido.

Pode-se afirmar que o conhecimento gerado através da implementação de um compilador torna-se um grande diferencial ao profissional de tecnologia de informação que se propõe a desenvolver um software de qualidade, através de boas práticas de programação.

FONTE: JUNIOR, G. A.; TAMAE, R. Y. Uma breve introdução ao estudo e implementação de compiladores. Disponível em: http://faef.revista.inf.br/imagens_arquivos/arquivos_destaque/mPd7q0kH4YgxlRK_2013-5-28-10-54-8.pdf. Acesso em: 4 ago. 2022.