Java中的指针逻辑

我需要找到一种方法，通过getter函数直接修改Java中类的私有成员。我知道我可以用这样的指针在C++中做这件事；p>

class FooBar
{
    private:
        Foo foo;

    public:
        Foo* getFoo()
        {
            return &foo;
        }
}

然后我可以通过公共函数

getFoo（）

直接操作私有变量

foo

，因为getFoo（）返回指针（例如

getFoo（）->callFunction（）；

）

---

所以我想知道的是，有没有一种方法可以在Java中复制完全相同的效果？？。。。。有什么办法吗？

因为Java没有

指针。但是，您可以使用getter和setter来实现这一点，它将帮助您实现这一点

class myclass{
private myclass val;  // private field

//get the private field
public myclass getVal(){
return val;
}

//set/change the member field value
public void setVal(myclass val){
this.val=val;
}

}

在java中，getter返回对该对象的引用，因此可以依赖返回对象的公共方法来对其进行mofid。如果你详细说明你想做什么，我可以进一步详细说明。例如,

如果getter返回一个列表，则调用方可以使用add或remove方法修改该列表

class FooBar {
    private Foo foo;

    public Foo getFoo() {
        return foo;
    }
}

Java中的所有对象变量都是对对象的引用，因此可以将它们视为“锁定”指针。“锁定”的意思是你不能用它做任何指针运算。
你必须提供一个getter和setter

class FooBar {

    private Foo foo;

    public Foo getFoo() {
        return foo;
    }

    public void setFoo(Foo foo) {
        this.foo = foo;
    }

}

Java是按值传递的，或者更具体地说，是按值传递引用。这意味着将传递所有引用类型，以便：

List<String> a = myObj.getList();
a.add("My String"); // this modifies the source list

List<String> b = new ArrayList<String>();
a = b; // this doesn't change the source list's reference

但是请注意，反射是一个高级主题，在大多数情况下是糟糕编程的症状。
您需要什么可以通过简单的getter访问，如前所示。
一些重要细节：

如果你想像我一样思考

getFoo()->callFunction();

确保：


Foo类是可见的（如果您在同一个包中，则为默认修饰符；如果调用方是subclass或public，则为protected，否则为public）
callFunction（）是可见的（相同的规则）

如果你想像我一样思考

getFoo().value = newValue;

确保值是可修改的，这意味着类Foo不会将值定义为final：

class Foo {
    // in this case value is immutable
    final Bar value;
}

在最后一个案例中，编译器会告诉你，“最后的字段Foo.Valuy不能被赋值”。
< P>即使C++中，这也是个坏主意，因为如果对象被解除分配，指针现在指向一个无效的内存位置。这就是为什么Java中没有指针的原因之一；为了保护要从恶意指针访问的内存。因此，在Java中，对私有字段的所有访问都必须通过封闭对象本身进行，通常使用get/set组合

但是，我认为使用set（）并不是您想要的解决方案；可能是因为您有一个来自不同类的对象集合，这些对象不共享除对象之外的公共层次结构。如果是这种情况，那么一个潜在的解决方案就是创建并使用一个公共接口。通过这种方式，您可以使用这个公共接口存储这些不同对象的引用，并以相同的公共方式操作它们；例如：

static void test() {

    List<IntegerGetSet> list = new ArrayList<IntegerGetSet>();
    list.add (new A1(1));
    list.add (new B1(2));

    for (IntegerGetSet igs: list) {
        igs.set (igs.get() * 10);               
        System.out.println(igs.get()); 
    }
}

interface IntegerGetSet {   
    public int get();
    public void set (int i);
}

static class A1 implements IntegerGetSet {

    private int i;

    public A1 (int i) { this.i = i; }

    @Override
    public int get() {
        return i;
    }

    @Override
    public void set(int i) {
        this.i = i;
    }       
}

static class B1 implements IntegerGetSet {
    private int i;

    public B1 (int i) { this.i = i; }

    @Override
    public int get() {
        return i;
    }

    @Override
    public void set(int i) {
        this.i = i;
    }       
}

static void test（）{
列表=新的ArrayList（）；
增加（新A1（1））；
增加（新B1（2））；
用于（整数集igs:列表）{
igs.set（igs.get（）*10）；
System.out.println（igs.get（））；
}
}
接口整数集{
公共int get（）；
公共无效集（int i）；
}
静态类A1实现IntegerGetSet{
私人互联网i；
公共A1（inti）{this.i=i；}
@凌驾
公共int get（）{
返回i；
}
@凌驾
公共无效集（int i）{
这个。i=i；
}       
}
静态类B1实现IntegerGetSet{
私人互联网i；
公共B1（inti）{this.i=i；}
@凌驾
公共int get（）{
返回i；
}
@凌驾
公共无效集（int i）{
这个。i=i；
}       
}

如果你不能修改这些类，那么你将有更复杂的事情要做；例如，按照另一篇文章的建议使用反射。
您尝试过什么？请显示不适合您的Java代码，返回Java引用应该完全符合您的要求。
static void test() {

    List<IntegerGetSet> list = new ArrayList<IntegerGetSet>();
    list.add (new A1(1));
    list.add (new B1(2));

    for (IntegerGetSet igs: list) {
        igs.set (igs.get() * 10);               
        System.out.println(igs.get()); 
    }
}

interface IntegerGetSet {   
    public int get();
    public void set (int i);
}

static class A1 implements IntegerGetSet {

    private int i;

    public A1 (int i) { this.i = i; }

    @Override
    public int get() {
        return i;
    }

    @Override
    public void set(int i) {
        this.i = i;
    }       
}

static class B1 implements IntegerGetSet {
    private int i;

    public B1 (int i) { this.i = i; }

    @Override
    public int get() {
        return i;
    }

    @Override
    public void set(int i) {
        this.i = i;
    }       
}