Apostila de Introdução à Linguagem de

Programação Java

Autor: Manus AI

Prefácio

Bem-vindo(a) à sua jornada no mundo da programação Java! Esta apostila foi

cuidadosamente elaborada para fornecer uma introdução clara e concisa a uma das
linguagens de programação mais populares e influentes do planeta. Seja você um
estudante, um profissional de outra área buscando uma transição de carreira, ou
simplesmente alguém curioso sobre como a tecnologia funciona, este guia é o seu
ponto de partida ideal.

Java, desenvolvido pela Sun Microsystems (agora parte da Oracle), é conhecido por
sua filosofia "Write Once, Run Anywhere" (Escreva uma vez, execute em qualquer
lugar), que o torna incrivelmente versátil. Ele é a espinha dorsal de inúmeras
aplicações corporativas, sistemas Android, grandes dados, e muito mais. Aprender
Java não é apenas adquirir uma nova habilidade de programação; é abrir portas para
um vasto ecossistema de desenvolvimento e inovação.

Nesta apostila, abordaremos os conceitos fundamentais, desde a configuração do

ambiente de desenvolvimento até a compreensão da sintaxe básica, estruturas de
controle, e uma introdução aos princípios da Programação Orientada a Objetos (POO).
Cada tópico será acompanhado de exemplos práticos e exercícios para solidificar seu
aprendizado.

Nosso objetivo é desmistificar a programação e torná-la acessível, construindo uma

base sólida para que você possa explorar horizontes mais avançados no futuro.
Prepare-se para pensar de forma lógica, resolver problemas e criar suas primeiras
aplicações. A aventura começa agora!

Boa leitura e bom aprendizado!

Capítulo 1: Introdução ao Java

1.1 O que é Java?

Java é uma linguagem de programação de alto nível, orientada a objetos, e de

propósito geral, lançada pela Sun Microsystems em 1995. Sua principal característica e
um dos pilares de sua popularidade é a portabilidade, expressa no lema "Write Once,
Run Anywhere" (WORA). Isso significa que um código Java compilado pode ser
executado em qualquer plataforma que possua uma Máquina Virtual Java (JVM)
instalada, independentemente do sistema operacional ou hardware subjacente [1].

Java foi projetado com cinco objetivos principais em mente:

1. Simples, Orientado a Objetos e Familiar: Ser fácil de aprender e usar, com uma
abordagem orientada a objetos desde o início.

2. Robusto e Seguro: Oferecer um ambiente de execução seguro e confiável, com

gerenciamento automático de memória (garbage collection) e tratamento de
exceções.

3. Arquitetura Neutra e Portátil: Ser independente de plataforma, permitindo que

o código compilado seja executado em qualquer sistema.

4. Alto Desempenho: Embora interpretado, o uso de compiladores Just-In-Time

(JIT) na JVM permite um desempenho próximo ao de linguagens compiladas.

5. Interpretado, Multithreaded e Dinâmico: Suportar a execução de múltiplas

tarefas simultaneamente (multithreading) e ser capaz de se adaptar a ambientes
em constante mudança.

1.2 História e Características

A história do Java começou no início dos anos 90, como parte do "Projeto Green" da
Sun Microsystems, liderado por James Gosling. Inicialmente chamado de Oak, o
projeto visava criar uma linguagem para dispositivos eletrônicos de consumo. No
entanto, com o advento da World Wide Web, percebeu-se o potencial do Java para o
desenvolvimento de aplicações web, e a linguagem foi renomeada e lançada
publicamente em 1995 [2].
Desde então, Java evoluiu significativamente, com lançamentos regulares de novas
versões (JDKs) que adicionam recursos e melhorias. Algumas das características mais
marcantes do Java incluem:

Orientação a Objetos: Tudo em Java é tratado como um objeto, o que facilita a

modularidade, reutilização de código e a organização de projetos complexos.

Plataforma Independente: Graças à JVM, o código Java é compilado para

bytecode, que é então executado pela JVM, tornando-o independente do sistema
operacional.

Gerenciamento Automático de Memória: O "Garbage Collector" do Java libera

automaticamente a memória que não está mais sendo utilizada, evitando
vazamentos de memória e simplificando o desenvolvimento.

Multithreading: Suporte nativo para a criação de aplicações que podem

executar várias tarefas simultaneamente, melhorando a responsividade e o
desempenho.

Segurança: Java incorpora recursos de segurança robustos, como o "sandbox"

da JVM, que restringe o acesso de programas a recursos do sistema.

Comunidade Vasta e Ecossistema Rico: Uma das maiores comunidades de

desenvolvedores do mundo e um vasto conjunto de bibliotecas, frameworks e
ferramentas que aceleram o desenvolvimento.

1.3 Máquina Virtual Java (JVM), JRE e JDK

Para entender como o Java funciona, é crucial conhecer os três componentes

principais de seu ecossistema:

Máquina Virtual Java (JVM)

A JVM é o coração do Java. É um programa que atua como um interpretador para o

bytecode Java. Quando você compila um arquivo .java , ele é transformado em um
arquivo .class contendo bytecode. A JVM lê esse bytecode e o traduz para as
instruções nativas do sistema operacional em que está sendo executada. É a JVM que
garante a portabilidade do Java [3].
Java Runtime Environment (JRE)

O JRE é um pacote que contém a JVM e as bibliotecas de classes necessárias para

executar aplicações Java. Se você apenas precisa executar programas Java em seu
computador, o JRE é suficiente. Ele não inclui ferramentas de desenvolvimento, como
o compilador Java (javac) [4].

Java Development Kit (JDK)

O JDK é um superconjunto do JRE. Ele inclui o JRE, a JVM, e todas as ferramentas

necessárias para desenvolver, compilar, depurar e executar aplicações Java. Para
qualquer desenvolvedor Java, o JDK é um componente essencial. As ferramentas mais
importantes incluídas no JDK são:

javac : O compilador Java, que transforma o código-fonte ( .java ) em bytecode

( .class ).

java : O lançador de aplicações Java, que inicia a JVM e executa o bytecode.

jar : Ferramenta para empacotar classes e recursos em arquivos JAR (Java

Archive).

javadoc : Ferraenta para gerar documentação a partir de comentários no

código-fonte.

Em resumo:

JDK = JRE + Ferramentas de Desenvolvimento

JRE = JVM + Bibliotecas de Classes

1.4 Configuração do Ambiente de Desenvolvimento (JDK, IDE)

Para começar a programar em Java, você precisará configurar seu ambiente de

desenvolvimento. Isso envolve a instalação do JDK e, opcionalmente, de uma
Integrated Development Environment (IDE).

1.4.1 Instalação do JDK

1. Download: Visite o site oficial da Oracle (ou OpenJDK) e faça o download da

versão mais recente do JDK compatível com seu sistema operacional (Windows,
macOS, Linux). Recomenda-se sempre a versão LTS (Long Term Support) [5].
 2. Instalação: Siga as instruções do instalador. Geralmente, é um processo simples
de "próximo, próximo, finalizar".

3. Variáveis de Ambiente (PATH e JAVA_HOME): Após a instalação, é fundamental

configurar as variáveis de ambiente JAVA_HOME e adicionar o diretório bin do
JDK à variável PATH do seu sistema. Isso permite que você execute os comandos
java e javac a partir de qualquer diretório no terminal.
Windows: Vá em Propriedades do Sistema > Variáveis de Ambiente. Crie
JAVA_HOME apontando para o diretório de instalação do JDK (ex:
C:\Program Files\Java\jdk-17 ). Edite a variável Path e adicione
%JAVA_HOME%\bin .

macOS/Linux: Edite o arquivo de configuração do seu shell (ex: .bashrc ,

.zshrc ) e adicione as linhas: bash export JAVA_HOME=/path/to/your/jdk
export PATH=$`PATH:`$JAVA_HOME/bin Substitua /path/to/your/jdk
pelo caminho real do seu JDK (ex:
/Library/Java/JavaVirtualMachines/[Link]/Contents/Home ).

4. Verificação: Abra um novo terminal e digite java -version e javac -version .

Se as versões forem exibidas corretamente, seu JDK está configurado.

1.4.2 Escolha e Instalação de uma IDE (Ambiente de Desenvolvimento Integrado)

Embora seja possível programar Java usando um editor de texto simples e o terminal,
uma IDE oferece recursos poderosos que aumentam drasticamente a produtividade.
As IDEs mais populares para Java são:

IntelliJ IDEA: Considerada por muitos a IDE mais completa e inteligente para
Java, com versões Community (gratuita) e Ultimate (paga) [6].

Eclipse: Uma IDE de código aberto muito popular, com uma vasta gama de
plugins e uma grande comunidade [7].

VS Code (com extensões Java): Embora não seja uma IDE completa por si só, o
Visual Studio Code, com as extensões apropriadas (como o Extension Pack for
Java), oferece um ambiente de desenvolvimento leve e eficaz para Java [8].

Recomendação: Para iniciantes, o IntelliJ IDEA Community Edition ou o VS Code com

as extensões Java são excelentes pontos de partida devido à sua interface intuitiva e
recursos de assistência ao código.

Instalação da IDE (Exemplo com IntelliJ IDEA Community Edition):

 1. Download: Acesse o site da JetBrains e baixe o IntelliJ IDEA Community Edition
[6].

2. Instalação: Siga o assistente de instalação. É um processo direto.

3. Primeiro Projeto: Ao abrir a IDE pela primeira vez, você poderá criar um novo
projeto Java. A IDE detectará automaticamente seu JDK instalado e configurará o
projeto para você.

Com o JDK instalado e uma IDE configurada, você está pronto para escrever seu
primeiro programa Java!

