Question

传递参数在日常编程中很常见，但是我们应该将参数作为对象或值传递吗？

（A）

public boolean isGreaterThanZero(Payment object) {
    if (object.getAmount() > 0) {
       return true;
    }

    return false;
}

（B）

public boolean isGreaterThanZero(int amount) {
    if (amount > 0) {
       return true;
    }

    return false;
}

Answer 1

这些都没有。

使用适当的OOP，您可以在Payment对象上使用isGreaterThanZero（），即：

class Payment {
  int amount
  public boolean isGreaterThanZero() {
    return amount > 0
  }
}

然后：

Payment payment
boolean flag = payment.isGreaterThanZero()

Answer 2

假设您询问参数传递，而不是关于对象设计......

在设计方法时，您需要考虑许多方面。

该方法可以在其他地方使用吗？在您的示例中，答案可能是肯定的 - 它可以判断任何int是否大于零 - 在这种情况下（B）更有用。
如果方法需要多个参数并且特定于代码中的某个对象，则传递该对象。

在有意义的地方，尝试减少代码中模块之间的依赖关系。在您的示例中，（A）引入了对Payment对象的不必要依赖。但是，如果该方法需要Payment对象的几个成员变量（因为它特定于付款），那么无论如何都要传递Payment对象作为参数。

Answer 3

这是一个人为的例子，但如果这是接收类与Payment的唯一交互，我会使用该值来解耦。没有必要创建多余的类依赖。

编辑：马塞尔和我在同一时间输入同样的东西。 :)这个。

Answer 4

这个问题的答案将特定于特定情况，因此没有办法给出确定的答案，但是何时使用哪种方法的问题仍然有效。

我会在以下时间传递一个对象：

该方法需要处理从外部传入的大量数据。最好将这些参数包装在一个对象中，因为这样做意味着您可以让该方法采用一个参数，而不是每个数据值一个。您还可以将参数验证逻辑重新考虑到包装器类中以获得更好的局部性.1。
在API中经常使用相同的参数组合

当参数很少时我会传递一个值，并且它们都是简单的值类型。

Answer 5

根据OOP概念，我们应该使用Objects。但是，不要过度使用它。例如，在您的示例中，我会使用int。但是在我在很多地方使用多个值的方法中，我会使用一个对象我不会仅使用一个数据成员“Payment”创建amount类。

Answer 6

我的目标是让事情脱钩。如果所有isGreaterThanZero（）确实需要的是金额，那么int版本更好，因为它没有将实现耦合到Payment类。

Answer 7

我认为我们应尽可能使用原始类型（int，double，boolean，char）作为参数，因为存在基本类型并非偶然。我更喜欢第二个选项，因为它更通用（它不会强迫你提供Payment对象，任何int值都会很好）。但是当你需要对象的状态（对象数据的至少两个值）时，情况可能会改变，你可以使用值作为参数以获得更一般的使用可能性，或者将对象用作参数以简化。

Answer 8

是的，我们可以在Java程序中将对象作为参数传递。

第一种方式

     class demo
     {private int length=1;
      private int breadth=1;
      private int area;
      void input(int length,int breadth)
      {
         this.length=length;
         this.breadth=breadth;
      }
      void add(demo d1,demo d2)
      {
          length=d1.length+d2.length;
         breadth=d1.breadth+d2.breadth;
      }
     void output()
     {
         System.out.println("\nLength="+length+"\nBreadth="+breadth);
     }

        public static  void main(String args[])
        {

            demo d1=new demo();
            demo d2=new demo();
            d1.input(1, 1);
            d1.output();
            d2.input(2, 2);
            d2.output();
            demo d3=new demo();
            d3.add(d1, d2);
            d3.output();

        }

     }

第二种方式



     class demo
     {private int length;
      private int breadth;

      void input(int length,int breadth)
      {
         this.length=length;
         this.breadth=breadth;
      }
     demo add(demo d2)
      { demo obj=new demo();//Neccesary as we want to return complete  
                                     object irrespective of its number of data fields
          obj.length=length+d2.length;//Storing the length of two objects  
                                                     in the obj 
         obj.breadth=breadth+d2.breadth;
         return obj;
      }
     void output()
     {
         System.out.println("\nLength="+length+"\nBreadth="+breadth);
     }

        public static  void main(String args[])
        {

            demo d1=new demo();
            demo d2=new demo();
            d1.input(1, 1);
            d2.input(2, 2);
            demo d3=d1.add(d2);//Here we created new object d3 called  
                                         add() by d1 and passed d2 object through it 
            d3.output();

        }

     }

Answer 9

有时，将对象地址（或指针，句柄，无论你调用它）作为参数传递，然后将其转换为方法（作为被收集对象的实例），然后将对象作为参数传递。它只是一种限制编译方式的方法。如果有时它没有改变任何东西，在其他情况下通过地址将广泛使程序更快。它是一个低级编译器，但它确实可以使代码更快。

Answer 10

Addenum我之前的回答。它还取决于编译器优化和方法调用上下文。如果在调用方法之前已经定义了对象，或者如果它是一种可以从内联和优化中受益的方法，那么使用该地址并不是一个好主意。如果你处于循环中，那么使用地址是个好主意。您必须考虑一下如何在特定程序中使用该方法（=预测它将如何编译）。

10 个答案: