2009-09-13 79 views
3

我想在java中实现堆栈(使用列表界面:Interface List)。Java继承与组合(实现堆栈)

我想实现它两种不同的方式:使用组合和继承。

对于继承,所以到目前为止,我有:

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

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

对于成分,我有:

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 
} 

我很困惑,哪里何去何从。我之前从未使用过接口,所以我应该使用List方法来“模仿”堆栈,例如使用Array或ArrayList?

此外,对于组成,我不明白什么方法应该进入StackComposition和什么应该进入StackViaList。在不完全理解接口以及继承和组合之间,我有点失落。我似乎无法“得到它”呢...

任何帮助将不胜感激,谢谢!

+3

家庭作业,对吧? – cletus 2009-09-13 23:37:07

回答

9

对于组合,栈类应该有一个列表,而不是实现或扩展一个基于列表的类。继承是一个“是”关系,而组合是一个“有一个”关系。

例如:

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

请注意,你可能会想这样做一个泛型类,而不是处理原始对象,但是这将是想法。

在这种情况下,基于组合的解决方案可能比基于继承的解决方案更可取。当你从一个类/接口继承时,你应该问自己,堆栈是一个列表?大多数Stacks不应该为用户提供对所有原始List方法的访问,所以最好隐藏使用List作为内部数据结构的面。使用组合列表可以让你完全隐藏你使用List作为内部结构的事实。

+0

Andy- 感谢您的帮助。我明白你的意思了。我已经实现了继承和组合的堆栈。我看到所有的原始List方法都必须包含继承,而这对于堆栈而言是毫无意义的。谢谢 :) – littleK 2009-09-14 00:16:59

2

我不认为这是一个真正的问题。这是一个“你能为我做作业吗”的问题。

更多有意义的问题是:

  • 是什么继承和组合之间的区别?
  • 与每个实现堆栈有什么优点/缺点?
  • 什么是堆栈?

Andy对这三个人都给出了很好的答案。

不幸的是,它看起来像原来的海报的老师自己不太了解这个概念,因为这个任务是无意义的。实现java.util.List的类不是堆栈,或者说,作为堆栈使用并不安全,因为它要求非堆栈安全操作是公共的。堆栈比列表更具限制性。

难怪原始的海报很混乱。

1

你有概念颠倒。

继承,正如这个词所说的那样,当你从一个现有对象中“获取”这个功能。这被称为IS-A关系。例如卡车IS-A车辆。

在你的第一个不是继承的例子中,因为你没有从列表中取出任何东西。在您的示例中,您正在“实施”该列表不是“扩展”它。

构图是当你使用他人(你正在组合对象)建立一个对象。这被称为HAS-A关系。例如卡车HAS-A车轮(但不是车轮)。在您的示例中,您正在“扩展”(继承)其他对象

最后OOP中的接口是对象承诺履行的“合同”。对象将响应什么函数或消息。

在Java中,“接口”也是定义对象响应的方法的工件。

因此,对于栈你将不得不然后,使用继承您可以创建堆栈实现定义一个协议栈所拥有的方法(接口)

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

。要做到这一点,你必须扩展(或继承)其他类的功能。我们假设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 
    } 
} 

由于您是从ArrayList“继承”,所以大部分您所需要的已经存在。但是,这是否代表IS-A关系?一个Stack IS-ArrayList总是这样吗?

要使用构图来实现堆栈,您必须将对象与另一个“结合”。

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

的实施是非常相似的,你使用“添加”,从ArrayList中

所不同的是“删除”方法使用继承你不仅使用这些第一案两种方法,但是你完全将你的对象耦合到ArrayList本身(因为你也继承了所有其他方法,并且属性ArrayList具有)

当您使用组合时,您不会将对象arrayl ist(或耦合很低,这是一件好事)您只是使用另一个对象来帮助您完成这项工作。在这种情况下,它是一个ArrayList。

从外部(使用合成),你没有看到里面有一个ArrayList,这是信息隐藏。你的课程的用户(客户端)只能看到两种可用的“推”和“流行”方法,而你的课堂上没有什么可以做的。它看起来像一个“真正的”堆栈。

对于继承(使用extends关键字),类的客户端也会看到ArrayList中的所有方法,尽管您可能希望只使用弹出和推式,但并不妨碍客户端使用“removeRange”。

结论:了解is-a和has-a关系之间的差异对于OO技术是必不可少的。我希望这对你有所帮助。

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



    } 
}