java lang NullPointerException

Version imprimable

Bonsoir,

Une erreur toute bête et pourtant...

J'ai deux classes que l'on retrouve dans des ArrayList.

La classe Avion et la classe Vol.

A savoir qu'un avion peut réaliser plusieurs vols, en ce sens, j'ai une collection de Vol dans avion.

Aussi, je souhaite pouvoir ajouter des vols à cette collection... Mais mon raisonnement me conduit à un NullPointerException...

Voici des extraits de code :
Code:

1 2 3 4 5 6 7 /*0*/desAvions.add(new Avion("Airbus A340-300", 295, 129300, 55600, 100, 13000, 140640,140640)); /*0*/desVols.add(new VolMilitaire(100,desAvions.get(0))); Vol unVol = desVols.get(0); Avion unAvion = desAvions.get(0); unAvion.addVol(unVol);
Dans la classe Avion
Code:

1 2 3 4 5 6 7 8 private ArrayList<Vol> mesVols; public void addVol(Vol unVol) { mesVols.add(unVol); };
Pourquoi ce dump d'erreur ?

Citation:

Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
at trafficaerien.Avion.addVol(Avion.java:141)
at trafficaerien.i_trafficAerien.initialiser(i_trafficAerien.java:165)
at trafficaerien.i_trafficAerien.initComponents(i_trafficAerien.java:36)
at trafficaerien.i_trafficAerien.<init>(i_trafficAerien.java:29)
at trafficaerien.i_trafficAerien$2.run(i_trafficAerien.java:224)
at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:209)
at java.awt.EventQueue.dispatchEvent(EventQueue.java:597)
at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:269)
at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:184)
at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:174)
at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:169)
at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:161)
at java.awt.EventDispatchThread.run(EventDispatchThread.java:122)

14/04/2009, 21h54
Ricky81

As tu instancié tes listes ? :wink:

Avec l'ensemble du code on y verrait plus clair :P
14/04/2009, 22h04
Deallyra

Les instancier ?

Hum... A quel endroit ?

Dans le code du main oui mais pas dans les classes...

Voici une archive

et s'il faut un modèle conceptuel pour la représentation des données j'en ai un à dispo

(merci)

Dans la classe Avion, tu n'as ni setter te permettant d'attribuer une valeur à "mesVols", ni initialisation.

Tu peux, au choix, compléter ton code ainsi :

Code:

1
2
 
private ArrayList<Vol> mesVols = new ArrayList();

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    /**
     * Constructeur de la classe
     * @param String marque Marque de l'avion
     * @param int capaciteDePersonnes Nombre de places passagers
     * @param int consommationEnVol Carburant consommé lors du trajet de l'avion
     * @param int altitudeMaximale Altitude maximale de couloir aérien pour l'avion
     * @param int volumeDuReservoir Volume de carburant du réservoir.
     */
  	public Avion(String marque, int capaciteDePersonnes, int masseAVide,
            int capaciteDeChargement, int consommationEnVol,
            int altitudeMaximale, int capaciteReservoir, int volumeDuReservoir)
	{
        this.identifiant = ++compteurIdentifiant;
        this.marque = marque;
        this.capaciteDePersonnes = capaciteDePersonnes;
        this.masseAVide = masseAVide;
        this.capaciteDeChargement = capaciteDeChargement;
        this.consommationEnVol = consommationEnVol;
        this.altitudeMaximale = altitudeMaximale;
        this.capaciteReservoir = capaciteReservoir;
        this.volumeDuReservoir = volumeDuReservoir;
        this.mesVols = new ArrayList();
	}

au passage, utilises plutôt l'interface List pour type tes listes :wink:

ex.

Code:

1
2
3
4
5
6
7
 
    private List<Vol> mesVols = new ArrayList();
 
    public List<Vol> getMesVols()
    {
        return this.mesVols;
    };

14/04/2009, 22h23
Deallyra

Si ce n'est pas abuser, que m'apporte de plus l'interface List par rapport à la déclaration en ArrayList ?

(je fais les modifications >.< )
14/04/2009, 22h30
Ricky81

Citation:

Envoyé par Deallyra

Si ce n'est pas abuser, que m'apporte de plus l'interface List par rapport à la déclaration en ArrayList ?

(je fais les modifications >.< )

Ca te permet de manipuler la liste en dehors de ta classe sans être lié à une quelconque implémentation, et donc de changer sans impact l'implémentation le jours ou tu te dis qu'une liste chaînée fais mieux l'affaire. Bonne lecture :wink:
14/04/2009, 22h55
Deallyra

Hum...

Si j'ai bien comprit, je dois préférer List parce que mes collections sont à taille variable tout le temps ?

(merci pour la lecture :3 )
14/04/2009, 23h10
Ricky81

Citation:

Envoyé par Deallyra

Hum...

Si j'ai bien comprit, je dois préférer List parce que mes collections sont à taille variable tout le temps ?

(merci pour la lecture :3 )

Non, à moins de devoir recourir à des spécificités de l'ArrayList en dehors de ta classe, sur la liste qu'une instance de cette classe pourrait retourner, l'objectif est de masquer l'implémentation (donc de permettre aux autres classes de manipuler la liste sans connaître de qu'elle implémentation il s'agit).
14/04/2009, 23h11
tchize_

tu dois préférer List parce que c'est une interface, alors que ArrayList est une implémenation de cette interface. Ca rend ton code plus souple et lpsu évolutif, sans perdre de fonctionnalité, puisque tous tes besoins se retrouvent dans l'interface.
14/04/2009, 23h13
Astartee

Citation:

Envoyé par Deallyra

Si j'ai bien comprit, je dois préférer List parce que mes collections sont à taille variable tout le temps ?

Non...
List est une interface, qui peut être implémentée par différentes classes ayant chacune leurs défauts et leurs qualités (mémoire utilisée, vitesse d'accès aux données, contraintes d'unicité, tri, etc). En gros, du moment qu'on peut ajouter ou enlever des éléments, c'est une liste ; ce qui change c'est la réalité derrière, qui va impliquer des performances différentes selon les traitements effectués.
Aujourd'hui tu utilises une ArrayList et ça convient parfaitement. Tu peux déclarer ta liste en tant que ArrayList, et utiliser "ArrayList" dans toutes tes méthodes. Cependant, si un jour tu décidais d'ajouter de nouveaux traitements sur ta liste, et que tu te rendais compte que d'un point de vue performance il serait plus intéressant d'utiliser un autre type de liste (par exemple LinkedList), tu vas devoir modifier tout ton code. Tandis que si tu avais déclaré des "List" partout au lieu de "ArrayList", la seule modification à effectuer pour utiliser une autre implémentation serait l'instanciation de ta liste : l'expression new ArrayList() à transformer en new LinkedList().
Utiliser l'interface au lieu du type réel te permet de pouvoir faire évoluer ton code plus facilement si nécessaire, c'est tout.
15/04/2009, 07h44
Deallyra

Ok ^^

Merci de vos réponses :)