eredità java contro composizione (implementazione di uno stack)

Question

Sto cercando di implementare uno Stack in Java (utilizzando l'interfaccia elenco: Elenco interfacce ).

Voglio implementarlo in due modi diversi: usando la composizione e l'ereditarietà.

Per eredità, finora ho:

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

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

Per la composizione, ho:

 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
 }

Sono confuso su dove andare da qui. Non ho mai usato un'interfaccia prima, quindi dovrei usare i metodi List per "imitare" una pila, ad esempio utilizzando una matrice o una matrice?

Inoltre, per la composizione, non capisco quali metodi dovrebbero andare in StackComposition e quali dovrebbero andare in StackViaList. Tra interfacce che non comprendono appieno, eredità e composizione, sono un po 'perso. Non riesco proprio a " ottenerlo " Eppure ...

Qualsiasi aiuto sarebbe apprezzato, grazie!

Answer 1

Per la composizione, la classe di stack deve avere un elenco, non implementare o estendere una classe basata su elenco. L'ereditarietà è un "IS A" relazione, mentre la composizione è un "HA A". rapporto.

Ad esempio:

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.
}

Nota che probabilmente vorrai rendere questa una classe generica, piuttosto che occuparti di oggetti grezzi, ma questa sarebbe l'idea.

In questo caso, la soluzione basata sulla composizione è probabilmente preferibile rispetto alla soluzione basata sull'ereditarietà. Quando erediti da una classe / interfaccia, dovresti chiederti: Stack è un elenco? La maggior parte degli stack non dovrebbe fornire all'utente l'accesso a tutti i metodi di elenco non elaborati, quindi è meglio nascondere la faccia che si sta utilizzando un elenco come struttura di dati interna. L'uso di un Elenco composto ti consente di nascondere completamente il fatto che stai utilizzando un Elenco come struttura interna.

Answer 2

Non penso che questa sia una vera domanda. Questo è un "puoi fare i compiti per me" domanda.

Domande più significative sarebbero:

• Qual è la differenza tra eredità e composizione?
• Quali sono i vantaggi / gli svantaggi di implementare uno stack con ciascuno?
• Che cos'è uno stack?

Andy ha dato buone risposte a tutti e tre.

Sfortunatamente, sembra che l'insegnante del poster originale non capisca molto bene i concetti, dato che il compito è privo di senso. Una classe che implementa un java.util.List non è uno stack, o meglio, non è sicuro da usare come uno stack, perché richiede che le operazioni non stack-safe siano pubbliche. Uno stack un'interfaccia piuttosto più limitante di un elenco.

Non c'è da stupirsi che il poster originale sia confuso.

Answer 3

Hai i concetti sottosopra.

Ereditarietà , come dice la parola, quando " prendi " da un oggetto esistente la funzionalità. Questo è noto come relazione IS-A. Ad esempio un veicolo IS-A per camion.

Nel tuo primo esempio questa non è eredità, perché non stai prendendo nulla dall'elenco. Nel tuo campione stai "implementando" tale elenco non " si estende " esso.

Composizione è quando costruisci un oggetto usando altri (stai combinando oggetti). Questo è noto come relazione HAS-A. Ad esempio una ruota Truck HAS-A (ma non è una ruota). Nel tuo campione stai "estendendo" (ereditando) da un altro oggetto

Infine interfaccia in OOP è il "contratto" un oggetto si impegna a compiere. Quali funzioni o messaggi risponderà un oggetto.

In Java "interfaccia" è anche un artefatto in cui sono definiti i metodi a cui risponderà un oggetto.

Quindi, per uno stack dovresti definire i metodi di uno Stack (l'interfaccia)

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

Quindi, utilizzando ereditarietà è possibile creare l'implementazione dello stack. Per fare ciò dovrai estendere (o ereditare) funzionalità da altre classi. Diciamo 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
     }
}

Poiché stai " ereditando " da ArrayList, quasi tutto ciò di cui hai bisogno è già lì. Ma questo rappresenta una relazione IS-A? È vero che una Stack IS-An ArrayList sempre?

Per implementare lo stack usando composizione devi " combinare " il tuo oggetto con un altro.

  /**
   * 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 );
    }
 }

L'implementazione è molto simile, stai utilizzando " aggiungi " e " rimuovi " metodi dall'ArrayList

La differenza è che nel primo caso usando ereditarietà non stai solo usando questi due metodi, ma stai accoppiando il tuo oggetto completamente alla ArrayList stessa (perché hai anche ereditato tutti gli altri metodi e attributo di ArrayList)

Quando usi composizione , non accoppi il tuo oggetto all'arraylist (o l'accoppiamento è basso, il che è una buona cosa) Stai semplicemente usando un altro oggetto per aiutarti a fare il lavoro. In questo caso era un ArrayList.

Dall'esterno (usando la composizione), non vedi all'interno un ArrayList, che nasconde informazioni. L'utente (il client) della tua classe vede solo due metodi disponibili " push " e " pop " e non c'è nient'altro che si possa fare con la tua classe. Sembra un "reale" Stack.

Con l'ereditarietà (usando la parola chiave extends), il client della classe vede anche tutti i metodi da ArrayList sebbene tu possa desiderare che vengano usati solo pop e push, nulla impedisce al client di usare " removeRange " per esempio.

Conclusioni: comprendere le differenze tra le relazioni is-a e has-a è essenziale per la tecnologia OO. Spero che questo ti aiuti.

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();



    }
}