Referências

[1] DevMedia. Introdução a Linguagem de Programação Java. Disponível em:

[Link] [2] Medium.
Introdução à Linguagem de Programação Java. Disponível em:
[Link]
linguagem-de-programa%C3%A7%C3%A3o-java-e5ca540ae7fc [3] Blog Cubos
Academy. Introdução ao JAVA: Guia para Iniciantes. Disponível em:
[Link] [4] DIO.
Entendendo Java - Sintaxe e Funcionalidades Principais. Disponível em:
[Link]
[5] Oracle. Java SE Downloads. Disponível em:
[Link] [6] JetBrains. IntelliJ IDEA:
The Capable & Ergonomic Java IDE. Disponível em: [Link]
[7] Eclipse Foundation. Eclipse IDE for Java Developers. Disponível em:
[Link]
developers [8] Visual Studio Code. Java in Visual Studio Code. Disponível em:
[Link]

Capítulo 2: Sintaxe Básica

2.1 Estrutura de um programa Java (classes, métodos, main)

Todo programa Java é construído em torno de classes e objetos. Uma classe é um

modelo ou "planta" para criar objetos, enquanto um objeto é uma instância dessa
classe. O ponto de entrada para a execução de qualquer aplicação Java é o método
main [9].

Vamos analisar a estrutura básica de um programa "Olá, Mundo!" em Java:

public class OlaMundo {

public static void main(String[] args) {
[Link]("Olá, Mundo!");
}
}

Análise do Código:

public class OlaMundo : Declara uma classe pública chamada OlaMundo . Em

Java, o nome do arquivo ( .java ) deve ser exatamente o mesmo nome da classe
pública contida nele. A palavra-chave public significa que a classe é acessível
de qualquer lugar. class é a palavra-chave para definir uma classe.

public static void main(String[] args) : Este é o método principal (main)

onde a execução do programa começa. Vamos quebrar cada parte:
public : O método é acessível de qualquer lugar.

static : O método pode ser chamado sem a necessidade de criar uma

instância da classe. Isso é importante porque a JVM precisa de um ponto de
entrada para iniciar o programa sem ter que instanciar a classe OlaMundo
primeiro.

void : Indica que o método não retorna nenhum valor.

main : É o nome padrão do método que a JVM procura para iniciar a

execução.

(String[] args) : Define um parâmetro para o método main , que é um

array de strings. Ele permite que o programa receba argumentos da linha
de comando quando é executado.

[Link]("Olá, Mundo!"); : Esta linha imprime a string "Olá,

Mundo!" no console. System é uma classe padrão do Java, out é um objeto
estático da classe PrintStream dentro de System , e println() é um método
que imprime uma linha de texto e adiciona uma quebra de linha no final.
2.2 Variáveis e tipos de dados

Variáveis são espaços na memória usados para armazenar dados. Em Java, toda
variável deve ter um tipo de dado especificado antes de ser usada. Java é uma
linguagem fortemente tipada, o que significa que o tipo de uma variável é verificado
em tempo de compilação [10].

Existem dois tipos de dados em Java:

1. Tipos Primitivos: Armazenam valores simples e são predefinidos pela

linguagem.

2. Tipos de Referência: Armazenam referências a objetos. (Abordaremos mais

sobre objetos em capítulos posteriores).

2.2.1 Tipos de Dados Primitivos

Java possui 8 tipos de dados primitivos, que podem ser categorizados em:

Números Inteiros:
byte : 8 bits, de -128 a 127.

short : 16 bits, de -32.768 a 32.767.

int : 32 bits, de -[Link] a [Link] (mais comum para inteiros).

long : 64 bits, para números inteiros muito grandes.

Números de Ponto Flutuante (Decimais):

float : 32 bits, para números decimais de precisão simples.

double : 64 bits, para números decimais de precisão dupla (mais comum

para decimais).

Caracteres:
char : 16 bits, armazena um único caractere Unicode.

Booleanos:
boolean : Armazena true ou false .

Declaração e Inicialização de Variáveis:

Para declarar uma variável, você especifica o tipo e o nome da variável. Você pode
inicializá-la no momento da declaração ou posteriormente.
 int idade = 30; // Declara e inicializa uma variável int
double preco = 19.99; // Declara e inicializa uma variável double
char inicial = 'J'; // Declara e inicializa uma variável char
boolean isAtivo = true; // Declara e inicializa uma variável boolean
String nome = "Maria"; // String é um tipo de referência, mas é muito usada
como se fosse primitivo

// Declaração sem inicialização

int quantidade;
quantidade = 100; // Inicialização posterior

2.3 Operadores (aritméticos, relacionais, lógicos)

Operadores são símbolos que realizam operações em variáveis e valores. Java possui
vários tipos de operadores [11].

2.3.1 Operadores Aritméticos

Usados para realizar operações matemáticas básicas:

Operador Descrição Exemplo Resultado

+ Adição 5 + 3 8

- Subtração 5 - 3 2

* Multiplicação 5 * 3 15

/ Divisão 5 / 3 1 (int)

% Módulo (resto) 5 % 3 2

++ Incremento x++ (x=x+1)

-- Decremento x-- (x=x-1)

Exemplo:
 int a = 10;
int b = 3;

[Link]("a + b = " + (a + b)); // 13

[Link]("a - b = " + (a - b)); // 7
[Link]("a * b = " + (a * b)); // 30
[Link]("a / b = " + (a / b)); // 3 (divisão inteira)
[Link]("a % b = " + (a % b)); // 1

a++; // a agora é 11
b--; // b agora é 2

2.3.2 Operadores Relacionais (Comparação)

Usados para comparar dois valores e retornar um resultado booleano ( true ou

false ):

Operador Descrição Exemplo Resultado

== Igual a 5 == 3 false

!= Diferente de 5 != 3 true

> Maior que 5 > 3 true

< Menor que 5 < 3 false

>= Maior ou igual a 5 >= 3 true

<= Menor ou igual a 5 <= 3 false

Exemplo:

int x = 10;
int y = 20;

[Link]("x == y: " + (x == y)); // false

[Link]("x != y: " + (x != y)); // true
[Link]("x > y: " + (x > y)); // false
[Link]("x < y: " + (x < y)); // true

2.3.3 Operadores Lógicos

Usados para combinar expressões booleanas e retornar um resultado booleano:

 Operador Descrição Exemplo Resultado

&& AND lógico (true && false) false

|| OR lógico (true || false) true

! NOT lógico !true false

Exemplo:

boolean condicao1 = true;

boolean condicao2 = false;

[Link]("condicao1 && condicao2: " + (condicao1 && condicao2)); //

false
[Link]("condicao1 || condicao2: " + (condicao1 || condicao2)); //
true
[Link]("!condicao1: " + (!condicao1)); // false

2.4 Entrada e saída de dados ([Link], Scanner)

Interagir com o usuário é fundamental em muitos programas. Em Java, a saída de

dados para o console é comumente feita usando [Link]() , como já
vimos. Para a entrada de dados, a classe Scanner é uma ferramenta poderosa e fácil
de usar [12].

2.4.1 Saída de Dados: [Link]() e [Link]()

[Link](dado) : Imprime o dado fornecido no console e, em

seguida, avança para a próxima linha (adiciona uma quebra de linha).

[Link](dado) : Imprime o dado fornecido no console, mas não

avança para a próxima linha. O próximo dado impresso continuará na mesma
linha.

Exemplo:

[Link]("Olá, ");
[Link]("Mundo!"); // Saída: Olá, Mundo!

int numero = 10;

[Link]("O número é: " + numero); // Concatenação de string com
número
2.4.2 Entrada de Dados: Classe Scanner

A classe Scanner está localizada no pacote [Link] e é usada para ler a entrada do
usuário a partir do console. Para usá-la, você precisa importá-la e criar um objeto
Scanner .

Passos para usar Scanner :

1. Importar a classe Scanner : Adicione import [Link]; no início do

seu arquivo Java.

2. Criar um objeto Scanner : Scanner entrada = new Scanner([Link]);

3. Usar métodos para ler diferentes tipos de dados: nextInt() , nextDouble() ,

nextLine() , etc.

4. Fechar o objeto Scanner : [Link](); (importante para liberar

recursos).

Exemplo:

import [Link]; // Importa a classe Scanner

public class EntradaDeDados {

public static void main(String[] args) {
Scanner entrada = new Scanner([Link]); // Cria um objeto Scanner

[Link]("Digite seu nome: ");

String nome = [Link](); // Lê uma linha de texto (String)

[Link]("Digite sua idade: ");

int idade = [Link](); // Lê um número inteiro (int)

[Link]("Digite sua altura (ex: 1,75): ");

double altura = [Link](); // Lê um número decimal (double)

[Link]("\nOlá, " + nome + "!");

[Link]("Você tem " + idade + " anos.");
[Link]("Sua altura é " + altura + " metros.");

[Link](); // Fecha o objeto Scanner

}
}

Observações sobre Scanner :

Quando você lê um número ( nextInt() , nextDouble() ) e depois tenta ler uma

linha ( nextLine() ), pode ocorrer um problema de "quebra de linha pendente".
O nextInt() lê apenas o número, deixando o caractere de nova linha no buffer.
O nextLine() subsequente lê essa quebra de linha vazia. Para resolver isso,
 adicione um [Link](); extra após ler um número, antes de ler uma
string.

Referências (continuação)

[9] DevMedia. Entendendo a estrutura de um código Java. Disponível em:

[Link]
[10] CodeGym. Sintaxe Java: uma breve introdução à linguagem. Disponível em:
[Link]
linguagem-de-programacao [11] DIO. Entendendo Java - Sintaxe e Funcionalidades
Principais. Disponível em: [Link]
funcionalidades-principais [12] Rocketseat. Java: Um guia completo para iniciantes.
Disponível em: [Link]
java-guia-iniciantes

