/////////////////////////////////////////////////////////////////////////////////////
// Exemples où on ne demande rien au type T
/////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////
// sans interface
////////////////////////////////////////////////////

class Couple<T>{
    private T x;
    private T y;
    public Couple(T xx, T yy){
	x=xx;
	y=yy;
    }
    public T getX(){return x;}
    public T getY(){return x;}
}

//ou penser à une classe ListeChainee<T>
//intérêt par rapport à "ne pas utiliser <T> et déclarer x et y comme Object" : x et y doivent être du même type

//attention déclarer class MaClasse<Voiture>  (avec un vrai type qui existe déjà) n'a pas de sens
//le <T> sert justement à déclarer un nom de type variable

class TestCouple{
    public static void main(String []args){
	Couple<Integer> c = new Couple<>(2,3);
	//on peut aussi faire Couple<UneInterface> c2 = ..
    }
}

////////////////////////////////////////////////////
// avec interface
////////////////////////////////////////////////////
    
interface IEnsemble<T>{
     void ajouter(T t);
     void supprimer(T t);
 }


//tout comme dans la librairie Java on a  "class ArrayList<T> implements Collection<T>", ici on aura:


//on peut avoir une classe normale  qui implémente cette interface
class MaCollection implements IEnsemble<String>{
    //.. 
    public void ajouter(String t){
	//..
    }

    public void supprimer(String t){
	//..
    }

}

//ou une classe générique qui implémente cette interface
class Ens<T> implements IEnsemble<T>{
    //on imagine une implem
    public void ajouter(T t){
	//..
    }

    public void supprimer(T t){
	//..
    }
    
    //on peut d'ailleurs utiliser d'autres classes génériques :
    //private ArrayList<T> t;
    //
}

class TestEns{
    public static void main(String []args){
	//1) Ens<Integer> e = new Ensemble();
	//2) on peut aussi faire Ens<UneInterface> e = ..
	//3) On peut aussi imaginer :
	// uneMethode(IEnsemble<T>) (dans une classe ou méthode générique)
	// uneMethode(IEnsemble<Voiture>) 
    }
    
}





/////////////////////////////////////////////////////////////////////////////////////
// Exemples où on demande quelque chose au type T
/////////////////////////////////////////////////////////////////////////////////////
    
//attentin à la syntaxe, c'est class Truc<T extends Interf> et pas Truc<T implements Interf>
					      
////////////////////////////////////////////////////
// ex du cours
////////////////////////////////////////////////////

class Vehicule{}

class Garage<T extends Vehicule> {
}


////////////////////////////////////////////////////
// ex avec du <T extends Interface<T>> 
////////////////////////////////////////////////////

interface Comparable<T>{
    boolean estPlusGrand(T t);
}

class CoupleCompaV1<T extends Comparable<T>>{
    T o1;
    T o2;
    public CoupleCompaV1(T x1, T x2){
	o1 = x1;
	o2 = x2;
    }
    public T getMax(){
	if(o1.estPlusGrand(o2)){
	    return o1;
	}
	else{
	    return o2;
	}
    }
    
}
    
class MonInt implements Comparable<MonInt>{
    int x;
    public MonInt(int xx){x=xx;}
    public boolean estPlusGrand(MonInt m){
	return x>m.x;
    }
}

class Test{
    public static void main(String[] args){
	CoupleCompaV1<MonInt> c1 = new CoupleCompaV1<>(new MonInt(2),new MonInt(3));
	MonInt max = c1.getMax();

	CoupleCompaV1<Gene<String>> c2 = new CoupleCompaV1<>(new Gene<String>("coucou",3),new Gene<String>("hello",4));
    }
}

// pour  poursuivre cet exemple, on peut même faire une classe Generique qui implémente l'interface, cette fois ci on ne "demande rien" au type
    

class Gene<T> implements Comparable<Gene<T>>{ //classe qui permet de "transformer" tout T en type qui implemente l'interface
    T x;
    int i;
    public Gene(T xx, int ii){x=xx;i=ii;}
    public boolean estPlusGrand(Gene<T> t){return i > t.i;}
}


    //   On pourrait utiliser cette classe Gene, soit par comme dans le main au dessus, ou via une autre classe generique

    
class Truc1<T>{ //classe juste pour utiliser CoupleCompaV1
	CoupleCompaV1<Gene<T>> c; //chouette ! car CoupleCompaV1<T> pas possible : T n'implémente pas Comparable, mais Gene<T> oui : Gene a transformé T quelconque en un T qui sait implémenter
}