herencia de Java versus composición (implementación de una pila)

Question

Estoy tratando de implementar una pila en Java (usando la interfaz de la lista: Lista de interfaces ).

Quiero implementarlo de dos maneras diferentes: usando composición y herencia.

Por herencia, hasta ahora tengo:

 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;

 public class StackInheritance implements List {
      //implement list methods
 }

Para la composición, tengo:

 import java.util.List;

 public abstract class StackComposition implements List {
     // implement some standard methods
 }

 public class StackViaList extends StackComposition {
     // implement methods that have not been implemented in the abstract
     // class
 }

Estoy confundido en cuanto a dónde ir desde aquí. Nunca he usado una interfaz antes, así que se supone que debo usar los métodos de Lista para "imitar". una pila, usando un Array o un ArrayList por ejemplo?

Además, para la composición, no entiendo qué métodos deberían ir a StackComposition y qué debería ir a StackViaList. Entre no entender completamente las interfaces, así como la herencia y la composición, estoy un poco perdido. Parece que no puedo simplemente "obtenerlo" todavía ...

Cualquier ayuda sería apreciada, ¡gracias!

Answer 1

Para la composición, la clase de pila debe TENER una lista, no implementar o extender una clase basada en Lista. La herencia es un " ES A " relación, mientras que la composición es un '' TIENE A '' relación.

Por ejemplo:

public class StackWithComposition
{
    // StackWithComposition HAS A List (rather than IS A List)
    private List myList = new ArrayList();

    public void push(object item)
    {
        // add item to myList, etc.
    }

    public object pop()
    {
        // return item at top (or end) of myList
    }

    // etc.
}

Tenga en cuenta que probablemente desee hacer de esta una clase genérica, en lugar de tratar con objetos sin procesar, pero esta sería la idea.

En este caso, la solución basada en la composición es probablemente preferible a la solución basada en la herencia. Cuando hereda de una clase / interfaz, debe preguntarse, ¿es el Apilar una lista? La mayoría de las Pilas no deberían proporcionar al usuario acceso a todos los métodos de Lista sin procesar, por lo que es mejor ocultar la cara que está usando una Lista como estructura de datos interna. El uso de una Lista compuesta le permite ocultar completamente el hecho de que está usando una Lista como estructura interna.

Answer 2

No creo que esta sea una pregunta real. Esta es una "¿puedes hacer mi tarea por mí"? pregunta.

Las preguntas más significativas serían:

• ¿Cuál es la diferencia entre herencia y composición?
• ¿Cuáles son las ventajas / desventajas de implementar una pila con cada una?
• ¿Qué es una pila?

Andy dio buenas respuestas a los tres.

Desafortunadamente, parece que el maestro del afiche original no comprende muy bien los conceptos, ya que la tarea no tiene sentido. Una clase que implementa una java.util.List no es una pila, o más bien, no es segura de usar como una pila, porque requiere que las operaciones no aptas para la pila sean públicas. Una pila es una interfaz bastante más limitante que una lista.

No es de extrañar que el póster original esté confundido.

Answer 3

Tienes los conceptos al revés.

Herencia , como dice la palabra es cuando usted "toma" de un objeto existente la funcionalidad. Esto se conoce como relación IS-A. Por ejemplo, un camión IS-A vehículo.

En su primera muestra eso no es herencia, porque no está tomando nada de la lista. En su muestra está "implementando" esa lista no se extiende eso.

Composición es cuando construyes un objeto usando otros (estás combinando objetos). Esto se conoce como relación HAS-A. Por ejemplo, una rueda Truck HAS-A (pero no es una rueda). En su muestra, usted está "extendiendo" (heredando) de otro objeto

Finalmente, la interfaz en OOP es el " contrato " un objeto se compromete a cumplir. Qué funciones o mensajes responderá un objeto.

En Java " interfaz " también es un artefacto donde se definen los métodos que responderá un objeto.

Entonces, para una pila, tendría que definir los métodos que tiene una pila (la interfaz)

public interface Stack {
     public void push( Object o );
     public Object pop();
}

Luego, usando herencia puede crear la implementación de la pila. Para hacer esto, tendrá que extender (o heredar) la funcionalidad de otra clase. Digamos ArrayList

 /**
  * Sample stack implementation using inheritance
  */
public class ArrayListStack extends ArrayList implements Stack {
// you use the keyword extends because you're inheriting from ArrayList
// and the keyword implements because you claim to respond to push and pop methods.

     public void push( Object o ) {
          this.add( o ); // add inherited from ArrayList
     }
     public Object pop() {
         return this.remove( this.size() -1 ); // remove inherited from ArrayList
     }
}

Como estás " heredando " de ArrayList, la mayoría de lo que necesita ya está allí. Pero, ¿esto representa una relación IS-A? ¿Es cierto que un Stack IS-An ArrayList siempre?

Para implementar la pila utilizando composición , debe "combinar". tu objeto con otro.

  /**
   * Sample stack implementation using composition
   */ 
 public class ComposedStack  implements Stack {
      // you didn't extend anything here

      // But you'll need another object to help you 
      // to do the work.
      private ArrayList holder = .... // Should be declared as List holder = ....


    public void push( Object o ) {
         this.holder.add( o );
    }

    public Object pop() {
        return this.holder.remove( this.holder.size() -1 );
    }
 }

La implementación es muy similar, estás usando " add " y " eliminar " métodos de la ArrayList

La diferencia es que, en el primer caso, al usar herencia , no solo está usando estos dos métodos, sino que está acoplando su objeto completamente a la propia ArrayList (porque también ha heredado todos los demás métodos , y atribuirle a ArrayList)

Cuando usas composición , no acoplas tu objeto a la lista de arrays (o el acoplamiento es bajo, lo cual es bueno) Simplemente estás usando otro objeto para ayudarte a hacer trabajo. En este caso era una ArrayList.

Desde afuera (usando la composición), no ves que hay una ArrayList adentro, eso es ocultar información. El usuario (el cliente) de su clase solo ve dos métodos disponibles '' empujar '' y "pop" y no hay nada más que se pueda hacer con tu clase. Parece un "real" Pila.

Con la herencia (usando la palabra clave extend), el cliente de la clase también ve todos los métodos de ArrayList aunque puede querer que solo se usen pop y push, nada impide que el cliente use " removeRange " por ejemplo.

Conclusión: Comprender las diferencias entre las relaciones is-a y has-a es esencial para la tecnología OO. Espero que esto te ayude.

Answer 4

class stack
{

    int n,item,top;
    public stack()
    {
        n=7;
        top=-1;
    }}
    class student extends stack
    {
    int [] stk=new int[4];
    public void insert(int a)
    {
        if(top>=n-1)
        System.out.println("over flow");
        else
        {
            top++;
            stk[top]=a;
        }   
    }
        public void deletestk()
    {
        if(top<0)
            System.out.println("under flow");
            else
            {
                item=stk[top];
                top--;
                    System.out.println("deleted item are"+item);
            }
    }
        public void destroy()
    {
        if(top<0)
            System.out.println("under flow");
            else
            {

            top=-1;
    }
    }
    public void view()
    {
        int i;
        i=top;
        while(i>=0)
        {
                System.out.println(stk[i]);
                i--;
        }
    }   

    }
    class stackfloat extends stack
    {

        float [] stk=new float[6];
    }
    class stkstring extends stack
    {
        String [] stk=new String[5];
    }
    class stackmain
{
    public static void main(String arg[])
    {
        stack ob=new stack();
        student obj=new student();
            obj.deletestk();
        obj.insert(5);
            obj.insert(6);
                obj.insert(64);
                    obj.insert(45);
                        obj.insert(3);
                        obj.view();
                        obj.deletestk();
                        obj.view();
                        obj.destroy();
                        obj.view();



    }
}