“通过引用”是糟糕的设计吗？ [关闭]

Question

所以，我刚开始学习 Java，发现根本没有“通过引用”这种东西。我正在将一个应用程序从 C# 移植到 Java，而原始应用程序具有 int 和 double，它们是“ref”或“out”参数。

起初我以为我可以传入“整数”或“双精度”，因为那是引用类型，所以值会改变。但后来我了解到这些引用类型是不可变的。

所以，我创建了一个“MutableInteger”类和一个“MutableDouble”类，并将它们传递给我的函数。它有效，但我想我必须违背该语言的原始设计意图。

“通过引用传递”是一般糟糕的设计吗？我应该如何改变我的思维方式？

有这样的功能似乎是合理的：

bool MyClass::changeMyAandB(ref int a, ref int b)
{
    // perform some computation on a and b here

    if (success)
        return true;
    else return false;
}

这是糟糕的设计吗？

Answer 1

如果您将代码结构化为清晰、易于理解的抽象，则面向对象的编程是最好的。

数字，作为一种抽象，是不可变并且没有身份（即“五”总是一个“五”，不存在“多重五个实例")。

您要发明的是一个“可变数字”，它是可变的并且具有标识。这个概念有点笨拙，你最好用更有意义的抽象（对象）来建模你的问题。

考虑代表事物并具有特定界面的对象，而不是单个值块。

Answer 2

在适当支持它的语言中设计不错，(*) 但是当您必须定义 MutableInt 类只是为了在两个方法之间进行通信时，肯定有问题。

您发布的示例的解决方案是返回一个包含两个整数的数组，并通过 null 返回或异常表示失败。这并不总是有效，所以有时你必须...

• 在当前对象上设置属性（当一个类中的两个方法通信时）；
• 传入该方法可能修改的整数数组（当需要多次传递大量整数时）；
• 创建一个辅助类，比如Result，它封装了计算的结果（当您处理int 和float 而不是两个整数时），并且可能将实际计算作为方法或构造函数；
• 使用您建议的习语，然后考虑使用Apache Commons 或其他好的库中对它的支持。

(*) 只是糟糕的语言设计。在 Python 或 Go 中，您会返回多个值并且不用担心。

Answer 3

通过引用传递值对象通常是一种糟糕的设计。

它适用于某些场景，例如用于高性能排序操作的数组位置交换。

您需要此功能的原因很少。在 C# 中，使用 OUT 关键字通常本身就是一个缺点。 out 关键字有一些可接受的用法，例如DateTime.TryParse(datetext, out DateValue)，但 out 参数的标准用法是糟糕的软件设计，它希望通常模仿使用标志来表示所有内容的不良做法。

Answer 4

“通过引用”是糟糕的设计吗？

一般不会。您需要了解您的具体场景并问自己一个函数的作用。而且您需要正确定义您的编码风格，尤其是在您为他人编码时（分发库）。

当您的函数返回多个输出时，通常会使用按引用传递。返回一个包含函数返回的所有信息的ResultContainer 对象通常是个好主意。以以下 C# 示例为例：

bool isTokenValid(string token, out string username)

VS

AuthenticationResult isTokenValid(string token)

class AuthenticationResult {
    public bool AuthenticationResult;
    public string Username;
}

不同之处在于带有引用（在本例中为output）参数的方法清楚地强调了它只能用于验证令牌或可选地用于提取用户信息。因此，即使您有义务传递一个参数，如果您不需要它，您也可能会丢弃它。第二个示例代码更冗长。

如果你有这样的方法当然最好第二种设计

bool doSomething(object a, ref object b, ref object c, ref object d, ... ref object z);

因为您会将它们全部包装到一个容器中。

现在让我澄清一下：在 Java 和 C# 中，非原始类型总是作为克隆引用传递。这意味着objects 本身没有被克隆，只有对它们的引用被克隆到堆栈中，然后你不能指望在返回后指向一个完全不同的对象。相反，您总是希望该方法修改对象的状态。否则，您只需 clone() 对象就可以了。

所以诀窍来了：MutableInteger，或者更好的Holder 模式，是通过引用传递原始值的解决方案。

当您的 IDL 具有引用参数时，CORBA idl2java 编译器当前使用它。

在您的具体情况下，我无法回答您的设计好坏，因为您展示的方法过于笼统。所以想想吧。就像输入一样，如果我对多媒体信息应用某种后处理功能，甚至像加密一样，我会使用引用传递。对我来说，下面的设计看起来不错

encrypt(x);

VS

x = encrypt(x);

Answer 5

您参与的糟糕设计是使用MutableInteger 类。 2 永远是 2。明天就是 2。

标准的 Java/OO 模式通常是让此类项目成为类的实例，并让该类操作/管理它们。

接下来是AtomicInteger。再说一次，我从来没有遇到过需要传递它的情况，但是如果你不想重构很多代码（你的问题是一个“好习惯”，所以我不得不对你很苛刻），那就更好了选项。原因是如果你让一个整数转义到另一个函数，从封装的角度来看，你不知道另一个函数会在同一个线程上运行。因此并发性是个问题，你会可能需要原子引用类提供的并发性。 （另见AtomicReference。）

Answer 6

在调用者堆栈中修改 var 的方法可能会非常令人困惑。

理想情况下，语言应该支持返回多个值，这样可以解决这类问题。

但在此之前，如果您必须使用“out”参数，则必须这样做。

Answer 7

当然，这取决于您正在处理的特定问题，但我会说，在大多数情况下，如果您需要这样的功能，您的设计就不是非常面向对象的。
你想达到什么目的？ 如果这个数字 a 和 b 必须一起操作，可能它们属于 MyClass 类，你需要的是一个实例方法。类似的东西：

class MyClass{
     private int a;
     private int b;
     //getters/setters/constructors
     public boolean dothings(){
     // perform some computation on a and b here
        if (success)
             return true;
        else return false;
        //why not just return success?
     } 

}

Answer 8

“通过引用传递”是一般糟糕的设计吗？我应该如何改变我的思维方式？ 无需制作一个 POJO bean 来保存您的值，将该 bean 发送到函数并取回新值。当然，在某些情况下，您调用的函数可以返回值（如果它总是只有一件事您想要返回，但您谈论的是 vars，所以我认为它不止一个）。

传统上制作具有需要更改的属性的 bean 示例：

class MyProps{
int val1;
int val2;//similarly can have strings etc here
public int getVal1(){
return val1;
}
public void setVal1(int p){ 
val1 = p;
}// and so on other getters & setters

}

或者可以用泛型创建一个类来保存任何对象

class TVal<E>{
E val;
public E getValue(){
return val;
}
public void setValue(E p){
val = p;
}
}

现在使用你的类通过容器的引用来传递：

public class UseIt{
    void a (){
      TVal<Integer> v1 = new TVal<Integer>();
      v1.setValue(1);//auto boxed to Integer from int
      TVal<Integer> v2 = new TVal<Integer>();
      v2.setValue(3);
      process(v1,v2);
      System.out.println("v1 " + v1 + " v2 " + v2);
    }

    void process(TVal<Integer> v,TVal<Integer> cc){
        v.setValue(v.getValue() +1);
        cc.setValue(cc.getValue() * 2);
    }
}