Interface MyInterface
{
    void doeIets();
}

Class A implements MyInterface
{
    void doeIets()
    {
        .....
    }
}

Class B implements MyInterface
{
    void doeIets()
    {
        .....
    }
}

Class C
{
    //een andere class die niets doet
}

//Deze class gaat objecten accepteren die de MyInterface implementeren.
//Als je geen specifieke interface wilt kan je ook gewoon <T> typen.
//Dan kan deze klasse ieder type object aanvaarden.
Class MySpecialArray<T extends MyInterface>
{


    private data;

    public MySpecialArray()
    {
        data = new T[10]; //onze array kan 10 objecten vasthouden van type T.
    }


    public bool add(T object)
    {
        //some logic checks
        //get an index to store the object

        data[index] = object;
    }

    //..some other colorfull functions


}


//in je applicatie ergens wil je nu die MySpecialArray gebruiken
//wat is er zo speciaal aan? Niets maar als je bv een specifieke collection implementatie wilt omdat je een betere of andere
//collectie manier hebt, dan kan dat. Er zijn al honderden collecties gemaakt.
//Hier dan de usage:
MySpecialArray<A> collectA = new MySpecialArray<A>();
collectA.add(new A());
collectA.add(new B()); //error want we aanvaarden enkel A types.

MySpecialArray<C> collectC = new MySpecialArray<C>(); //error want C extends niet van de interface



//wat hebben we nog? Je kan bv ook key,value gebruiken als generics. (HashMaps maken hier gebruik van)
Class MyAwsomeHashMap<K,V> { ... }