ANOTAÇÕES DE ESTUDOS
(OU NÃO).

Data: 13/03/2025

OPERADORES, JAVA


public class OperadoresJava {
    public static void main(String[] args) {
        // Operadores Aritméticos
        int a = 10;
        int b = 5;
        System.out.println("Operadores Aritméticos:");
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));

        // Operadores de Atribuição
        int c = 20;
        c += 5; // c = c + 5
        System.out.println("\nOperadores de Atribuição:");
        System.out.println("c += 5: " + c);
        c -= 3; // c = c - 3
        System.out.println("c -= 3: " + c);

        // Operadores de Comparação
        System.out.println("\nOperadores de Comparação:");
        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));

        // Operadores Lógicos
        boolean x = true;
        boolean y = false;
        System.out.println("\nOperadores Lógicos:");
        System.out.println("x && y: " + (x && y));
        System.out.println("x || y: " + (x || y));
        System.out.println("!x: " + !x);

        // Operadores Unários
        System.out.println("\nOperadores Unários:");
        int z = 10;
        System.out.println("++z: " + (++z)); // pré-incremento
        System.out.println("z++: " + (z++)); // pós-incremento
        System.out.println("z após pós-incremento: " + z);
    }
}

Resumos

Os operadores em Java são usados para realizar operações em variáveis e valores. Existem vários tipos de operadores, e cada tipo serve para uma finalidade específica. A seguir, explicamos os principais operadores:

1. Operadores Aritméticos

Estes operadores realizam operações matemáticas:

  • + : Soma
  • - : Subtração
  • * : Multiplicação
  • / : Divisão
  • % : Módulo (resto da divisão)

Exemplo


 int a = 10;
 int b = 5;
 int soma = a + b; 
 // soma = 15

2. Operadores de Atribuição

Usados para atribuir valores a variáveis:

  • = : Atribuição simples
  • += : Atribuição com soma
  • -= : Atribuição com subtração
  • *= : Atribuição com multiplicação
  • /= : Atribuição com divisão
  • %= : Atribuição com módulo

Exemplo


int a = 10;
a += 5;  
// a = a + 5; Agora a vale 15

3. Operadores de Comparação

Esses operadores comparam dois valores e retornam um valor booleano (true ou false).

  • == : Igualdade
  • != : Desigualdade
  • > : Maior que
  • < : Menor que
  • >= : Maior ou igual
  • <= : Menor ou igual

Exemplo


int a = 10;
int b = 5;
boolean resultado = a > b;  
// resultado = true

4. Operadores Lógicos

São usados para operações com expressões booleanas.

  • && : E lógico
    (ambos precisam ser verdadeiros)
  • || : Ou lógico
    (pelo menos um precisa ser verdadeiro)
  • ! : Não lógico
    (inverte o valor de verdadeiro para falso e vice-versa)

Exemplo


boolean x = true;
boolean y = false;
boolean resultado = x && y;  
// resultado = false

5. Operadores Unários

Operadores que operam em um único valor.

  • ++ : Incremento
    (aumenta o valor da variável em 1)
  • -- : Decremento
    (diminui o valor da variável em 1)
  • + : Indica valor positivo
  • - : Indica valor negativo

Exemplo


int z = 10;
z++;  
// z é incrementado 
// agora z = 11

Data: 14/03/2025

Criando um RPG em Java
Inspirado em Solo Leveling!!

Introdução

Em Solo Leveling, Sung Jin-Woo começa como o caçador mais fraco de todos kkkkjj (conhecido como o caçador mais fraco da humanidade.. sera mesmo?), mas tudo muda quando ele recebe uma segunda chance, UM SISTEMA.. e esse sistema permite que ele evolua sem limites (o cara é foda patroa) e isso é muito a cara de RPG, não concorda? porque em RPG'S, os personagens tambem podem subir de nível, ganhar habilidades (dependendo do rpg) e ficarem mais fortes. Dito isso, hoje vamos recriar parte desse sistema de solo leveling em JAVA (medo kkkj) explicando cada conceito e sua relação com a jornada do nosso menino Sung.

Sung Jin-Woo

Criando um sistema de RPG em Java

Primeiro vamos criar uma classe, e essa classe vai se chamar Hunter

Em Solo Leveling, nosso menino Sung possui atributos como força, agilidade, vitalidade, etc. Vamos representar isso com uma classe (e você já sabe o nome, esquece não, é Hunter) e toda classe precisa de um construtor.

Hunter class


import java.util.Random;
import java.util.Scanner;

