Em Java, a criação de métodos estáticos permite a execução de funções utilitárias sem a necessidade de instanciar uma classe. Um exemplo comum é a operação aritmética de elevar um número ao quadrado. Embora a biblioteca padrão forneça o método Math.pow(), implementar uma lógica personalizada pode ser útil para entender o funcionamento de métodos estáticos e tipos primitivos.

public class CalculadoraEstatica {

    public static void main(String[] args) {
        int limite = 10;
        
        for (int i = 1; i <= limite; i++) {
            int resultado = obterQuadrado(i);
            // Alternativa utilizando a biblioteca padrão:
            // int resultado = (int) Math.pow(i, 2);
            System.out.printf("Valor: %d | Quadrado: %d%n", i, resultado);
        }
    }

    /**
     * Calcula o quadrado de um inteiro de forma estática.
     */
    public static int obterQuadrado(int numero) {
        return numero * numero;
    }
}

Além de operações matemáticas simples, a geração de números pseudoaleatórios é uma tarefa frequente. O método Math.random() retorna um valor de ponto flutuante entre 0.0 e 1.0. Para obter um intervalo específico, como valores de 1 a 6 (simulando um dado), aplicamos uma trasnformação linear. Abaixo, o exemplo utiliza uma interface gráfica simples para exibir os resultados.

import javax.swing.JOptionPane;

public class GeradorDeDados {
    public static void main(String[] args) {
        StringBuilder saida = new StringBuilder();
        int totalSorteios = 20;

        for (int cont = 1; cont <= totalSorteios; cont++) {
            // Gera um número entre 1 e 6
            int face = 1 + (int) (Math.random() * 6);
            saida.append(face).append("  ");
            
            if (cont % 5 == 0) {
                saida.append("\n");
            }
        }

        JOptionPane.showMessageDialog(null, saida.toString(), 
            "Sequência de Números Aleatórios", JOptionPane.PLAIN_MESSAGE);

        System.exit(0);
    }
}

É importante compreender que a classe java.util.Random utiliza uma "semente" (seed) para inicializar seu algoritmo. Se dois objetos Random forem criados com a mesma semente, eles produzirão exatamente a mesma sequência de valores, tornando o processo determinístico. Para obter sequências variadas, geralmente utiliza-se o tempo atual do sistema como semente.

import java.util.Random;

public class AnaliseDeSementes {
    public static void main(String[] args) {
        long sementeFixa = 50;

        Random g1 = new Random(sementeFixa);
        Random g2 = new Random(sementeFixa);
        Random g3 = new Random(System.currentTimeMillis());

        System.out.println("Gerador 1 (Semente 50): " + g1.nextInt(100));
        System.out.println("Gerador 2 (Semente 50): " + g2.nextInt(100));
        System.out.println("Gerador 3 (Tempo Atual): " + g3.nextInt(100));
        
        // g1 e g2 sempre retornarão o mesmo valor na primeira chamada
    }
}

Para casos onde é necessário implementar o próprio algoritmo de geração, o Gerador Linear Congruencial (LCG) é uma das técnicas mais clássicas. Ele utiliza uma fórmula matemática para produzir uma sequência de números que aparentam ser aleatórios com base em parâmetros pré-definidos como multiplicador e módulo.

public class AlgoritmoLCG {
    public static void main(String[] args) {
        // Parâmetros comuns para o algoritmo LCG
        final long MODULO = (long) Math.pow(2, 31) - 1;
        final long MULTIPLICADOR = 16807;
        final long INCREMENTO = 0;
        
        long valorAtual = 1; // Semente inicial
        int quantidade = 1000;

        System.out.println("Gerando " + quantidade + " números:");
        for (int i = 0; i < quantidade; i++) {
            valorAtual = (MULTIPLICADOR * valorAtual + INCREMENTO) % MODULO;
            
            // Exibe apenas os primeiros 10 para demonstração
            if (i < 10) {
                System.out.println("Valor " + (i + 1) + ": " + valorAtual);
            }
        }
    }
}