Joseph Crawford, uno de mis lectores, leyó un artículo sobre cómo no me gusta escribir captadores y definidores y sugirió que podría usar los métodos mágicos __get y __set.
Te diré por qué no es buena idea usarlos de forma normal. También les contaré una historia en la que realmente resultaron útiles: crear tipos estáticos en PHP (un lenguaje dinámico).
Para aquellos que no están familiarizados con los métodos __get y __set, son dos métodos "mágicos" que funcionan así:
clase Animal ( función __get($propiedad) ( //... ) función __set($propiedad, $valor) ( ///... ) ) $vaca = nuevo Animal; $vaca->peso = "1 tonelada"; // igual que $vaca->__set("peso", "1 tonelada") print $vaca->peso; // igual que print $vaca->__get("peso");

Normalmente, los métodos anteriores se utilizan para crear propiedades dinámicas. ¿Qué conclusión se puede sacar de esto? Si desea crear propiedades aleatorias, simplemente use un hash (también conocido como una matriz con claves).
¿Qué tienen de bueno los captadores y definidores?
Echemos un vistazo:
clase Animal ( public $pesoEnKgs; ) $vaca = nuevo Animal; $vaca->pesoEnKgs = -100;

¿Qué? ¿Peso negativo? Esto es incorrecto desde la mayoría de los puntos de vista.
Una vaca no debería pesar menos de 100 kg (eso creo :). Dentro de 1000 es aceptable.
¿Cómo podemos garantizar tal limitación?
Usar __get y __set es una forma bastante rápida.
clase Animal (privado $propiedades = matriz(); función pública __get($nombre) ( if(!empty($this->properties[$name])) ( return $this->properties[$name]; ) else ( lanzar nueva excepción("Propiedad no definida ".$nombre." referenciada." ) ) función pública __set($nombre, $valor) ( ​​if($nombre == "peso") ( if($valor< 100) { throw new Exception("The weight is too small!") } } $this->propiedades[$nombre] = $valor; ) ) $vaca = nuevo Animal; $vaca->pesoEnKgs = -100; //lanza una excepción

¿Qué pasa si tiene una clase con entre 10 y 20 propiedades y las verifica? En este caso, los problemas son inevitables.
función pública __set($nombre, $valor) ( ​​if($nombre == "peso") ( if($valor< 100) { throw new Exception("The weight is too small!") } if($this->peso != $peso) ( Pastor::notifyOfWeightChange($vaca, $peso); ) ) if($nombre == "piernas") ( if($valor != 4) ( throw new Exception("El número de patas es demasiado pequeño o demasiado grande") ) $this->numberOfLegs = $numberOfLegs; $this->numberOfHooves = $numberOfLegs; ) if($name == "milkType") ( ... ya entiendes la idea ... ) $this->properties[$nombre] = $valor; )

Por el contrario, los captadores y definidores están en su mejor momento cuando se trata de validación de datos.
clase Animal ( privado $peso; privado $númeroDePiernas; privado $númeroDePezuñas; público $apodo; función pública setNúmeroDePiernas($númeroDePiernas) ( if ($númeroDePiernas != 100) ( throw new Exception("El número de patas es demasiado pequeño o demasiado grande"); ) $this->numberOfLegs = $numberOfLegs; $this->numberOfHooves = $numberOfLegs; ) función pública getNumberOfLegs() ( return $this->numberOfLegs; ) función pública setWeight($peso) ( if ($peso< 100) { throw new Exception("The weight is too small!"); } if($this->peso != $peso) ( Pastor::notifyOfWeightChange($vaca, $peso); ) $this->peso = $peso; ) función pública getWeight() ( return $this->weight; ) )

Nada se compara con las funciones de acceso directo (obtener, configurar;) de C#. Es probable que este tipo de soporte aparezca pronto en PHP, pero por ahora no nos relajemos...
Cada método es responsable únicamente de su propia área, lo que hace que el código sea más fácil de navegar. Todavía es mucho código, pero es más limpio que la versión __set. Existe un buen enfoque heurístico, que es el siguiente: si su método (función) ocupa más de 1 pantalla, debe acortarlo. Esto hará que el código sea más fácil de leer.
También almacenamos algo de lógica empresarial. Siempre habrá exactamente tantas pezuñas como patas, y si notamos un cambio en el peso del ganado, avisaremos inmediatamente al pastor.
Como no nos importan los apodos de las vacas ni los verificamos, dejemos que los datos sean públicos sin captadores ni definidores.
Nuevamente, realmente no escribí todos estos captadores y definidores: PHP Storm lo hizo por mí. Simplemente escribí lo siguiente:
clase Animal ( privado $peso; privado $númeroDePiernas; )

Y presioné Alt+Insertar -> Captadores y definidores. PHPStorm generó todo automáticamente.
Ahora, como beneficio adicional de PHP Storm, cuando trabajo con captadores y definidores, tengo la posibilidad de utilizar la función de autocompletar:

En el caso de __get no tengo esta opción, solo puedo escribir esto:
$vaca->peso = -100

Ahora la vaca “pesa” (pesos) menos 100 kg.
Puedo olvidar que esto es peso en kg, solo escriba peso y todo funcionará.
Por lo tanto, los captadores y definidores pueden ser muy útiles (pero aun así no los adores, no eres un programador de Java). Si solo quieres propiedades gratuitas, usa una matriz:
$vaca = array("peso" => 100, "piernas" => 4);

Este truco es mucho más fácil de realizar que __get y __set.
Pero, si desea estar seguro de que sus datos siempre tengan solo valores válidos, utilice configuradores con validación. Si tiene un entorno de desarrollo integrado (IDE) como PHP Storm, le encantarán los configuradores porque son muy fáciles de usar. En lugar de $cow->setLegs() para PHP Storm, será suficiente escribir cosl. ¡Sí, fácil! No hay más errores tipográficos y puedes ver qué parámetros toma el método.
El método __set tiene otro inconveniente. Solo acepta 1 parámetro. ¿Y si necesitas 2? Por ejemplo, como aquí: $tienda1->setPrice("artículo-1", 100). Debes fijar el precio del producto en la tienda. El método __set no le permitirá hacer esto, pero el configurador sí.

Implementación de interfaz Colocar Es una colección desordenada que no puede contener datos duplicados.

Interfaz Colocar incluye los siguientes métodos:

Para interactuar con la familia Colocar relatar Conjunto de hash, Conjunto de árboles Y LinkedHashSet. En conjuntos Colocar Diferentes implementaciones utilizan diferentes órdenes de almacenamiento de elementos. En HashSet, el orden de los elementos está optimizado para una búsqueda rápida. El contenedor TreeSet almacena objetos ordenados en orden ascendente. LinkedHashSet almacena elementos en el orden en que fueron agregados.

Conjunto de datos HashSet

Constructores de HashSet:

// Crea un conjunto vacío con una capacidad inicial de 16 y un factor de carga predeterminado de 0,75 public HashSet(); // Creando un conjunto a partir de elementos de la colección public HashSet(Collection c); // Crea un conjunto con la capacidad inicial especificada y // el factor de carga predeterminado (0,75) public HashSet(int initialCapacity); // Crea un conjunto con la capacidad inicial especificada y // el factor de carga public HashSet(int inicialCapacity, float loadFactor);

Métodos HashSet

• tamaño int público()
• booleano público está vacío ()
• agregar booleano público (Objeto o)
• addAll booleano público (Colección c)
• eliminación booleana pública (Objeto o)
• removeAll booleano público (Colección c)
• booleano público contiene (Objeto o)
• vacío público claro()
• Clon de objeto público()
• iterador público iterador()
• Objeto público aArray()
• booleano público retener todo (Colección c)

Conjunto de hash contiene métodos similares a ArrayList. La excepción es el método add(Object o), que sólo agrega un objeto si falta. Si se agrega un objeto, el método add devuelve verdadero; en caso contrario, falso.

Ejemplo de uso de HashSet:

Conjunto de hash hashSet = nuevo HashSet (); hashSet.add("Patatas"); hashSet.add("Zanahoria"); hashSet.add("Remolacha"); hashSet.add("Pepinos"); // La siguiente entrada no debe estar en el conjunto hashSet.add("Patatas"); // Imprime el tamaño establecido en la consola System.out.println("HashSet size = " + hashSet.size()); // Imprime las entradas del iterador en la consola itr = hashSet.iterator(); mientras (itr.hasNext()) ( System.out.println(itr.next().toString()); )

Deberíamos ver sólo 4 entradas en la consola. Cabe señalar que el orden en que se agregan los registros al conjunto será impredecible. Conjunto de hash utiliza hash para acelerar la recuperación.

Ejemplo de uso Conjunto de hash con valores enteros. Agregamos valores del 0 al 9 de 25 posibles valores seleccionados aleatoriamente al conjunto; no habrá duplicación.

Aleatorio aleatorio = nuevo Aleatorio(30); Colocar iset = nuevo HashSet (); para(int i = 0; i< 25; i++) iset.add(random.nextInt(10)); // Вывести в консоль записи Iterator

Cabe señalar que la implementación Conjunto de hash no se sincroniza. Si varios subprocesos acceden a un conjunto de hash simultáneamente y uno o más subprocesos deben modificar el conjunto, entonces se debe sincronizar externamente. Es mejor hacerlo en el momento de la creación para evitar el acceso accidental y no sincronizado al conjunto:

Colocar set = Colecciones.synchronizedSet (nuevo HashSet ());

Conjunto de datos LinkedHashSet

Clase LinkedHashSet hereda Conjunto de hash sin agregar ningún método nuevo, y mantiene una lista vinculada de los elementos del conjunto en el orden en que fueron insertados. Esto permite una iteración ordenada de la inserción en el conjunto.

Constructores LinkedHashSet:

// Crea un conjunto vacío con una capacidad inicial (16) y un valor de factor de carga predeterminado (0,75) public LinkedHashSet() // Crea un conjunto a partir de los elementos de la colección public LinkedHashSet(Collection c) // Crea un conjunto con una inicial especificada capacidad y un valor de factor de carga predeterminado (0,75) public LinkedHashSet(int inicialCapacity) // Crea un conjunto con la capacidad inicial especificada y el factor de carga public LinkedHashSet(int inicialCapacity, float loadFactor)

Así como Conjunto de hash, LinkedHashSet no sincronizado. Por lo tanto, cuando se utiliza esta implementación en una aplicación con muchos subprocesos, algunos de los cuales pueden realizar cambios en el conjunto, la sincronización se debe realizar en la etapa de creación:

Colocar set = Collections.synchronizedSet (nuevo LinkedHashSet ());

Conjunto de datos TreeSet

Clase Conjunto de árboles Crea una colección que utiliza un árbol para almacenar elementos. Los objetos se almacenan en orden ascendente.

Constructores de TreeSet:

// Crear un conjunto de árboles vacío, ordenado según el // ordenamiento natural de sus elementos TreeSet() // Crear un conjunto de árboles que contenga los elementos del conjunto especificado, // ordenados según el orden natural de sus elementos. TreeSet(Colecciónc) // Crea un conjunto de árboles vacío, ordenado según el comparador TreeSet(Comparatorcomparador) // Crea un conjunto de árbol que contiene los mismos elementos y usa // el mismo orden que el conjunto ordenado especificado TreeSet(SortedSet s)

Métodos TreeSet

• adición booleana (Objeto o)
• booleano addAll(ColecciónC)
• Techo de objeto(Objeto o)
• vacío claro()
• Clon de TreeSet()
• Comparadorcomparador()
• booleano contiene (Objeto o)
• Iterador