INSTITUTO MÉDIO COMERCIAL DE LUANDA

COORDENÇÃO DO CURSO DE INFORMÁTICA DE GESTÃO

JAVA E SEUS FUNDAMENTOS

Luanda, 2022
 INSTITUTO MÉDIO COMERCIAL DE LUANDA

COORDENÇÃO DO CURSO DE INFORMÁTICA DE GESTÃO

JAVA E SEUS FUNDAMENTOS

Trabalho apresentado para avaliação da

disciplina de Projeto Tecnológico do
curso de Informática de Gestão
ministrado pela professora Luísa Silva.

Luanda, 2022
2
Elaborado por:

29. Keven dos Santos

30. Leonildo Miguel

31. Lucas Victor

32. Luís Manuel

33. Mafuta Domingos

34. Massala Bernardo

35. Petelson Virgílio

36. Pimba Cristóvão

Curso: Informática de Gestão

Classe: 12ª

Turma: ATI

3
DEDICATÓRIA

Dedicamos o nosso trabalho a comunidade de desenvolvedores de software.

4
AGRADECIMENTOS

Primeiramente agradecemos á Deus pai todo poderoso pela vida.

Ás nossas famílias pelo incentivo aos estudos e pela força para continuar.

Aos nossos amigos e colegas pelo apoio material e emocional.

A todos o nosso sincero muito obrigado.

5
EPIGRAFE

“Se você mostrar os problemas às

pessoas, e indicar uma solução, elas
vão se mobilizar para agir.”

Bill Gates

6
ÍNDICE

DEDICATÓRIA........................................................................................................................4
AGRADECIMENTOS.............................................................................................................5
EPIGRAFE................................................................................................................................6
I. INTRODUÇÃO.....................................................................................................................9
1.1. Introduzir o tema.......................................................................................................9
1.1.1. Delimitação do tema..................................................................................................9
1.1.2. Justificação do tema...................................................................................................9
1.2. Formulação do problema...........................................................................................9
1.3. Objetivos...................................................................................................................10
1.3.1. Objetivo geral..........................................................................................................10
1.3.2. Objetivos específicos...............................................................................................10
II. FUNDAMENTAÇÃO TEÓRICA....................................................................................11
2.1. Orientação a Objetos...................................................................................................11
2.1.1 Objetos......................................................................................................................11
2.1.1.1 Objeto pai e filho...............................................................................................12
2.1.1.2 Comunicação e coordenação de objetos............................................................12
2.1.2 Classes......................................................................................................................12
2.1.3 Encapsulamento........................................................................................................12
2.1.4 Herança.....................................................................................................................13
2.1.5 Polimorfismo............................................................................................................13
2.1.6 Abstração..................................................................................................................13
2.2 Introdução ao Java........................................................................................................13
2.2.1 História.....................................................................................................................14
2.2.2 Web x Aplicativos....................................................................................................15
2.2.3 Java Development Kit – JDK...................................................................................15
2.2.4 Características da Linguagem...................................................................................16
2.2.4.1 Simples e familiar..............................................................................................16
2.2.4.2 Orientada a Objetos............................................................................................16
2.2.4.3 Compilada e Interpretada...................................................................................16
2.2.4.4 Pronta para Redes..............................................................................................16
2.2.4.5 Distribuído.........................................................................................................16
2.2.4.6 Multiprocessamento (Multithread)....................................................................17
2.2.4.7 Portabilidade......................................................................................................17
2.2.4.8 Coletor de Lixo – Garbage Coletor....................................................................17
2.2.4.9 Segura................................................................................................................17
3 Fundamentos da Linguagem...........................................................................................18
7
 3.1 Comentários.................................................................................................................18
3.2 Palavras chaves..............................................................................................................18
3.3 Tipos de Dados...............................................................................................................19
3.4 Variáveis ou Atributos..................................................................................................19
3.5 Constantes......................................................................................................................19
3.6 Operadores.....................................................................................................................20
3.6.1 Operadores Aritméticos............................................................................................20
3.6.3 Operadores Lógicos..................................................................................................20
3.6.4 Atribuição Composta................................................................................................20
3.6.5 Operadores Incremental e Decremental...................................................................21
3.6.6 Operador Ternário....................................................................................................21
3.7 Conversões com Tipos Primitivos................................................................................21
3.8 Controle de Fluxo..........................................................................................................22
3.8.1 Sentenças Condicionais............................................................................................22
3.8.2 Loops Indeterminados..............................................................................................23
3.8.3 Loops Determinados.................................................................................................24
3.8.4 Múltiplas Seleções....................................................................................................24
3.8.5 Manipulações diversas..............................................................................................25
3.9 Arrays.............................................................................................................................26
3.10 Strings...........................................................................................................................27
III. METODOLOGIA............................................................................................................28
CONCLUSÃO.........................................................................................................................29
BIBLIOGRAFIA.....................................................................................................................30

