Not sure if he's mistaken or just used unfortunate wording.

Essentially, having a bunch of synchronized methods on a class, means
that for the duration of the client code calling those individual
methods, there is a lock preventing another thread accessing something.

However, if the client code does not obtain a lock on the entire object
(or the part of it that needs protecting) when calling those
synchronized  methods, then multiple threads can cause problems.

E.g.

class MySynchronizedClass {
  public synchronized int getValue() {
    return theValue;
  }

  public synchronized void increment() {
     theValue++;
  }

  private int theValue = 0;
}

Now, the two methods are synchronized, but unless the client code which
makes use of both methods, synchronizes the entire object, then we have
problems. E.g.

// client code using the above class.

void someMethod(MySynchronizedClass synchronizedClass) {
   if (synchronizedClass.getValue() == 10) {
      synchronizedClass.increment();
   }
}

The problem here, is that the lock is obtained for the duration of each
method. So lock is obtained when getValue() is called, then released.
Then obtained again when increment() is called and released.

This means that during the time it takes one thread to move from the
getValue() to the increment() call, another thread may have already
called increment().  Which would mean that the increment() method has
been called twice.

The code should be...

void someMethod(MySynchronizedClass synchronizedClass) {

   synchronize(synchronizedClass) {
     if (synchronizedClass.getValue() == 10) {
        synchronizedClass.increment();
     }
   }

}

This mean the lock will be obtained for the entire duration and no other
thread can get between the two methods.

Is he wrong? Or does he make the additional assumption that the class is
well designed? My opinion of the standard Java classes is that they are,
although arguably not perfect.