Cursus Java2 1.5: Oefeningen op overerving

Toepassing: maak een toepassing bestaande uit drie klassen:

Student: houdt de naam, voornaam en leeftijd van een Student bij. Voorzie een gepaste constructor.
Klas: houdt de naam van een klas bij en de studenten van de klas (in een Arraylist van Student-objecten).
Met de methode nieuweStudent voeg je een Student toe aan de Klas. Met de methode toonStudenten toon je de studenten van de klas.

Extra: Maak een methode sorteer die de Studenten van de klas sorteert op naam.
Schoolprog: hoofdroutine - hier maak je klassen (1A, 1B, 2A, ...) aan, voeg je studenten toe aan de klassen, toon je klassen.

Toon /verberg

/* *********************************************************************
 * Klasse : Student

 * Doel: info over een student
 *         
 * **********************************************************************/
public class Student{
    
    public String naam;
    public String voornaam;
    public int leeftijd;
    
    
    public Student(String naam, String voornaam, int leeftijd) {
        this.naam = naam;
        this.voornaam = voornaam;
        this.leeftijd = leeftijd;
    }   
}



import java.util.*;
/* *********************************************************************
 * Klasse : Klas

 * Doel: info over een klas, bevat een ArrayList met studenten
 *         
 * **********************************************************************/
public class Klas  {
    
    protected String naam;
    ArrayList studenten = new ArrayList();
   
    public Klas(String n) {
        naam = n;
    }
    
    public void nieuweStudent(String n,String v, int l){
        Student nstudent = new Student(n,v,l);
        studenten.add(nstudent);
    }
    
    public void toonStudenten(){
        for(int i=0;i<studenten.size();i++){
            System.out.println(((Student)studenten.get(i)).naam +" " 
                                +((Student)studenten.get(i)).voornaam
                                +" " +((Student)studenten.get(i)).leeftijd);
        }
    }
    
    
    /* ******************************************************
     * methode: sorteer
     * doel: zelfgeschreven sorteeralgoritme
     * werking : eerst alle namen van studenten in en ArrayList stoppen
     *           deze nieuwe ArrayList sorteren
     *           Studenten aan ArrayList stsort toevoegen in de volgorde van de namen
     *           ArrayList studenten gelijkstellen aan stsort
     * *******************************************************/
    public void sorteer(){
        ArrayList namen = new ArrayList();
        ArrayList stsort = new ArrayList();
        
        for(int i=0;i<studenten.size();i++){
            namen.add((String)((Student)studenten.get(i)).naam);
        }
        Collections.sort(namen);
        
        for(int i=0;i<namen.size();i++){
            for(int j=0;j<studenten.size();j++){
                if((String)((Student)studenten.get(j)).naam == (String)namen.get(i)){
                    stsort.add(studenten.get(j));
                }
            }
        }
        
        this.studenten = stsort;
        
        namen = null;
        stsort=null;
    }
    
   
}



import java.util.*;
/* *********************************************************************
 * Klasse : Schoolprog

 * Doel: hoofdroutine voor het programma
 * **********************************************************************/
public class Schoolprog {
    
    
    public static void main(String[] args) {
        Klas klas1 = new Klas("1A");
        Klas klas2 = new Klas("1B");
        
        klas1.nieuweStudent("Peters","Jefke",18);
        klas1.nieuweStudent("Janssens","Sofie",23);
        
        //gebruik van eigen sorteeralgoritme
        klas1.sorteer();
        klas1.toonStudenten();
        
    }
}

Uitvoer:

Janssens Sofie 23
Peters Jefke 18

School 2 - ListIterator

Toepassing: School2: ListIterator

Gebruik voor het tonen van de Studenten geen zelgemaakte lus maar maak gebruik van de ListIterator-interface.

Lijst-objecten zoals een ArrayList, LinkedList, ... erven over van de klasse AbstractList. Deze klasse vormt een lege implementatie van de List-interface (vergelijkbaar met adapterklassen). De List-interface bevat een aantal handige methoden , o.a. methode listIterator om een lijstiterator aan een lijst-object toe te voegen.

Aangezien een ArrayList reeds overerft van de AbstractList-klasse kunnen we de List-methoden onmiddellijk gebruiken bij het maken van een ArrayList.

In de oplossing gebruik ik de methode listIterator, deze methode retourneert een ListIterator-object waarmee we door de lijst kunnen scrollen (voorwaarts en achterwaarts). Een ListIterator-object ondersteund onder meer de methoden hasNext en next.

Voor een handige werking van de ListIterator met de Student-objecten stel ik eerst een Student-object gelijk aan de volgende waarde van de ListIterator. Ik zorg er dan wel voor dat de klasse Student een constructor zonder parameters bevat.

Toon /verberg

public class Klas  {
	...
	public void toonStudenten(){
        	ListIterator stit = studenten.listIterator();
        	Student nst = new Student();
        	while(stit.hasNext()){  
            	nst = (Student)stit.next();
            	System.out.println(nst.naam +" " +nst.voornaam +" " +nst.leeftijd);
        	}
    }
	...
}

public class Student{
    
    ...
    
    public Student(){
    }
	...
}

School 3 - Comparable

Toepassing: School3: Comparable

Zorg er voor dat bij het tonen van studenten deze automatisch per leeftijd worden gesorteerd, maak gebruik van de interface Comparable.

De interface Comparable staat je toe de natuurlijke sortering van elementen aan te geven.

De methode compareTo moet worden geïmplementeerd, binnen deze methode geef je de sortering op.
Je zorgt ervoor dat de methode compareTo een negatief getal, nul of een postitief getal retourneert bij minder, gelijk of groter dan het specifiek object.
Bij het gebruik van deze methode moet je de ClassCastException opwerpen om zeker te zijn dat je dezelfde objecten vergelijkt.

