Question

目前正致力于让两个对象互相交互;比如让“人”（对象）互相交谈。我的问题是，如果我生成了两个随机对象，或者包含不同属性的“人”，如果它们都是静态的，我如何让它们在我的班级中相互交互？如果我必须以静态方式生成它们，我只是不确定如何将它们传递给另一个。

为了简单起见，让我们说我只想让他们自我介绍。那个人A和B人打招呼，并且有人B回答“嗨人A，我的名字是B”。

这是我的generateAgent（）方法：

public class Agent {

  public static Object generateAgent() {
    //Create static object randomAgent
    Agent randomAgent = new Agent();

    //Create this agent's properties:
    //1. Get a Gender/Name
    randomAgent.getName();

    //More Attributes below....
    return randomAgent;
  }
}

这是我的sayHelloTo()方法：

public void sayHelloTo(String name) {
  //More Code here
  return;
}

然后在我的其他java文件中，如果它们都是静态的，我如何将对象A / B（代表人A / B）传递给我的Agent类？我不确定我到底错过了什么。

public class DiscussionDirector {
  public void discuss() {

    //Create Two People:
    Agent a = new Agent();
    a.generateAgent();

    Agent b = new Agent();
    b.generateAgent();

    //Have them introduce themselves:
    a.sayHelloTo(); // ----> Not sure what parameters and such go here to pass successfully

    return;
  }
}

Answer 1

你对这里发生的事情有一些基本的误解（注释评论）：

public class Agent {
  public static Object generateAgent() {
    Agent randomAgent = new Agent();//This creates an object on the HEAP
    //eliding everything else
    return randomAgent;//This returns the newly created object
  }
}

现在让我们看一下generateAgent()：

的调用

public class DiscussionDirector {
  public void discuss() {
    Agent a = new Agent();//Here you create a new agent on the HEAP
    a.generateAgent();//And here you call into the Agent class to do the same thing
      //note that generateAgent returns an Object that you're 'forgetting' about.
    return;
  }
}

所以请稍等一下。静态函数generateAgent是所谓的“工厂方法”，它确保“正确”创建对象（但程序员定义该对象）并返回该对象的实例。因此，您的签名是错误的，因为它表示您要归还Object而不是Agent。它应该是：

public static Agent generateAgent() {//Declares the type of object being given back
  Agent randomAgent = new Agent();
  //eliding everything else
  return randomAgent;
}

请注意，此函数可以在任何知道Agent类的类中进行，因为它是静态的;它不需要Agent的实例才能运行。静态方法通常也在类上调用，而不是对象实例：

Agent a1 = Agent.generateAgent();//sets a1 to the returned result of generateAgent()
  //this is an Agent object. 
Agent a2 = a1.generateAgent();//sets a2 to a DIFFERENT, new agent object
  //At this point there are two instances of Agent on the heap
  //This form of invocation is generally reserved for non-static methods
    //Usually a warning will be generated, too, by your IDE.

请记住仔细考虑函数消耗的内容（参数）及其返回的内容。如果它返回void，则函数的点是它在内部执行的任何操作，但如果它是其他内容，则可以考虑将输入转换为输出的函数。在这种情况下，您不会将任何内容转换为新代理。

要正确理解这一点，请将类定义（public class Agent...）视为对象的蓝图。可以在不存在任何方法实例的情况下执行这些类中的任何static方法。每当你编写new Agent（或new任何东西）时，你就会在堆上创建一个新的实例对象（不是堆栈的内存部分）。只能在对象实例上调用非静态方法。有关详情，请参阅此Answer。

Answer 2

您可能并不是指使用static generateAgent()方法而是使用构造函数。请参阅以下内容：

public Agent()
{
    this.setName("new Name");
    //more attributes
}

请注意，在构造函数中，您不使用返回类型，例如void或Object，并且它必须与类的名称匹配。执行Agent a = new Agent();

时，将自动调用构造函数

这样，您就不需要不必要的a.generateAgent();

我确定您注意到我使用setName()函数来应用名称。这是标准的Java命名约定，以确保其他对象正在设置并正确获取属性。您可能会在代理下面有一个名为String的{{1}}变量和一个“getter”和“setter”：

name

现在您可以保持public String getName() { return this.name; } public void setName(String newName) { this.name = newName; }代码相同，但在DiscussionDirector下，您可以调用这样的函数：sayHelloTo

有很多方法可以扩展我所说的任何内容，所以如果您有任何其他问题，请告诉我。

Answer 3

你的行

Agent a = new Agent();   //creates an instance of Agent in variable a
a.generateAgent();       //creates another instance which is discarded
                         //this static method unnecessarily called on an instance
                         //the method is static, but there is no such thing as a 
                         //static object, only object instances.

Agent b = new Agent();   //creates a third instance
b.generateAgent();       //creates a fourth instance, this one thown away

a.sayHelloTo();     //method called on the first instance you created

您可能需要一个带参数的方法，并在“a”上调用它并传递“b”。该对象可以保持对另一个对象的引用，并且可以在另一个对象上调用方法。

也许是这样的：

public class Agent {
    Agent neighbor;
    String name;

    public Agent(String myName) {
        //initialization code
        name = myName;
        neighbor = null;    //not strictly necessary, but included for clarity
    }

    public void introduce(Agent other) {
         neighbor = other;
    }

    public String getName() {
        return name;
    }

    public String getNameAndNeighbor() {
        if (neighbor==null) {
            return "my name is "+name+" and I have no neighbor";
        }
        else {
            return "my name is "+name+" and my neighbor's name is "+neighbor.getName();
        }
    }
}

以下主要代码：

Agent a = new Agent("Harry");
Agent b = new Agent("Joe");
a.introduce(b);
b.introduce(a);
System.out.println( a.getNameAndNeighbor() );

//produces "my name is Harry and my neighbor's name is Joe"

这些对象中的每一个都有一个成员'neighbor'，它引用另一个对象，并允许它们在另一个对象上调用方法。

Answer 4

http://www.seas.gwu.edu/~drum/java/lectures/module4/module4.html

该网站有一个很好的例子。但基本上你需要为人们创建一个实例对象来进行交流。这里的问题是public void discuss（）不是静态的。如果它是静态的，那么它可以从您的其他类代理继承。

使用Java不确定OOP

4 个答案: