Java 1: N beziehung uml, verständnisfragen

[ali7566]

Hallo leute,

ich habe folgendes Programm Programmiert jedoch sind mir einzelne Punkte noch nicht ganz klar.

Es handelt sich um eine 1:N beziehung zwischen Arzt und Patient: 1 Arzt hat mehrere Patienten.

Hier mal das Programm mit den Klassen:

Die 3te Klasse:

import java.util.ArrayList;
import java.util.Iterator;

public class doc
{
static int krank;
static String fach, isim;

public static void main(String [] args)
{
Arzt meinArzt= new Arzt();
meinArzt.setName("Alixxxx");
meinArzt.setFachgebiet("Dermatologie");

Patient meinPatient= new Patient(meinArzt);
meinPatient.setName("Klaus");
meinPatient.setKrankenkassennummer(12345);

Patient meinPatient2= new Patient(meinArzt);
meinPatient2.setName("Dieter");
meinPatient2.setKrankenkassennummer(123456);

System.out.println("Die Patienten von Dr. "+meinArzt.getName()+" lauten: \n"+" Fachgebiet: "+meinArzt.getFachgebiet());

ArrayList liste1= meinArzt.getMeinPatient();
//Was passiert hier genau, das Obejkt holt sich mit der methode get die Patiendendaten ?

Iterator i= liste1.iterator();

while(i.hasNext()) //Was bedeutet das i.hasNext() genau ? {
Patient einPatient= ((Patient)i.next()); //was hat i.next
isim= einPatient.getName(); // dann zu bedeuten ?
krank= einPatient.getKrankenkassennummer();
System.out.println(isim);
System.out.println(krank);
}

}
}

Die Klasse Arzt:

import java.util.ArrayList;
import java.util.Iterator;

public class Arzt {

// Anfang Variablen
private String Name;
private String Fachgebiet;
private ArrayList meinPatient= new ArrayList();
// Ende Variablen

// Anfang Ereignisprozeduren
public String getName() {
return Name;
}

public void setName(String Name) {
this.Name = Name;
}

public String getFachgebiet() {
return Fachgebiet;
}

public void setFachgebiet(String Fachgebiet) {
this.Fachgebiet = Fachgebiet;
}

public ArrayList getMeinPatient() {
return meinPatient;
}

public void setMeinPatient(ArrayList meinPatient) {
this.meinPatient = meinPatient;
}

// Ende Ereignisprozeduren
}

Die Klasse Patient:

import java.util.ArrayList;
import java.util.Iterator;

public class Patient {

// Anfang Variablen
private String Name;
private int Krankenkassennummer;
private Arzt meinArzt;
// Ende Variablen

// Anfang Ereignisprozeduren
public String getName() {
return Name;
}

public void setName(String Name) {
this.Name = Name;
}

public int getKrankenkassennummer() {
return Krankenkassennummer;
}

public void setKrankenkassennummer(int Krankenkassennummer) {
this.Krankenkassennummer = Krankenkassennummer;
}

public Arzt getMeinArzt() {
return meinArzt;
}

public void setMeinArzt(Arzt meinArzt) {
this.meinArzt = meinArzt;
}

public Patient(Arzt doc) // Kann mir jemand diese Stelle jemand
{ // erklären? hier wird doch die beziehung
meinArzt= doc; // 1:n gesetzt ?
ArrayList liste= meinArzt.getMeinPatient();
liste.add(this); }

// Ende Ereignisprozeduren
}

zusätzlich frage:

-Warum wird die Beziehung in der Klasse Patient gemacht wenn die Variable ArrayList meinPatient in Arzt ist ?

 

[der_guru]

ArrayList liste1= meinArzt.getMeinPatient();
//Was passiert hier genau, das Obejkt holt sich mit der methode get die Patiendendaten ?

Iterator i= liste1.iterator();

while(i.hasNext()) //Was bedeutet das i.hasNext() genau ?
Das Heißt gibt es weitere Elmente in der Liste die per i.next() noch nicht abgefragt wurden

Patient einPatient= ((Patient)i.next());
hohlt das nächste Element aus der Liste

isim= einPatient.getName();
/ Hohlt den Namen des Patienten Objekte

krank= einPatient.getKrankenkassennummer();
Das selbe mit der Krankenkassennummer

// ausgabe auf den Standard out beider daten (Name und nummer)
System.out.println(isim);
System.out.println(krank);