Capítulo 3: Estruturas de Controle

As estruturas de controle são fundamentais em qualquer linguagem de programação,

pois permitem que você controle o fluxo de execução do seu programa. Elas decidem
quais blocos de código devem ser executados e quantas vezes. Em Java, as principais
estruturas de controle são as condicionais ( if , else if , else , switch ) e os laços
de repetição ( for , while , do-while ) [13].

3.1 Condicionais (if, else if, else, switch)

As estruturas condicionais permitem que o programa tome decisões com base em

certas condições.

3.1.1 if , else if , else

O if é a estrutura condicional mais básica. Ele executa um bloco de código se uma

condição for verdadeira. O else é usado para executar um bloco de código
alternativo se a condição do if for falsa. O else if permite testar múltiplas
condições em sequência.

Sintaxe:
 if (condicao) {
// Bloco de código a ser executado se a condição for verdadeira
} else if (outraCondicao) {
// Bloco de código a ser executado se a primeira condição for falsa e esta
for verdadeira
} else {
// Bloco de código a ser executado se todas as condições anteriores forem
falsas
}

Exemplo:

int idade = 18;

if (idade >= 18) {

[Link]("Você é maior de idade.");
} else {
[Link]("Você é menor de idade.");
}

int nota = 75;

if (nota >= 90) {

[Link]("Conceito A");
} else if (nota >= 80) {
[Link]("Conceito B");
} else if (nota >= 70) {
[Link]("Conceito C");
} else {
[Link]("Conceito D");
}

3.1.2 switch

A estrutura switch é usada para selecionar um dos muitos blocos de código a serem
executados. É uma alternativa mais limpa para longas cadeias de if-else if quando
você está testando uma única variável contra múltiplos valores [14].

Sintaxe:

switch (expressao) {
case valor1:
// Bloco de código a ser executado se expressao == valor1
break;
case valor2:
// Bloco de código a ser executado se expressao == valor2
break;
default:
// Bloco de código a ser executado se nenhum dos casos anteriores for
correspondido
}
 A expressao pode ser um byte , short , char , int , String (a partir do Java
7), ou um enum .

A palavra-chave break é crucial; ela encerra a execução do switch após um

case ser correspondido. Sem break , a execução "cairá" para o próximo case
(fall-through).

O default é opcional e é executado se nenhum dos case s corresponder.

Exemplo:

int diaDaSemana = 3; // 1=Domingo, 2=Segunda, etc.

String nomeDia;

switch (diaDaSemana) {
case 1:
nomeDia = "Domingo";
break;
case 2:
nomeDia = "Segunda-feira";
break;
case 3:
nomeDia = "Terça-feira";
break;
case 4:
nomeDia = "Quarta-feira";
break;
case 5:
nomeDia = "Quinta-feira";
break;
case 6:
nomeDia = "Sexta-feira";
break;
case 7:
nomeDia = "Sábado";
break;
default:
nomeDia = "Dia inválido";
}
[Link]("Hoje é " + nomeDia);

3.2 Laços de repetição (for, while, do-while)

Os laços de repetição permitem que um bloco de código seja executado

repetidamente enquanto uma condição for verdadeira ou por um número específico
de vezes.

3.2.1 for

O laço for é ideal quando você sabe exatamente quantas vezes deseja repetir um
bloco de código.
Sintaxe:

for (inicializacao; condicao; atualizacao) {

// Bloco de código a ser executado repetidamente
}

inicializacao : Executada uma única vez no início do laço.

condicao : Avaliada antes de cada iteração. Se for verdadeira, o bloco de código

é executado. Se for falsa, o laço termina.

atualizacao : Executada após cada iteração do bloco de código.

Exemplo:

// Imprime números de 0 a 4
for (int i = 0; i < 5; i++) {
[Link]("Número: " + i);
}

// For-each loop (Enhanced for loop) - para iterar sobre arrays e coleções
String[] frutas = {"Maçã", "Banana", "Laranja"};
for (String fruta : frutas) {
[Link]("Fruta: " + fruta);
}

3.2.2 while

O laço while é usado quando você não sabe o número exato de iterações, mas quer
que o laço continue enquanto uma condição for verdadeira.

Sintaxe:

while (condicao) {
// Bloco de código a ser executado repetidamente
// É crucial que a condição se torne falsa em algum momento para evitar um
loop infinito
}

Exemplo:

int contador = 0;
while (contador < 5) {
[Link]("Contador: " + contador);
contador++; // Incrementa o contador para que a condição eventualmente se
torne falsa
}
3.2.3 do-while

O laço do-while é semelhante ao while , mas garante que o bloco de código seja
executado pelo menos uma vez, pois a condição é avaliada após a execução do bloco.

