Question

我已经通过多种方式看到了这个问题，但代码通常是针对用户的，而且我迷失了一点。如果我错过了一个清晰简单的解释，我很抱歉！我只需要理解这个概念，并且我已经迷失在我所看到的重复上。所以我尽可能地简化了我自己的问题，以找到问题的根源。

我的目标是拥有一个我要求变量的主类，然后让这些用户输入的变量通过一个单独的类中的方法进行评估，并根据变量的内容返回一条消息。

    import java.io.*;


    public class MainClass {

       public static void main(String[] args) {

          InputStreamReader input = new InputStreamReader(System.in);
          BufferedReader reader = new BufferedReader(input);   

          String A;
          String B;

          try {

               System.out.println("Is A present?");
               A = reader.readLine();

               System.out.println("Is B present?");
               B = reader.readLine();

               Assess test = new Assess();

} catch (IOException e){
  System.out.println("Error reading from user");
  }
 }
}

我尝试使用的方法是：

public class Assess extends MainClass {

 public static void main(String[] args) {

  String A = MainClass.A;
  String B = MainClass.B;

  if ((A.compareToIgnoreCase("yes")==0) && 
     ((B.compareToIgnoreCase("yes")==0) | (B.compareToIgnoreCase("maybe")==0))) 
         {
         System.out.println("Success!");
         }

  else {
    System.out.println ("Failure");
       }
}


}

我认识到我没有正确地要求输出，但是我甚至无法到达那里并弄清楚我在那里做了什么，直到我得到完全编译的东西在我弄清楚如何在类之间正确传递值之前，我无法做到这一点。我知道有很多方法可以做到这一点，例如使用数组。我正在寻找从一个类内部输入到另一个类的变量的概念上最简单的方法;我需要理解这里的基本概念，我知道这是超级基本的，但我只是愚蠢，阅读可能重复的问题并没有帮助。

我知道如果变量是静态的并且在开始时全局声明，而不是如何从子类中发送它，我知道怎么做（我知道它不可能直接从子类发送...... ？我必须以某种方式设置它，然后将该设置值拉入另一个类）。

Answer 1

为了将变量传递给对象，您有两个选项


Constructor - 将在创建对象时传递参数

Mutator method - 会在您调用方法时传递参数

例如在您的Main类中：

Assess assess = new Assess(A, B);

或者：

Assess assess = new Assess();
assess.setA(A);
assess.setB(B);

在Assess类中，您必须添加构造函数方法

public Assess(String A, String B)

或者setter方法

public void setA(String A)
public void setB(String B)

另外，Assess类不应该扩展主类并包含静态main方法，它与主类无关。

下面是一个代码示例！

Assess.java

public class Assess {

    private a;
    private b;

    public Assess(String a, String b) {
        this.a = a;
        this.b = b;
    }

    public boolean check() {
         if ((A.compareToIgnoreCase("yes")==0) && 
             ((B.compareToIgnoreCase("yes")==0) ||
             (B.compareToIgnoreCase("maybe")==0))) 
         {
             System.out.println("Success!");
             return true;
         } else {
             System.out.println ("Failure");
             return false;
         }

MainClass .java

public class MainClass {

    public static void main(String[] args) {

      InputStreamReader input = new InputStreamReader(System.in);
      BufferedReader reader = new BufferedReader(input);   

      String A;
      String B;

      try {

           System.out.println("Is A present?");
           A = reader.readLine();

           System.out.println("Is B present?");
           B = reader.readLine();

           Assess test = new Assess(A, B);

           boolean isBothPresent = test.check(); 
           // ................

      } catch (IOException e){
          System.out.println("Error reading from user");
      }
 }

Answer 2

我认为您正在寻找的是方法参数。

在方法定义中，您可以定义方法名称及其所需的参数。例如，如果你有一个方法assess接受一个字符串并返回一个整数，你会写：

public int assess(String valueToAssess)

并使用代码跟随它，使用valueToAssess执行任何操作，以确定要返回的整数。当您确定i是要返回的int时，您将放置语句

return i;

进入方法;终止方法并将该值返回给调用者。

调用者获取要声明的字符串，然后调用该方法并传入该字符串。如果你明白我的意思，那么它更像是推送而不是 pull 。

...
String a = reader.readLine();
int answer = assess(a);
System.out.println("I've decided the answer is " + answer);

这就是你要找的东西吗？

Answer 3

子类可以访问超类的公共成员。如果要使用{class}。{member}（即MainClass.A）访问成员，则需要在方法之外静态声明。

public class MainClass {
    public static String A;
    public static String B;
    ...
}
public class Subclass {
    public static void main(String[] args) {
        // You can access MainClass.A and MainClass.B here
    }
}

可能更好的选择是创建一个具有这两个字符串作为对象的类，可以对其进行操作，然后传入Assess类

public class MainClass {
    public String A;
    public String B;
    public static void main(String[] args) {
        // Manipulate A, B, assign values, etc.
        Assess assessObject = new Assess(A, B);
        if (assessObject.isValidInput()) {
            System.out.println("Success!");
        } else {
            System.out.println("Success!");
        }
    }
}
public class Assess {
    String response1;
    String response2;
    public Assess (String A, String B) {
        response1 = A;
        response2 = B;
    }
    public boolean isValidInput() {
        // Put your success/fail logic here
        return (response1.compareToIgnoreCase("yes") == 0);
    }
}

Answer 4

首先，您不需要继承。有一个类你的主类包含main主要来自Assess类。创建构造函数或setter方法以在Assess类中设置变量。例如。公共类MainClass { public static void main（String [] Args） { 评估ns = new Assess（）; ns.setterMethod（要设置的变量）; } }

Answer 5

我不能100％确定你的问题，但听起来你只需要从子类中访问一个类中存在的变量。有几种方法......

您可以将它们设为公共静态变量，并在您在Assess类中显示时引用它们。但是，它们位于MainClass使用中的错误位置

public static String A, B;

您可以在父类（在您的示例中为MainClass）中将这些变量设置为public或protected。不建议公开，因为您不知道修改它们的人或修改者。您可以从子类中引用这些内容，就像在子类中一样。

public String A, B;    // Bad practice, who modified these?
protected String A, B;

可能引起争议最少的方法是让他们成为私人成员并使用＆＃34;访问者＆＃34; （getter和setters）。这使得它们可以通过编程方式访问，它允许您设置断点以捕获修改它们的罪魁祸首，并且还允许您实现许多模式，例如观察者等，以便修改这些模式可以根据需要调用服务。如果＆＃34; A＆＃34;是日志文件的路径，更改其值也可能导致旧日志关闭，新的日志将被打开 - 只需更改文件名称即可。

private String A, B;

public setA(String newValue) {
   A = newValue;
}
public String getA() {
   return A;
}

但是......

你的问题是＆＃34;发送到子类＆＃34;，但是你知道如何使用全局变量来解决这个问题。我想说最简单的方法是使用构造函数提供值，有效地注入值。

还有其他方法，但是，您的示例显示了构造函数执行的评估。如果您的Assess类有一个单独的方法来执行评估，您只需使用变量作为参数调用它。

你的例子令人困惑，因为两个类都有主要方法，而子类进行评估 - 我认为你会想要相反的 - 让MainClass扩展评估，使＃34; MainClass评估＆＃39;或者＃34; ，让主要分配字符串评估＆＃39;值（或将它们作为参数传递给父类＆＃39; ＆＃34;评估＆＃34;方法（＆＃34; super＆＃34;为清晰起见而添加）：

super.setA(local_a);
super.setB(local_b);
super.assess();

或

super.assess(A, B);

简单地将变量传递给新类，然后在Java中输出

5 个答案: