0Pricing
Java Academy · Aula

Classes Utilitárias e Métodos de Fábrica Estáticos

Projete classes utilitárias que não possam ser instanciadas e disponibilize métodos de fábrica estáticos como alternativas aos construtores.

Classes Utilitárias e Métodos de Fábrica Estáticos é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Classes utilitárias e métodos de fábrica estáticos

Classes utilitárias fornecem métodos auxiliares estáticos sem estado de instância. Métodos de fábrica estáticos são alternativas nomeadas aos construtores que oferecem melhor legibilidade, armazenamento em cache e flexibilidade.

Classes utilitárias

Uma classe utilitária não tem estado de instância — é um contêiner de métodos estáticos. Torne-a não instanciável declarando um construtor privado.

final class StringUtils {
    // Private constructor prevents instantiation
    private StringUtils() {
        throw new UnsupportedOperationException("Utility class");
    }

    public static boolean isBlank(String s) {
        return s == null || s.strip().isEmpty();
    }

    public static String capitalize(String s) {
        if (isBlank(s)) return s;
        return Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase();
    }
}

System.out.println(StringUtils.isBlank("  ")); // true
System.out.println(StringUtils.capitalize("hELLO")); // Hello

Classes utilitárias da biblioteca padrão

A biblioteca padrão de Java está repleta de classes utilitárias para coleções, matrizes, objetos, arquivos, caminhos e matemática.

import java.util.*;

List<Integer> nums = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3));

Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

System.out.println(Collections.min(nums)); // 1
System.out.println(Collections.max(nums)); // 9

Collections.shuffle(nums); // random order

int[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 1, 3, 4, 5]
System.out.println(Arrays.binarySearch(arr, 4)); // 3 (index)

Métodos de fábrica estáticos

Um método de fábrica estático é um método estático nomeado que cria e retorna uma instância. Benefícios: nomes descritivos, possibilidade de retornar instâncias armazenadas em cache ou de um subtipo e possibilidade de retornar um valor nulo.

class Connection {
    private final String host;
    private final int port;
    private final boolean ssl;

    private Connection(String host, int port, boolean ssl) {
        this.host = host; this.port = port; this.ssl = ssl;
    }

    // Named factory methods — more expressive than constructors
    public static Connection plain(String host) {
        return new Connection(host, 80, false);
    }
    public static Connection secure(String host) {
        return new Connection(host, 443, true);
    }
}
Connection c = Connection.secure("api.example.com");
// Much clearer than: new Connection("api.example.com", 443, true)

Armazenamento em cache com fábrica estática

Fábricas estáticas podem retornar instâncias armazenadas em cache, evitando alocações repetidas para valores comuns (como Integer.valueOf, que faz isso para -128..127).

class Color {
    private static final Map<String, Color> CACHE = new HashMap<>();

    public final int r, g, b;

    private Color(int r, int g, int b) {
        this.r = r; this.g = g; this.b = b;
    }

    public static Color of(int r, int g, int b) {
        String key = r + "," + g + "," + b;
        return CACHE.computeIfAbsent(key, k -> new Color(r, g, b));
    }

    public static final Color RED   = of(255, 0, 0);
    public static final Color GREEN = of(0, 255, 0);
    public static final Color BLUE  = of(0, 0, 255);
}
System.out.println(Color.of(255,0,0) == Color.RED); // true (cached)

Fábrica versus construtor: nomenclatura

Convenções comuns de nomenclatura para métodos de fábrica estáticos:

  • of — fábrica para agregação
  • from — fábrica para conversão
  • valueOf — fábrica para conversão (APIs mais antigas)
  • getInstance — instância única
  • create/newInstance — objeto novo
  • get — flexível
// Java API examples:
Optional.of(value)               // of
LocalDate.from(temporal)         // from
Integer.valueOf(42)              // valueOf
Calendar.getInstance()           // getInstance
Array.newInstance(type, length)  // newInstance

// Your own:
HttpRequest.post("https://api.example.com/users")
ApiResponse.error(404, "Not found")
Payment.creditCard("4242...", 9999, "USD")

Retornando subtipos

Um método de fábrica pode retornar um subtipo, enquanto o tipo de retorno declarado é a interface. Quem chama o método fica desacoplado da implementação concreta.

interface Validator<T> {
    boolean validate(T value);
    String errorMessage();
}

class EmailValidator implements Validator<String> {
    public boolean validate(String email) { return email.contains("@"); }
    public String errorMessage() { return "Invalid email address"; }
}

