# Aeroport

Cet exercice calcule le seuil de rentabilité des vols d’une compagnie aérienne.

Un aéroport est détermine par :  
• Un nom de code (chaîne de caractères).  
• Une longitude x (entier).  
• Une latitude y (entier).  
Ecrivez une classe Aeroport munie des attributs necessaires.  
Ecrivez un constructeur prenant en param`etres les donnees necessaires a son initialisation.  
Ecrivez un accesseur getNom du nom de code de l’aeroport.

  
Ecrivez une méthode distance(aero2) qui calcule et renvoie la distance d qui separe deux  
aeroports :

sqrt( (x2-x1)^2 +(y2-y1)^2)

```Java
import java.lang.Math;
public class Aeroport {
private String m_nom; // nom de code
private int m_x; // longitude
private int m_y; // latitude
public Aeroport(String n, int x, int y){
m_nom = n;
m_x = x;
m_y = y;
}
public String getNom(){
return m_nom;
}
public double distance(Aeroport aero2){
double dx = (m_x - aero2.m_x);
double dy = (m_y - aero2.m_y);
return Math.sqrt(dx*dx + dy*dy);
}
}
```

Pour simplifier, on suppose que le coˆut d’un vol est independant du nombre de passagers  
transportes : il est uniquement fonction de la capacite k de l’avion, du nombre de membres  
d’equipage m et de la distance d entre les aeroports selon la formule :  
100\*d\*sqrt(k+m)+50\*sqrt(d)  
Un vol sera donc constitue de :  
• Un nom (chaine de caract`eres).  
• Le nombre maximum de passagers k (entier positif) que l’avion peut transporter.  
• Le nombre de membres d’equipage m (entier positif).  
• La distance d (reel) entre les aeroports de depart et de destination

```Java
import java.lang.Math;
public class Vol {
private String m_nom; // nom du vol
private int m_k; // capacite (# de passagers)
private int m_m; // # de membres d’equipage
private double m_d; // distance
public Vol(String n, int k, int m, double d){
m_nom = n;
m_k = k;
m_m = m;
m_d = d;
}
public double eval(){return 100 * m_d * Math.sqrt((double)(m_k + m_m)) + 50 * Math.sqrt(m_d);
}
}
```

La compagnie a´erienne se pose la question suivante :  
« Les billets ´etant vendus PRIX\_BILLET euros, combien de passagers faut-il au  
minimum pour que le vol soit rentable ? ».  
Votre programme doit :  
• Instancier deux Aeroports et les initialiser avec les a´eroports de Mulhouse et de  
New-York.  
• Calculer et afficher la distance entre les a´eroports.  
• Instancier le Vol correspondant.  
• Calculer et afficher le coˆut du vol.  
• Demander le prix du billet.  
• Calculer et afficher le nombre de passagers minimum pour que le vol soit rentabilis´e.

```Powershell
Distance entre MLH et JFK = 46.6154
Cout du vol = 82151.2
Prix du billet? 400
Nombre de billets a vendre = 206
```

```Java
import java.util.Scanner;
import java.util.Locale;
import java.lang.Math;
public class PGCompagnie{
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
cin.useLocale(Locale.US);
Aeroport a1 = new Aeroport("MLH", 2, 46);
Aeroport a2 = new Aeroport("JFK", 40, 73);
double d = a1.distance(a2);
System.out.println("Distance entre "+a1.getNom()
+" et "+a2.getNom()
+" = "+d);
Vol vol = new Vol("EPF 123", 300, 8, d);
double c = vol.eval();
System.out.println("Cout du vol = "+c);
System.out.print("Prix du billet? ");
double prixbillet = cin.nextDouble();
int np = (int)(Math.ceil(c / prixbillet));
System.out.println("Nombre de billets a vendre = "+np);
}
}

```