Sorry I'm taking so long to reply.  I've been away from the list for a bit.

> This is a excerpt from the "Access Control" section of
> "Classes,Objects,and Variables":
> If a method is private, it may be called only within the context of the
> calling
> object--it is never possible to access another object's private method
> directly,
> even if the object is of the same class as the caller.
> 
> So... Could you explain the concept more clearly:
>  "within the context of the callling object"
> ?

All code is executed within the context of some object; i.e. some
object is doing the calling.  Generally, the object doing the calling
is the object whose method is being called.  In other words, you can
loosely translate "within the context of the callling object" as
"within a method of that object".  More accurately, the current
context-object is always stored in the special variable 'self'.


> And how can I write a statement which acess another object's private
> method
> directly?

Well, you can't; not really.  That's the whole difference between
public and private methods.  Make the method public if you want
someone else to have access to it, because that's what 'public' means.


> If I define the class like this:
> class A
>  private
>   def privAMethod
>   end
> end
> 
> we can make a new instance
> 
> a = A.new()
> 
> but, can't call the private method.
> 
> a.privAMethod
> 
> In the above "a.privAMethod" is a expression that access its own
> private method
> (anyway though this is not allowed)
> , not another objects.

No, the current object (in whose context this code is executed) is not
'a'.  Try this:

  p self

That will show you the context object.  This is the object that is
trying to call a's private method.  Only 'a' can call it's own private
methods (like in a public instance method, called by another object). 
For example:

  #  Untested code...
  class A
    def pubAMethod
      privAMethod
    end

    private

    def privAMethod
    end
  end

  a = A.new
  a.pubAMethod


Another way of thinking about it is that public methods can be called
by specifying the object whose method it is, followed by a dot (.) and
the method name.  Like with 'a.pubAMethod'.  But with private methods,
you aren't allowed to specify the object, so no "a.whatever" allowed. 
You have to call it from inside the object.  In fact, you'll even get
an error if you say 'self.privAMethod'... you aren't allowed to
specify the object at all.

Hope that helps,

Chris