1. Comprensión del estado del objeto:
* Estado definido: El estado de un objeto está representado por los valores almacenados en sus campos (variables de instancia). Estos valores definen la condición del objeto en un momento dado.
* Cambios de estado: El estado cambia cuando se llaman métodos en el objeto que modifica los valores de sus campos.
* Identidad de objeto vs. Estado: Es crucial distinguir entre la identidad de un objeto (su ubicación única en la memoria) y su estado (los datos que posee). Dos objetos pueden tener el mismo estado pero aún así ser objetos diferentes.
2. Principios y técnicas clave:
* Encapsulación (Ocultación de datos):
* Principio: Restringir el acceso directo a los campos del objeto. Hacer campos `privado`.
* Propósito: Protege el estado interno de la modificación no deseada. Le permite controlar cómo se accede y cambia el estado.
* Implementación: Use modificadores de acceso 'privado` para campos. Proporcione métodos públicos `getter` (accesor) y` setter` (mutador) para interactuar con el estado de manera controlada.
* Ejemplo:
`` `Java
persona de clase pública {
nombre de cadena privada;
edad privada int;
Persona pública (nombre de cadena, int Age) {
this.name =name;
this.age =edad;
}
public String getName () {
nombre de retorno;
}
public void setName (nombre de cadena) {
this.name =name;
}
public int getage () {
edad de retorno;
}
Public void setage (int a age) {
if (edad> =0) {// validación
this.age =edad;
} demás {
System.out.println ("La edad no puede ser negativa");
}
}
}
`` `` ``
* Acceso controlado con Getters and Setters:
* getters (accesorios): Métodos `público` que devuelven el valor de un campo. Proporcionan acceso de solo lectura al estado del objeto.
* setters (mutators): Métodos "público" que permiten la modificación del valor de un campo. De manera crucial, los establecedores deben incluir validación y lógica para garantizar que el estado permanezca consistente y válido.
* Inmutabilidad: Si desea evitar los cambios de estado después de la creación de objetos, no proporcione setters. Cree el objeto con toda la información de estado necesaria en el constructor.
* Validación:
* Propósito: Asegura que el estado del objeto siga siendo válido de acuerdo con las reglas de su solicitud.
* Implementación: Incluya lógica de validación en setters y constructores. Verifique los valores no válidos, como edades negativas, cadenas vacías o números fuera de rango.
* Ejemplo: (Consulte el método `setage` en la clase 'persona' anterior).
* Inmutabilidad:
* Principio: El estado de un objeto inmutable no se puede cambiar después de su creación.
* Beneficios:
* Seguridad del hilo: Los objetos inmutables son inherentemente seguros porque su estado no puede modificarse simultáneamente.
* Simplicidad: Más fácil de razonar y depurar porque el estado es predecible.
* almacenado en caché: Se puede almacenar en caché de forma segura sin preocuparse por los cambios.
* Implementación:
* Haga todos los campos `Final` y` Private`.
* No proporcione ningún setter.
* Si un campo es un objeto mutable (como una `List` o` Map`), devuelva una copia defensiva en el Getter para evitar la modificación externa.
* Ejemplo:
`` `Java
Public Final Clase ImmutablePoint {
Private final int x;
intención final privada;
public ImmutablePoint (int x, int y) {
this.x =x;
this.y =y;
}
public int getx () {
regresar x;
}
public int gety () {
regresar y;
}
}
`` `` ``
* Patrón de observador (para objetos dependientes):
* Cuándo usar: Cuando el estado de un objeto (el sujeto) afecta el estado de otros objetos (observadores).
* Mecanismo: El sujeto mantiene una lista de observadores y los notifica cada vez que cambia su estado. Los observadores se actualizan en consecuencia.
* Ejemplo: Un rastreador de precios de las acciones podría notificar a todos los inversores registrados cuando cambie el precio de una acción.
* Patrón de recuerdo (para la preservación del estado):
* Cuándo usar: Cuando necesite guardar y restaurar el estado de un objeto en diferentes puntos en el tiempo (por ejemplo, para la funcionalidad de deshacer/rehacer).
* Mecanismo: El objeto crea un objeto "recuerdo" que contiene una instantánea de su estado actual. El recuerdo se puede almacenar y luego usarse para restaurar el objeto a ese estado guardado.
* Patrón de estado (para el comportamiento basado en el estado):
* Cuándo usar: Cuando el comportamiento de un objeto cambia dependiendo de su estado interno.
* Mecanismo: Representar cada estado posible como una clase separada. El objeto de contexto (el objeto cuyo comportamiento cambia) contiene una referencia a un objeto de estado. Cuando se llama a un método en el contexto, delega la llamada al objeto de estado actual.
* Ejemplo: Una máquina expendedora podría tener estados como "inactivo", "seleccionar el producto", "dispensación" y "outofstock", cada uno con diferentes comportamientos.
* Seguridad de hilo (concurrencia):
* Importancia: Si varios subprocesos pueden acceder y modificar el estado de un objeto al mismo tiempo, debe garantizar la seguridad de los subprocesos.
* Técnicas:
* Sincronización: Use bloques o métodos 'sincronizados' para proteger las secciones críticas del código donde se modifica el estado.
* bloquea: Use `java.util.concurrent.locks` para un control más de grano fino sobre el bloqueo.
* Variables atómicas: Use clases `java.util.concurrent.atomic` (por ejemplo,` AtomicInteger`, `Atomicboolean`) para operaciones atómicas en tipos primitivos.
* objetos inmutables: Como se mencionó anteriormente, los objetos inmutables son inherentemente seguros de hilo.
* Ejemplo:
`` `Java
contador de clase pública {
private int count =0;
Public sincronizado nulo increment () {
contar ++;
}
public int getCount () {
recuento de retorno;
}
}
`` `` ``
* Serialización:
* Propósito: Convertir el estado de un objeto en un flujo de bytes para el almacenamiento o transmisión.
* Implementación: Implemente la interfaz `java.io.serializable`. El JVM maneja el proceso de serialización automáticamente. Puede personalizar la serialización utilizando la palabra clave `transitorio` (para excluir campos) y mediante la implementación de métodos` writeObject () `y` readobject () `.
* Consideraciones: Tenga en cuenta la compatibilidad de los objetos serializados cuando actualice la definición de clase.
3. Las mejores prácticas:
* Principio de menor privilegio: Solo otorga acceso al estado del objeto que es absolutamente necesario.
* Clare Naming: Use nombres descriptivos para campos, getters y setters para que el código sea fácil de entender.
* Documente su código: Explique el propósito de cada campo y el comportamiento esperado de Getters y Setters en los comentarios de Javadoc.
* Prueba a fondo: Escriba las pruebas unitarias para verificar que el estado del objeto se administre correctamente y que se aplican las reglas de validación.
* Considere el caso de uso: El mejor enfoque para la gestión estatal depende de los requisitos específicos de su aplicación. Elija las técnicas que proporcionen el equilibrio adecuado de flexibilidad, seguridad y rendimiento.
* Evite los campos públicos: Exponer directamente los campos como `público" es generalmente una mala práctica. Evite la encapsulación y dificulta controlar y mantener el estado.
* Copia defensiva: Al devolver objetos mutables de Getters, considere devolver una * copia defensiva * para evitar que la persona que llama modifique directamente el estado interno del objeto. Esto es especialmente importante en las clases inmutables.
* Considere usar registros (Java 14+): Los registros son una forma concisa de crear clases de datos inmutables. Generan automáticamente constructores, getters, `iguals ()`, `hashcode ()` y `toString ()`. Son adecuados para representar objetos de transferencia de datos (DTO) o estructuras de datos simples.
En resumen:
La gestión del estado del objeto en Java es un aspecto crítico del diseño orientado a objetos. Al adherirse a principios como encapsulación, inmutabilidad, validación y seguridad del hilo, puede crear aplicaciones robustas, mantenibles y confiables. Las técnicas específicas que elija dependerán de la complejidad de sus objetos y los requisitos de su aplicación.