Question

我有一个由机器人标记的Java评估。每当我上传我的作业时，它都会显示一个这样的屏幕。

A good object-oriented design places each method into the most appropriate
class. The most appropriate class for a method should be the same class as
the data fields that that method needs to access. If you don't place a method
into the right class, then this will most likely increase the amount of
communication that is required between your classes.

The score below measures the amount of communication between your classes. A
lower score is better.

19 method invocations between classes
7 arguments passed between classes
15 results returned between classes

Amount of communication = invocations + 2*inputs + 2*outputs = 63

现在，“类之间的方法调用”，“类之间传递的参数”和“类之间返回的结果”究竟是什么意思？

Answer 1

类之间的方法调用

如果要从其他类调用该方法，类包含自己的方法，则必须使用此实例 < EM>类

例如：

class A{
    public void methodA(){
    }
}
class B{
    public void methodB(){
    }
}

如果我想从课程methodA()拨打B，我必须使用此功能：

public void methodB(){
    A a = new A();
    a.methodA(); // method invocation between classes
}

类之间传递的参数

这一次methodA()需要参数，而B需要字段，可以用作参数

class A{
    public void methodA(int argument){
    }
}
class B{
    private int fieldB = 42;
    public void methodB(){
    }
}

要从methodA()拨打B，您会将参数从类传递给其他人。

public void methodB(){
    A a= new A();
    a.methodA(fieldB); //Argument passed between classes
}

课程之间返回的结果

现在methodA() 返回结果，这是代码。

class A{
    public int methodA(){
        return 42;
    }
}
class B{
    private int fieldB;
    public void methodB(){
    }
}

要使用/处理类 methodA()中B的返回的值，您必须这样做：

public void methodB(){
    A a= new A();
    fieldB = a.methodA(); //Result returned between classes
}

Answer 2

我不得不说：

类之间的方法调用
假设您有课程X和Y。这可以是任何时间类X调用类Y上的某个方法。

如，

class Y
{
    public void foo() { }
}
class X
{
    public void someMethod()
    {
        Y y = new Y();
        y.foo();
    }
}

在类之间传递的参数
可能意味着两件事之一。

要么直接访问另一个类的字段。

class Y
{
    public int number;
}
class X
{
    public void someMethod()
    {
        Y y = new Y();
        int yNum = y.number;
    }
}

或者在提供参数的地方调用了一个方法。（最有可能的情况）

class Y
{
    public void foo(int arg) { }
}
class X
{
    public void someMethod()
    {
        Y y = new Y();
        y.foo(56);
    }
}

类之间返回的结果
从另一个返回值的类的方法接收值。例如，吸气剂或其他方法。

class Y
{
    public int foo() { return 42; }
    private int number;
    public int getNumber() { return number; }
}
class X
{
    public void someMethod()
    {
        Y y = new Y();
        int yFoo = y.foo();
        int yNumber = y.getNumber();
    }
}

面向对象的类通信

2 个答案: