Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Jolielady wrote:Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Ce n'est pas d'aide dont tu as besoin, mais d'apprendre à programmer.
Jolielady wrote:
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Ce n'est pas d'aide dont tu as besoin, mais d'apprendre à programmer.
Jolielady wrote:Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
En appliquant les notions et les principes dela P.O.O, écrire un
programme qui fait appel aux notions de classe, surcharge, Héritage,
et polymorphisme
Bon
Voici ce que j'ai mais je crois que je n'ai pas le droit de le mettre
comme ça, un à la suite de l'autre, puisque ça génère un méchant
paquet d'erreurs...
alors le voici:
class etudiant {
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Ce n'est pas d'aide dont tu as besoin, mais d'apprendre à programmer.
Salut,
"Jolielady" a écrit dans le message de news:Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
^^^^^^^^
Belge ou Canadienne ? J'ai touvé, Canadienne.
class etudiant {
// Où sont passés tes données ?
private String nom;
private String ecole;
Tu as le droit d'abuser des modificateurs pour expliciter la portée de tes
variables, méthodes et classes.etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
Je suppose que inc_etudiant(), c'est pour incrementer le nombre d'etudiants
?}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
Disons que l'unité de test unitaire en Java est la classe, c'est pourquoi je
te conseille d'avoir une méthode main() dans chacune de tes classes plutôt
que d'avoir recours à une autre classe, ce qui peut générer des diffcultés
supplémentaires, du genre "Dans quel paquetage j'ai mis çà déjà ?"//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
C'est plutôt une redéfinition (désolé pour mon profil C++), qui ne fait ici
pas autre autre chose que le constructeur de la classe dérivée.}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Reprenons, voici une classe de base Etudiant pas trop dégueu :
//--Etudiant.java-----------------------------------------------------------
----------------
import java.lang.*;
import java.io.*;
public class Etudiant {
// données membres privées, principe d'encapsulation
private String nom;
private String ecole;
// donnée propre à la classe, pas à un objet (ou instance de classe)
static private int _nbEtudiants = 0; // nb instances de la classe
Etudiant
// constructeurs
public Etudiant(String nom, String ecole)
{ setNom(nom); setEcole(ecole); _incNbEtudiants(); }
public Etudiant(String nom)
{ setNom(nom); setEcole("Cité"); _incNbEtudiants(); }
// modificateurs
public void setNom(String nom)
{ this.nom = nom; }
public void setEcole(String ecole)
{ this.ecole = ecole; }
// accesseurs
public String getNom()
{ return this.nom; }
public String getEcole()
{ return this.ecole; }
public static int _getNbEtudiants()
{ return _nbEtudiants; }
// a priori, on ne souhaite pas augmenter le nb d'etudiants sans en
creer, donc on peut mettre cette methode private
private static void _incNbEtudiants()
{ _nbEtudiants++; }
public static void main(String someArgs[])
{
Etudiant Celine = new Etudiant("Celine Dion","Ecole de chant du
Quebec");
Etudiant Richard =new Etudiant("Richard Cocciante","Ecole de chant du
Quebec");
System.out.println(Celine.getNom()+" est a l'ecole :
"+Celine.getEcole());
System.out.println(Richard.getNom()+" est a l'ecole :
"+Richard.getEcole());
System.out.println("Y'a "+_getNbEtudiants()+" etudiants");
}
}
...et une classe dérivée pas trop dégueu :
//--EtudiantCite.java-------------------------------------------------------
----------------
import java.lang.*;
import java.io.*;
public class EtudiantCite extends Etudiant {
EtudiantCite(String nom)
{ super(nom,"Cite"); }
// redefinition de la methode heritee getNom() (polymorphisme)
public String getNom()
{ return new String("L'ami "+super.getNom()); }
public static void main(String args[])
{
EtudiantCite Daniel = new EtudiantCite("Daniel Lavoie");
System.out.println(Daniel.getNom()+" est a l'ecole :
"+Daniel.getEcole());
}
}
Pour ce genre de choses, je te conseille enfin de regarder structures de
données et collections toutes faites dans le paquetage java.util pour
ordonner par exemple une liste d'étudiants.
a+, regis
Salut,
"Jolielady" <jolielady@primus.ca> a écrit dans le message de news:
1436d0b5.0402061501.50d5be99@posting.google.com...
Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
^^^^^^^^
Belge ou Canadienne ? J'ai touvé, Canadienne.
class etudiant {
// Où sont passés tes données ?
private String nom;
private String ecole;
Tu as le droit d'abuser des modificateurs pour expliciter la portée de tes
variables, méthodes et classes.
etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
Je suppose que inc_etudiant(), c'est pour incrementer le nombre d'etudiants
?
}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
Disons que l'unité de test unitaire en Java est la classe, c'est pourquoi je
te conseille d'avoir une méthode main() dans chacune de tes classes plutôt
que d'avoir recours à une autre classe, ce qui peut générer des diffcultés
supplémentaires, du genre "Dans quel paquetage j'ai mis çà déjà ?"
//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
C'est plutôt une redéfinition (désolé pour mon profil C++), qui ne fait ici
pas autre autre chose que le constructeur de la classe dérivée.
}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Reprenons, voici une classe de base Etudiant pas trop dégueu :
//--Etudiant.java-----------------------------------------------------------
----------------
import java.lang.*;
import java.io.*;
public class Etudiant {
// données membres privées, principe d'encapsulation
private String nom;
private String ecole;
// donnée propre à la classe, pas à un objet (ou instance de classe)
static private int _nbEtudiants = 0; // nb instances de la classe
Etudiant
// constructeurs
public Etudiant(String nom, String ecole)
{ setNom(nom); setEcole(ecole); _incNbEtudiants(); }
public Etudiant(String nom)
{ setNom(nom); setEcole("Cité"); _incNbEtudiants(); }
// modificateurs
public void setNom(String nom)
{ this.nom = nom; }
public void setEcole(String ecole)
{ this.ecole = ecole; }
// accesseurs
public String getNom()
{ return this.nom; }
public String getEcole()
{ return this.ecole; }
public static int _getNbEtudiants()
{ return _nbEtudiants; }
// a priori, on ne souhaite pas augmenter le nb d'etudiants sans en
creer, donc on peut mettre cette methode private
private static void _incNbEtudiants()
{ _nbEtudiants++; }
public static void main(String someArgs[])
{
Etudiant Celine = new Etudiant("Celine Dion","Ecole de chant du
Quebec");
Etudiant Richard =new Etudiant("Richard Cocciante","Ecole de chant du
Quebec");
System.out.println(Celine.getNom()+" est a l'ecole :
"+Celine.getEcole());
System.out.println(Richard.getNom()+" est a l'ecole :
"+Richard.getEcole());
System.out.println("Y'a "+_getNbEtudiants()+" etudiants");
}
}
...et une classe dérivée pas trop dégueu :
//--EtudiantCite.java-------------------------------------------------------
----------------
import java.lang.*;
import java.io.*;
public class EtudiantCite extends Etudiant {
EtudiantCite(String nom)
{ super(nom,"Cite"); }
// redefinition de la methode heritee getNom() (polymorphisme)
public String getNom()
{ return new String("L'ami "+super.getNom()); }
public static void main(String args[])
{
EtudiantCite Daniel = new EtudiantCite("Daniel Lavoie");
System.out.println(Daniel.getNom()+" est a l'ecole :
"+Daniel.getEcole());
}
}
Pour ce genre de choses, je te conseille enfin de regarder structures de
données et collections toutes faites dans le paquetage java.util pour
ordonner par exemple une liste d'étudiants.
a+, regis
Salut,
"Jolielady" a écrit dans le message de news:Mon travail #2 est le suivant: (et oui je suis etudiante en webmestre)
^^^^^^^^
Belge ou Canadienne ? J'ai touvé, Canadienne.
class etudiant {
// Où sont passés tes données ?
private String nom;
private String ecole;
Tu as le droit d'abuser des modificateurs pour expliciter la portée de tes
variables, méthodes et classes.etudiant(String nom, String ecole)
{
setNom(nom);
setEcole(ecole);
inc_etudiant();
Je suppose que inc_etudiant(), c'est pour incrementer le nombre d'etudiants
?}
etudiant(String nom)
{
setNom(nom);
setEcole("Cité");
inc_etudiant();
}
}
class Test
{
public static void main(String arg[]) {
etudiant un_etudiant = new student("Paul","Algonquin");
etudiant un_autre_etudiant = new student("Roger");
}
}
Disons que l'unité de test unitaire en Java est la classe, c'est pourquoi je
te conseille d'avoir une méthode main() dans chacune de tes classes plutôt
que d'avoir recours à une autre classe, ce qui peut générer des diffcultés
supplémentaires, du genre "Dans quel paquetage j'ai mis çà déjà ?"//Surcharge dans une classe héritée d'une méthode existante
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
public void setName(String nom) {
super.setName(nom);
setSchool("Cité");
}
C'est plutôt une redéfinition (désolé pour mon profil C++), qui ne fait ici
pas autre autre chose que le constructeur de la classe dérivée.}
//Héritage
class etudiant_Cite extends etudiant {
etudiant_Cite(String nom) {
super(nom,"Cité"); // appel du constructeur de la superclasse
}
}
class Test
{
public static void main(String arg[]) {
etudiant_Cite Paul = new etudiant_Cite("Paul");
System.out.println(Paul.getSchool()); // affiche ``Cité''
}
}
//Polymorphisme
class Test {
public static void main(String arg[]) {
etudiant a_etudiant;
a_etudiant = new etudiant("Rachel","Algonquin");
System.out.println(a_etudiant.getNom()); // ``Rachel''
a_etudiant = new etudiant_Cite("toto");
System.out.println(a_etudiant.getEcole()); // ``Cité''
}
Si vous vouliez bien jeter un oeil et me dire ce que vous en pensez,
Merci beaucoup de votre patience, votre gentillesse et SURTOUT votre
AIDE précieuse
Reprenons, voici une classe de base Etudiant pas trop dégueu :
//--Etudiant.java-----------------------------------------------------------
----------------
import java.lang.*;
import java.io.*;
public class Etudiant {
// données membres privées, principe d'encapsulation
private String nom;
private String ecole;
// donnée propre à la classe, pas à un objet (ou instance de classe)
static private int _nbEtudiants = 0; // nb instances de la classe
Etudiant
// constructeurs
public Etudiant(String nom, String ecole)
{ setNom(nom); setEcole(ecole); _incNbEtudiants(); }
public Etudiant(String nom)
{ setNom(nom); setEcole("Cité"); _incNbEtudiants(); }
// modificateurs
public void setNom(String nom)
{ this.nom = nom; }
public void setEcole(String ecole)
{ this.ecole = ecole; }
// accesseurs
public String getNom()
{ return this.nom; }
public String getEcole()
{ return this.ecole; }
public static int _getNbEtudiants()
{ return _nbEtudiants; }
// a priori, on ne souhaite pas augmenter le nb d'etudiants sans en
creer, donc on peut mettre cette methode private
private static void _incNbEtudiants()
{ _nbEtudiants++; }
public static void main(String someArgs[])
{
Etudiant Celine = new Etudiant("Celine Dion","Ecole de chant du
Quebec");
Etudiant Richard =new Etudiant("Richard Cocciante","Ecole de chant du
Quebec");
System.out.println(Celine.getNom()+" est a l'ecole :
"+Celine.getEcole());
System.out.println(Richard.getNom()+" est a l'ecole :
"+Richard.getEcole());
System.out.println("Y'a "+_getNbEtudiants()+" etudiants");
}
}
...et une classe dérivée pas trop dégueu :
//--EtudiantCite.java-------------------------------------------------------
----------------
import java.lang.*;
import java.io.*;
public class EtudiantCite extends Etudiant {
EtudiantCite(String nom)
{ super(nom,"Cite"); }
// redefinition de la methode heritee getNom() (polymorphisme)
public String getNom()
{ return new String("L'ami "+super.getNom()); }
public static void main(String args[])
{
EtudiantCite Daniel = new EtudiantCite("Daniel Lavoie");
System.out.println(Daniel.getNom()+" est a l'ecole :
"+Daniel.getEcole());
}
}
Pour ce genre de choses, je te conseille enfin de regarder structures de
données et collections toutes faites dans le paquetage java.util pour
ordonner par exemple une liste d'étudiants.
a+, regis
Merci beaucoup, avec vos recommandations je vais pouvoir m'appliquer a
voir mon probleme. En passant Regis comment as tu trouver que j'etais
canadienne????
Merci beaucoup, avec vos recommandations je vais pouvoir m'appliquer a
voir mon probleme. En passant Regis comment as tu trouver que j'etais
canadienne????
Merci beaucoup, avec vos recommandations je vais pouvoir m'appliquer a
voir mon probleme. En passant Regis comment as tu trouver que j'etais
canadienne????
