Definición compuesta: Organice objetos en una estructura de árbol para lograr una jerarquía "parcial", de modo que el cliente tenga un uso constante de objetos individuales y objetos combinados.
El compuesto es más fácil de entender. Estos objetos en el cuerpo de composición tienen una interfaz común. Se puede describir como tirar de cien movimientos.
Por lo tanto, el modo compuesto utiliza el modo Iterator, que es similar a la cadena de responsabilidad.
Beneficios compuestos:
1. Simplemente las llamadas del cliente, y el cliente puede usar una estructura de combinación o un solo objeto de manera consistente. código.
2. Es más fácil agregar partes de objetos al cuerpo de combinación. El cliente no tiene que cambiar el código porque ha agregado un nuevo componente de objeto.
Cómo usar compuesto
Primero, defina una interfaz o clase abstracta. Administración de composiciones compuestas.
El siguiente código se define como una clase abstracta y generalmente intenta usar la interfaz tanto como sea posible.
La copia del código es la siguiente:
Equipo de clase abstracta pública {
nombre de cadena privada;
// Precio de Internet
Public Abstract Double NetPrice ();
// precio de descuento
Public Abstract Double DiscountPrice ();
// Añadir método de piezas
Public Boolean ADD (Equipo Equipo) {return false;
// Eliminar el método de pieza
Public Boolean Remover (Equipo Equipo) {return false;
// Tenga en cuenta aquí, aquí hay un método para acceder a clases de componentes.
public Iterator iter () {return null;
Equipo público (nombre de cadena final) {this.name = name;
}
El equipo de clase abstracta es la definición de componente, que representa los objetos de la clase compuesta, y varios métodos comunes se definen en el equipo.
La copia del código es la siguiente:
El disco de clase pública extiende el equipo {
disco público (nombre de cadena) {super (nombre);
// Definir el precio de la red de disco a 1
Public Double NetPrice () {return 1.;
// Definir que el precio de descuento del disco es de 0.5% de descuento.
Public Double DiscountPrice () {return .5;
}
El disco es un objeto, o un componente, en el cuerpo de combinación, que es un solo elemento (primitivo).
Otra posibilidad es que un componente también sea una combinación, es decir, hay un 'hijo' bajo este componente. Ahora necesitamos definir esta combinación:
La copia del código es la siguiente:
Abstract Class Composseequipment extiende el equipo {
privado int i = 0;
// Defina un vector para almacenar 'hijo'
Equipo LSIT privado = new ArrayList ();
public composteequipment (nombre de cadena) {super (nombre);
Public Boolean Add (Equipo Equipment) {
this.equipment.add (equipo);
devolver verdadero;
}
Public Double NetPrice () {
Doble netprice = 0.;
Iterator iter = Equip.Iterator ();
para (iter.hasnext ())
netPrice+= ((equipo) iter.next ()). netPrice ();
devolver netprice;
}
public Double DiscountPrice () {
Double descuentoPrice = 0.;
Iterator iter = Equip.Iterator ();
para (iter.hasnext ())
descuentoPrice+= ((equipo) iter.next ()). DiscountPrice ();
devolver descuento -price;
}
// Tenga en cuenta aquí, aquí hay un método para acceder a componentes en su propia combinación.
// La razón por la cual el disco anterior no existe es porque el disco es un elemento único.
public Iterator Iter () {
devolver equipo.iterator ();
}
// sobrecarga el método de iterador
public boolean Hasnext () {return i <equipo.size ();
// sobrecarga el método de iterador
Objeto público Next () {
if (hasnext ())
devolución de equipos.Elementat (i ++);
demás
tirar nueva nosuchelementException ();
}
}
El compositor de composición anterior hereda el equipo y proporciona métodos de acceso externos para los objetos dentro de él, la sobrecarga de iterador es una interfaz de Java Collection y una implementación del patrón de iterador.
Echemos un vistazo a las dos categorías específicas de compositeo: chasis de caja de disco y gabinete de caja. caja, como la unidad de disquete de disco duro, etc. Sin lugar a dudas, ambos son de combinación.
La copia del código es la siguiente:
Chasis de clase pública extiende Compossiceequipment {
chasis público (nombre de cadena) {super (nombre);
public Double NetPrice () {return 1.+super.netprice ();
Public Double DiscountPrice () {return .5+super.discountPrice ();
}
El gabinete de clase pública extiende Composseequipment {
gabinete público (nombre de cadena) {super (nombre);
public Double NetPrice () {return 1.+super.netprice ();
Public Double DiscountPrice () {return .5+super.discountPrice ();
}
Hasta ahora hemos completado la arquitectura de todo el modelo compuesto.
Podemos ver el código de la composición de la llamada del cliente:
La copia del código es la siguiente:
Gabinete gabinete = nuevo gabinete ("torre");
Chasis chasis = nuevo chasis ("chasis de PC");
// Inserte el chasis de PC en la torre (empaque el disco en la caja)
gabinet.add (chasis);
// Inserte un disco duro de 10 GB al chasis de PC (instale el disco duro en la caja de disco)
chassis.add (nuevo disco ("10 GB"));
// llamando al método netPrice ();
System.out.println ("netPrice ="+gabinet.netprice ());
System.out.println ("descuento ="+gabinet.discountPrice ());
Los métodos llamados anteriormente son NetPrice () o DiscountPrice ().
El compuesto es un modelo muy inteligente que encarna la sabiduría.
Tomando el foro como ejemplo, hay muchas publicaciones (mensajes) en una versión (foro). , por lo que ingresamos a Jive, eche un vistazo a cómo se implementa.
Anatomía
En Jive, Forumthread es un contenedor de contenedores (combinación) de forummessages. Es decir, ForumThread es similar al Compositeequipment en nuestro ejemplo anterior.
La copia del código es la siguiente:
[hilo]
|- [Mensaje]
|- [Mensaje]
|- [Mensaje]
|- [Mensaje]
|- [Mensaje]
Vemos el siguiente código en Forumthread:
La copia del código es la siguiente:
interfaz pública Forumthread {
....
Public Void AddMessage (para un montaje de parentmessage, forumsage Newmessage)
lanza no autorizadoxception;
Public void DeletEmessage (mensaje de paraummera)
lanza no autorizadoxception;
Mensajes públicos de Iterator ();
....
}
Similar a Composseequipment, proporciona métodos para acceder a componentes en su propio cuerpo combinado: agregar, eliminar y recorrer.
Basado en mi análisis de Jive en otros modelos, básicamente hemos entendido el marco del sistema de foro Jive. .