Java 访问静态变量

我有一个下面的场景。有两类A类和B类。这两个类都具有以下性质

甲级 B类 b=？

---

如果我在什么地方出错，请纠正我。谢谢。

即使是对象或原语也不可能，因为java支持按值传递而不是按引用传递

即使是对象或原语也不可能，因为java支持按值传递而不是按引用传递

即使是对象或原语也不可能，因为java支持按值传递而不是按引用传递

即使是对象或原语也不可能，因为java支持按值传递而不是按引用传递

你不能那样做。但是，您可以为两个变量编写这样的方法：

private static void setValue(int value) {
    b = val;
    A.a = val;
}

---

<>如果你坚持“直接”，考虑移动到C/C++：

你不能这样做。但是，您可以为两个变量编写这样的方法：

private static void setValue(int value) {
    b = val;
    A.a = val;
}

---

<>如果你坚持“直接”，考虑移动到C/C++：

你不能这样做。但是，您可以为两个变量编写这样的方法：

private static void setValue(int value) {
    b = val;
    A.a = val;
}

---

<>如果你坚持“直接”，考虑移动到C/C++：

你不能这样做。但是，您可以为两个变量编写这样的方法：

private static void setValue(int value) {
    b = val;
    A.a = val;
}

---

如果你坚持“直接”，考虑移动到C/C++：

不，甚至<代码>静态公共整数a＝10；<代码>，这是一种引用类型，不会改变这一点，因为您正在改变变量指向的对象

您可以做的是设置getter和setter，一个la C#属性：

private static int a;
private static int b;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA; b = newA}
public static int GetB() {return b;}

如果您希望

b

仅仅是基于

a

的计算，这非常简单：

private static int a;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA;}
public static int GetB() {return a - 3;}

但是，如果您只需要一条语句来更新这两条语句，那么可以使用

b = a = 3;

---

不过也不太令人兴奋。

不。甚至

静态公共整数a=10，这是一种引用类型，不会改变这一点，因为您正在改变变量指向的对象

public class A {
    private static int a;
    private static int b;

    static {
        setAB(10);
    }

    public static int getA() {
        return a;
    }

    public static int getB() {
        return b;
    }

    public static void setAB(int value) {
        a = value;
        b = value;
    }
}

您可以做的是设置getter和setter，一个la C#属性：

private static int a;
private static int b;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA; b = newA}
public static int GetB() {return b;}

如果您希望
b
仅仅是基于
a
的计算，这非常简单：

private static int a;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA;}
public static int GetB() {return a - 3;}

但是，如果您只需要一条语句来更新这两条语句，那么可以使用

b = a = 3;

不过也不太令人兴奋。
不。甚至
静态公共整数a=10，这是一种引用类型，不会改变这一点，因为您正在改变变量指向的对象

public class A {
    private static int a;
    private static int b;

    static {
        setAB(10);
    }

    public static int getA() {
        return a;
    }

    public static int getB() {
        return b;
    }

    public static void setAB(int value) {
        a = value;
        b = value;
    }
}

您可以做的是设置getter和setter，一个la C#属性：

private static int a;
private static int b;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA; b = newA}
public static int GetB() {return b;}

如果您希望
b
仅仅是基于
a
的计算，这非常简单：

private static int a;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA;}
public static int GetB() {return a - 3;}

但是，如果您只需要一条语句来更新这两条语句，那么可以使用

b = a = 3;

不过也不太令人兴奋。
不。甚至
静态公共整数a=10，这是一种引用类型，不会改变这一点，因为您正在改变变量指向的对象

public class A {
    private static int a;
    private static int b;

    static {
        setAB(10);
    }

    public static int getA() {
        return a;
    }

    public static int getB() {
        return b;
    }

    public static void setAB(int value) {
        a = value;
        b = value;
    }
}

您可以做的是设置getter和setter，一个la C#属性：

private static int a;
private static int b;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA; b = newA}
public static int GetB() {return b;}

如果您希望
b
仅仅是基于
a
的计算，这非常简单：

