Some pseudo code and names will help here:

 public synchronized void outer() {
   System.out.println("this method is synchronized");
   /* some code... */
   inner();
   /* more code... */
 }

 public void inner() {
   System.out.println("this method is unsynchronized");
   /* some code... */
 }

Only outer() is synchronized, and others are still free to call
inner() directly. Realize though that the original thread does not
leave outer() when it calls inner(), so outer() is still protected by
the synchronization during the time it executes inside inner().

/gordon

It isn't unless there are no direct calls to the unsynchronised
method.

By analogy if you have a guard checking everyone coming into building,
you don't need one on every door once they get in.

The guard at the front door only lets one person into the building at
a time. There is no way than visitor can bump into any other people,
even if there are no such guards ensuring no more than one person to a
room.

synchronisation is like a guard ensuring but one thread at a time can
enter a region of code.