8
I. INTRODUÇÃO

1.1. Introduzir o tema

A World Wide Web (WWW) transformou a Internet. Os usuários não estavam mais restritos a
sistemas de informação em modo texto, pois a Web com seu sistema de hipertexto e hipermídia não só
dá ao usuário um alto grau de seletividade como também abre diversas opções para informação em
outras mídias. Usando a Web, pode-se acessar informação sob a forma de gráficos, textos, sons e até
mesmo vídeos. No entanto, a Web não possui interatividade real, ou seja, uma interação entre o
usuário e a aplicação em tempo real, dinâmica e visual.

É dentro deste contexto que surge o Java. Java veio trazer a interatividade que falta na Web. Com um
Web Browser suportando Java, pode-se ter animações e aplicações interativas, e ainda programas em
Java que implementam protocolos de informação e novos formatos de mídia. As características do
Java enriquecem a comunicação, informação e interação na Web, por possibilitar ao usuário a
distribuição de conteúdos executáveis, ao invés de apenas páginas em HTML e arquivos multimídia.

Com origem no trabalho da Sun Microsystems para construir uma linguagem de programação com o
intuito de criar software que pudesse ser executado em diferentes arquiteturas, surgiu o Java, que se
propõe a ser uma linguagem para distribuição de conteúdo executável através da Web. Java traz um
novo interesse as páginas da Web através de aplicações que podem dar ao usuário um retorno
imediato, e aceitar entrada do mesmo continuamente através do teclado e do mouse.

1.1.1. Delimitação do tema

Esta pesquisa delimitou-se em desenvolver conceitos sobre a linguagem de programação java e seus
principais fundamentos.

1.1.2. Justificação do tema

Com o grande crescimento no ramo da informática nos últimos anos especialmente com o surgimento
de dispositivos eletrônicos cada vez mais sofisticados, os programadores sentiram-se obrigados a
aprender e a desenvolver linguagens de programação cada vez mais robustas e multiplataforma.

1.2. Formulação do problema

Com o surgimento de tecnologias cada vez mais inovadoras nos últimos anos tornou-se importante
entender como estas funcionam e como poderiam ser melhoradas.

9
Portanto buscou-se reunir dados ou informações com o propósito de responder ao seguinte problema
de pesquisa: De que forma ajudou o surgimento da linguagem de programação java?

1.3. Objetivos

1.3.1. Objetivo geral

O presente trabalho tem como objetivo geral entender os principais fundamentos que fazem da
linguagem de programação java uma linguagem multiplataforma.

1.3.2. Objetivos específicos

 Descrever os objetivos do java;

 Mostrar os elementos que dela fazem parte;
 Descrever como o uso da linguagem de programação java facilita a migração do código-
fonte para outras plataformas.

10
II. FUNDAMENTAÇÃO TEÓRICA

2.1. Orientação a Objetos

Inovações tecnológicas surgidas na área de Informática têm criado uma necessidade de utilização e
manipulação de informações que antigamente não eram utilizadas. Os tipos de dados complexos,
como os objetos, passaram a ser manipulados através das linguagens de programação, que passaram a
receber a conotação de Linguagem de Programação Orientada a Objetos.

A programação estruturada, em se tratando, principalmente, de manutenção de sistemas, possui taxas

de reutilização muito baixas, dificultando a manutenção dos programas anteriormente desenvolvidos.

A orientação a objetos tem como objetivo principal modelar o mundo real, e garantir que as taxas de
manutenibilidade (manutenção) serão maiores diante deste contexto. Isso é possível, pois utilizando
uma linguagem de programação orientada a objetos consegue-se obter um desenvolvimento mais
rápido, visto que este desenvolvimento ocorre em módulos, em blocos de códigos correspondentes aos
objetos e seus acoplamentos. Através da orientação a objetos pode-se obter uma maior qualidade e
agilidade no
desenvolvimento, pois o fator reusabilidade (reutilização) permite que se reutilize outros objetos que
foram anteriormente desenvolvidos e podem ser facilmente incorporados na aplicação. A reusabilidade
também garante uma manuseabilidade melhor do programa, pois os testes referentes aos componentes,
já foram previamente executados, garantindo assim a utilização coesa dos objetos.

A orientação a objetos surgiu na década de 60, baseada na Teoria dos Tipos da Álgebra, mas somente
na década de 90 começou a ser amplamente utilizada computacionalmente. Ela tem como princípio
fundamental representar o mundo real e a forma de se interagir com os objetos.

2.1.1 Objetos

Em programação um objeto é um elemento que representa alguma entidade (abstrata ou concreta) do

domínio de interesse sob análise, ou seja, um objeto é todo elemento tangível ou intangível (físico ou
lógico) com limites e significados bem definidos que se deseja representar.

