You can access those values, and manipulate them via Reflection. By this mechanism you can check fields and invoke methods.

See this table:

                   Access Levels
Modifier     | Class  | Package   |  Subclass | World
-------------+--------+-----------+-----------+--------
public       |   Y    |     Y     |     Y     |   Y
protected    |   Y    |     Y     |     Y     |   N
no modifier  |   Y    |     Y     |     N     |   N
private      |   Y  ← |     N     |     N     |   N    

The only way to access to private fields is with the Reflection API as next:

Field field1 = A.class.getDeclaredField("field1");
// Make it accessible as it is a private field otherwise you won't be able to get the value
field1.setAccessible(true);
MyClass obj = (MyClass) field1.get(a);

However using Reflection API should be your last resort as it is more a hack in this case than a real solution.

You're just using field access. Having a getSet() method would make no difference, as the Java compiler won't use an accessor method automatically for you.

I suspect what you're missing is that private access isn't determined by the object whose member you're trying to access - the code in Cage has access to the private members of any other Cage, including the set field.

Section 6.6 of the Java Language Specification describes access control, including:

Otherwise, if the member or constructor is declared private, then access is permitted if and only if it occurs within the body of the top level class (§7.6) that encloses the declaration of the member or constructor.

you can access them, by using reflection,

Test test = new Test()
Field field = test.getClass().getDeclaredField("x");
field.setAccessible(true);

System.out.println(field.getName() + "="+field.get(test ));

but, you shouldn't do this

In order to access private fields, you need to get them from the class's declared fields and then make them accessible:

Field f = obj.getClass().getDeclaredField("stuffIWant"); //NoSuchFieldException
f.setAccessible(true);
Hashtable iWantThis = (Hashtable) f.get(obj); //IllegalAccessException

EDIT: as has been commented by aperkins, both accessing the field, setting it as accessible and retrieving the value can throw Exceptions, although the only checked exceptions you need to be mindful of are commented above.

The NoSuchFieldException would be thrown if you asked for a field by a name which did not correspond to a declared field.

obj.getClass().getDeclaredField("misspelled"); //will throw NoSuchFieldException

The IllegalAccessException would be thrown if the field was not accessible (for example, if it is private and has not been made accessible via missing out the f.setAccessible(true) line.

The RuntimeExceptions which may be thrown are either SecurityExceptions (if the JVM's SecurityManager will not allow you to change a field's accessibility), or IllegalArgumentExceptions, if you try and access the field on an object not of the field's class's type:

f.get("BOB"); //will throw IllegalArgumentException, as String is of the wrong type

That is the whole point of private fields; they are not accessible outside the scope of the enclosing class.

You got the following options:

1. Change that class to provide a getter
2. Change your overall design, to either not need that value; or find another way to make it available to both classes
3. Not recommended: use reflection and its ability to override the "private" protection at run time

Access modifiers work on class level not on object level.

You are allowed to access k.i since the code lies within the same class as in which the member i is declared.

The rationale is (afaik) the following: You encapsulate the data (partly) in order to ease future maintenance and refactorings. When you refactor code, you refactor classes, not objects.

It is possible using reflection, see this link for a good explanation of how. How do I read a private field in Java?

That said, you really really need to have an extremely good reason for doing so, because if you don't control the code chances are that sometime down the road the owner of that code makes a change and everything breaks at runtime. And if you own the code there is no reason to do it in the first place.

If you control the code or have access to the owner, do the right thing and implement proper access methods to get the data you need.

Referring to the official JPA specification (final version, JPA 2.1) in Section 2.2 (page 24) we find:

The persistent state of an entity is accessed by the persistence provider runtime either via JavaBeans style property accessors (“property access”) or via instance variables (“field access”). Whether persistent properties or persistent fields or a combination of the two is used for the provider’s access to a given class or entity hierarchy is determined as described in Section 2.3, “Access Type”.

In Section 2.3.1 (page 27) this definition is made more concrete - with respect to your question:

By default, a single access type (field or property access) applies to an entity hierarchy. The default access type of an entity hierarchy is determined by the placement of mapping annotations on the attributes of the entity classes and mapped superclasses of the entity hierarchy that do not explicitly specify an access type. [...]

• When field-based access is used, the object/relational mapping annotations for the entity class annotate the instance variables, and the persistence provider runtime accesses instance variables directly. All non-transient instance variables that are not annotated with the Transient annotation are persistent.

• When property-based access is used, the object/relational mapping annotations for the entity class annotate the getter property accessors, and the persistence provider runtime accesses persistent state via the property accessor methods. All properties not annotated with the Transient annotation are persistent.

The term directly refers to an access strategy which allows the manipulation of an object's field (value) without the need to use getter/setter methods. In Java and for most OR-mappers (at least the ones I know of) this is achieved via Introspection - using the Java Reflection API. This way, classes' fields can be inspected for and manipulated to hold/represent data values from the (relational) database entries (i.e., their respective columns).

For instance, the provider Hibernate gives the following explanation in their User Guide:

2.5.9. Access strategies

As a JPA provider, Hibernate can introspect both the entity attributes (instance fields) or the accessors (instance properties). By default, the placement of the @Id annotation gives the default access strategy.

Important note:

Be careful when experimenting with different access strategies! The following requirement must hold (JPA specification, p. 28):

All such classes in the entity hierarchy whose access type is defaulted in this way must be consistent in their placement of annotations on either fields or properties, such that a single, consistent default access type applies within the hierarchy.

Hope it helps.

You can use the Apcache commons FieldUtils

FieldUtils.readField(object, myfield, true);

or else you can use the Reflection as is described and answered in the linked duplicate. So you can set the setAccessible(true) before invoking your method.

m = object.getClass().getDeclaredMethod(mymethod);
m.setAccessible(true);
m.invoke(object);

Four disadvantages that I can think of:

1. If you want to have a read-only and mutable form of the same entity, a common pattern is to have an immutable class Entity that exposes only accessors with protected member variables, then create a MutableEntity which extends it and adds setters. Your version prevents it.
2. The use of getters and setters adheres to the JavaBeans convention. If you want to use your class as a bean in property-based technologies, like JSTL or EL, you need to expose public getters.
3. If you ever want to change the implementation to derive the values or look them up in the database, you'd have to refactor client code. An accessor/mutator approach allows you to only change the implementation.
4. Least astonishment - when I see public instance variables, I immediately look for who may be mutating it and worry that I am opening pandora's box because encapsulation is lost. http://en.wikipedia.org/wiki/Principle_of_least_astonishment

That said, your version is definitely more concise. If this were a specialized class that is only used within a specific package (maybe package scope is a good idea here), then I may consider this for one-offs. But I would not expose major API's like this.