What is the difference between an abstract class and an interface in LLD?

Both an abstract class and an interface define a contract, but they answer different questions, and that's how I decide between them. An abstract class models an is-a relationship and lets subtypes share both state and code. So Vehicle as an abstract class can hold common fields like the license plate and a concrete start method that every vehicle reuses, plus an abstract method like requiredSize that each subclass must define. The key thing is it carries implementation and instance state.

An interface is a pure capability — a can-do. Something like Parkable or Comparable says any class that implements me can do this thing, and those classes don't have to be related at all. A Car and a Bicycle might both be Parkable without sharing a base class. Interfaces hold no instance state; even with Java 8 default methods, which let you add behaviour, there are still no instance fields.

So my rule of thumb is simple: use an abstract class when your subtypes genuinely share implementation and you want to avoid duplicating it, and use an interface when otherwise-unrelated classes need to share a capability. And because Java only allows extending one class but implementing many interfaces, you often combine them — a Car extends the Vehicle abstract class for shared code and implements Parkable and maybe Insurable for orthogonal capabilities. Reaching for an interface when there's real shared code just leads to copy-pasted logic across every implementation.