Synchronized statements and deadlock

Question

I've been reading on the tutorial about synchronized statements:
http://java.sun.com/docs/books/tutorial/essential/concurrency/locksync.html
...and I don't understand when it says, about the following example:
    public void addName(String name) {
        synchronized(this) {
            lastName = name;
            nameCount++;
        nameList.add(name);
    }"In this example, the addName method needs to synchronize changes to lastName and nameCount, but also needs to avoid synchronizing invocations of other objects' methods. (Invoking other objects' methods from synchronized code can create problems that are described in the section on Liveness.) "
Why do I need to avoid synchronizing invocations of nameList object? When thread1 gets an instrinsic lock to the instance of this class, does it also get a lock on the nameList object?
I suppose they're saying that I should avoid synchronizing invocations of nameList object to avoid deadlock, but I can't see how a deadlock would occur here.
I've read about deadlock but the example on the tutorial seams a different case to me because that example puts to objects crossing data between each other.
Another doubt is: in the deadlock example, which is found here
http://java.sun.com/docs/books/tutorial/essential/concurrency/deadlock.html
thread1 invokes synchronized method "bow" on object alphonse, while thread2 invokes that same method on object gaston. Does this garantee that the methods will not interleave? Doesn't it have to be the same object being used on both threads?
Quoting the same tutorial: "It is not possible for two invocations of synchronized methods on the same object to interleave."
Help appreciated on clarifying this.

Answer 1

>
If you use the first bit of code and make another block to synchronize on nameList then you could have another method that synchronizes inside on nameList and that could deadlock if it also needs to synchronize on this.
I'm still confused. If I had in MyClass
public void addName(String name) {
    synchronized(this) {
        lastName = name;
        nameCount++;
        nameList.add(name);
}which I understand is equivalent to
public void synchronize addName(String name) {
        lastName = name;
        nameCount++;
        nameList.add(name);
}and then I had
public void removeName(String name) {
    synchronized(this) {
        lastName = null;
        nameCount--;
        nameList.remove(name);
}then when thread1 invoked myClass.addName(someString) would acquire a lock on myClass and thread2, invoking myClass.removeName(someString) would have to wait for thread1 to conclude. It doesn't seam to be nothing wrong on this to me...
Please help.