import java.lang.Math;

interface Iquadrilatere{
   //tous les attributs sont forcement public static final (même si on le ne mentionne pas!)
   //toutes les méthodes sont forcement public abstract (même si on le ne mentionne pas!) (.. sauf les méthodes "default" où l'on peut mettre du code)
   //pas de constructeur
    public static final int nbcote = 4;
    public abstract int perimetre();
}

class Rectangle implements Iquadrilatere{
    private int l,h;

    public Rectangle(int ll, int hh){
	l=ll;
	h=hh;
    }

    //à implem sinon classe doit être abstraite
    public int perimetre(){
	return 2*(l+h);
    }
}

class Losange implements Iquadrilatere{

    
    // on imagine que l'on code une classe Losange avec les tailles des 2 diagonales (la diag "verticale" et "l'horizontale)
    private int diagH,diagV; 
    
    public  Losange(int t1, int t2){
	diagH = t1;
	diagV = t2;
    }

    public int perimetre(){
	double h = (double)diagH/2;
	double v = (double)diagV/2;
	double diag = Math.sqrt(h*h+v*v);
	return 4*(int)diag;
    }

}


///////////////////////////////////////////////////////
// utilisation & intéret des interfaces
///////////////////////////////////////////////////////

// on a ici une classe dont on peut coder toutes les méthodes sans savoir quel quadrilatère
// se "cache" : on a juste besoin que les objets sachent faire "perimetre" -> donc on utilise Iquadrlatere

class ManipIquadrilatere{
    //surtout pas Rectangle!
    private Iquadrilatere q1;
    private Iquadrilatere q2;

    public ManipIquadrilatere(Iquadrilatere a, Iquadrilatere b){
	q1=a;
	q2=b;
    }

    public int sommePerimetre(){
	return q1.perimetre()+q2.perimetre();
    }

    public int nbcoteTotal(){
	return q1.nbcote+q2.nbcote;//s'écrit aussi return 2*Iquadrilatere.nbcote;
    }

    public static void main(String[] args){
	Rectangle r = new Rectangle(3,4);
	Losange l = new Losange(8,9);
	System.out.println("perim l " + l.perimetre());
	ManipIquadrilatere manip = new ManipIquadrilatere(r,r);
	System.out.println("somme = " + manip.sommePerimetre());
    }
    
}

//les interfaces n'apparaissent pas forcement qu'en attribut d'une classe, on pourrait aussi imaginer un exemple du type

class Outils{
     public static int sommePerimetres(Iquadrilatere[]t){
	 int res = 0;
	 for(int i=0;i<t.length;i++){
	     res+=t[i].perimetre();
	 }
	 return res;
     }

    public static void main(String[] args){
	Rectangle r = new Rectangle(3,4);
	Losange l = new Losange(8,9);
	Iquadrilatere[]t = new Iquadrilatere[2];
	t[0]=r;
	t[1]=l;
	int somme = Outils.sommePerimetres(t);
	System.out.println("somme = " + somme);
    }

}

///////////////////////////////////////////////////////
// héritage entre interfaces
///////////////////////////////////////////////////////

// on ajoute une nouvelle interface 

interface Irectangle extends Iquadrilatere{
    public abstract int getH();
    public abstract int getL();
}

//maintenant, si Rectangle implémentait aussi Irectangle (avec "class Rectangle implements Iquadrilatere, Irectangle {..}"), elle devrait également fournir
//getH et getL