Question

I am unable to understand how this works

public void addToRule(Rule r) {
    if (!getRuleList().contains(r)) {
        getRuleList().addElement(r);
    }
}

If I run this code:

obj.addToRule(r);
System.out.println(getRuleList().contains(r));

it prints out true how can this happen?

btw ruleList is a vector member of the main class and is not a static variable(don’t think this matters but sharing anyway).

import java.util.Vector;


public class RuleEngine{

    private Vector ruleList = new Vector();

    public Vector getRuleList(){
        return ruleList;
    }

    public void addToRule(Rule r){
        if(!getRuleList().contains(r))
            getRuleList().addElement(r);
    }

    public static void main(String args[]){
        RuleEngine re = new RuleEngine();
        Rule r = new Rule("Rule1");
        re.addToRule(r);
        System.out.println(re.getRuleList().contains(r));
    }
}

class Rule{
    public String name = "";
    public Rule(String nam){
        this.name=nam;
    }
}

OK people have told me that this works because of the pass by reference in java. I get it. but what can i do to get a copy of that object instead of its reference?

Answer 1

From your comments it looks like you have not completely understood what the difference is between a value and a reference in Java. Basically, objects are always passed around as references in Java.

Consider

class Test {
    private List list = new ArrayList();
    public List getList() {
        return list;
    }
}

The getList() method will return a reference to the list object. It will not return a copy of the list object. Doing something like

Test test = new Test();
String s = "ABC";
test.getList().add(s);
System.out.println(test.getList().contains(s));

Will return true since the first time getList() is called, a referece to the list is returned, on which add(s) is invoked. The second time getList() is called, it returns a reference to the same list, not a copy of it, not a new list – the same reference. Calling contains(s) will return true since it the same list onto which the object s was added.

Consider this, however.

Test test1 = new Test();
Test test2 = new Test();
String s = "ABC";
test1.add(s);
System.out.println(test2.getList().contains(s));

This will print out “false”. Why? test1.getList() returns a reference to the list inside test1 and test2.getList() returns a reference to the list inside test2. Here, s was added to test1:s list, so it will not be contained inside test2:s list.