继承模板抽象类C＃

Question

To save myself some writing, you to save you some reading, I constructed a basic example to help me explain what I am trying to achieve.

Say you have a program that uses both a stack class and a queue class, and both classes have the same methods/functions, an optimal choice would probably be to create ab abstract class and inherit it in both classes. If the classes are generic, then the abstract class has to be generic as well. So here's an example of how the abstract class would look like:

public abstract class Sequence <T>
{
    public abstract void push(T value);
    public abstract T pop();
    public abstract T peek();
    public abstract int size();
    public abstract bool isEmpty();
}

And let's assume that the following is the Stack class that'll need to inherit the Sequence class:

public class Stack<T>
{
    private List<T> stk;

    public Stack ()
    {
        stk = new List<T>();
    }

    public void push(T value)
    {
        stk.Add(value);
    }

    public T pop()
    {
        T topValue = peek();
        stk.RemoveAt(size () - 1);
        return topValue;
    }

    public T peek()
    {
        return stk[size() - 1];
    }

    public int size()
    {
        return stk.Count;
    }

    public bool isEmpty()
    {
        return size() == 0;
    }
}

Now, my question is, how would you inherit the Sequence class from Stack ? As you may have noticed already, what I am trying to get right is the syntax, not the functionality of the program. I wasn't able to find a solution that directly applies to my problem.

Answer 1

how would you inherit the Sequence class from Stack?

Not. First thing, you need to turn this around, Stack has to derive from Sequence.

Second point, when Sequence<T> only contains abstract members you might as well make it an interface . More flexible in the long run.

And the actual syntax is not so complicated:

public interface ISequence <T>
{
    void Push(T value);
    T Pop();
    ...
}

public class Stack<T> : ISequence<T>
{    
    public void Push(T value)
    {
        stk.Add(value);
    }
    ...
}

(I changed the capitalization to standard C# conventions)

And the same syntax applies to abstract class Sequence :

public class Stack<T> : Sequence<T> 
{ 
    public override void Push(T value)
    {
        stk.Add(value);
    }
    .... 
}

Answer 2

I made 2 changes to your code:

added override for the methods

The actual inheritance

public class Stack<T> : Sequence<T>
{
    private List<T> stk;

    public Stack()
    {
        stk = new List<T>();
    }

    override public void push(T value)
    {
        stk.Add(value);
    }

    override public T pop()
    {
        T topValue = peek();
        stk.RemoveAt(size() - 1);
        return topValue;
    }

    override public T peek()
    {
        return stk[size() - 1];
    }

    override public int size()
    {
        return stk.Count;
    }

    override public bool isEmpty()
    {
        return size() == 0;
    }
}