Preference for interfaces as reference types:
If a suitable interface exists, you should reference objects through it rather than the concrete class.
This applies to parameters, return values, variables, and fields.

Flexibility when using interfaces:
Using interfaces allows you to change the implementation without affecting the code.
Example: changing from LinkedHashSet to HashSet or TreeSet, just change the constructor.

When NOT to use interfaces:
Implementation-specific functionality:
If an implementation offers something not required by the interface (e.g. LinkedHashSet guarantees iteration order, but HashSet does not).

Without a proper interface:
Some classes like String or BigInteger do not have equivalent interfaces and must be used directly.

Class-based frameworks:
Example: OutputStream in the java.io package is referenced through an abstract class, not an interface.

Implementation-specific methods:
Example: PriorityQueue implements Queue, but has a comparator() method not present in Queue. Only use the class if you need this extra method.

Benefit:
Using interfaces makes the program more flexible and modular, allowing you to easily change implementations without breaking existing code.

Code Examples
Good example: Use interface as type

Set s = new LinkedHashSet();

Bad example: Using the concrete class as type

LinkedHashSet s = new LinkedHashSet();

Flexibility: Changing the implementation without affecting the code

Set s = new TreeSet();

Example of using a final class like String

String str = "Hello";

Example of using a framework base class

OutputStream output = new FileOutputStream("file.txt");