我有一个预编译错误

Question

Here is the assignment:

Modify the maze problem in Chapter 4 so that it can start from a user defined starting position (other than 0, 0) and search for a user defined ending point.

The whole program seems to look fine, and I still have to mess with the user-inputted part, but there is one line that has an error and I don't know how to get rid of it. Any help would be appreciated.

The line that has the error is: StackADT stack = new LinkedStackADT (); And it is telling me that LinkedStackADT cannot be resolved to a type.

Also, how do I get the maze to take in user-defined starting positions and ending points? Thanks for any possible help!

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

You don't have a type (or a class) defined as LinkedStackADT . You do have a type LinkedStack , but it's abstract so the new will fail. If you remove the abstract keyword from LinkedStack , it should be instantiatable. (note: instantiatable is not a real word)