herança java contra composição (implementação de uma pilha)

Question

Eu estou tentando implementar uma pilha em java (usando a interface lista: Lista de interface ).

Eu quero implementá-lo de duas maneiras diferentes: usando composição e herança.

Por herança, até agora eu tenho:

 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 a composição, eu tenho:

 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
 }

Estou confuso quanto ao local onde ir a partir daqui. Eu nunca usei uma interface antes, então eu deveria usar os métodos Lista para "imitar" uma pilha, utilizando uma matriz ou um ArrayList por exemplo?

Além disso, para a composição, eu não entendo o que os métodos devem ir para StackComposition eo que deve entrar em StackViaList. Entre as interfaces não totalmente compreensão, bem como herança e composição, eu estou um pouco perdido. Eu não posso parecem apenas "pegar" ainda ...

Qualquer ajuda seria apreciada, obrigado!

Answer 1

Para a composição, a classe pilha deve ter uma lista, não implementar ou estender uma classe baseado em lista. A herança é um "é um" relacionamento, ao passo que a composição é um "tem um" relacionamento.

Por exemplo:

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

Note que você provavelmente iria querer fazer isto uma classe genérica, ao invés de lidar com objetos crus, mas isso seria a idéia.

Neste caso, a solução de base de composição é provavelmente preferível através da solução à base de herança. Quando você herdar de uma classe / interface, você deve perguntar a si mesmo, é o Stack uma lista? A maioria das pilhas não deve fornecer ao usuário o acesso a todos os métodos Lista matérias, por isso é melhor para esconder o rosto que você está usando uma lista como a estrutura de dados interna. Usando uma lista composta permite ocultar completamente o fato de que você está usando uma lista como a estrutura interna.

Answer 2

Eu não acho que isso é uma questão real. Este é um "você pode fazer minha lição de casa para mim" pergunta.

perguntas mais significativa seria:

• O que é a diferença entre herança e composição?
• Quais são as vantagens / desvantagens da implementação de uma pilha com cada um?
• O que é uma pilha?

Andy deu boas respostas para todos os três.

Infelizmente, parece que o professor do cartaz original não compreender os conceitos muito bem a si mesmo, uma vez que a atribuição é absurdo. Uma classe que implementa uma java.util.List não é uma pilha, ou melhor, não é seguro para uso como uma pilha, porque requer que as operações de não-pilha segura públicas. Uma pilha de uma interface um pouco mais limitante do que uma lista.

Não admira que o autor original é confuso.

Answer 3

Você tem os conceitos de cabeça para baixo.

Inheritance , como a palavra diz é quando você "tomar" a partir de um objeto existente a funcionalidade. Esta é conhecida como relação é-um. Por exemplo, um caminhão IS-A Veículo.

Na sua primeira amostra que não é herança, porque você não está tomando nada da lista. Em sua amostra você está "de execução" não essa lista "estendendo-lo".

Composição é quando você cria um objeto usando outros (você está combinando objetos). Este é saber como tem-um relacionamento. Por exemplo, um caminhão TEM-A roda (mas não é uma roda). Em sua amostra você está "ampliando" (herdar) a partir de outro objeto

Finalmente Interface em OOP é o "contrato" um objeto está empenhada em cumprir. Que funções ou mensagens de um objeto irá responder.

Em Java "interface" é também um artefato onde os métodos de um objeto irá responder são definidos.

Assim, para uma pilha você teria que definir os métodos de uma pilha tem (a interface)

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

Em seguida, usando herança você pode criar a implementação da pilha. Para fazer isso você vai ter que estender (ou herdar) funcionalidade de outra classe. Vamos dizer 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
     }
}

Uma vez que você está "herdar" de ArrayList, mais do que você precisa já está lá. Mas, será que isso representa um IS-A relatioship? É verdade que uma pilha é-An ArrayList sempre?

Para implementar a pilha usando composição você tem que "combinar" o seu objeto com outro.

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

A implementação é muito semelhante, você está usando "Adicionar" e "Remover" métodos de ArrayList

A diferença é o no primeiro caso, utilizando herança você não está apenas usando estes dois métodos, mas você está acoplando seu objeto completamente ao próprio ArrayList (porque você também tem herdar todos os outros métodos e atribuem o ArrayList tem)

Quando você usa composição , você não par o seu objeto para o ArrayList (ou o acoplamento é baixa, o que é uma coisa boa) Você está simplesmente usando outro objeto para ajudá-lo a fazer o trabalhos. Neste caso, foi um ArrayList.

Do lado de fora (usando composição), você não vê há um dentro ArrayList, que a informação do esconderijo. O usuário (o cliente) de sua classe ver apenas dois métodos disponíveis "push" e "pop" e não há nada mais que poderia ser feito com a sua classe. Parece um "real" Stack.

Com a herança (usando estende palavra-chave), o cliente da classe ver também todos os métodos de ArrayList embora você pode querer que apenas pop e empurrar são usados, previne nada do cliente para usar 'removeRange', por exemplo.

Conclusão: Entender as diferenças entre é-a e tem-um relacionamento é essencial para a tecnologia OO. Espero que isso ajuda você.

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



    }
}