Este es un ejercicio del curso de Java en Coursera.

Estoy tratando de aprender Java para hacer el , que empecé el año pasado para superar mi complejo de inferioridad como programador y no pude terminar porque … no se programar (en Java). Lo cierto es que me compré dos libros para este curso, y me prometí a mi mismo que no iba a comprar más libros hasta no aprender bastante de estos.

Entonces tengo 20 días para ponerme a tiro con este lenguaje, que es bastante pesado. Así que encontré este curso en francés que parece bastante básico y estoy tratando de hacer los ejercicios.

El primero es el más corto, y sirve para practicar polimorfismo, constructores, inheritance y la keyword super. El programa sirve para administrar una base de datos con la gente que va a la universidad, hay una secretaria, un profesor y dos estudiantes.

Todos tienen nombre y año de ingreso, pero después los parámetros de cada objeto son distintos (la secretaria y el profesor tienen un salario, el profesor enseña una materia, los estudiantes tienen una nota promedio).

El programa tiene una clase básica (Lien),

 

class Direction {
  // main: crea un array de Liens y los rellena con objetos
  //        de una clase que desciendo de Liens
  public static void main(String[] args) {
    // creo un array de liens
    Lien[] l = new Lien[4];
    // lo relleno con descendientes de liens
    l[0] = new Etudiant("Gaston Peutimide", 2013, "systèmes", 6.0);
    l[1] = new Etudiant("Yvan Rattrapeur", 2011, "systèmes", 2.5);
    l[2] = new Secretaire("Sophie Scribona", 2005, "LMT", 5000.0);
    l[3] = new Enseignant("Mathieu Matheu", 1998, "Mathématiques Pures", 
                                                  10000.0, "Physique");
    for (int i = 0; i < l.length; i++) {
      System.out.println(l[i]);
      System.out.println("-------------");
    }
  }
}
class Lien {
  // atributos: los heredan todos los objetos
  String nom;
  int anne;
  // constructor
  Lien(String nom, int anne) {
    this.nom = nom;
    this.anne = anne;
  }
  // imprimir, los objetos que descienden de Lien
  // llaman este método y agregan cosas
  public String toString() {
    return "Nom: " + nom + "\n" + "Anne: " + anne;
  }
}

class Employee extends Lien {
  // atributos propios de esta clase
  double salaire;
  String labo;
  // constructor
  Employee(String nom, int anne, String labo, double salaire) {
    super(nom, anne);
    this.labo = labo;
    this.salaire = salaire;
  }
  // para imprimir el objeto
  public String toString() {
    // uso super para llama el mismo método de la super clase
    String s = super.toString();
    s = s + "\nLaboratoire: " + labo;
    s = s + "\nSalaire: " + salaire;
    return s;
  }
}

class Secretaire extends Employee {
  // constructor
  Secretaire(String nom, int anne, String labo, 
                                   double salaire) {
   // llama al constructor de la super clase
    super(nom, anne, labo, salaire); 
  }
  // imprime el objeto
  public String toString() {
  String s = super.toString();
  return "Secretaire: \n" + s;
  }
}

class Enseignant extends Employee {
  // atributos
  String section;
  // constructor
  Enseignant(String nom, int anne, String labo, 
                         double salaire,String section) {
    // llama al constructor de la super-clase
    super(nom, anne, labo, salaire);
    // asigna los campos propios de esta clase
    this.section = section;
  }
  // para imprimir el objeto
  public String toString() {
    String s = super.toString();
    s = "Enseignant: \n" + s + "\nSection: " + section;
    return s;
  }
}

class Etudiant extends Lien {
  //atributos
  String section;
  double note;
  // constructor
  Etudiant(String nom, int anne, 
            String section, double note) {
    super(nom, anne);
    this.section = section;
    this.note = note; 
  }
  public String toString() {
    String s = super.toString();
    s = s + "\nSection: " + section;
    s = s + "\nNote Moyenne: " + note;
    return "Etudiant: \n" + s;
  }
}

Lo más complicado del programa es el uso de super. Usar super.toString() no parece muy ortodoxo. No entiendo si super es una keyword o un método.

Lo otro parece bastante raro viniendo de un lenguaje con dynamic typing como Python o Ruby. En el método principal, creo un array de Liens, y después lo relleno con objetos de clases descendientes de Liens.

Luego, itero el el array y llamo toString() de cada objeto. Y estoy llamando a toString() de las subclases (Secretaire, Etudiant, etc.). Lo que hace el compilador es evaluar el receptor del mensaje l[0], y enviarle a ese objeto el mensaje toString(). Lo más raro es que el type checker haya dejado pasar el hecho de que l es un array de Liens pero tiene Secretaires, Etudiants, etc. adentro…

 

 

Anuncios