Sintaxe:

do {
// Bloco de código a ser executado pelo menos uma vez
// e repetidamente enquanto a condição for verdadeira
} while (condicao);

Exemplo:

int i = 0;
do {
[Link]("Valor de i: " + i);
i++;
} while (i < 0); // A condição é falsa, mas o bloco é executado uma vez
// Saída: Valor de i: 0

3.2.4 break e continue

break : Usado para sair imediatamente de um laço ( for , while , do-while ) ou

de uma estrutura switch .

continue : Usado para pular a iteração atual de um laço e prosseguir para a

próxima iteração.

Exemplo:

for (int j = 0; j < 10; j++) {

if (j == 5) {
break; // Sai do laço quando j for 5
}
if (j % 2 != 0) {
continue; // Pula números ímpares
}
[Link]("J: " + j);
}
// Saída: J: 0, J: 2, J: 4
Referências (continuação)

[13] DevMedia. Estruturas de Controle em Java. Disponível em:

[Link] (Exemplo de
URL, a URL real pode variar) [14] DIO. Estruturas Condicionais e de Repetição em Java.
Disponível em: [Link]
em-java (Exemplo de URL, a URL real pode variar)

Capítulo 4: Orientação a Objetos (Conceitos Iniciais)

Java é uma linguagem fundamentalmente orientada a objetos (POO). A Programação

Orientada a Objetos é um paradigma de programação que organiza o design do
software em torno de dados, ou objetos, em vez de funções e lógica. Um objeto pode
ser definido como uma instância de uma classe, que é uma estrutura que define o
estado (atributos) e o comportamento (métodos) que um objeto de seu tipo terá [15].

Os quatro pilares da POO são: Encapsulamento, Herança, Polimorfismo e Abstração.

Neste capítulo, focaremos nos conceitos básicos de Classes, Objetos, Atributos,
Métodos e Construtores.

4.1 Classes e Objetos

Como mencionado, uma classe é um modelo ou um "projeto" para criar objetos. Ela
define as características (atributos) e as ações (métodos) que os objetos criados a
partir dela terão. Pense em uma classe como a planta de uma casa: ela descreve como
a casa será, mas não é a casa em si.

Um objeto é uma instância concreta de uma classe. É a "casa" construída a partir da

planta. Você pode criar vários objetos a partir da mesma classe, e cada objeto terá
seus próprios valores para os atributos definidos na classe.

