public synchronized vod f()
{
  //....(*)
}

public vod f()
{
  synchronized(this)
  {
  //....(*)
  }
}

А>public synchronized vod f()
А>{
А>  //....(*)
А>}
А>

А>public vod f()
А>{
А>  synchronized(this)
А>  {
А>  //....(*)
А>  }
А>}
А>

The synchronized statement (§14.18) computes a reference to an object; it then attempts to perform a lock action on that object and does not proceed further until the lock action has successfully completed. (A lock action may be delayed because the rules about locks can prevent the main memory from participating until some other thread is ready to perform one or more unlock actions.) After the lock action has been performed, the body of the synchronized statement is executed. If execution of the body is ever completed, either normally or abruptly, an unlock action is automatically performed on that same lock.

A synchronized method (§8.4.3.6) automatically performs a lock action when it is invoked; its body is not executed until the lock action has successfully completed. If the method is an instance method, it locks the lock associated with the instance for which it was invoked (that is, the object that will be known as this during execution of the body of the method). If the method is static, it locks the lock associated with the Class object that represents the class in which the method is defined. If execution of the method's body is ever completed, either normally or abruptly, an unlock action is automatically performed on that same lock.

А>>public synchronized vod f()
А>>{
А>>  //....(*)
А>>}
А>>

А>>public vod f()
А>>{
А>>  synchronized(this)
А>>  {
А>>  //....(*)
А>>  }
А>>}
А>>

public static synchronized vod f()
{
  //....(*)
}

public static vod f()
{
  synchronized(TheClass.class)
  {
  //....(*)
  }
}

myobject.privatevariable=newvalue;

public interface ClassLoaderClientConnection {

  byte[] getClassData(String classname) throws NullPointerException, SecurityException, IOException;
    void validate() throws IOException,SocketException
    void tryrepair() throws SocketException;
}

ВП>myobject.privatevariable=newvalue;  
ВП>

ВП>public interface ClassLoaderClientConnection {

ВП>  byte[] getClassData(String classname) throws NullPointerException, SecurityException, IOException;
ВП>    void validate() throws IOException,SocketException
ВП>    void tryrepair() throws SocketException;
ВП>} 
ВП>

• NullPointerException — его вообще выскакивать в правильной программе не должно, если выскакивает надо править код где оно выскакивает
  
• SecurityException — аналогично, только надо править код в том месте, где вызывается метод
  
• SocketException — сразу говорит о том, что мы используем сокеты. А если я захочу грузить классы из БД?

ВП>Потому что в статические методы не передаётся "неявный аргумент объекта". а если работа с SharedJDBCConnection идёт постоянно и интенсивно, то... хотя крохи но "наптимизировать" можно. "Курочка по зёрнышку, а убирать авгиевый курятник пришел Геракл"

что открывает реализацию класса (в том числе и для клиентов функциональных классов).

ВП>>public interface ClassLoaderClientConnection {

ВП>>  byte[] getClassData(String classname) throws NullPointerException, SecurityException, IOException;
ВП>>    void validate() throws IOException,SocketException
ВП>>    void tryrepair() throws SocketException;
ВП>>} 
ВП>>

8.4.3.6 synchronized Methods
These are the same locks that can be used by the synchronized statement (§14.18); thus, the code:

class Test {
    int count;
    synchronized void bump() { count++; }
    static int classCount;
    static synchronized void classBump() {
        classCount++;
    }
}

has exactly the same effect as:

class BumpTest {
    int count;
    void bump() {
        synchronized (this) {
            count++;
        }
    }
    static int classCount;
    static void classBump() {
        try {
            synchronized (Class.forName("BumpTest")) {
                classCount++;
            }
        } catch (ClassNotFoundException e) {
                ...
        }
    }
}

8.4.3.6 synchronized Methods
A synchronized method acquires a lock (§17.1) before it executes. For a class (static) method, the lock associated with the Class object for the method's class is used. For an instance method, the lock associated with this (the object for which the method was invoked) is used.
These are the same locks that can be used by the synchronized statement (§14.18); thus, the code:

class Test {
int count;
synchronized void bump() { count++; }
static int classCount;
static synchronized void classBump() {
classCount++;
}
}

has exactly the same effect as:

class BumpTest {
int count;
void bump() {
synchronized (this) {
count++;
}
}
static int classCount;
static void classBump() {
try {
synchronized (Class.forName("BumpTest")) {
classCount++;
}
} catch (ClassNotFoundException e) {
...
}
}
}

private final Object fooLocker = new Object();
public synchronized void foo() {
}
public void fooTheSameSync() {
   synchronized(fooLocker) {
   }
}

private static final Object fooLocker = new Object();
public static synchronized void foo() {
}
public static void fooTheSameSync() {
   synchronized(fooLocker) {
   }
}

public void foo1() {
   syncronized (this) {
      // Если мы тут, то ни один другой метод не вызывается
      // Из других потоков
   }
}
public void foo2() {
   syncronized (this) {
      // Если мы тут, то ни один другой метод не вызывается
      // Из других потоков
   }
}

• Во-первых, метод помеченный как синхронизированный синхронизируется на объекте, которому он принадлежит, в случае instance метода (и т.д. по спецификации) а не на отдельном объекте для каждого такого метода.
  
• Во-вторых, зачем синхронизировать доступ к отдельному методу? Синхронизация необходима для предотвращения одновременного доступа к объекту, что бы не нарушить инвариантность его состояния. Если для некоторого метода необходимо синхронизировать доступ к некоторому подможеству состояния объекта (читай подможеству атрибутов) нежели в остальных методах, имеет смысл подумать о "выделении класса"!