Das Ganze unten sieht wie ein Konstruktor für die Klasse Patient aus (aufgrund das kein Rückgabetyp (entweder void oder Klassentyp oder primitiven datentyp) angeben ist
public Patient(Arzt doc)
{
meinArzt= doc; // 1:n gesetzt ?
ArrayList liste= meinArzt.getMeinPatient();
liste.add(this); }

In diesem Konstrukt wird die liste aller Patienten des Arztes doc ausgelesen und das neuerzeugte Patientenobjekt hinzugefügt.

andere Schreibweise wäre:
Patient a = new Patient(behandelnderArzt1);
behandelnderArzt1.add(a);

Hoff ich konnte dir helfen.

mfg
guru

Edit:
Warum wird die Beziehung in der Klasse Patient gemacht wenn die Variable ArrayList meinPatient in Arzt ist ?
In der Klasse Patient wird nur das Objekt in die ArrayList des Arztes hinzugefügt.
Die Beziehung wird nur in den ArrayLists der Ärzte verwaltet.

mfg die 2te

 

[Meolus]

Also in der Patientenklasse ist diese Funktion "Patient" ja der Konstruktor, welche das Objekt initialisiert:

public Patient(Arzt doc) // Kann mir jemand diese Stelle jemand
{ // erklären? hier wird doch die beziehung
meinArzt= doc; // 1:n gesetzt ? /* erstelle Referenz auf Arzt */
ArrayList liste= meinArzt.getMeinPatient(); /* erstelle Referenz auf Patientenliste des referenzierten Arztes */
liste.add(this); } /* füge dieses Objekt der referenzierten Liste des referenzierten Arztes hinzu */

// Ende Ereignisprozeduren
}

Damit kann man auf jedenfall von einer 1:n beziehung zwischen Patienten und Ärzten reden, aber das kann man nicht an einer Zeile festmachen.
Das Hinzufügen des Patieten zur Patientenliste des Arztes wird an der Stelle gemacht, weil es einfach intuitiv ist, beim Aufnehmen eines Patienten diesen direkt einem Arzt zu zuordnen. Prinzipiell könnte man ähnliches natürlich auch an anderer Stelle machen.



Ganz oben in der dritten Klasse wird wiederum die Patientenliste des Arztes referenziert und dann im folgenden durchgegangen. "hasNext()" und "next()" sind Standardfunktionen um entsprechend diese Patientenliste dann durch zu gehen. In der Dokumentation zur Iterator-Klasse steht mehr: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Iterator.html

 

[ag3nt]

Hallo,

also in der aktuellen Umsetzung ist doch einiges im argen, aber dazu erst später ein paar Worte. Die wesentlichen Punkte wurden ja schon beantwortet, daher auch nur ein kleines Beispiel am Anfang zur Vollständigkeit

...

ArrayList liste1= meinArzt.getMeinPatient();
Iterator i= liste1.iterator();
while(i.hasNext()) 
{
	Patient einPatient = ((Patient)i.next()); 
	[color=red]isim = einPatient.getName(); //eine Zuweisung an das Klassenattribut (mit Verlaub ziemlich unüblich und unsinnig)[/color]
	krank= einPatient.getKrankenkassennummer();
	System.out.println(isim);
	System.out.println(krank);
}

Das lässt sich sich in neueren Java-Versionen deutlich eleganter schreiben:

...

for( Patient iPatient : meinArzt.getMeinPatient() ) 
{
	String name = iPatient.getName();
	int krank   = iPatient.getKrankenkassennummer();
	System.out.println(name);
	System.out.println(krank);
}

Um die 1:N Beziehung zu modellieren muss, dir klar sein dass ein Arzt natürlich immer alle Patienten kennen muss und sein Patient immer den Arzt.

Die aktuelle Implmentierung ist also sogar falsch!


Die Klasse Arzt sollte in etwa so aussehen:

public class Arzt  {
	
	....
	
	private Collection<Patient> _patient = new Vector<Patient>();

	public void addPatient(Patient aPatient) 
	{	
		if( !this._patient.contains(aPatient) ) 
		{	
			this._patient.add(aPatient);
			aPatient.setMeinArzt(this);
		} 
	}

	public void removePatient(Patient aPatient) 
	{
		if( this._patient.contains(aPatient) ) 
		{	
			this._patient.remove(aPatient);			
			aPatient.setMeinArzt(null);
		} 
	}

	....
}

und die Klasse Patient in etwa so:

class Patient {
	
	private Arzt meinArzt;
	
	...
	
	public Patient(Arzt doc)
	{	
		setMeinArzt(doc); 	
	}
	
	public void setMeinArzt(Arzt meinArzt) 
	{
		if( this.meinArzt != meinArzt ) 
		{	
			if( this.meinArzt != null ) 
			{	
				Arzt alterArzt = this.meinArzt;
							
				this.meinArzt = null;
			
				// teile dem bisherigen Arzt mit, dass der Patient diesem Arzt nicht mehr zugewiesen ist
				alterArzt.removePatient( this );
			}			
			
			if( meinArzt != null ) 
			{
				//mache Arzt beim Patienten bekannt
				this.meinArzt = meinArzt;
			
				// mache den Patienten beim Arzt bekannt
				meinArzt.addPatient( this );
			}
		}
	}
	
	....
	
}

nur so lässt sich die 1:N Beziehung korrekt und vollständig aufrecht erhalten

 

[Meolus]

Das lässt sich sich in neueren Java-Versionen deutlich eleganter schreiben:

...

for( Patient iPatient : meinArzt.getMeinPatient() ) 
{
	String name = iPatient.getName();
	int krank   = iPatient.getKrankenkassennummer();
	System.out.println(isim);
	System.out.println(krank);
}

"System.out.println(isim);" muss natürlich "System.out.println(name);" lauten, bevor das hier Verwirrung stiftet.