Object oriented design is a pretty neat concept, but I'm struggling on how to wrap my head around most of its facets. I think the key to a good object oriented design is having a good grasp on how to look at it. I usually look at object-oriented this way:

Classes are Real-world entities or objects

Instance Fields are entity's attributes, ('has A')

Methods are like actions, verbs, Entity's abilities 

Interfaces are like abilities that you can imbue on an object. It could also be an 'is A or can do' relationship whose implementations are not set in stone. Superman is a Krypton, being a Kryptonian comes with a set of special abilities, like flying, freeze-breath, etc. Superman fly different from Green Lantern and Goku and especially Batman, that is why Flight as interface is probably a good idea if you're creating a Fictional Universe.

```
public class SuperMan extends Man implements Kryptonian{}

public interface Kryptonian extends Flight, FreezeBreath{
    public void fly();
    public void coolBreath();
}

```

Problem comes along when you add Generics into the mix? Because the given type parameters somehow creates a contract between the class/interface and the type.

```
public interface Flight<T>{
     public void fly(T t);
}

```

In this example, Flight is coupled with a T, T could be a superhero a bird or anything that can fly.But is that really how I should imagine it? Because that seems like the same as what plain interfaces do? Although, a parameterized interface is still an interface, the coupling with the type T is what really bothers me. Moreover, things also get complicated when you add bounded restriction on the parameter type. 

```
public class Pidgey<T extends Bird> implements Flight<T>{}

```

what real-world concrete object can you identify T with? The above example is pretty wrong, although using the class parameter to also restrict the type of Flight is probably a good design, because Flight is still independent enough that other classes could still use it without any restriction. But the example itself is wrong. Pidgey is a Bird that can fly, but what what could T be? Well, T could be anything, it could be another object or abilities. The question is what are its implications, why put T there? What are real-world examples of doing so?

It's easy to understand when you talk about collections, since collections are like containers. You can create a wide variety of containers that holds different kinds of objects.

```
public class WaterBottle<T extends Liquid> implements UniqueCap{}

```

But I've seen Generics being used not just on a container-like objects? How could one design such objects, what did they consider?