在没有吸气剂的情况下访问Model类的私有变量

Question

I have a Model class defined in my project. and as usual it has some private variables and public getters and setters

public class Person{

 private ArrayList<String> mark;

 public void setMark(ArrayList<String> mark){
  this.mark = mark;
 }

 public void getMark(){
  return this.mark;
 }
}

Suppose in some other class I am using this Model like

Person person = new Person();
ArrayList<String> mark = new ArrayList();
mark.add("10");
mark.add("15");
mark.add("18");
person.setMark();

then the private variable of person holds the value "my name", the I am accessing the variable using public getter of the class like

ArrayList<String> localMark = person.getMark()

so as per my knowledge person.getMark() returns the reference of private variable name, so if I modify the local variable 'localMark', then it will effect the private variable of Person class, so there it breaks the private property of the variable

ex:

 ArrayList<String> localMark = person.getMark();
 System.out.println(localMark.get(0)); // will be "10"
 localMark.set(0,"25") // person.mark will be changed
 System.out.println(person.getMark().get(0)); //will be printing "25"

most of the developers following the same design pattern I guess, but what is the correct way to create Models

EDIT

As per the comment of vinod I checked, and Strings it passes value but not reference but for ArrayList... it returns reference.

Answer 1

You have a reference (name) to an object instance (the value of name). As the reference is private, you're in full control of it.

When you return a reference, you in fact return it 'by value' , meaning that a copy of the reference is returned. Both references point to the same value (the String instance)).

An outside caller obtaining the reference can assign a new value, but your model's own reference is unaffected by that and still points to the value.

It's like a dog (object) on a leash (reference).

• When you return a reference you're returning a new leash onto the same dog.
• The owner of the new reference can modify your dog (pet it, shave it, whatever) when the dog is mutable (which Strings are not, so it cannot be modified)
• ...or he can attach a new dog to his leash
• ...but he can never (reflection aside) attach YOUR leach to another dog.

Answer 2

If the instance being exposed by call to get() is mutable , then whatever changes you make in some other place will be reflected in the instance everywhere it is used.

Example :

methodX classA - 
 List<String> locaNamesList = person.getNamesList();
 locaNamesList.clear();

Somewhere else
methodY classB -
List<String> locaNamesList = person.getNamesList(); // note the same person instance should be used.
//locaNamesList will be empty here

Just re-assigning the reference won' change anything.

List<String> locaNamesList = person.getNamesList();
locaNamesList = null; // won't change the actual list. You are setting local field locaNamesList to null and not the actual instance.

You have to use defensive-copies of mutable instances and pass them around if you don't want the original instance to be changed by external players (provided you can't make the instance itself immutable )