je voudrais faire accélerer la moto et afficher sa vitesse.
 
 
public class Vehicules {
 
public int vitesse=0;
 
public void accel(){
vitesse++;}
 
public class Moto extends Vehicules{
       public Moto kawa=new Moto();
       }
public static void main(String[] args){
 kawa.accel();
 System.out.println(kawa.vitesse);
 }
}

Et où est ton pb ?

mon prob c'est que ça affiche 0 comme vitesse
alros que je veux exercer la methede dessu pour avoir +1.

Pour moi le code serait :
 
public class Vehicules {  
 
public int vitesse;  
 
public Vehicules() {
vitesse = 0;}  
 
public void accel(){  
vitesse++;}  
}
 
public class Moto extends Vehicules{  
       [...]
}  
 
public static void main(String[] args){  
Moto kawa = new Moto();
kawa.accel();  
System.out.println(kawa.vitesse);  
}
 
Je n'initialise pas les attributs de classe dans leur définition mais plutôt dans le constructeur (ça sert à ça).
Je pense que tu as d'autres fonctions membres dans Moto sinon ç a ne sert à rien de créer une classe qui hérite de Véhicules (kawa = new Vehicules().
Dans la classe Moto, tu crées une instance de cette même classe ce qui me semble peu plausible.

[edit]--Message édité par DuffBeer--[/edit]

 
Tu as créée une instance de moto au début de la définition de ta classe moto. Tu dois créer cette instance dans ta méthode main.
 
public class Moto extends Vehicules
{
...
    public static void main(String[] args)
    {
        Moto kawa=new Moto();
 kawa.accel();
 System.out.println(kawa.vitesse);
    }
}

oui dans la methode main. mais le problème
c'est que après la moto je veux aussi des camions,bus,train..
et je peux pas tout mettre dans la methode main !
suis-je obligé de créer toute mes objet dans main.
(y a un moyen de les créer dans leurs propre clase)
 
en fait mon prob, c'est d'accéder à une variable d'instance par une methode de classe.

Je ne comprend pas pourquoi tu ne veux pas instancier tes classes dans le main, c'est de la conception objet : on déclare et on définie des classes puis on instancie ces mêmes classes dans le main.
Une solution intermédiaire serait :
 
