我有一個預編譯錯誤

Question

這是作業：

修改第4章中的迷宮問題，使其可以從用戶定義的起始位置（0、0除外）開始並搜索用戶定義的終點。

整個程序看起來似乎不錯，但是我仍然必須弄亂用戶輸入的部分，但是只有一行出現錯誤，我不知道該如何擺脫它。 任何幫助，將不勝感激。

有錯誤的行是： StackADT stack = new LinkedStackADT（）; 它告訴我LinkedStackADT無法解析為一種類型。

另外，如何使迷宮進入用戶定義的起點和終點？ 感謝您的任何幫助！

public class Maze
{

public interface StackADT<T>  {

    public void push (T element);

    public T pop();

    public T peek();

    public boolean isEmpty();

    public int size();

    public String toString();
}

public static void main(String[] args){

abstract class LinkedStack<T> implements StackADT<T>
{
    private int count;      
    private LinearNode<T> top;

    public LinkedStack()
    {
        count = 0;          
        top = null;     
    }

    class LinearNode<T>
    {
        private LinearNode<T> next;
        private T element;

        public LinearNode()
        {
            next = null;
            element = null;
        }

        public LinearNode(T elem)
        {
            next = null;
            element = elem;
        }

        public LinearNode<T> getNext()
        {
            return next;
        }

        public void setNext(LinearNode<T> node)
        {
            next = node;
        }

        public T getElement()
        {
            return element;
        }


        public void setElement(T elem)
        {
            element = elem;
        }
    }

    class Position 
    {
        private int x; 
        private int y;

        Position ()
        {
            x = 0;
            y = 0;
        }

        public int getx()
        {
            return x;
        }

        public int gety()
        {
            return y;
        }

        public void setx1(int a)
        {
            x = a;
        }

        public void sety(int a)
        {
            y = a;
        }

        public void setx(int x2) {

        }
    }

private final int TRIED = 3;

private final int PATH = 7;

private int [][] grid = {{1,1,1,0,1,1,0,0,0,1,1,1,1},
                        {1,0,0,1,1,0,1,1,1,1,0,0,1},
                        {1,1,1,1,1,0,1,0,1,0,1,0,0},
                        {0,0,0,0,1,1,1,0,1,0,1,1,1},
                        {1,1,1,0,1,1,1,0,1,0,1,1,1},
                        {1,0,1,0,0,0,0,1,1,1,0,0,1},
                        {1,0,1,1,1,1,1,1,0,1,1,1,1},
                        {1,0,0,0,0,0,0,0,0,0,0,0,0},
                        {1,1,1,1,1,1,1,1,1,1,1,1,1}};

public StackADT<Position> push_new_pos(int x, int y,
                                        StackADT<Position> stack)
{
Position npos = new Position();
    npos.setx1(x);
    npos.sety(y);
    if (valid(npos.getx(),npos.gety()))
        stack.push(npos);
    return stack;
}

public boolean traverse ()
{
    boolean done = false;
    Position pos = new Position();
    Object dispose;
    StackADT<Position> stack = new LinkedStackADT<Position> ();
    stack.push(pos);

    while (!(done))
    {
        pos = stack.pop();
        grid[pos.getx()][pos.gety()] = TRIED; // this cell has been tried
        if (pos.getx() == grid.length-1 && pos.gety() == grid[0].length-1)
            done = true; // the maze is solved
        else
{
            stack = push_new_pos(pos.getx(),pos.gety() - 1, stack);
            stack = push_new_pos(pos.getx(),pos.gety() + 1, stack);
            stack = push_new_pos(pos.getx() - 1,pos.gety(), stack);
            stack = push_new_pos(pos.getx() + 1,pos.gety(), stack);
        }
    }
    return done;
}

private boolean valid (int row, int column)
{
    boolean result = false;
    if (row >= 0 && row < grid.length &&
            column >= 0 && column < grid[row].length)
        if (grid[row][column] == 1)
            result = true;

    return result;
}

public String toString ()
{
    String result = "\n";

    for (int row=0; row < grid.length; row++)
    {
        for (int column=0; column < grid[row].length; column++)
        result += grid[row][column] + "";

    result += "\n";
    }
    return result;
}


}
}
}

Answer 1

您沒有定義為LinkedStackADT的類型（或類）。 您確實有一個LinkedStack類型，但是它是抽象類型，因此new將失敗。 如果從LinkedStack刪除abstract關鍵字，則它應該是可實例化的。 （注意：可實例化不是一個真實的詞）