palavra-chave private em Java

A palavra-chave private em Java é um modificador de acesso usado para restringir a visibilidade de campos, métodos e construtores à classe definidora. Esse mecanismo de encapsulamento ajuda a proteger o estado interno de um objeto e promove a ocultação de dados.

Uso

O modificador de acesso private garante que os membros (campos, métodos, construtores) de uma classe sejam acessíveis somente dentro da mesma classe. É comumente usado para reforçar o encapsulamento e impedir o acesso não autorizado de fora da classe.

Sintaxe

class ClassName {
    private dataType fieldName;
    
    private returnType methodName() {
        // method body
    }
}

• dataType fieldName: Declaração de um campo privado.
• returnType methodName(): Declaração de um método privado.

Exemplos

Exemplo 1: Campo privado

public class Person {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

Neste exemplo, o campo name é declarado como private, o que significa que não pode ser acessado diretamente de fora da classe Person. Os métodos setName e getName fornecem acesso controlado a esse campo.

Exemplo 2: Método privado

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    private int subtract(int a, int b) {
        return a - b;
    }
    
    public int performSubtraction(int a, int b) {
        return subtract(a, b);
    }
}

Aqui, o método subtract é privado e só pode ser chamado dentro da classe Calculator. O método performSubtraction fornece uma interface pública para você usar o método subtract.

Exemplo 3: Construtor privado

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // private constructor
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Este exemplo demonstra um padrão singleton em que o construtor é privado, garantindo que apenas uma instância da classe Singleton possa ser criada. O método getInstance oferece uma maneira de acessar a instância única.

Dicas e práticas recomendadas

• Encapsulamento: Use o site private para encapsular o estado interno de uma classe e expor somente os métodos necessários para interagir com esse estado.
• Acesso controlado: Forneça métodos getter e setter públicos para controlar como os campos privados são acessados e modificados.
• Classes imutáveis: Para classes imutáveis, torne os campos private e final e evite fornecer setters.

  public class ImmutableClass {
      private final int value;
      
      public ImmutableClass(int value) {
          this.value = value;
      }
      
      public int getValue() {
          return value;
      }
  }

• Segurança: Use o site private para ocultar métodos e dados confidenciais que não devem ser expostos a outras classes.
• Padrão Singleton: Nos padrões singleton, use um construtor privado para evitar a instanciação direta da classe.