JAVA：基本JAVA逻辑

我只使用过一点java，但是有一些小的逻辑问题我似乎永远都不懂，我会马上给出一个例子。 我目前有以下代码：

class test {

public static void main(String[] args) {
    ST<String, Integer> st;
    st = new ST<String, Integer>();

    for (int i = 0; !StdIn.isEmpty(); i++) {
        String key = StdIn.readString();
        st.put(key, i);
    }

    st.put("P", 5); // Put method

    for (String s : st.keys()) {
        StdOut.println(s + " " + st.get(s));
    }

  }
}

并在代码中调用该方法，而不是“put”方法。但是我不能编译它，因为方法“addValue”不知道变量

st

然后我想写两行：

ST<String, Integer> st;
st = new ST<String, Integer>();

ST；
st=新的st（）；

进入类构造函数，但这并没有成功。有人能解释一下这背后的逻辑吗？因为我显然遗漏了一些东西。为了练习，我如何以一种好的方式将代码拆分成方法？+如果有人知道一个好地方可以阅读这样的逻辑，我将不胜感激

---

提前谢谢

变量

st

只有main方法知道，因为您在那里声明了它。要允许从其他方法访问，您应该创建一个类成员。这是一个应该做你想做的事情的类：

class test {

    private static ST<String, Integer> st;

    public static void main(String[] args) {
        st = new ST<String, Integer>();

        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }

        addValue();

        for (String s : st.keys()) {
            StdOut.println(s + " " + st.get(s));
        }

    }

    public static void addValue() {
        st.put("P", 5);
    }
}

类测试{
私有静态ST；
公共静态void main（字符串[]args）{
st=新的st（）；
对于（int i=0；！StdIn.isEmpty（）；i++）{
String key=StdIn.readString（）；
圣普特（基普，i）；
}
附加值（）；
对于（字符串s:st.keys（））{
StdOut.println（s+“”+st.get（s））；
}
}
公共静态void addValue（）{
圣普特（“P”，5）；
}
}

这里有几个问题

类名应为大写，在本例中为

Test

（约定）

具有main方法的类应为public（约定）

ST

不是Java的一部分（在您的评论中，您编写了它作为库的一部分，这些信息应该是问题的一部分），对于

StdIn

和

StdOut

也是如此

您的类位于默认包中，但这对于测试来说是可以的

要真正解决您的问题，有两种解决方案。BlithE已经向您展示了一个，另一个是David Zhou在评论中提到的：

// missing ST StdIn and StdOut, they probably need too be imported
public class Test {

    public static void main(String[] args) {
        ST<String, Integer> st;
        st = new ST<String, Integer>();

        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }

        addValue(st);

        for (String s : st.keys()) {
            StdOut.println(s + " " + st.get(s));
        }

    }

    public static void addValue(ST<String, Integer> st) {
        st.put("P", 5);
    }
}

//缺少ST StdIn和StdOut，它们可能也需要导入
公开课考试{
公共静态void main（字符串[]args）{
ST；
st=新的st（）；
对于（int i=0；！StdIn.isEmpty（）；i++）{
String key=StdIn.readString（）；
圣普特（基普，i）；
}
附加值（st）；
对于（字符串s:st.keys（））{
StdOut.println（s+“”+st.get（s））；
}
}
公共静态无效附加值（ST）{
圣普特（“P”，5）；
}
}

您可以将其添加为类成员

class test {

    private static ST<String, Integer> st;

    public static void main(String[] args) {
         st = new ST<String, Integer>();

        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }

        addValue();

        for (String s : st.keys()) {
            StdOut.println(s + " " + st.get(s));
        }

    }

    public static void addValue() {
        st.put("P", 5);
    }
}

---

从阅读变量范围开始：您需要将方法

addValue（）

添加到

ST

类中。然后，您可以简单地调用this.put（“P”，5）内部

addValue（..）

而不是

st.put（..）

-另外，在main方法中，您可以执行

ST.addValue（）

要调用它，或者将其作为@DavidZhou这样的变量传递，需要一个静态字段。目前，您只有方法中的变量，必须通过参数传递它

public static void addValue（ST ST）

，并像

addValue（ST）

一样调用它。谢谢大家，ST类来自一个我无法控制BTW的库。这是一个非常好的观点，这也是我正在寻找的。我现在尝试了不同的方法来实现我想要的，这是学习逻辑的一个非常好的方法。谢谢哦，顺便说一句，为了对此有所帮助，私有字段“ST”必须是静态的。我不知道为什么？为了访问静态方法中的类变量，这个变量也必须是静态的。这意味着对于该类的所有实例，该变量只有一个“版本”。例如，如果对象A在

st

中添加了一个条目，那么对象B可以“看到”这一点。为了避免使用静态变量，应该像David Zhou建议的那样，将必要的变量作为方法参数传递。

class test {

    private static ST<String, Integer> st;

    public static void main(String[] args) {
         st = new ST<String, Integer>();

        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }

        addValue();

        for (String s : st.keys()) {
            StdOut.println(s + " " + st.get(s));
        }

    }

    public static void addValue() {
        st.put("P", 5);
    }
}

public static void addValue(ST<String, Integer> st) {
    st.put("P", 5);
}

addValue(st);