Met de sort-methode van de Collections-klasse uit het pakket java.util kan je de sortering doorvoeren. Als argumenten geef je een object uit een klasse door die de interface Comparable implementeert.

Toon /verberg

/* *********************************************************************
 * Klasse : Student

 * Doel: info over een student
 * Interfaces: Comparable - standaardsortering via methode compareTo
 *              met deze interface kan je instanties van deze klasse
 *              vergelijkbaar maken.           
 * **********************************************************************/
public class Student implements Comparable{
    
    ...
    
     /* *********************************************************************
     * methode: CompareTo - verplicht uit interface Comparable
     * Doel: standaardsortering bij het sorteren van Studenten
     * 
     * werking: algmeen : public int compareTo(Object o)                     
     * **********************************************************************/
    public int compareTo(Object andereStudent) throws ClassCastException {
    	if (!(andereStudent instanceof Student))
      		throw new ClassCastException("Student-object verwacht.");
    	int andereStudentLeeftijd = ((Student) andereStudent).leeftijd;  
    	return this.leeftijd - andereStudentLeeftijd;    
  }
}


import java.util.*;

public class Klas  {
  ...
}


import java.util.*;
/* *********************************************************************
 * Klasse : Schoolprog

 * Doel: hoofdroutine voor het programma
 * **********************************************************************/
public class Schoolprog {
    
    
    public static void main(String[] args) {
        Klas klas1 = new Klas("1A");
        Klas klas2 = new Klas("1B");
        
        klas1.nieuweStudent("Peters","Jefke",18);
        klas1.nieuweStudent("Janssens","Sofie",23);
        
        Collections.sort(klas1.studenten);
        klas1.toonStudenten();
        System.out.println("");
        
        
        klas2.nieuweStudent("Lopers","Jenny",19);
        klas2.nieuweStudent("Averechts","Eric",52);
        klas2.nieuweStudent("Dippie","Koen",36);
        
        Collections.sort(klas2.studenten);
        klas2.toonStudenten();
        System.out.println("");
        
    }
    
}

Uitvoer:

Peters Jefke 18
Janssens Sofie 23

Lopers Jenny 19
Dippie Koen 36
Averechts Eric 52

School 4 - Comparator

Toepassing: School4: Comparator

Wanneer je meerdere sorteermogelijkheden maak je best gebruik van de interface Comparator uit het pakket java.util. Deze interface vereist dat je de methode compare overridet.

In de oplossing zorgen we ervoor dat we drie Comparator-instanties hebben waarmee we kunnen sorteren op leeftijd, naam en voornaam. Voor het maken van de Comparator-objecten maken we gebruik van anonieme binnenklassen met supertype Comparator.

Toon /verberg

import java.util.Comparator;


/* *********************************************************************
 * Klasse : Student

 * Doel: info over een student
 * 
 *             
 * **********************************************************************/
public class Student {
    
    ...
    
     
    public static Comparator leeftijdComparator = new Comparator() {
    public int compare(Object student, Object anderestudent) {
      int leeftijd1 = ((Student) student).leeftijd;
      int leeftijd2 = ((Student) anderestudent).leeftijd;
      if(leeftijd1 < leeftijd2) return -1;
      if(leeftijd1 > leeftijd2) return 1;
      else return 0;
    }
   };
    
    public static Comparator naamComparator = new Comparator() {
    public int compare(Object student, Object anderestudent) {
      String naam1 = ((Student) student).naam;
      String voornaam1 = ((Student) student).voornaam;
      String naam2 = ((Student) anderestudent).naam;
      String voornaam2 = ((Student) anderestudent).voornaam;

      if (!(naam1.equals(naam2)))
        return naam1.compareTo(naam2);
      else
        return voornaam1.compareTo(voornaam2);
    }
  };
  
  public static Comparator voornaamComparator = new Comparator() {
    public int compare(Object student, Object anderestudent) {
      String naam1 = ((Student) student).naam;
      String voornaam1 = ((Student) student).voornaam;
      String naam2 = ((Student) anderestudent).naam;
      String voornaam2 = ((Student) anderestudent).voornaam;

      if (!(voornaam1.equals(voornaam2)))
        return voornaam1.compareTo(voornaam2);
      else
        return naam1.compareTo(naam2);
    }
  };
}


import java.util.*;

public class Klas  {
	...
}


import java.util.*;

/* *********************************************************************
 * Klasse : Schoolprog

 * Doel: hoofdroutine voor het programma
 * **********************************************************************/
public class Schoolprog {
    
    
    public static void main(String[] args) {
        Klas klas1 = new Klas("1A");
        Klas klas2 = new Klas("1B");
        
        klas1.nieuweStudent("Peters","Jefke",18);
        klas1.nieuweStudent("Janssens","Sofie",23);
          
        klas2.nieuweStudent("Lopers","Jenny",19);
        klas2.nieuweStudent("Averechts","Eric",52);
        klas2.nieuweStudent("Dippie","Koen",36);
        
        
        //sorteringen volgens een Comparator-klasse
        //hiervoor hebben we in de klasse Student het pakket java.util.Comparator nodig
        Collections.sort(klas2.studenten,Student.leeftijdComparator);
        klas2.toonStudenten();
        System.out.println("");
        
        Collections.sort(klas2.studenten,Student.naamComparator);
        klas2.toonStudenten();
        System.out.println("");
        
        Collections.sort(klas2.studenten,Student.voornaamComparator);
        klas2.toonStudenten();
        System.out.println("");
        
        
    }
    
}

Cursus Java2 1.5: Oefeningen overerving

School1 - klassen

School 2 - ListIterator

School 3 - Comparable

School 4 - Comparator