Anwendungen des OODM auf die ADB / NDB

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

Klasse Person

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

Klasse Person public class Person { private String geschlecht; private int geburtsDatum; private int todesDatum; private String geburtsOrt; private String sterbeOrt; private int id; public class Name {//innere Klasse private String nachname; private String vorname; private ArrayList<String> pseudonym = new ArrayList<String> (); private ArrayList<String> namensVariation = new ArrayList<String> (); }//Ende der Inneren Klasse {

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

Konstruktor von Person public class Person { private int id; private static ArrayList<Integer> personenIDListe = new ArrayList<Integer>(); public Person(){ id=(int)(100*Math.random()*Math.random()*10); while(personenIDListe.contains(id)){ }personenIDListe.add(id); } public int getId() { return id; }

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

Eltern und Kinder public class 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);} } public void setMutter(Person mutter) { this.mutter = mutter; mutter.setKinder(this); public Person getMutter() { return mutter;

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

Attribute von Klasse Studiert public class Studiert { private int studiumsId; private int anfang; private int ende; private float anzahlInMonaten; }

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

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

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

Studiert und Person public class Person { Studiert student =new Studiert(); public void 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); }

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

Verschiedene Fächer einer Person public class Studiert { private HashMap<Person,ArrayList<Fach>> personFaecherKombi = new HashMap<Person,ArrayList<Fach>>(); public void setPersonFaecherKombi( Person p, Fach f) { ArrayList<Fach> a = personFaecherKombi.get(f); a.add(f); personFaecherKombi.clear(); personFaecherKombi.put(p,a); }

public class Fach { Studiert studium = new Studiert(); public void 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); }

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

Klasse Werk public class Werk{ private String titel; private int jahr; private int artId; private String artTyp; }

Konstruktor der Klasse Werk public class Werk{ private int artId; private static ArrayList<Integer> artIDListe = new ArrayList<Integer>(); public void Werk(){ artId=(int)(Math.random()*Math.random()*100); while(artIDListe.contains(artId)){ artId=(int)(100*Math.random()*Math.random()*10); }artIDListe.add(artId);} }

Liste von Werken einer Person public class Person { private ArrayList<Werk> werke =new ArrayList<Werk>(); }

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

Leeres Interface Fundstelle public interface Fundstelle { }

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); }

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)){ } referenzIDListe.add(referenzID);

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