Um objeto é uma entidade autocontida que contém atributos e comportamento, e nada mais. Em vez
de ter uma estrutura de dados com campos (atributos) e transmite essa estrutura em toda a lógica do
programa que atua nela (comportamento), em uma linguagem orientada a objetos, dados e lógica de
programa são combinados. Essa combinação pode ocorrer em níveis completamente diferentes, de
objetos com baixa granularidade, como Number, a objetos com alta granularidade, como um
serviço FundsTransfer em um aplicativo financeiro amplo.
11
2.1.1.1 Objeto pai e filho

Um objeto pai é aquele que serve como base estrutural para derivação de objetos-filho mais
complexos. Um objeto-filho assemelha-se ao seu pai, mas é mais especializado. Com o paradigma
orientado a objetos, é possível reutilizar os atributos comuns e o comportamento do objeto pai,
incluindo nesses objetos-filho atributos e comportamentos diferentes.

2.1.1.2 Comunicação e coordenação de objetos

Os objetos se comunicam enviando mensagens (chamadas de métodos na linguagem Java). Além

disso, em um aplicativo orientado a objetos, o código do programa coordena as atividades entre
objetos para executar tarefas dentro do contexto do domínio de aplicativo específico.

2.1.2 Classes

As classes representam ideias ou conceitos e classificam os objetos que têm propriedades similares.
Além da especificação de atributos, a definição de uma classe descreve também qual o comportamento
dos objetos, ou seja, que funcionalidades podem ser aplicadas a objetos da classe, funcionalidades
essas que são descritas através de métodos.

Outros elementos associados as classes são:

 Construtor e destrutor: métodos especiais que definem o comportamento do objeto

de uma classe no momento da sua criação e destruição. Em algumas linguagens, como
em C++, um método destrutor é utilizado para liberar recursos do sistema (como
memória), já em outras, como em Java e C#, isto é realizado de modo automático pelo
coletor de lixo.
 Propriedade: define o acesso a um estado do objeto.
 Evento: define um ponto em que o objeto pode chamar outros procedimentos de
acordo com seu comportamento e estado interno.

2.1.3 Encapsulamento

Através do encapsulamento pode-se ocultar informações irrelevantes para os outros objetos que
interagem com estes objetos. O encapsulamento permite que os atributos de uma determinada classe
somente sejam modificados utilizando métodos que interajam com o mesmo. Assim, as modificações
através dos métodos garantem que não há manipulações indevidas aos atributos. Isto é, uma classe
pode utilizar recursos de outra classe sem a necessidade de conhecer o código fonte destes recursos,
mesmo reimplementando-os. As entradas, os processamentos e as saídas de um objeto não influenciam
os dos outros, pois os seus relacionamentos são apenas referenciados.
12
2.1.4 Herança

A herança é mais uma característica do mundo real incorporado no mundo orientado a objetos. É um
mecanismo que define variáveis e métodos comuns a todos os objetos de um certo tipo. Assim, a partir
de uma determinada classe, pode-se ter subclasses e superclasses. As subclasses não são limitadas aos
estados e comportamentos definidos pela superclasse elas podem adicionar variáveis e métodos ao seu
escopo. Entre estas características da herança, a manipulação das classes que herdam métodos e
atributos permite que se modularize o código de tal forma que cada objeto tem uma funcionalidade
própria e garante assim uma coesão das informações.

2.1.5 Polimorfismo

O polimorfismo permite que referências de tipos de classes mais abstratas representem o

