["Jakob Bieling" <argfhesNGtzkQBGarg@rot13.com>]

you can put the classes in the same package and use package-private
access, but what you *really* want to do is to think long and hard
about your design;  if you need to expose the inner workings of one
class to another class, chances are that your code will be very hard
to debug, understand and maintain.
bottom line: _I do not recommend you do this_!

at the very least I would define a getter which returns a reference to
the data in question, using the most general data type you can live
with, so that access to the internals are defined, and if possible,
somewhat restricted.  you could also ensure read-only access or make a
defensive copy of the data, but from what I understand, your
environment is memory-constrained so the defensive copy might defeat
the purpose.

for example if you have an instance of a HashMap inside one class that
you wish to return you could for instance do:

 public Map getFoo() {
     return Collections.unmodifiableMap(myHashMapInstance);
 }

which would give you (reasonably) safe access to the underlying data
without making too many commitments.

-Bjørn

You can use a method to access the data (which is good programming
practise anyway), but make the return value a copy of the list in
the method before it is returned. This will stop any user code
changing which elements are in the list, but will take up more memory

Hi,

   thanks for the quick responses. I rethought my design and did find
the cause. The data in A that B needed to access, should have been in B
alltogether (because it partly resembled the displaying state of the
data). It also solved the other implementation problems that came along
with that ;)

Thanks again :)

You can make the data protected, then do B extends A.

You might make B an inner class of A. You can create a small package
and put both A and B in it and make the data default.