第一年的prgorammer需要java中nullpointer异常的帮助

作为第一年作业的一部分，我需要创建一个类，该类使用提供的链表实现来实现提供的堆栈接口，然后由另一个提供的类进行测试。我能够使用自己的LL轻松完成作业；但是，有人告诉我，我需要使用提供的那个

Exception in thread "main" java.lang.NullPointerException
    at StackLL.<init>(StackLL.java:21)
    at StackTester.main(StackTester.java:91)

测试仪

StackTester.java

    /**
 * StackTester.java
 *
 * Some test cases for a stack.
 */
public class StackTester
{
    public static void testOne (Stack s)
    {
        try
        {
            if (s.size() != 0 || !s.isEmpty())
                System.out.println("1: Failed size or isEmpty.");
            s.push(1);
            s.push(2);

            if (s.size() != 2 || s.isEmpty())
                System.out.println("2: Failed size or isEmpty.");

            if (!(s.pop() == 2))
                System.out.println("3: Failed pop");

            if (!(s.peek() == 1))
                System.out.println("4: Failed peek");

            if (!(s.pop() == 1))
                System.out.println("5: Failed pop");

            if (s.size() != 0 || !s.isEmpty() )
                System.out.println("6: Failed size or isEmpty.");
        }
        catch (StackEmptyException e)
        {
            System.out.println(e);
        }   
    }

    public static void testTwo (Stack s)
    {
        try
        {       
            for (int i = 0; i < 100; i++)
            {
                s.push(i);
            }

            if (s.size() != 100)
                System.out.println("7: Failed size.");

            for (int i = 99; i >= 0; i--)
            {
                if (!(s.pop() == i))
                {
                    System.out.println("Failed pop for: " + i);
                    break;
                }   
            }
        }
        catch (StackEmptyException e)
        {
            System.out.println("Failed testTwo.");
            System.out.println(e);
        }   
    }

    public static void testThree (Stack s)
    {
        try {
            while (!s.isEmpty())
                s.pop();
        }
        catch (StackEmptyException e) {
            System.out.println ("Failed empty stack test (popped on a non empty stack threw exception)");
        }

        try
        {
            s.pop();
            System.out.println("Failed empty stack test.");
        }
        catch (StackEmptyException e)
        {
            /* If we get here, we 
             * passed the previous test.
             */
        }
    }

    public static void main (String args[])
    {
        Stack s1 = new StackLL();
        Stack s2 = new StackLL();
        Stack s3 = new StackLL();

        testOne(s1);
        testTwo(s2);
        testThree(s3);
    }
}

/**
*StackTester.java
*
*堆栈的一些测试用例。
*/
公共类堆栈测试器
{
公共静态void testOne（堆栈）
{
尝试
{
如果（s.size（）！=0 | |！s.isEmpty（））
System.out.println（“1：大小失败或为空”）；
s、 推（1）；
s、 推（2）；
如果（s.size（）！=2 | | s.isEmpty（））
System.out.println（“2：大小失败或为空”）；
如果（！（s.pop（）==2））
System.out.println（“3：失败的pop”）；
如果（！（s.peek（）==1））
System.out.println（“4：peek失败”）；
如果（！（s.pop（）==1））
System.out.println（“5：失败的pop”）；
如果（s.size（）！=0 | |！s.isEmpty（））
System.out.println（“6：大小失败或为空”）；
}
捕获（StackEmptyException e）
{
系统输出打印ln（e）；
}   
}
公共静态void testTwo（堆栈）
{
尝试
{       
对于（int i=0；i<100；i++）
{
s、 推（i）；
}
如果（s.size（）！=100）
System.out.println（“7：失败的大小”）；
对于（int i=99；i>=0；i--）
{
如果（！（s.pop（）==i））
{
System.out.println（“针对：+i的失败弹出窗口”）；
打破
}   
}
}
捕获（StackEmptyException e）
{
System.out.println（“失败的testTwo”）；
系统输出打印ln（e）；
}   
}
公共静态无效测试三（堆栈）
{
试一试{
而（！s.isEmpty（））
s、 pop（）；
}
捕获（StackEmptyException e）{
System.out.println（“空堆栈测试失败（在非空堆栈引发异常时弹出）”；
}
尝试
{
s、 pop（）；
System.out.println（“空堆栈测试失败”）；
}
捕获（StackEmptyException e）
{
/*如果我们到了这里，我们
*通过了先前的测试。
*/
}
}
公共静态void main（字符串参数[]）
{
Stack s1=新StackLL（）；
Stack s2=新StackLL（）；
Stack s3=新StackLL（）；
测试一（s1）；
试验二（s2）；
测试三（s3）；
}
}

查看错误消息中给出的代码行（我假设它是

size（）

函数中的return语句），并思考NullPointerException的含义--null的变量尚未初始化。然后问问你自己，我是否希望这个变量在这里初始化？如果是，那么询问为什么不是，应该在哪里初始化？如果没有，那么您在给定的位置有一个逻辑错误。

查看错误消息中给出的代码行（我假设它是

size（）

函数中的return语句），并思考NullPointerException的含义——null的变量尚未初始化。然后问问你自己，我是否希望这个变量在这里初始化？如果是，那么询问为什么不是，应该在哪里初始化？如果否，则在给定位置存在逻辑错误。