comportamento das classes concretas que referenciam. Assim, é possível tratar vários tipos de maneira
homogênea (através da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e
significa "muitas formas" (“poli” = muitas, “morphos” = formas).

O polimorfismo permite definir duas abordagens como: sobreposição(override) e

sobrecarga(overload). A sobreposição ocorre quando duas ou mais classes derivadas de uma mesma
superclasse podem invocar métodos que possuem a mesma identificação(assinatura), mas
comportamentos distintos. Enquanto que a sobrecarga dos métodos ocorre quando em uma mesma
classe, métodos possuem os mesmos nomes, mas assinaturas diferentes.

2.1.6 Abstração

Abstração é a habilidade de concentrar nos aspetos essenciais de um contexto qualquer, ignorando

características menos importantes ou acidentais. Trata-se da capacidade de abstrair, ou isolar
características principais de um todo, para considerar individualmente, criando, desse forma, objetos.

Assim, através de classes, objetos, atributos, métodos, dentre outras características da orientação a
objetos, consegue-se modelar o mundo real e abstrair informações incorporando-as à linguagem Java.

2.2 Introdução ao Java

Java é a linguagem de programação orientada a objetos, desenvolvida pela Sun Microsystems, capaz
de criar tanto aplicativos para desktop, aplicações comerciais, softwares robustos, completos e
independentes, aplicativos para a Web. Alem disso, caracteriza-se por ser muito parecida com C++,
eliminando as características consideradas complexas, dentre as quais ponteiros e herança múltipla.

13
2.2.1 História

Em 1991, um pequeno grupo de funcionários da Sun incluindo James Gosling mudou-se para a San
Hill Road, uma empresa filial. O grupo estava iniciando um projeto denominado Projeto Green, que
consistia na criação de tecnologias modernas de software para empresas eletrônicas de consumo, como
dispositivos de controle remoto das TV a cabo. Logo o grupo percebeu que não poderia ficar preso as
plataformas, pois os clientes não estavam interessados no tipo de processador que estavam utilizando e
fazer uma versão do projeto para cada tipo de sistema seria inviável. Desenvolveram então o sistema

operacional GreenOS, com a linguagem de programação Oak. Eles se basearam no inventor do Pascal,
através da linguagem USCD Pascal, que foi o pioneiro da linguagem intermediária ou máquina virtual.

Em 1993, surgiu uma oportunidade para o grupo Green, agora incorporado como FirstPerson a Time-
Warner, uma empresa que estava solicitando propostas de sistemas operacionais de decodificadores e
tecnologias de vídeo sob demanda. Isso foi na mesma época em que o NCSA lançou o MOSAIC 1.0, o
primeiro navegador gráfico para Web. A FirstPerson apostou nos testes de TV da Time-Warner, mas
esta empresa preferiu optar pela tecnologia oferecida pela Silicon Graphics.

Depois de mais um fracasso, a FirstPerson dissolveu-se e metade do pessoal foi trabalhar para a Sun
Interactive com servidores digitais de vídeo. Entretanto, a equipe restante continuou os trabalhos do
projeto na Sun. Apostando na Web, visto que os projetos estavam sendo todos voltados para a WWW,
surgiu a idéia de criar um browser com independência de plataforma, que foi o HotJava.

Como a equipe de desenvolvimento ingeria muito café enquanto estavam trabalhando, várias xícaras
de café foram inseridas até que o projeto estivesse pronto. Finalmente em maio de 1995, a Sun
anunciou um ambiente denominado Java (homenagem às xícaras de café) que obteve sucesso graças a
incorporação deste ambiente aos navegadores (browsers) populares como o Netscape Navigator e
padrões tridimensionais como o VRML (Virtual Reality Modeling Language – Linguagem de
Modelagem para Realidade VIrtual).

A Sun considera o sucesso do Java na Internet como sendo o primeiro passo para utilizá-lo em
decodificadores da televisão interativa em dispositivos portáteis e outros produtos eletrônicos de
consumo – exatamente como o Java tinha começado em 1991. Sua natureza portátil e o projeto
robusto permitem o desenvolvimento para múltiplas plataformas, em ambientes tão exigentes como os
da eletrônica de consumo.

14
2.2.2 Web x Aplicativos

Programas escritos em Java, podem ser Applets, Aplicativos ou ainda Servlets. Os aplicativos são
programas que necessitam de um interpretador instalado na máquina. Enquanto que Applets são
programas carregados juntamente com páginas HTML. O interpretador, no caso das Applets, é o
próprio browser. Não necessita instalação, basta que o browser usado ofereça suporte a Java. Já no
caso dos Servlets, são programas desenvolvidos em Java que são interpretados pelo Servidor Web. Os
servlets são utilizados na geração dinâmica de páginas HTML. Atualmente, são muito utilizados na
combinação com JSP (Java Server Pages) para a utilização do MVC (Model View Controller).

2.2.3 Java Development Kit – JDK

O Java Development Kit (JDK) é qualquer implementação da Plataforma Java Standard Edition,
Plataforma Java Enterprise Edition ou Plataforma Java Micro Edition lançada pela Oracle Corporation
na forma de um produto binário destinado a Desenvolvedores Java no Solaris, Linux, macOS ou
Windows. O JDK inclui uma JVM privada e alguns outros recursos para concluir o desenvolvimento
de um aplicativo Java. Desde a introdução da plataforma Java, tem sido de longe o mais amplamente
utilizado Software Development Kit (SDK). Em 17 de novembro de 2006, a Sun anunciou que iria
lançá-lo sob a GNU General Public License (GPL), tornando-se software livre. Isso aconteceu em
grande parte em 8 de maio de 2007, quando a Sun contribuiu com o código-fonte para o OpenJDK.

O JDK é separado em 3 edições: o Java 2 Standard Edition (J2SDK), o Java 2 Enterpise Edition
(J2EE) e o Java Micro Edition (J2ME). Cada uma engloba um conjunto de pacotes diferentes
fornecendo aos usuarios uma forma organizada e diferenciada para desenvolver aplicações. Ou seja, os
usuários que desejem desenvolver aplicações para Palm Tops, celulares, dispositivos pequenos, deve
utilizar o J2ME para desenvolver as suas aplicações.

Os principais componentes do kit de desenvolvimento são:

 Javac (compilador)
 Java (interpretador)
 Appletviewer (visualizador de applets)
 Javadoc (gerador de documentação)
 Jar (programa de compactação)

A utilização do JDK é feita da seguinte forma: primeiro escreve-se o programa fonte em Java,
utilizando qualquer editor de texto ou IDE para Java como Eclipse, JCreator, JBuilder, JDeveloper,
Bloco de Notas, TextPad(com pluggins), dentre outros devendo ser compilado utilizando um
compilador javac.
15
2.2.4 Características da Linguagem

2.2.4.1 Simples e familiar

Linguagem simples e de fácil manipulação, possui sintaxe muito parecida com C++ que é uma das
mais conhecidas no meio. Java é muitas vezes considerada uma versão simplificada da linguagem C+
+, onde Java não possui características como arquivos headers, ponteiros, sobrecarga de operadores,
classes básicas virtuais, dentre outras que somente aumentavam a dificuldade dos programadores com
a linguagem C++.

2.2.4.2 Orientada a Objetos

Paradigma atualmente mais utilizado na construção de softwares. Permite que se focalize o dado,
enfim, o objeto. Java não é uma linguagem 100% orientada a objetos, como Smaltalk, onde qualquer
elemento, (operadores, sinais, tipos de dados,..) são objetos. Em Java há os tipos primitivos de dados
que não são objetos, mas foram criados e incorporados ao Java para permitir uma melhor forma de
utilização da linguagem pelos programadores. Outra característica importante da linguagem Java em
relação à linguagem C++, é que Java não suporta herança múltipla.

2.2.4.3 Compilada e Interpretada

Um programa desenvolvido em Java necessita ser compilado, gerando um bytecode. Para executá-lo é
necessário então, que um interpretador leia o código binário, o bytecode e repasse as instruções ao
processador da máquina específica. Esse interpretador é conhecido como JVM (Java Virtual Machine).
Os bytecodes são conjuntos de instruções, parecidas com código de máquina. É um formato próprio do
Java para a representação das instruções no código compilado.

2.2.4.4 Pronta para Redes

As funcionalidades que são fornecidas pela linguagem Java para desenvolver programas que
manipulem as redes através das APIs são simples e de grandes potencialidades. Através destas APIs
pode-se manipular protocolos como TCP/IP, HTTP, FTP e utilizar objetos da grande rede via URLs.

2.2.4.5 Distribuído

Programas Java são “linkados” em tempo de execução. Os bytecodes gerados durante a compilação só
serão integrados na execução. Um objeto X existente em um arquivo quando instanciado, somente será
alocado na memória em tempo de execução. Se alguma alteração ocorrer na classe que define o objeto
X, somente o arquivo da classe com a alteração necessita ser compilado.

16
2.2.4.6 Multiprocessamento (Multithread)

Suporta a utilização de threads. Threads são linhas de execução, executadas concorrentemente dentro
de um mesmo processo. Diferentemente de outras linguagens, programar utilizando Threads é simples
e fácil na linguagem Java.

2.2.4.7 Portabilidade

Pode ser executado em qualquer arquitetura de hardware e sistema operacional, sem precisar ser re-
compilado. Um programa Java pode ser executado em qualquer plataforma que possua um
interpretador Java (ambiente de execução). Além disso, não há dependência de implementação, como
por exemplo, os tamanhos dos tipos primitivos não diferem entre si, são independentes da maquina em
que está a aplicação. Assim, o tipo int possui sempre um tamanho de 32-bits em Java e em qualquer
máquina que esteja sendo executado.

2.2.4.8 Coletor de Lixo – Garbage Coletor

Se não houver nenhuma referência a um objeto que tenha sido criado na memória, o coletor de lixo
destrói o objeto e libera a memória ocupada por ele. O coletor de lixo é executado de tempos em
tempos. Quando a JVM percebe que o sistema diminuiu a utilização do processador, ela-JVM- faz
com que o coletor de lixo execute e este vasculha a memória em busca de algum objeto criado e não
referenciado. Em Java nunca se pode explicitamente liberar a memória de objetos que se tenha alocado
anteriormente.

O Garbage Collector é uma grande vantagem para desalocação de memória, que é um grande
inconveniente para programadores que trabalham com ponteiros e necessitam liberar o espaço
alocado, visto que é o proprio sistema que se encarrega desta limpeza, evitando erros de desalocação
de objetos ainda em uso.

2.2.4.9 Segura

O Java fornece uma série de mecanismos para garantir a segurança dos aplicativos. Um programa em
Java não tem contato com o computador real; ele conhece apenas a máquina virtual (JVM). A máquina
virtual decide o que pode ou não ser feito. Um programa Java nunca acessa dispositivos de entrada e
saída, sistema de arquivos, memória, ao invés disso ele pede a JVM que acesse.

17
3 Fundamentos da Linguagem

3.1 Comentários

Comentários como o próprio nome instiga, são notas que podem ser incluídas no código fonte para
descrever o que se quiser. Assim, não modificam o programa executado e servem somente para ajudar
o programador a melhor organizar os seus códigos.

O Java suporta comentários como C. Qualquer informação especificada entre os caracteres de

comentário será ignorada pelo compilador. Os tipos de comentários são os seguintes:

 Comentário de bloco
/* texto */
Todo o texto é ignorado. Este tipo de comentário pode ocupar várias linhas.
 Comentário de Linha
// texto
Todo o texto depois de // até o final da linha será ignorado.
 Comentário do JavaDoc
/** Comentário para documentação
*/
Este último é um tipo especial de comentário que vai armazenar as diretivas para a geração automática
da documentação das classes, utilizando o JAVADOC.

3.2 Palavras chaves

Toda linguagem tem um grupo de palavras que o compilador reserva para seu próprio uso. Essas
palavras-chaves não podem ser usadas como identificadores em seus programas.

18
São elas:

abstract do implements package throw boolena double

impor private throws break else inner

protected transient byte extends instanceof public

try case final int rest var

cast finally interface return void catch

float long short volatile char for

native static while class future new

super const generic null switch continue

goto operator synchronized default if outer

this

3.3 Tipos de Dados

Java é uma linguagem fortemente tipada, ou seja, todas as variáveis definidas na linguagem devem
possuir um tipo de dados definido. Além disso, a linguagem possui os tipos primitivos de dados que
permite que os mesmos tenham tamanhos pré-determinados (fixos) para cada tipo, independente da
máquina que o programa está sendo compilado ou interpretado.

3.4 Variáveis ou Atributos

Em Java, toda variável ou atributo possui um tipo definido antes da declaração da variável. Os
atributos ou variáveis são locais onde os dados são mantidos. O tipo de um atributo determina o tipo
de informação que pode ser armazenada nele.

Atributos em Java podem ser declarados no corpo da classe ou podem ser declarados localmente em
qualquer parte da implementação de um método.

3.5 Constantes

As constantes em Java são definidas através da palavra reservada FINAL. Esta palavra reservada tem
por características atribuir somente uma vez o valor à variável. Para determinar que uma variável é
uma constante, basta inserir a palavra reservada no início da definição da mesma. As constantes em
Java têm por característica e estilo serem escritas em caixa alta e inicializadas com um determinado
valor.

19
3.6 Operadores

3.6.1 Operadores Aritméticos

Os operadores aritméticos são como outros operadores de outras linguagens tradicionalmente

conhecidas. Exemplos deles são mostrados na tabela 2.

Operador Nome Exemplo

+ Adição 23+29
- Subtração 29-23
* Multiplicação 0.5 * salário
/ Divisão 100/42
% Módulo 57/5

3.6.2 Operadores Relacionais

Os operadores relacionais permitem que se realizem comparações entre os operadores.

Operador Nome Exemplo

== Igual 10 == 10
!= Diferente 3 != 2
< Menor 4 < 10
> Maior 10 > 6
>= Maior ou igual 3 >= 3
<= Menor ou igual 5 <= 6

3.6.3 Operadores Lógicos

Operador Nome Exemplo

&& AND (0 < 2) && ( 10 > 5)
|| OR ( 10 >11 ) || (10 < 12 )
! NOT !( 1= = 4 )
^ XOR ( 1!= 0) ^ ( 3< 2 )
?: Condicional 3>2? (comandoSe):(comandoSenão)
& AND binário 3(00000011) & 2(00000010)= 2(00000010)
| OR Binário 3(00000011) | 2(00000010)= 3(00000011)

3.6.4 Atribuição Composta

Para facilitar a programação, Java oferece um tipo de atribuição chamada atribuição composta. Esse
tipo de atribuição pode ser utilizado quando se deseja atribuir a uma variável X, o valor de X
adicionado a 10, por exemplo.

20
 Exemplos:

x += 10; // Equivale x = x + 10;

x += y; // Equivale x = x + y;

a -= b; // Equivale a = a – b;

a *= 3; // Equivale a = a * 3;

3.6.5 Operadores Incremental e Decremental

Os operadores incrementais e decremental também foram desenvolvidos para facilitar a programação.

O Java oferece uma maneira simples para fazer o incremento ou decremento em variáveis. O
incremento é dado pelo operador ++ e o decremento pelo operador --. Este decremento ou incremento
pode ser feito antes ou depois da utilização da variável, dependendo da necessidade do programador
em relação a atribuição do dado. Colocando os operadores antes das variáveis será realizado primeiro
a operação para depois o valor da variável ser utilizado. Ao contrário, caso o operador esteja
localizado após a variável, será realizado primeiramente a variável para depois ser realizado o
incremento ou o decremento da variável.

Exemplos:

i++; //Equivalente a: i = i +1;

i--; //Equivalente a: i = i -1;

++i; //Equivalente a: i = i +1;

--i; //Equivalente a: i = i -1;

3.6.6 Operador Ternário

O operador ternário permite que se realize operações simplificadas de condições. Uma condição
trabalhada no Java como IF-THEN-ELSE, pode ser manipulada através do operador ternário.

O operador ternário é formado por uma condição, e em caso positivo, é executada uma ação e em caso
negativo, outra ação pode ser executada.

3.7 Conversões com Tipos Primitivos

A conversão entre tipos primitivos de dados é uma prática bastante comum e necessária. Deve-se ter
bastante cuidado para não perder informações ou obter um resultado que não se esperava. Para efetuar
uma conversão é necessário usar um mecanismo chamado type cast, onde o compilador vai converter

21
de um tipo para outro. Isso é feito colocando o nome do tipo que se quer converter entre parênteses
(CORNELL,2002).

3.8 Controle de Fluxo

A maioria dos programas toma decisões que afetam seu fluxo. As declarações que tomam essas
decisões são chamadas de declarações de controle.

O controle de fluxo no Java pode ser utilizado tanto por sentenças condicionais, quanto por controle de
estruturas de repetição. O controle de fluxo é similar ao C/C++, facilitando a utilização e manipulação
destas estruturas.

3.8.1 Sentenças Condicionais

# Declaração IF

As sentenças condicionais são determinadas pela estrutura IF-ELSE, onde no Java pode se observar
através do comando IF, como exemplificado abaixo:

Sintaxe:
if ( boolean )
declaração1;
else
declaração2;
Exemplo:
if (fim == true)
System.out.println(“Término!”);
else
System.out.println(“Continuando...”);
Para mais de um comando ser executado depois da declaração, utiliza-se o conceito de blocos,
delimitados por chaves { }.

A declaração IF pode ser também utilizada quando a condição não é satisfeita como o ELSE,
exemplificado abaixo:

Exemplo:

if (fim == true){
cont = 0;
System.out.println(“Término”);
} else {
22
 cont = cont +1;
System.out.println(“Continuando...”);
}
A condição ELSE, sempre trabalha com o IF mais próximo delimitado por um bloco de código.

if (x>0)
if (y>=0)
sinal=0;
else
sinal=1;

3.8.2 Loops Indeterminados

Os loops indeterminados são representados por laços de repetição que contém uma condição de saída.

# Declaração WHILE

Utilizada quando não se quer que o corpo do laço seja necessariamente executado. A expressão de
comparação é avaliada antes que o laço seja executado.

Sintaxe:

while (booleano)

declaração;

Exemplo:

while ( i != 0 ){
salario = salario * 0.5;
i--;
}
Declaração DO - WHILE

Utilizada quando se quer que o corpo do laço seja necessariamente executado, pelo menos uma vez. A
expressão de comparação é avaliada depois que o laço for executado.

Sintaxe:
do
declaração
while (booleano);
Exemplo:
23
 do {
salario = salario * 0.5;
i--;
} while ( i != 0 );

3.8.3 Loops Determinados

Os loops determinados são responsáveis por executar um trecho de código por uma quantidade de
vezes pré-determinada.

Declaração For

Fornece uma expressão para inicializar as variáveis, seguida por uma expressão de comparação e
depois um lugar para incrementar ou decrementar as variáveis de laço. A declaração pode ser um
comando simples ou um bloco de comandos.

Sintaxe:

for (expressao; booleano; expressao)

declaracao;

Exemplo:

for (i = 0; i < 20; i ++)

salario = salario * 0.5;
As variáveis que são definidas dentro da sentença FOR, não podem usar os seus valores

fora do loop. Isso ocorre, pois a variável perde o escopo, visto que está sendo definida para

ser utilizada dentro do laço FOR.

3.8.4 Múltiplas Seleções

Declaração Switch

Aceita inteiro na expressão de comparação. Mas, como pode haver as conversões implicitas (cast
implícitos) pelo compilador, ele passa a aceitar também os tipos char, byte, short ou int. Esse valor é
procurado nas declarações case que vem depois da declaração switch e o código adequado é
executado.

Sintaxe:
switch ( expressão ) {

24
 case valor: declaração;
...
default: declaração;
}
Exemplo:
switch ( cmd ){
case 1: System.out.println(“Item do menu 1”);
break;
case 2: System.out.println(“Item do menu 2”);
break;
case 3: System.out.println(“Item do menu 3”);
break;
default: System.out.println(“Comando invalido!”);
}
O comando break deve ser colocado ao final de cada cláusula case, pois senão todas as condições que
forem satisfeitas, serão executadas. Ou seja, caso a condição do switch tenha uma condição que é
satisfeita por mais de um case, todos que satisfizerem estacondição serão executados. Por isso, o break
é importante para garantir que quando um case for satisfeito, mais nenhum deles serão executados
também.

3.8.5 Manipulações diversas

# Declaração Return

Declaração utilizada para transferir controle. Retorna informações de métodos, encerrando a execução
e retornando para o local de onde o método foi chamado.

Sintaxe:
return expressão;
Exemplo:
class Teste{
public int Potencia ( int base, int n){
int result = base;
for ( int i = 0; i < n-1; i ++ )
result = result * base;
return result;
}

25
 }
# Declaração break e continue
Declarações de desvio usada para sair de um laço ou método antes do normal. O tipo determina para
onde é transferido o controle. O break é utilizado para transferir o controle para o final de uma
construção de laço (for, do, while ou switch). O laço vai encerrar independentemente de seu valor de
comparação e a declaração após o laço será executada.
Exemplo:
int i = 0;
while (true) {
System.out.println(i);
i++;
if ( i > 10 ) break;
}
A declaração continue faz com que a execução do programa continue voltando imediatamente para o
início do laço, porém para a próxima interação.
Exemplo:
for (int i = -10; i<10; i++){
if ( i == 0 )
continue;
System.out.println(1/i);
}

3.9 Arrays

Um array normalmente é usado para armazenar um grupo de informações semelhantes. Todos os itens
de um array devem ser do mesmo tipo em tempo de compilação. Se o array for formado por tipos
primitivos, eles devem ser todos do mesmo tipo.
Arrays são inicializados com o uso do operador new. Pense em cada elemento do array como um
objeto distinto. O tipo mais simples de array é um array de dimensão de um tipo primitivo – por
exemplo, um int. O código para criar e inicializar esse array segue abaixo:
int[] nums = new int [5];
Os colchetes depois do tipo de dado int, dizem ao compilador que é um array de inteiros. O operador
new instancia o array e chama o construtor para cada elemento. O construtor é do tipo int e pode
conter cinco elementos. Arrays podem ser multimensionais. Durante a instanciação, um array
multidimensional deve ter pelo menos uma de suas dimensões especificadas. A seguir, exemplos de
como criar um array bidimensional.

26
 Exemplo:
int [][] numlist = new int [2][];
int[][] lista = new int[5][5];
Arrays podem ser inicializados na hora da criação, colocando-se os valores inicias desejados entre
chaves {}. Não é necessário especificar o tamanho – Java irá inicializar o array com o número de
elementos especificados.
Exemplo:
int[] nums = {1, 2, 3, 4, 5};
int[][] nums = {(1,1), (2,2), (3,3), (4,4), (5,5)};
Os arrays podem ser indexados por um valor byte, short, int ou char. Não se pode indexar arrays com
um valor long, ponto flutuante ou booleano. Se precisar usar um desses tipos deve-se fazer uma
conversão explícita. Os arrays são indexados de zero até o comprimento do array menos um.
long sum( int [] lista ){
long result = 0;
for ( int i = 0; i < lista.length; i++ ){
result = result + lista[i];
}
return result;
}

3.10 Strings

Uma String é um tipo definido pela classe String e contém métodos e variáveis. Uma String é a unica
classe que pode ser instanciado sem usar o operador new. A seguir exemplos da utilização de strings.
Exemplo:
//criação do String

String str = “Hello”;

int inteiro = 4;
String novo = str + “ valor do inteiro: ” + inteiro;

//Concatenação de strings
//extração dos cinco primeiros caracteres do string novo
String substr = novo.substring(5);

27
III. METODOLOGIA

Entende-se a metodologia como um conjunto de métodos e técnicas que visam a realização de

várias tarefas, seguindo uma ordem de actividades devidamente esclarecida para atingir um
determinado objectivo. Além disso, ela fornece uma série de mecanismos próprios para a
elaboração de trabalhos científicos. Por tanto, a metodologia torna possível a recolha e o
tratamento de informações visando a aquisição de conhecimentos cujo seu objectivo principal
é a resolução de um determinado problema.

Para a realização deste trabalho, três metodologias foram aplicadas, sendo uma o método histórico,
que visa estudar os acontecimentos do passado para entender sua sua influência nos dias de hoje e
consequentemente foi utilizado para entender a evolução do processo de desenvolvimento de software
orientado a objecto.

De acordo com os procedimentos utilizados para a recolha de informações, optou-se pela

utilização do método hipotético-dedutivo proposto por Karl Popper que diz que a pesquisa científica
com abordagem hipotético-dedutiva inicia-se com a formulação de um problema e com sua descrição
clara e precisa, a fim de facilitar a obtenção de um modelo simplificado e a identificação de outros
conhecimentos e instrumentos, relevantes ao problema, que auxiliarão o pesquisador em seu trabalho.

28
CONCLUSÃO

29
BIBLIOGRAFIA

Oracle Oracle Java Technologies | Oracle

TheServerSide www.theserverside.com

MundoOO www.mundooo.com.br

Wikipédia https://pt.wikipedia.org/wiki/Java_(linguagem_de_programa%C3%A7%C3%A3o)

Caelum; Java e Orientação a Objetos.

30