Mutable types in Java?

Ipman1971's answer is partially correct. A class is mutable when it allows its state to be altered, that is, to modify the values ​​of the fields it contains, either by making its fields public or by providing methods that allow the values ​​of the fields to be altered.

An immutable class not only does not provide methods that allow its state to be modified, but once an object of that class is initialized, its state cannot be altered in any way. Any operation that results in an altered state actually returns a new object of the same class but with the changed state. To achieve this, the following conditions must be satisfied in the class definition:

1. Fields must be declared as constants. In the case of Java, this is achieved by adding the modifier finalto the fields.
2. The fields must themselves be immutable.
3. If operations must be performed on the class to alter the state, methods must be defined that return an instance of the class instead of modifying the state directly (which would be "impossible" since the fields are declared as final).

Here's an example of an immutable class that keeps all these aspects in mind:

public class Inmutable {
    //los primitivos son inmutables por defecto
    private final int id;
    //String es una clase inmutable
    private final String nombre;
    //List no se puede saber si es inmutable pero eso tiene arreglo
    //la clase a almacenar en esta lista también debe ser inmutable
    //sino Inmutable no sería del todo inmutable
    private final List<BigDecimal> listaNumeros;
    //En Java, la clase java.util.Date no es inmutable
    //por ende, para trabajar con una fecha en una clase inmutable
    //hay dos opciones: 1) Almacenar el long que representa al tiempo
    //en lugar de almacenar Date. 2) Utilizar clases de un API que provee
    //manejo de fechas para Java como Joda Time o Date and Time disponible
    //desde Java 8 en el paquete java.time
    //Para este caso, utilizaré la opción 1)
    private final long fechaNacimiento;

    //en el constructor se deben inicializar todos los campos
    //ojo: se recibe un como parámetro
    public Inmutable(int id, String nombre, List<BigDecimal> listaNumeros, Date fechaNacimiento) {
        this.id = id;
        this.nombre = nombre;
        //para el caso de la lista, se decora para que sea inmutable
        this.listaNumeros = Collections.unmodifiableList(listaNumeros);
        //en el caso de Date, se almacena solo el valor entero
        this.fechaNacimiento = fechaNacimiento.getTime();
    }

    //se crean getters para acceder a los campos
    //se devuelve el primitivo puesto que no se puede modificar su valor
    public int getId() {
        return this.id;
    }
    //se devuelve la instancia directamente puesto que no se puede modificar su estado
    public String getNombre() {
        return this.nombre;
    }
    //se puede devolver esta lista puesto que ya es inmutable
    //no hay problema si el cliente intenta modificarla
    //se lanzara una excepción por el comportamiento de la lista
    //devuelta por Collections#unmodifiableList
    public List<BigDecimal> getListaNumeros() {
        return this.listaNumeros;
    }
    //se devuelve una instancia de Date para el cliente de esta clase
    //puesto que esta instancia de Date no está asociada a la clase
    //no importa si el cliente modifica su estado
    public Date getFechaNacimiento() {
        return new Date(fechaNacimiento);
    }

    //se agregan dos operaciones
    //una para agregar valores a la lista de numeros
    //otro para "cambiar" la fecha de nacimiento

    public Inmutable agregaNumero(BigDecimal numero) {
        //preparamos la nueva lista a utilizar
        List<BigDecimal> nuevaListaNumeros = new ArrayList<>(listaNumeros);
        nuevaListaNumeros.add(numero);
        //siempre se crea una nueva instancia a devolver
        //de esta forma la instancia actual no altera su estado
        return new Inmutable(id, nombre, nuevaListaNumeros, new Date(fechaNacimiento));
    }

    public Inmutable setFechaNacimiento(Date fechaNacimiento) {
        return new Inmutable(id, nombre, listaNumeros, fechaNacimiento);
    }
}

Well, I think you will understand quickly, a mutable object has properties that can change their value, for this the class has methods that allow the modification of the properties.

And an immutable object is one that does not allow its properties to be modified, they are assigned at its creation and cannot be modified. I give you an example:

public class Mutable {
  private int id;

  Mutable(int id) {
    this.id=id;
  }

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id=id;
  }

}

public class Inmutable {
  //final cumple dos roles
  //1. Forzar que se inicialize el campo 1 sola vez en la clase
  // y que no se le pueda cambiar el valor
  //2. Fuerza que el campo se inicie en el constructor de la clase
  private final int id;

  Inmutable(int id) {
    this.id=id;
  }

  public int getId() {
    return id;
  }

}