Function only visible to a specific class

Question

Hi All
I am implementing a tree hierachy with a classes call 'Tree" and "Node". Inside the Node class, I have a function call "setName" for setting the name of the node. This function will only ever be used by Tree for setting the name of the nodes inside the tree. Is there anyway I can make the restriction so that this function will only ever be visible to the class "Tree" only?

Answer 1

It also depends the way you want to model your Tree/Node concepts.
In particular you will often hear something along the lines of: "if the setName function is only Tree's business, then it should be a method of Tree itself".
You could object that even if this method is implemented in Tree, you need a way to associate the name to the corresponding object held in the tree.
But stuffing the name in the Node itself is maybe not the right way: if the name property does not belong to the entity held in the node (if the name concept is only relevant to the Tree), then it could be stored in another attribute of the Tree class (such as a Map of names keyed by the path).
Now if you want other classes to read that name (but not set it), you have several options:
1) If your Node class only represent the building block of a tree structure (with the wiring, management of children, etc...),
then other classes maybe don't need to see it : if they want to know the data at a certain node in the tree, they can ask the tree, something along Tree.getDataAtpath(...)..
Even if these other class need other things like getNumberOfChildren, and especially getNameAtPath(...), you can write your Tree class to provide these services.
Note that I assummed above that you have a path notion, independant of the name data, to identify nodes in the tree structure, otherwise you wouldn't need to read the name from the Tree. In case your client classes can get a Node reference without knowing about the Tree or the path in the Tree, you probably fall in case 2.
2) Now if your Node class represents the building block of a tree structure PLUS the data it contains:
First note that this model is not very flexible because it mixes the wiring of a tree structure with the business logic of the entity contained in the tree structure.
But one way you can model it is to separate the concerns in two interfaces (say, GenericNode and MyNodeData), implemented by the same NodeImpl class, and expose only MyNodeData to the outside. If your setName method belongs to the GenericNode, tree can invoke it but client classes will not even know it exists.
Note that this doesn't protect against malicious calls (client code could simply cast the reference to GenericNode or NodeImpl). It just protects from accidental usage. It reminds the convention that "only Tree should set the name", but does not enforce it.
What do you think of a pedantic generalization such as:
The Java replacement to C++'s [i]friend concept is to spread functionalities among interfaces.?