Domine a Linguagem de Programação Java

A linguagem de programação Java é uma das mais populares e amplamente utilizadas no mundo

da programação, conhecida pela sua robustez, portabilidade e escalabilidade. Este documento tem

como objetivo fornecer uma visão detalhada da teoria necessária para dominar o Java, abordando

desde os conceitos mais simples até as estruturas mais complexas da linguagem.

### Capítulo 1: Introdução ao Java

Java é uma linguagem de programação orientada a objetos (OOP), o que significa que ela é

baseada em classes e objetos. Sua principal característica é o princípio "Write Once, Run

Anywhere" (Escreva uma vez, execute em qualquer lugar), graças à máquina virtual Java (JVM),

que permite a execução de programas em qualquer plataforma compatível com Java.

A linguagem foi criada por James Gosling, em 1995, na Sun Microsystems (agora parte da Oracle

Corporation). Java é amplamente usada para o desenvolvimento de aplicações empresariais,

móveis (com Android), sistemas embarcados e muito mais.

### Capítulo 2: Conceitos Fundamentais

#### 2.1 Sintaxe Básica

A sintaxe do Java é a base de toda a linguagem e determina como o código é estruturado. A seguir,

apresentamos a estrutura básica de um programa Java:

```java
public class HelloWorld {

public static void main(String[] args) {

[Link]("Olá, Mundo!");

```

1. `public class HelloWorld`: Define uma classe chamada `HelloWorld`.

2. `public static void main(String[] args)`: Define o método principal, que é o ponto de entrada para

qualquer programa Java.

3. `[Link]("Olá, Mundo!");`: Exibe a mensagem "Olá, Mundo!" no console.

#### 2.2 Variáveis e Tipos de Dados

Em Java, as variáveis são usadas para armazenar valores. Cada variável deve ser declarada com

um tipo específico. Os tipos de dados primitivos em Java incluem:

- `int`: Para números inteiros.

- `double`: Para números decimais.

- `char`: Para caracteres.

- `boolean`: Para valores lógicos (`true` ou `false`).

- `String`: Para cadeias de caracteres.

Exemplo de declaração de variáveis:

```java

int numero = 10;

double preco = 25.5;

char letra = 'A';

boolean ativo = true;

String nome = "Eliseu";

```

### Capítulo 3: Controle de Fluxo

#### 3.1 Estruturas Condicionais

As estruturas condicionais permitem executar diferentes blocos de código com base em uma

condição.

- `if`: Executa um bloco de código se a condição for verdadeira.

- `else`: Executa um bloco alternativo se a condição do `if` for falsa.

- `switch`: Executa diferentes blocos de código com base em valores específicos.

Exemplo:

```java

int idade = 20;

if (idade >= 18) {

[Link]("Você é maior de idade.");

} else {

[Link]("Você é menor de idade.");

```
#### 3.2 Estruturas de Repetição

As estruturas de repetição permitem executar um bloco de código várias vezes.

- `for`: Repetição com número de iterações definido.

- `while`: Repetição enquanto a condição for verdadeira.

- `do-while`: Repetição que sempre ocorre pelo menos uma vez.

Exemplo de `for`:

```java

for (int i = 0; i < 5; i++) {

[Link]("Número: " + i);

```

### Capítulo 4: Programação Orientada a Objetos (OOP)

A Programação Orientada a Objetos é um dos pilares do Java. Ela permite organizar e modularizar

o código, criando classes e objetos.

#### 4.1 Classes e Objetos

Uma classe é um molde para criar objetos. Um objeto é uma instância de uma classe. Vamos criar

uma classe `Carro` como exemplo:

```java

public class Carro {

String modelo;

int ano;

public Carro(String modelo, int ano) {

[Link] = modelo;

[Link] = ano;

public void exibirInfo() {

[Link]("Modelo: " + modelo + ", Ano: " + ano);

```

Neste exemplo, `Carro` é uma classe que tem dois atributos (`modelo` e `ano`) e um método

(`exibirInfo`).

#### 4.2 Herança

A herança permite que uma classe herde as propriedades e métodos de outra classe. A classe

derivada (subclasse) pode adicionar novos métodos ou sobrescrever métodos existentes.

Exemplo de herança:

```java
public class Veiculo {

String marca;

public void acelerar() {

[Link]("Acelerando...");

public class Carro extends Veiculo {

String modelo;

public void exibirInfo() {

[Link]("Marca: " + marca + ", Modelo: " + modelo);

```

#### 4.3 Polimorfismo

O polimorfismo permite que um objeto de uma classe derivada seja tratado como um objeto da

classe base. Ele pode alterar o comportamento dos métodos herdados.

Exemplo de polimorfismo:

```java

Veiculo v = new Carro();

[Link]();
```

#### 4.4 Encapsulamento

O encapsulamento é o processo de esconder os detalhes internos de uma classe e permitir o

acesso controlado através de métodos públicos. Ele é feito usando modificadores de acesso como

`private`, `public` e `protected`.

Exemplo de encapsulamento:

```java

public class ContaBancaria {

private double saldo;

public void depositar(double valor) {

saldo += valor;

public double getSaldo() {

return saldo;

```

### Capítulo 5: Coleções e Generics

#### 5.1 Listas e Conjuntos

Em Java, as coleções são usadas para armazenar múltiplos elementos. A interface `List` armazena

elementos em ordem e permite duplicatas, enquanto a interface `Set` armazena elementos sem

duplicatas.

Exemplo de lista:

```java

import [Link];

ArrayList<String> lista = new ArrayList<>();

[Link]("Java");

[Link]("Python");

[Link]("C++");

```

#### 5.2 Generics

Generics permitem que você escreva código que funcione para qualquer tipo de dado, enquanto

ainda mantém a segurança de tipos. Por exemplo:

```java

public class Caixa<T> {

private T item;

public void armazenar(T item) {

[Link] = item;
 }

public T pegar() {

return item;

```

### Capítulo 6: Aplicações Práticas

Agora que cobrimos os conceitos básicos e intermediários de Java, vamos aplicar esses

conhecimentos na criação de uma aplicação simples.

#### Exemplo: Calculadora Simples

```java

import [Link];

public class Calculadora {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Digite o primeiro número:");

double num1 = [Link]();

[Link]("Digite o segundo número:");

double num2 = [Link]();

[Link]("Escolha a operação (+, -, *, /):");

String operacao = [Link]();

double resultado = 0;

switch (operacao) {

case "+":

resultado = num1 + num2;

break;

case "-":

resultado = num1 - num2;

break;

case "*":

resultado = num1 * num2;

break;

case "/":

if (num2 != 0) {

resultado = num1 / num2;

} else {

[Link]("Erro: Divisão por zero!");

break;

default:

[Link]("Operação inválida!");

return;

}
 [Link]("Resultado: " + resultado);

```

Este programa permite que o usuário entre com dois números e escolha uma operação matemática

para calcular o resultado.

### Conclusão

Com a teoria e exemplos apresentados, você agora tem uma base sólida para começar a

desenvolver aplicações em Java, utilizando conceitos de Programação Orientada a Objetos,

controle de fluxo, coleções e mais. A prática contínua será essencial para se tornar um

desenvolvedor Java altamente competente.