class Validators {
    // Returns interface type — hides implementation
    public static Validator<String> email() { return new EmailValidator(); }
    public static Validator<String> notBlank() {
        return new Validator<>() {
            public boolean validate(String s) { return s != null && !s.isBlank(); }
            public String errorMessage() { return "Value required"; }
        };
    }
}

Builder por meio de fábrica estática

Combine um construtor privado com uma fábrica estática e um Builder nested para construir objetos complexos.

class EmailMessage {
    private final String to, subject, body;
    private final boolean html;

    private EmailMessage(Builder b) {
        this.to = b.to; this.subject = b.subject;
        this.body = b.body; this.html = b.html;
    }

    public static Builder builder(String to) { return new Builder(to); }

    public static class Builder {
        private final String to;
        private String subject = "", body = "";
        private boolean html = false;

        Builder(String to) { this.to = to; }
        public Builder subject(String s) { this.subject = s; return this; }
        public Builder body(String b) { this.body = b; return this; }
        public Builder html() { this.html = true; return this; }
        public EmailMessage build() { return new EmailMessage(this); }
    }
}
EmailMessage.builder("alice@co.com").subject("Welcome!").html().build();

Validação em métodos de fábrica

Métodos de fábrica são excelentes para validar a entrada antes da construção — lance exceções significativas com contexto.

class PortNumber {
    private final int value;

    private PortNumber(int value) { this.value = value; }

    public static PortNumber of(int port) {
        if (port < 1 || port > 65535)
            throw new IllegalArgumentException(
                "Port must be 1-65535, got: " + port);
        return new PortNumber(port);
    }

    public static PortNumber http()  { return new PortNumber(80); }
    public static PortNumber https() { return new PortNumber(443); }

    public int value() { return value; }
    public boolean isPrivileged() { return value < 1024; }
}
System.out.println(PortNumber.https().isPrivileged()); // true

API de coleções: fábricas estáticas

Java 9+ adicionou List.of(), Set.of() e Map.of() — métodos de fábrica estáticos que criam coleções imutáveis.

import java.util.*;

List<String> fruits = List.of("Apple", "Banana", "Cherry");
Set<Integer> ids    = Set.of(1, 2, 3, 4, 5);
Map<String, Integer> ages = Map.of("Alice", 30, "Bob", 25);

// All are unmodifiable:
try {
    fruits.add("Durian"); // UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Cannot modify!");
}

// Map.entry and Map.ofEntries for > 10 entries
Map<String, String> config = Map.ofEntries(
    Map.entry("host", "localhost"),
    Map.entry("port", "8080")
);

Quando preferir métodos de fábrica

Prefira métodos de fábrica estáticos a construtores quando:

  • Você quiser um nome descritivo
  • A fábrica puder retornar uma instância armazenada em cache ou de um subtipo
  • For necessária uma validação antes da construção
  • Você quiser controlar a quantidade de instâncias (Singleton, conjunto)
// Constructor: hard to know what this means
new Complex(0.5, -1.2);

// Factory: clear meaning
Complex.fromPolar(1.3, Math.PI / 4); // polar form
Complex.rectangular(0.5, -1.2);      // rectangular form

// Constructor: no caching
new Boolean(true); // deprecated — creates new object!

// Factory: returns cached instance (Boolean.TRUE or FALSE)
Boolean.valueOf(true); // returns Boolean.TRUE singleton

Verificação rápida

Qual é a principal vantagem de um método de fábrica estático em relação a um construtor público?

Recapitulação: classes utilitárias e métodos de fábrica estáticos

Principais conclusões:

  • Classes utilitárias: classe final com construtor privado e apenas métodos estáticos
  • Métodos de fábrica estáticos são alternativas nomeadas aos construtores
  • Nomenclatura comum: of, from, valueOf, getInstance, criar, newInstance
  • Fábricas podem retornar instâncias armazenadas em cache — consulte Integer.valueOf(-128..127)
  • Fábricas podem retornar subtipos enquanto ocultam a implementação concreta
  • Use builders dentro das fábricas para construções complexas com vários parâmetros

Perguntas Frequentes

A aula “Classes Utilitárias e Métodos de Fábrica Estáticos” é grátis?

Sim — o texto completo de “Classes Utilitárias e Métodos de Fábrica Estáticos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Classes Utilitárias e Métodos de Fábrica Estáticos”?

Projete classes utilitárias que não possam ser instanciadas e disponibilize métodos de fábrica estáticos como alternativas aos construtores. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Classes Utilitárias e Métodos de Fábrica Estáticos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Regras de Sobrecarga de Métodos
  2. Parâmetros Varargs
  3. Campos e Constantes Estáticos
  4. Classes Utilitárias e Métodos de Fábrica Estáticos
← Voltar para Java Academy