您有

私有LinkedList值在StackLL中

这表示“这个类有一个名为
values
的字段，类型为
LinkedList
”。它不会将对象分配给
值
，因此当您尝试访问它时，会发生NullPointerException

您应该能够通过为
值指定一个值来修复它，即：

private LinkedList value=new LinkedList（）

（我不知道您是否已经了解了泛型，但是如果已经了解了，请记住添加类型，例如
LinkedList
）
您有
私有LinkedList值在StackLL中

这表示“这个类有一个名为
values
的字段，类型为
LinkedList
”。它不会将对象分配给
值
，因此当您尝试访问它时，会发生NullPointerException

您应该能够通过为
值指定一个值来修复它，即：

private LinkedList value=new LinkedList（）

（我不知道您是否已经了解了泛型，但如果已经了解，请记住添加类型，例如，
LinkedList
）
您从未在StackLL中实例化LinkedList对象。因此，当您第一次尝试访问它时，它会破坏NPE。
您从未在StackLL中实例化LinkedList对象。因此，当您第一次尝试访问它时，它会导致NPE崩溃。
在NullPointerExceptions中，您将看到它发生的地方。这将帮助您和我们解决问题：）谢谢链接。不幸的是，通过列出的步骤让我更加不知道到底出了什么问题。计数应初始化为0，因此不应指向null。我尝试使用nullpointer异常来捕获这个案例；然而，我只是以另一个nullpointer错误结束。在NullPointerException中，您将看到它发生的那一行。这将帮助您和我们解决问题：）谢谢链接。不幸的是，通过列出的步骤让我更加不知道到底出了什么问题。计数应初始化为0，因此不应指向null。我尝试使用nullpointer异常来捕获这个案例；然而，我只是得到了另一个空指针错误
/**
 * A linked list implementation of the Stack ADT.
 *
 */

public class StackLL implements Stack
{
    // The linked list that will contain the values in the stack
    private LinkedList values;

    public int size()
    {
        return values.size();
    }

    public boolean isEmpty()
    {
        if (values.size() <= 0) {
            return true;
        }
        return false;
    }

    public void push(int element)
    {
        values.addToStart(element);
    }

    public int pop() throws StackEmptyException
    {
        if (values.size() == 0) {
            throw new StackEmptyException();
        }
        else {
            return values.removeFromStart();
        }
    }
    public int peek() throws StackEmptyException
    {
        if (values.size() == 0) {
            throw new StackEmptyException();
        }
        else { //This is a pretty silly way to do this, but I can't think of any other way without making my own linked list method.
            int elementVal = values.removeFromStart();
            values.addToStart(elementVal);
            return elementVal;
        }
    }
}

/**
 * Stack.java
 *
 * A specification of the Stack ADT
 *
 */
public interface Stack
{
    int size();
    boolean isEmpty();
    void push (int element);
    int pop() throws StackEmptyException;
    int peek() throws StackEmptyException;
}

class StackEmptyException extends Exception
{
    public StackEmptyException ()
    {
        super();
    }

    public StackEmptyException (String s)
    {
        super(s);
    }
}

    /**
 * StackTester.java
 *
 * Some test cases for a stack.
 */
public class StackTester
{
    public static void testOne (Stack s)
    {
        try
        {
            if (s.size() != 0 || !s.isEmpty())
                System.out.println("1: Failed size or isEmpty.");
            s.push(1);
            s.push(2);

            if (s.size() != 2 || s.isEmpty())
                System.out.println("2: Failed size or isEmpty.");

            if (!(s.pop() == 2))
                System.out.println("3: Failed pop");

            if (!(s.peek() == 1))
                System.out.println("4: Failed peek");

            if (!(s.pop() == 1))
                System.out.println("5: Failed pop");

            if (s.size() != 0 || !s.isEmpty() )
                System.out.println("6: Failed size or isEmpty.");
        }
        catch (StackEmptyException e)
        {
            System.out.println(e);
        }   
    }

    public static void testTwo (Stack s)
    {
        try
        {       
            for (int i = 0; i < 100; i++)
            {
                s.push(i);
            }

            if (s.size() != 100)
                System.out.println("7: Failed size.");

            for (int i = 99; i >= 0; i--)
            {
                if (!(s.pop() == i))
                {
                    System.out.println("Failed pop for: " + i);
                    break;
                }   
            }
        }
        catch (StackEmptyException e)
        {
            System.out.println("Failed testTwo.");
            System.out.println(e);
        }   
    }

    public static void testThree (Stack s)
    {
        try {
            while (!s.isEmpty())
                s.pop();
        }
        catch (StackEmptyException e) {
            System.out.println ("Failed empty stack test (popped on a non empty stack threw exception)");
        }

        try
        {
            s.pop();
            System.out.println("Failed empty stack test.");
        }
        catch (StackEmptyException e)
        {
            /* If we get here, we 
             * passed the previous test.
             */
        }
    }

    public static void main (String args[])
    {
        Stack s1 = new StackLL();
        Stack s2 = new StackLL();
        Stack s3 = new StackLL();

        testOne(s1);
        testTwo(s2);
        testThree(s3);
    }
}