Question

这可能看起来像一个愚蠢的问题，但这个函数实际上会影响变量bool（我将如何使用它有更大的背景，但这基本上是我不确定的）？（我具体询问java）

void truifier (boolean bool) {
    if (bool == false) {
        bool = true;
    }
}

Answer 1

考虑一个稍微不同的例子：

public class Test {

    public static void main(String[] args) {
        boolean in = false;
        truifier(in);
        System.out.println("in is " + in);
    }

    public static void truifier (boolean bool) {
        if (bool == false) {
            bool = true;
        }
        System.out.println("bool is " + bool);
    }
}

运行此程序的输出将是：

bool is true
in is false

bool变量将更改为true，但只要truifier方法返回，该参数变量就会消失（这就是人们说它“超出范围”时的意思“）。但是，传递给in方法的truifier变量保持不变。

Answer 2

正如另一个响应指出的那样，当作为参数传递时，将在本地为您的truifier函数创建一个布尔值，但是一个对象将按位置引用。因此，根据您使用的参数类型，您可以得到两个非常不同的结果！

perm

但是，如果您没有使用布尔值，而是使用对象，则参数可以修改对象。 //此代码输出正确

Answer 3

void truifier (boolean bool) {
    if (bool == false) {
        bool = true;
    }
}

void demo () {
    boolean test = false;
    truifier (test); 
    // test is still false
    System.out.println (test);
}

你知道你可以使用文字常量来调用函数 - 这里应该修改什么？

void demo2 () {
    truifier (false); 
}

或者使用最终的局部变量

void demo2 () {
    final boolean b = false;
    truifier (b); 
}

或者使用类中的属性：

class X {
    private boolean secret = false; 

    void demo3 () {
        truifier (secret); 
    }
}

在所有这些调用中，truifier获取对相关对象的引用的本地副本。

boolean b = false;
// b -> false

b是对象“false”的引用 - 或者在这种情况下是原始值。

boolean c = b; 
// c -> false, not: c-> b -> false
c = true; 
// c -> true

c已更改，但不是b。 c不是b的别名，而是引用的副本，现在副本引用true。这里只有2个真实对象（原语）：true和false。

在方法调用中，将生成并传递引用的副本，并且对该引用的更改仅影响此引用。但是，没有深度复制。对于要更改属性的类，将在外部更改该属性，但不能替换类本身。或数组：您可以更改数组的内容（引用副本指向同一个数组）但不更改数组本身（例如，大小）。好吧 - 您可以在方法中更改它，但外部引用是独立的，而不是更改。

k = [a, b, c, d]
l = k; 
l [2] = z;
// l=k=[a, b, z, d]
l = [p, q, r]
// k = [a, b, z, d]

Answer 4

是的，只会在函数的范围内。

Answer 5

是的，在方法的范围内。但是，分配方法参数有时被认为是一种不好的做法，它会降低代码的可读性并使其更容易出错。您应该考虑在方法体中创建新的布尔变量并为其分配参数。

此外，您的示例可以像这样重写：

if (!bool) {
    bool = true;
}

Answer 6

原来的问题似乎是“按参考呼叫”或缺乏参与。

为了更清楚，请考虑：

 void caller() {
    boolean blooean = false;
    truifier(blooean);
    System.err.println(blooean);
 }

这将打印'false'。

在trueifier结尾处的类似调用将打印'true'。

Answer 7

您可以执行以下操作：

首先，将布尔变量与类结合起来

class MyBoolean {
private boolean b;
}

第二，添加一个合适的构造函数：

class MyBoolean {
private boolean b;
public MyBoolean(boolean b) {
this.b = b;
}

然后，您添加2种方法：get和alter； get方法返回布尔变量的当前值，并且alter方法切换其值。

class MyBool {
        private boolean b;
        public MyBool(final boolean b) { this.b = b; }
        public boolean getValue() { return b; }
        public void alter() { 
            if(b == true) {
                b = false;
                return;
            }
            b = true;
        }

    @Override
    public String toString() {
        return b+"";
    }
}

因此，您没有定义布尔变量，而是定义了MyBoolean Object。

然后将这个对象传递给“ truifier”函数，对其进行一些改动：

public static void truifier(MyBoolean b) {
b.alter();
}

最后，现在更改了“ b”对象中的布尔变量的值。

更改函数参数的值？

7 个答案: