There are several key differences:
1) synchronized code always use objects as locks to prevent other threads from entering the synchronized block. For instance methods, they are synchronized on the 'this' reference, and for static methods they are synchronized on the instance of the Class object method belongs to. In blocks if code using the synchronized(object) {} syntax you can use any object as the lock
2) Because of 1) you have a lot more granularity with the synchronized(object) {} syntax rather than synchronized method. You can have different methods synchronize on different objects, or different parts of a method synchronized on different objects.
3) Best practice is to minimize the code inside synchronized blocks because they prevent concurrent threads from executing - losing any advantage of multi-threaded applications. Synchronized blocks help let those portions of a method that do not access shared resources to be run simultaneously while still keeping those parts that need to be shared thread-safe.
To combine 2 and 3, lets setup this scenario:
You have a Customer which has a Shopping Cart and some Recommendations. Your client is allowed to have multiple threads operating on the Customer at once. You have three methods for accessing data to the customer:
In this scenario, you couldn't add an item to the cart in one
thread while adding recommendations in another thread, even though they don't access the same shared data because you are synchronizing on the Customer object. But if you changed it to:
Now you can change recommendations while modifying/displaying the cart and vice-versa and so run more code in parallel.