public class Hunter {
    private String nome;
    private int nivel;
    private int experiencia;
    private int forca;
    private int agilidade;
    private int vitalidade;

    // Construtor da classe
    public Hunter(String nome) {
        this.nome = "Sung Jin-Woo"; // poderia ser qualquer um
        this.nivel = 1;
        this.experiencia = 0;
        this.forca = 10;
        this.agilidade = 10;
        this.vitalidade = 10;
    }
}

Aqui criamos a classe Hunter, que representa nosso menino Sung (caçador). Definimos os atributos principais (nome, nível, experiência) e os 3 (três) atributos essenciais (força, agilidade e vitalidade). O construtor inicializa esses valores, simulando nosso menino Sung começando sua jornada.

Agora, vamos criar um método para ganhar XP e verificar se nosso menino Sung sobe de nível.

ganharExperiencia method


public void ganharExperiencia(int xp) {
    this.experiencia += xp;
    System.out.println(nome + " ganhou " + xp + " XP!");
    verificarLevelUp();
}

Esse método adiciona XP ao Sung (caçador) e chama o método verificarLevelUp() que ainda vamos criar para ver se ele pode subir de nível.

Vamos criar o método para verificar se o Sung pode subir de nível.

verificarLevelUp method


private void verificarLevelUp() {
    // Fórmula simples para subir de nível
    if (experiencia >= nivel * 10) {
        experiencia -= nivel * 10;
        nivel++;
        forca += 5;
        agilidade += 3;
        vitalidade += 4;
        System.out.println(nome + 
        " subiu para o nível " + nivel + "!");
    }
}

Sempre que o jogador (Sung) acumular XP suficiente, ele vai subir de nível, melhorando seus atributos. A fórmula nivel * 10 define a quantidade de XP necessária para evoluir.

Agora, vamos criar um método para exibir os atributos.

mostrarStatus method


public void mostrarStatus() {
    System.out.println("\nStatus de " + nome + ":");
    System.out.println("Nível: " + nivel);
    System.out.println("Força: " + forca);
    System.out.println("Agilidade: " + agilidade);
    System.out.println("Vitalidade: " + vitalidade);
}

O que ele faz é nada mais, nada menos do que mostrar os atributos atuais do Sung (jogador) na tela.

Agora, vamos simular a batalha contra um monstro.

lutar method


public void lutar(Monstro monstro) {
    System.out.println(nome + 
    " entrou em combate contra " + monstro.getNome() + "!");
    Random random = new Random();
    Scanner scanner = new Scanner(System.in);
}

Aqui nós criamos o método lutar(), que recebe um monstro como parâmetro. O Random (aleatório) ajuda a gerar valores aleatórios (não me diga kkkkkj) para ataques, e o Scanner é para que você decida a ação a ser tomada.

vamos continuar o código

WHILE (lutar method)

você pode copiar o código (arrume as aspas "")


while (this.vitalidade > 0 && monstro.getVida() > 0) {
            System.out.println("Escolha sua ação: 
            1- Atacar, 
            2- Defender, 
            3- Esquivar");
            int escolha = scanner.nextInt();
            int danoCausado = 0;
            int danoRecebido = random.nextInt
            (monstro.getForca());

Aqui criamos um loop while, ele continua rodando até que o jogador ou o monstro fiquem sem vida. Pedimos pro jogador (usuário) escolher uma ação e geramos um valor aleatório de dano recebido :(

Vou te explicar cada partezinha, se liga

if (lutar method)


if (escolha == 1) { // Atacar
                danoCausado = random.nextInt(forca);
                monstro.receberDano(danoCausado);
                System.out.println(nome + " 
                atacou e causou " + 
                danoCausado + " de dano!");
            }

Se o jogador escolher atacar (1), calculamos um dano random, baseado em sua força e aplicamos ao desgraçadin (monstro).

else if (lutar method)


else if (escolha == 2) { // Defender
                danoRecebido /= 2;
                System.out.println(nome + " 
                defendeu e reduziu o dano para " 
                + danoRecebido + "!");
            }

Se o jogador escolher defender (2), reduzimos o dano, pela metade.

else if (lutar method)


else if (escolha == 3) { // Esquivar
                if (random.nextInt(100) < agilidade * 2) {
                    danoRecebido = 0;
                    System.out.println(nome 
                    + " esquivou do ataque!");
                } else {
                    System.out.println(nome 
                    + " tentou esquivar, mas foi atingido!");
                }
            }

Se o jogador tentar esquivar (3), verificamos randomicante se ele tem sucesso, isso com base em sua agilidade.

Seguindo nosso desenvolvimento, precisamos mostrar quanto de dano recebemos se der errado, certo?

Checar dano recebido


this.vitalidade -= danoRecebido;
            System.out.println(monstro.getNome() + " causou " 
            + danoRecebido 
            + " de dano!");
        }

Depois da ação do jogador, aplicamos o dano ao nosso personagem e seguimos o combate.

Agora precisamos mostrar se derrotamos o monstro, ou se ele nos derrotou xD.

Checar derrota ou vitoria


            if (this.vitalidade > 0) {
                System.out.println(nome 
                + " derrotou " + monstro.getNome() + "!");
                ganharExperiencia(10);
            } else {
                System.out.println(nome 
                + " foi derrotado por " 
                + monstro.getNome() + "...");
            }
        } finally {
          // Fechando o scanner
          // (boa prática) 
            scanner.close(); 
        }
    }
}

E assim, no final da batalha, verificamos quem venceu. Se nosso menino sung sobreviver, ele ganha XP. Se for derrotado, o jogo termina (o que convenhamos, é impossivel o menino sung ser derrotado.. eu acho kkkkk)

Criando a Classe Monstro

Bom, nosso menino Sung precisa de inimigos pra enfrentar né? (xD se não, não tem graça). Então vamos criar a classe Monstro para representar os adversários que ele vai encontrar nas dungeons!

Class monstro



public class Monstro {
    private String nome;
    private int nivel;
    private int vida;
    private int forca;
    
    // Construtor da classe
    public Monstro(String nome, int nivel) {
        this.nome = nome;
        this.nivel = nivel;
        this.vida = nivel * 15; // Vida baseada no nível
        this.forca = nivel * 3; // Força baseada no nível
    }
}

Aqui criamos a classe Monstro com os atributos básicos: nome, nível, vida e força. O construtor define a vida e força com base no nível do monstro (quanto maior o nível, mais forte é o desgraçadinho xD). Em Solo Leveling, as criaturas das dungeons variam muito em poder, então esse sistema permite criar monstros de diferentes níveis de dificuldade.

Agora precisamos implementar os métodos que vão permitir a interação com o caçador (Hunter):

Getters


// Getters necessários para a interação com a classe Hunter
    public String getNome() {
        return nome;
    }
    
    public int getVida() {
        return vida;
    }
    
    public int getForca() {
        return forca;
    }

Esses métodos "getters" permitem que a classe Hunter acesse os valores dos atributos do monstro. Isso é necessário para que nosso menino Sung saiba o nome do monstro que está enfrentando, quanto de vida ele tem e qual é a força dele (pra calcular o dano).

E claro, precisamos de um método para aplicar dano ao monstro quando o Sung atacar.

receber dano


// Método para receber dano
    public void receberDano(int dano) {
        this.vida -= dano;
        if (this.vida < 0) {
            this.vida = 0;
        }
    }

Esse método reduz a vida do monstro quando ele recebe dano. Também verificamos se a vida ficou negativa, pq seria estranho um monstro com vida abaixo de zero né? kkkj (mesmo que o sung seja forte o suficiente pra causar esse dano)

Por fim, vamos adicionar um método para mostrar o status do monstro, assim como fizemos para o Hunter.

mostrar status


// Método para mostrar status do monstro
    public void mostrarStatus() {
        System.out.println("\nStatus de " + nome + ":");
        System.out.println("Nível: " + nivel);
        System.out.println("Vida: " + vida);
        System.out.println("Força: " + forca);
    }
}

E assim podemos ver as informações do monstro na tela. Útil pra saber se vale a pena enfrentar aquele monstro ou se é melhor correr! (nosso menino é corajoso, mas no início ele precisa saber escolher suas batalhas).

Testando o Sistema

Agora que temos as classes Hunter e Monstro, podemos criar uma classe principal com o método main() para testar nosso sistema.

main


public class SoloLeveling {
    public static void main(String[] args) {
        // Criando nosso caçador Sung Jin-Woo
        Hunter sung = new Hunter();
        sung.mostrarStatus();
        
        // Criando um monstro para ele enfrentar
        Monstro goblin = new Monstro("Goblin", 1);
        goblin.mostrarStatus();
        
        // Iniciando a batalha!
        sung.lutar(goblin);
    }
}

Com isso, podemos testar o sistema básico de RPG inspirado em Solo Leveling! O Sung começa fraco (como no anime/manhwa), mas com cada batalha ele fica mais forte. E se você quiser adicionar mais mecânicas como habilidades especiais ou itens, pode expandir essas classes. Boa sorte!

Erga-se, caçador! Sua jornada está apenas começando.