Anwendungen des OODM auf die ADB / NDB

1. Anwendungen des OODM auf die ADB / NDB

2. Umsetzung des Er Diagramms in ein Objektorientiertes Datenmodell • Versuch möglichst nah am Konzept des Diagramms zu bleiben • Entitäten als Objekte realisiert • Für die Realisierung Java verwendet • Ergebnis: 10 Klassen

4. Klasse Person

5. Klasse Person • Atomare Attribute als elmentare Typen • Attribut mit weiteren Attributen als innere Klasse • Mehrwertige Attribute als ArrayList • Kapselung der Attribute und daraus folgende Probleme

6. Klasse Person • publicclass Person { • private String geschlecht; • privateint geburtsDatum; • privateint todesDatum; • private String geburtsOrt; • private String sterbeOrt; • privateint id; • publicclass Name {//innere Klasse • private String nachname; • private String vorname; • privateArrayList<String> pseudonym = new ArrayList<String> (); • privateArrayList<String> namensVariation = new ArrayList<String> (); }//Ende der Inneren Klasse • {

7. Klasse Person • Sicherstellung der Objektidentität. Jedes Objekt bekommt eine eindeutige Identifikation OID • Einsatz des Konstruktor • Automatische OID Erzeugung • Speicherung der ID in einer statischen ArrayList • ArrayList von außen nur über „get“-Methode erreichbar • Keine Set-Methode für IDListe

8. Konstruktor von Person • publicclass Person { • private int id; • privatestatic ArrayList<Integer> personenIDListe = newArrayList<Integer>(); • public Person(){ • id=(int)(100*Math.random()*Math.random()*10); • while(personenIDListe.contains(id)){ • id=(int)(100*Math.random()*Math.random()*10); • }personenIDListe.add(id); • } • publicint getId() { • return id; } • }

9. Eltern und Kinder • Verbindung mit Eltern über Referenzvariable • Kinder werden in ArrayList<Person> gespeichert • Beim verbinden der Eltern auch automatischer Eintrag in der Kinder-ArrayList • Get-Methoden für Mutter, Vater und Kinder

10. Eltern und Kinder • publicclass Person { • private ArrayList<Person> kinder = new ArrayList<Person>(); • private Person vater; • private Person mutter; • public void setKinder(Person kind) { • If(!kinder.conatins(kind)){ • kinder.add(kind);} • } • publicvoid setMutter(Person mutter) { • this.mutter = mutter; • mutter.setKinder(this); • } • public Person getMutter() { • return mutter; • }

12. Personen und Studium • Klasse Studiert • Klasse Institution • Klasse Fach • Atomare Attribute wie vorher schon gezeigt • OID wie bereits bei der Klasse Person gezeigt über Konstruktor • Studiert als eigene Klasse, da eigene Attribute im Diagramm • Person, Institution und Fach haben jeweils eine Referenz auf ein Objekt von Studiert • Problem: zeigen nicht auf das gleiche Objekt. Entwurfsmuster Singelton-Objekt auch keine Lösung

13. Attribute von Klasse Studiert • publicclass Studiert { • privateint studiumsId; • privateint anfang; • privateint ende; • privatefloat anzahlInMonaten; • }

14. Konstruktor der Klasse Studiert • publicclass Studiert { • privateint studiumsId; • privateint anfang; • privateint ende; • privatefloat anzahlInMonaten; • private ArrayList<Integer> studiumsIDListe = new ArrayList<Integer>(); • public Studiert(){//Konstruktor • studiumsId=(int)(100*Math.random()*Math.random()*10); • while(studiumsIDListe.contains(studiumsId)){ • studiumsId=(int)(100*Math.random()*Math.random()*10); • }studiumsIDListe.add(studiumsId); • } • }

15. Studierende Personen • public class Studiert { • private HashMap<Person,ArrayList<Institution>> personMap = new HashMap<Person,ArrayList<Institution>>(); • publicvoid setPersonenMap(Person p, ArrayList<Institution> iL){ • personMap.put(p,iL); • } • //überladene set-methode für Personen(Key) Institutionen(Value) • publicvoid setPersonenMap( Person p, Institution iL){ • ArrayList<Institution> i = personMap.get(p); • i.add(iL); • personMap.clear(); • personMap.put(p,i); • } • }

16. Studiert und Person • Erstellung eines „Studium“ Objekts in der Klasse „Person“ • Set-Methode greift über die Referenz auf die Objekt eigenen Setter-Methoden • Wichtigsten Informationen werden übergeben

17. Studiert und Person • publicclass Person { • Studiert student =new Studiert(); • publicvoid setStudienInformationen(int a, int e, float f, Institution i,String fachName){ • student.setAnfang(a); • student.setEnde(e); • student.setAnzahlinMonaten(f); • student.setPersonenMap(this,i); • Fach fach =new Fach(fachName); • student.setPersonFaecherKombi(this, fach); • }

18. Nach dem gleichen Prinzip greifen auch die Klassen Institution und Fach auf das Studiums Objekt zu. • Unterschied: • Fach speichert die Personen –Fächer Kombinationen ab. • Institution wie viel Personen an einer Institution studieren

19. Verschiedene Fächer einer Person • publicclass Studiert { • private HashMap<Person,ArrayList<Fach>> personFaecherKombi= newHashMap<Person,ArrayList<Fach>>(); • publicvoidsetPersonFaecherKombi( Person p, Fach f) { • ArrayList<Fach> a = personFaecherKombi.get(f); • a.add(f); • personFaecherKombi.clear(); • personFaecherKombi.put(p,a); • } }

20. publicclass Fach { • Studiert studium = new Studiert(); • publicvoid setStudienInformationen(int a, int e, float f, Institution i, Person p){ • studium.setAnfang(a); • studium.setEnde(e); • studium.setAnzahlinMonaten(f); • studium.setPersonenMap(p,i); • studium.setFachPersonenKombi(this,p); • } }

23. Werke einer Person • Werk und Art_des_Werks zu einer Klasse zusammengefasst • Werk schwache Entität • Attribute wie voran gegangen umgesetzt • Innerhalb der Klasse Person eine ArrayList welche nur Objekte vom Typ Werk aufnimmt • Plus übliche Getter und Setter Methoden

24. Klasse Werk • publicclass Werk{ • private String titel; • privateint jahr; • privateint artId; • private String artTyp; • }

25. Konstruktor der Klasse Werk • publicclass Werk{ • privateint artId; • private static ArrayList<Integer> artIDListe = new ArrayList<Integer>(); • publicvoid Werk(){ • artId=(int)(Math.random()*Math.random()*100); • while(artIDListe.contains(artId)){ • artId=(int)(100*Math.random()*Math.random()*10); • }artIDListe.add(artId);} • }

26. Liste von Werken einer Person publicclass Person { • private ArrayList<Werk> werke =new ArrayList<Werk>(); }

28. Verbindung zwischen Person und Fundstelle per Interface gelöst • Fundstelle fungiert als Interface für • Referenz und Priorität • In den Klassen Porträt und Referenz Attribute wie vorangegangen umgesetzt • Mit Konstruktor OID automatisch erstellt • In der Klasse Person eine ArrayListe vorhanden, welche nur Objekte vom Typ Fundstelle annimmt

29. Leeres Interface Fundstelle • public interface Fundstelle { • }

30. Klasse Proträt mit Interface Fundstelle • public class Protraet implements Fundstelle { • private String titel; • private int jahr; • private String autor; • private String ausstellungsOrt; • private static ArrayList<String> titelListe = new ArrayList<String>(); • public Protraet(String titel){ • this.titel= titel; • titelListe.add(titel); • } • }

31. Referenz und Interface Fundstelle • public class Referenz implements Fundstelle { • private int referenzID; • private String autor; • private String titel; • private String verlag; • private ArrayList<String> seiter; • private static ArrayList<Integer> referenzIDListe = new ArrayList<Integer>(); • public Referenz(){ • referenzID=(int)(100*Math.random()*Math.random()); • while(referenzIDListe.contains(referenzID)){ • referenzID=(int)(100*Math.random()*Math.random()); • } • referenzIDListe.add(referenzID); • }

32. Fundstellen in der Klasse Person • public class Person { • private ArrayList<Fundstelle> fundstellen = new ArrayList<Fundstelle>(); • }