Exemplo de Classe:
 public class Carro {
// Atributos (características)
String marca;
String modelo;
int ano;
String cor;

// Métodos (comportamentos)
public void ligar() {
[Link]("O carro " + marca + " " + modelo + " ligou.");
}

public void acelerar() {

[Link]("O carro " + marca + " " + modelo + " está
acelerando.");
}

public void frear() {

[Link]("O carro " + marca + " " + modelo + " está
freando.");
}
}

Criando Objetos (Instanciando a Classe):

Para criar um objeto a partir da classe Carro , usamos a palavra-chave new :

public class Garagem {

public static void main(String[] args) {
// Criando o primeiro objeto Carro
Carro meuCarro = new Carro();
[Link] = "Toyota";
[Link] = "Corolla";
[Link] = 2022;
[Link] = "Prata";

[Link]("Meu carro é um " + [Link] + " " +

[Link]);
[Link]();
[Link]();

// Criando o segundo objeto Carro

Carro carroDoVizinho = new Carro();
[Link] = "Honda";
[Link] = "Civic";
[Link] = 2023;
[Link] = "Preto";

[Link]("O carro do vizinho é um " + [Link] +

" " + [Link]);
[Link]();
}
}
4.2 Atributos e Métodos

Atributos

Atributos (também conhecidos como campos ou variáveis de instância) são as

características ou propriedades que definem o estado de um objeto. Eles são
declarados dentro da classe, mas fora de qualquer método. No exemplo da classe
Carro , marca , modelo , ano e cor são atributos [16].

Métodos

Métodos são as ações ou comportamentos que um objeto pode realizar. Eles são
funções definidas dentro de uma classe. No exemplo da classe Carro , ligar() ,
acelerar() e frear() são métodos. Métodos podem receber parâmetros e retornar
valores.

Exemplo de Método com Parâmetro e Retorno:

public class Calculadora {

public int somar(int a, int b) {
return a + b;
}

public double dividir(double a, double b) {

if (b == 0) {
[Link]("Erro: Divisão por zero!");
return 0.0;
}
return a / b;
}
}

public class TesteCalculadora {

public static void main(String[] args) {
Calculadora calc = new Calculadora();
int resultadoSoma = [Link](10, 5);
[Link]("Soma: " + resultadoSoma); // Saída: Soma: 15

double resultadoDivisao = [Link](10.0, 2.0);

[Link]("Divisão: " + resultadoDivisao); // Saída: Divisão:
5.0

[Link](10.0, 0.0); // Saída: Erro: Divisão por zero!

}
}
4.3 Construtores

Um construtor é um método especial em uma classe que é chamado

automaticamente quando um objeto dessa classe é criado (instanciado). O principal
propósito de um construtor é inicializar o estado do objeto, ou seja, atribuir valores
iniciais aos seus atributos [17].

Características dos construtores:

Possuem o mesmo nome da classe.

Não possuem tipo de retorno (nem mesmo void ).

Podem ter parâmetros.

Se você não definir nenhum construtor, Java fornece um construtor padrão (sem
argumentos) implicitamente.

Exemplo de Construtor:

Vamos adicionar um construtor à nossa classe Carro :

 public class Carro {
String marca;
String modelo;
int ano;
String cor;

// Construtor da classe Carro

public Carro(String marca, String modelo, int ano, String cor) {
[Link] = marca; // 'this' refere-se ao atributo da instância
[Link] = modelo;
[Link] = ano;
[Link] = cor;
[Link]("Um novo carro " + marca + " " + modelo + " foi
criado!");
}

public void ligar() {

[Link]("O carro " + marca + " " + modelo + " ligou.");
}

public void acelerar() {

[Link]("O carro " + marca + " " + modelo + " está
acelerando.");
}

public void frear() {

[Link]("O carro " + marca + " " + modelo + " está
freando.");
}
}

public class GaragemComConstrutor {

public static void main(String[] args) {
// Criando objetos usando o construtor
Carro meuCarro = new Carro("Toyota", "Corolla", 2022, "Prata");
[Link]("Meu carro é um " + [Link] + " " +
[Link]);
[Link]();

Carro carroDoVizinho = new Carro("Honda", "Civic", 2023, "Preto");

[Link]("O carro do vizinho é um " + [Link] +
" " + [Link]);
[Link]();
}
}

No exemplo acima, [Link] = marca; é usado para distinguir entre o atributo da

classe ( [Link] ) e o parâmetro do construtor ( marca ).

É possível ter múltiplos construtores em uma classe, desde que eles tenham diferentes
listas de parâmetros (isso é chamado de sobrecarga de construtores).
Referências (continuação)

[15] Alura. O que é Programação Orientada a Objetos (POO)?. Disponível em:

[Link] [16]
DevMedia. Classes, Atributos e Métodos em Java. Disponível em:
[Link] (Exemplo
de URL, a URL real pode variar) [17] Digital Innovation One. Construtores em Java.
Disponível em: [Link] (Exemplo de URL, a
URL real pode variar)

Capítulo 5: Arrays

Arrays são estruturas de dados que permitem armazenar múltiplos valores do mesmo
tipo em uma única variável. Eles são úteis quando você precisa lidar com uma coleção
de dados relacionados, como uma lista de notas de alunos, nomes de produtos ou
temperaturas diárias. Em Java, arrays têm um tamanho fixo, o que significa que o
número de elementos que eles podem conter é definido no momento da criação e não
pode ser alterado posteriormente [18].

5.1 Declaração e inicialização de arrays

Para usar um array em Java, você precisa primeiro declará-lo e depois inicializá-lo.

5.1.1 Declaração

A declaração de um array informa ao compilador o tipo de elementos que o array irá

armazenar e o nome da variável que fará referência a ele. A sintaxe básica é:

tipo[] nomeDoArray;
// ou
tipo nomeDoArray[]; // Menos comum, mas válido

Exemplos:

int[] numeros;
String[] nomes;
double[] temperaturas;
5.1.2 Inicialização

Após a declaração, você precisa inicializar o array, o que envolve alocar memória para
ele e, opcionalmente, atribuir valores iniciais. Existem algumas maneiras de fazer isso:

1. Usando a palavra-chave new e especificando o tamanho:

Esta é a forma mais comum. Você especifica o tipo e o tamanho do array. Os

elementos serão inicializados com valores padrão (0 para tipos numéricos, false
para booleanos, null para tipos de referência).

int[] numeros = new int[5]; // Um array de 5 inteiros

// numeros[0] = 0, numeros[1] = 0, ..., numeros[4] = 0

String[] nomes = new String[3]; // Um array de 3 Strings

// nomes[0] = null, nomes[1] = null, nomes[2] = null

2. Inicializando com valores diretamente (inicialização literal):

Você pode declarar e inicializar um array com valores específicos em uma única linha.
O tamanho do array será determinado pelo número de elementos fornecidos.

int[] notas = {85, 92, 78, 95, 88}; // Array de 5 inteiros com valores
predefinidos
String[] frutas = {"Maçã", "Banana", "Laranja"}; // Array de 3 Strings

3. Combinando new com inicialização literal (menos comum, mas válido):

double[] precos = new double[]{10.50, 20.00, 5.75};

5.2 Percorrendo arrays

Acessar os elementos de um array é feito usando um índice, que começa em 0 para o

primeiro elemento e vai até tamanhoDoArray - 1 para o último. Para percorrer todos
os elementos de um array, você pode usar laços de repetição.

5.2.1 Usando o laço for tradicional

Este método é útil quando você precisa do índice de cada elemento.

 int[] numeros = {10, 20, 30, 40, 50};

for (int i = 0; i < [Link]; i++) {

[Link]("Elemento no índice " + i + ": " + numeros[i]);
}
// Saída:
// Elemento no índice 0: 10
// Elemento no índice 1: 20
// Elemento no índice 2: 30
// Elemento no índice 3: 40
// Elemento no índice 4: 50

[Link] retorna o tamanho do array.

5.2.2 Usando o laço for-each (Enhanced for loop)

O laço for-each é uma forma mais concisa e legível de percorrer arrays (e coleções)
quando você não precisa do índice do elemento. Ele itera sobre cada elemento do
array, um por um.

String[] frutas = {"Maçã", "Banana", "Laranja"};

for (String fruta : frutas) {

[Link]("Fruta: " + fruta);
}
// Saída:
// Fruta: Maçã
// Fruta: Banana
// Fruta: Laranja

5.3 Arrays Multidimensionais

Java também suporta arrays multidimensionais, que são arrays de arrays. O mais
comum é o array bidimensional (matriz), que pode ser visualizado como uma tabela
com linhas e colunas.

Declaração e Inicialização de um Array Bidimensional:

int[][] matriz = new int[3][3]; // Uma matriz 3x3

// Inicialização com valores

int[][] matrizComValores = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

Percorrendo um Array Bidimensional:

Você geralmente usará laços for aninhados para percorrer arrays multidimensionais.

for (int i = 0; i < [Link]; i++) { // Percorre as linhas

for (int j = 0; j < matrizComValores[i].length; j++) { // Percorre as
colunas da linha atual
[Link](matrizComValores[i][j] + " ");
}
[Link](); // Quebra de linha após cada linha da matriz
}
// Saída:
// 1 2 3
// 4 5 6
// 7 8 9

Arrays são uma ferramenta poderosa para organizar dados, mas lembre-se de que seu
tamanho fixo pode ser uma limitação em cenários onde o número de elementos é
dinâmico. Para esses casos, Java oferece as Classes de Coleção (como ArrayList ),
que serão abordadas em tópicos mais avançados.

Capítulo 6: Exercícios Práticos

Para solidificar o conhecimento adquirido, a prática é essencial. Abaixo estão alguns

exercícios que abrangem os conceitos apresentados nesta apostila. Tente resolvê-los
por conta própria antes de procurar por soluções.

Exercício 6.1: Calculadora Simples

Crie um programa Java que funcione como uma calculadora simples. Ele deve:

1. Pedir ao usuário para digitar dois números.

2. Pedir ao usuário para escolher uma operação: + (soma), - (subtração), *

(multiplicação), / (divisão).

3. Realizar a operação escolhida e exibir o resultado.

4. Lidar com a divisão por zero, exibindo uma mensagem de erro apropriada.

Conceitos abordados: Entrada/Saída de dados ( Scanner ), variáveis, operadores

aritméticos, estruturas condicionais ( if-else if-else ou switch ).
Exercício 6.2: Verificador de Número Par/Ímpar

Crie um programa que solicite ao usuário um número inteiro e determine se ele é par
ou ímpar, exibindo a mensagem correspondente.

Conceitos abordados: Entrada de dados ( Scanner ), variáveis, operadores aritméticos

(módulo % ), estruturas condicionais ( if-else ).

Exercício 6.3: Tabuada

Desenvolva um programa que peça ao usuário um número inteiro e exiba a tabuada

desse número de 1 a 10.

Conceitos abordados: Entrada de dados ( Scanner ), variáveis, operadores

aritméticos, laços de repetição ( for ).

Exercício 6.4: Média de Notas

Crie um programa que:

1. Peça ao usuário para informar a quantidade de notas que deseja calcular a

média.

2. Leia as notas uma por uma.

3. Armazene as notas em um array.

4. Calcule e exiba a média das notas.

Conceitos abordados: Entrada de dados ( Scanner ), arrays, laços de repetição ( for

ou for-each ), variáveis, operadores aritméticos.

Exercício 6.5: Classe Pessoa

Crie uma classe chamada Pessoa com os seguintes atributos:

nome (String)

idade (int)

altura (double)
Crie um construtor para a classe Pessoa que receba nome , idade e altura como
parâmetros e os inicialize. Adicione um método apresentar() que imprima uma
mensagem como: "Olá, meu nome é [nome], tenho [idade] anos e [altura] metros de
altura."

No método main de outra classe, crie dois objetos Pessoa e chame o método
apresentar() para cada um.

Conceitos abordados: Classes, objetos, atributos, métodos, construtores,

[Link]() .

Referências (continuação)

[18] GeeksforGeeks. Arrays in Java. Disponível em:

[Link]