public class Vehicules {  
private int vitesse_;  
public int getVitesse() {
return vitesse_;}
public void setVitesse(int vit) {
vitesse_ = vit;}
public Vehicules() {  
setVitesse(0);}    
public void accel(){  
setVitesse(getVitesse()++);}  
}  
public class Moto extends Vehicules{  
       [...]  
}  
public class Camion extends Vehicules{  
       [...]  
}
public class Bus extends Vehicules{  
       [...]  
}    
public class Train extends Vehicules{  
       [...]  
}  
public class Convoi{  
private Moto moto_;
private Camion camion_;
private Bus bus_;
private Train train_;  
public Moto getMoto(){
return moto_;}
public Camion getCamion(){
return camion_;}
public Bus getBus(){
return bus_;}
public Train getTrain(){
return train_;}
public Convoi(){
moto_ = new Moto();
camion_ = new Camion();
bus_ = new Bus();
train_ = new Train();
}  
public static void main(String[] args){  
Convoi convoi_ = new Convoi();  
convoi_.getMoto().accel();  
System.out.println(convoi_.getMoto().getVitesse());    
}
 
J'espère que ça t'aidera et que je n'es pas fait trop de fautes.

[edit]--Message édité par DuffBeer--[/edit]

over mega cool !
merci

[citation][nom]DuffBeer a écrit[/nom]Je ne comprend pas pourquoi tu ne veux pas instancier tes classes dans le main, c'est de la conception objet : on déclare et on définie des classes puis on instancie ces mêmes classes dans le main.
 
parce que je débute en POO et que visiblement y a des choses que j'ai pas capté.

Si tu débutes en POO, je vais te donner quelques indications.
La durée de vie d'une instance est liée à l'endroit où elle se trouve.
exemple 1 :  
public static void main(String[] args){    
Convoi convoi_ = new Convoi();  
        // création des instances moto, bus...
delete convoi_;
        // destruction de toutes les instances puisqu'elles sont liées à l'instance de Convoi
Moto kawa = new Moto();
Bus bubu = new Bus();
        // création des instances Moto et Bus  
delete kawa;
        // destruction de l'instance Moto
} // destruction de l'instance Bus car fin du programme
 
Java a un avantage (ou inconvénient ?), c'est qu'il a un ramasse-miettes, c'est à dire qu'il se charge de gérer la mémoire et libérer les instances lorsqu'il n'en a plus besoin. Par exemple lorsque je détruit l'instance de Convoi, il se charge de détruire les instances des véhicules dans Convoi.
Dans d'autres langages POO (ex : C++), il faut se charger de ça en implémentant le destructeur.
exemple 2 :  
~Convoi(){
delete moto_;
delete bus_;
delete camion_;
delete train_;
}
 
De même, il convient de libérer toutes les instances que tu as déclaré explicitement avant la fin du programme afin de nettoyer la mémoire (dans Java le ramasse-miette s'en charge cf. exemple 1).
 
Et voilà. Simple non ?

oui je voit pas le rapport avec mes soucis.
 
le garabge collector je l'ai pigé ça.
 
c'est plutôt comment utilisé des variable d'objet dans un main...
main est condamné à utilisé des variable static parce que la methode main est static, et je trouve pas ça limpie. (pour le moment)

main est obligatoirement static du fait kil est appelé depuis l'exterieur pour executer le process...
Mais cela n'empeche pas ke tu instancie des objets a l'interieur...
 
P.S: dsl, mais jai pas tout lu... des topics...

si tu veux une instance d'une classe.. passe par un getInstance()... com ca ta kune instance ki sera utilisée partout... tu n'aura plus ka gerer des compteurs d'instances.. c un peu le principe du getinstance() de Calendar...

Pour ca, tu fais une methode static getInstance() de ta classe ou tu instancie ton objet... ensuite, tu joue avec les compteurs...
Mais, si tu veux plusieurs instances... de la meme classe.. tu peux aussi faire une methode d'instanciation static ki soccup de tout et te retourne une instance... (un new koi )

 
Tu ne peux pas utiliser des variables d'instance de ta classe  Moto dans le main directement.
 
Dans ton main tu dois d'abord créer une instance et ensuite l'utiliser. Dans ton code kawa est variable d'instance et non de classe.
 
vire la ligne "public Moto kawa=new Moto();" et place dans ton main cette ligne :  
Moto kawa=new Moto();
ensuite tu utilise ton objet kawa et invoque ta méthode accel()
kawa.accel();

le probleme viens de l init de la variable membre de la classe moto à 0

lamatrice> Ce ne sont que des indications, tu prends ce qui t'est utile.
Mon explication avait pour but de montrer qu'il était plus intéressant de distinguer l'instanciation des classes dans le main afin de pouvoir gérer séparément leur durée de vie. (solution de [FDS])
La classe Convoi est une solution alternative, mais je ne pense pas que regrouper les instanciations soient intéressant, en effet de cette façon tu lie la durée de vie de l'instance Convoi avec celles des autres véhicules.
Après, peut-être que tu as un intérêt à faire ça et dans ce cas je pense qu'on te proposera une meilleur solution (avis aux experts JAVA).
 

désolé d'avoir crée autant de remous, tout ça parce que  
-voulant jouer le caid, j'ai survoler trop vite des chapitres.
 
-et donc en retournant dans le chapirtre sur la methode main, et en le lisant entirèremen (cette fois). j'ai compris son fonctionnement.
du coup ça me semble clair (en tout cas pour la methode main)
 
-par ce que pour ce qui est des interfaces !!.. qu'on implemente chpigkedal mais je reviendrais avec des questions precises en temps voulu. merci à tous.
 
-encor une question, jamais deux sans douze : c'est au niveau des import de classes et du signe * ce symbole represente le niveau et les sous niveau ou pas ? exemple
import java.awt.*    
import java.awt.event
import java.awt.event.*
avec le premier normallement on devrait plus avoir besoin des deux autres import ? (oui ou non)
 
en fait je suis influencé par le symbole sous ms dos "n'importe quelle caractères".

l'etoile concerne uniquement les classes du package concerné.. les sous packages ne sont pas concernés...

C marrant, habituellement, on en chie avec l'objet plutot au niveau conception et methode ,avec les appels de methodes. Mais a cause du main, c du jamais vu