Java: Accessing private fields directly from anoth

Question

I'm writing a equals(Object obj) function for a class. I see that it is possible to access the private fields of obj from the caller. So instead of using a getter:

Odp other = (Odp) obj;
if (! other.getCollection().contains(ftw)) {

}

I can just access the field directly:

Odp other = (Odp) obj;
if (! other.collection.contains(ftw)) {

}

Is this bad practice?

Answer 1

This is a duplication of

Why can I access my private variables of the "other" object directly, in my equals(Object o) method

Private data is accessible by any instance of that class, even if one instance of class A is accessing the private members of another instance of A. It's important to remember that that access modifiers (private, protected, public) are controlling class access, not instance access

Answer 2

I tend to always use getters, because sometimes a getter isn't just "return(foo)". Sometimes they initialize things if they're null, or have some debug logging in them, or validate the current state in some way. It's more consistent.

Answer 3

Using private member for entity class may caused proxy class work incorrectly. Imagine hibernate create class by lazy query. If you check member variable , it return null. But if you call get() , it will fetch data from database and initialise the field.

Answer 4

That is fine and completely normal. It is a little bit odd to think that this can fiddle with the private fields of other, but it's okay because there's no way anything bad can happen as far as some third party being able to muck with an Odp object's internals. Any method of the Odp class can modify any private members of any Odp object, even non-this ones, but that's fine since any such methods can obviously be trusted!

Answer 5

No, it's not. The reason that private variables and methods are not accessable from other classes is to allow you to change the internals of your class without having to change all the code that uses the class (that and to prevent the user of your class from e.g. setting a variable to a value that it's never supposed to have).

If you use private variables of other objects that doesn't hurt anything, because if you'd restructure your class's internals, you'd have to change the code inside the class anyway.

Answer 6

I dont think this is bad practice, but a feature of the language. It not only allows you to test equals the way you do, but it is also useful in a Prototype pattern for object creation.