private static int a;
public static int GetA() {return a;}
public static int SetA(int newA) {a = newA;}
public static int GetB() {return a - 3;}

但是，如果您只需要一条语句来更新这两条语句，那么可以使用

b = a = 3;

不过也不是那么令人兴奋。
这可能会接近你想要的行为

public class A {
    private static int a;
    private static int b;

    static {
        setAB(10);
    }

    public static int getA() {
        return a;
    }

    public static int getB() {
        return b;
    }

    public static void setAB(int value) {
        a = value;
        b = value;
    }
}

class IntWrapper {
    int inside;
    public IntWrapper(int i) {
        inside = i;
    }
}
class A {
    static IntWrapper a = new IntWrapper(10);
    static IntWrapper b = a;
}
public class B {
   public static void main(String[] args) {
       A.a.inside = 5;
       System.out.println(A.b.inside);
   }
}

这可能会接近您想要的行为

class IntWrapper {
    int inside;
    public IntWrapper(int i) {
        inside = i;
    }
}
class A {
    static IntWrapper a = new IntWrapper(10);
    static IntWrapper b = a;
}
public class B {
   public static void main(String[] args) {
       A.a.inside = 5;
       System.out.println(A.b.inside);
   }
}

这可能会接近您想要的行为

class IntWrapper {
    int inside;
    public IntWrapper(int i) {
        inside = i;
    }
}
class A {
    static IntWrapper a = new IntWrapper(10);
    static IntWrapper b = a;
}
public class B {
   public static void main(String[] args) {
       A.a.inside = 5;
       System.out.println(A.b.inside);
   }
}

这可能会接近您想要的行为

class IntWrapper {
    int inside;
    public IntWrapper(int i) {
        inside = i;
    }
}
class A {
    static IntWrapper a = new IntWrapper(10);
    static IntWrapper b = a;
}
public class B {
   public static void main(String[] args) {
       A.a.inside = 5;
       System.out.println(A.b.inside);
   }
}

如果
b
是a的函数。。为什么不将其声明为静态函数：

class A {
    static IntWrapper a = 10;
    public static getB(){
       return a - 3;
    }
}

这样，当
a
更改和

如果您不需要设置
b
，则无法设置该行为
 如果
b
是a的函数。。为什么不将其声明为静态函数：

class A {
    static IntWrapper a = 10;
    public static getB(){
       return a - 3;
    }
}

这样，当
a
更改和

如果您不需要设置
b
，则无法设置该行为
 如果
b
是a的函数。。为什么不将其声明为静态函数：

class A {
    static IntWrapper a = 10;
    public static getB(){
       return a - 3;
    }
}

这样，当
a
更改和

如果您不需要设置
b
，则无法设置该行为
 如果
b
是a的函数。。为什么不将其声明为静态函数：

class A {
    static IntWrapper a = 10;
    public static getB(){
       return a - 3;
    }
}

这样，当
a
更改和

如果您不需要设置
b
，则无法设置该行为
 int是普通类型，而不是引用类型。所以当你做“b=a”时，你把b分配给10，而不是a。有人能帮我设置a的值，这样它就可以影响另一个静态变量b，这是通过字段访问无法实现的。Java是按值传递的。本质上，您可以将
b
设置为
a
的副本，在该时间点上设置为
a
的值。你必须将
b
重新定义为你想要的样子。正如索蒂里奥斯所指出的，你要求的东西实际上是不可能的。但你到底想达到什么目的呢？可能还有另一种方法。那么，是否可以将b更改为另一个类的更改。int是普通类型，而不是引用类型。所以当你做“b=a”时，你把b分配给10，而不是a。有人能帮我设置a的值，这样它就可以影响另一个静态变量b，这是通过字段访问无法实现的。Java是按值传递的。本质上，您可以将
b
设置为
a
的副本，在该时间点上设置为
a
的值。你必须将
b
重新定义为你想要的样子。正如索蒂里奥斯所指出的，你要求的东西实际上是不可能的。但你到底想达到什么目的呢？可能还有另一个