✔ 3SA im Fallbeispiel

M

Miaming

Mitglied
Hallo zusammen,

ich habe eine kleine Frage bezüglich des obigen Themas. Es geht um die drei Schichten Architektur von Java, die ich im Prinzip verstanden habe, allerdings versuche ich mich gerade an einer alten Klausuraufgabe (zur Vorbereitung auf eine bald anstehende Klausur) und wollte von einem etwas erfahrenerem Publkum eure Meinung hören:

Und zwar:

habe ich folgenden Quelltext gegeben:

Code: 
import java.util.*; 
public class Buch { 
   private String name; 
   private float preis; 
    
  private static Vector<Buch> buchContainer = new Vector<Buch>(); 
 
   public Buch(String name,float preis) 
    { 
      this.name = name; 
      this.preis = preis; 
    } 
         
   public String getName() {  
    return name;  
    } 
   public void setName(String name) { 
    this.name=name; 
  } 
   public float getPreis(){ 
    return preis; 
    } 
   public void setPreis(float preis){ 
    this.preis = preis; 
    } 
}

Zum Speichern und Laden von Buchobjekten wird die Klasse DBZugriff bereitgestellt,
die das Interface IDBZugriff implementiert.

Code: 
import java.io.IOException; 
import java.util.Vector; 
public interface IDBZugriff { 
  // Methode insert(), um Buch in die DB zu speichern 
  public void insert (int schluessel, String name, float preis) 
     throws IOException; 
  // Methode update(), um bearbeitetes Buch zu ändern 
public void update(int schluessel, String name, float preis)  
            throws IOException; 
  // Methode delete(), um Buch zu löschen 
  public void delete (int schluessel) throws IOException; 
  // Methode getAll(), um alle Bücher auszulesen 
  public Vector getAll () throws IOException; 
  // Methode liefert einen Schlüssel für ein neues Objekt 
  public int getNeuenSchluessel() throws IOException; 
}

Die Frage dazu lautet:

Erläutern Sie bitte, welche Änderungen an der Klasse Buch erforderlich sind, um die
Klasse Buch im Sinne einer Drei-Schichten-Architektur an diese Datenhaltung anzubin-den.


Meine Antwort dazu wäre:

Um im Sinne der 3SA zu handeln müsste die Klasse Buch so verändert werden, dass die Klasse von der hier angegeben Klasse DBZugriff erbt

Code: 
public class Buch extends DBZugriff

Somit wird gewährleistet, dass die Methoden in der Klasse Buch vorhanden sind um die Operationen wie insert, update, delete auszuführen.


Alllerdings frage ich mich gerade beim Schreiben dieser Antwort, ob dies wirklich eine richtige Antwort sein kann? Mir persönlich würde nämlich jetzt keine andere Änderungen an der Klasse Buch einfallen.

(Außer die Tatsache, dass die Buttons eingefügt werden müssen, dies geschieht aber nicht in der Fachkonzeptklasse Buch)

Weiß jemand rat oder könnte mir einen Tipp geben?

Würde mich sehr freuen, wenn jemand Kluges seinen Senf dazu geben könnte :p
 
Hi,
also meines erarchtens musst du die Klasse DBZugriff als eine static Variable in der Klasse Buch implementieren.
Java: 
import java.util.*; 
public class Buch { 
   private String name; 
   private float preis; 
    
   private static Vector<Buch> buchContainer = new Vector<Buch>(); 
   private final static IDBZugriff dbConnection = new DBZugriff();
   
   // ...
}
Da ein Buch n mal vorkommen kann und es immer nur 1 DBZugriff-Klasse geben soll, sollte das meiner Ansicht nach so implementiert werden.

Dann musst du natürlich die Methoden von der Klasse Buch noch so entsprechent implementieren, dass der gewünschte Wert von der jeweiligen Methode gesetzt/zurück gegeben wird.
Sprich im Konstruktor die Methode insert(...), in der Methode getName über getAll() den Namen von diesem Buch ermitteln. Und so verfährst du mit den anderen Methoden.

ps.: Bitte verwende die Java-Code Tags (siehe meine Signatur)

Gruß

Fabio
 
Zuletzt bearbeitet:
Hallo Fabio und danke für deine Antwort! Wenn ich ehrlich bin würde ich auf diesen Lösungsansatz nicht kommen -.-

kannst du vll versuchen mir zu erklären, warum du "direkt" auf deine aussage kommst?

"Ich weiß ich weiß, static Variablen sind nicht OOP, da aber ein Buch n mal vorkommen kann und es immer nur 1 DBZugriff-Klasse geben soll, sollte das meiner Ansicht nach so implementiert werden."

also ich würde selbst nie auf diese aussage kommen und nya deshalb die frage ob du es iwie "für dumme" erklären könntest?

Bin dir im übrigen schon einmal sehr dankbar für deine antwort!
 
Tut mir leid, da hab ich mich ein wenig falsch ausgedrückt. Static Variablen sind im dem Sinne nicht OOP wenn sie public sind. Eine Variable als private static final zu defninieren, bedeuted, dass diese Variable eine Konstante darstellt.

Drotzdem sollte man nicht vergessen, dass jede static Variable, Klasse, etc. für die komplette Programmlaufzeit exisitiert und nicht vom GC gelöscht werden.

ps.: Tut mir leid für die Verwirrung
 
Hallo nochmal, ich möchte gerne das Thema nocheinmal aufgreifen da es für mich irgendwie doch noch unklar ist.

Ich verstehe überhaupt nicht warum ich diese Zeile
Java: 
private final static IDBZugriff dbConnection = new DBZugriff();
in die Klasse Buch einfügen sollte.

Die Begründung die du genannt hast lässt sich irgendwie jetzt gerade nur schwer nachvollziehen. Wieso wird das Interface in der Fachkonzeptklasse (Buch) hier aufgeführt bzw. von diesem Interface ein neues Objekt erstellt?

Sorry evt. eine dumme frage allerdings ist es mir überhaupt nicht klar, wie man zu diesem Punkt kommt, ich würde mich freuen, wenn du Fabio irgendwie dazu eine passende / für mich verständliche Erklärung liefern könntest, da ich gerade sehr ratlos bin :(

PS: habe die Klassen Buch, Buecherverwaltung, DBZugriff und das Interface IDBZugriff hier erstellt und ja hurra die Deklaration der oben genannten Codezeile ist auch korrekt, allerdings hilft es mir so gar nicht weiter, da mir in diesem Zusammenhang absolut das Verständnis fehlt :(
 
Zuletzt bearbeitet:
Hallo nochmal,
es ist doch gar kein Problem, wenn du Fragen stellst, genau dafür ist doch tutorials.de gedacht. ;)

Also es sieht folgendermaßen aus. Du hast deine Klasse Buch. In dieser Klasse Buch, willst du über einen Datenbankzugriff die Daten zu diesem Buch raus holen.
Den Zugriff zu deiner Datenbank bekommst du mithilfe der Klasse DBZugriff. (Ich vermute mal, dass du die Datenbankverbindung in der DBZugriff-Klasse aufbaust.) Da es nicht ratsam ist, mehrere Datenbankverbindungen gleichzeitig offen zu haben, ist es gut, wenn das Objekt DBZugriff in der gesamten Laufzeit nur einmal erzeugt wird. Damit ein Objekt nur einmal erzeugt wird, macht man dieses Objekt static.
Java: 
private final static DBZugriff dbConnection = new DBZugriff();
Ob du nun über das Interface (IDBZugriff) angiebst oder die Klasse (DBZugriff), ist in deinem Fall noch egal. Erst später, wenn du mehrere Klassen ein Interface implementieren lässt, wird das wieder interessant werden für dich. ;)

Ich hoffe, dass ich damit deine Frage/n beantworten konnte. Falls nicht, lass es mich wissen.

Gruß

Fabio
 
Hallo Fabio und herzlichen Dank für deine Worte!

Diese Erklärung ist für mich um ehrlich zu sein deutlich besser zu verstehen! Zumindest erklärt es mir jetzt wieso man diese Codezeile überhaupt braucht ^^

Könntest du evt noch Angaben zu dieser von dir getroffenen Aussage machen:

Dann musst du natürlich die Methoden von der Klasse Buch noch so entsprechent implementieren, dass der gewünschte Wert von der jeweiligen Methode gesetzt/zurück gegeben wird.
Sprich im Konstruktor die Methode insert(...), in der Methode getName über getAll() den Namen von diesem Buch ermitteln. Und so verfährst du mit den anderen Methoden.
Zum Vergrößern anklicken....

Ist es Pflicht bzw. sind gleichnamig bei der Implementierung zu machen wenn ich die Datenbankverbindung aufbaue? Also das Hauptaugenmerk liegt nur auf der Klasse Buch ^^ Alle anderen Methoden sind für mich in diesem Zusammenhang nicht von Bedeutung (also betreffend zur Lösung der Aufgabe ^^)
 
Ok, folgendes. Wenn du deine Bücher in einer Datenbank speichern und wieder abfragen willst, musst du dafür irgendwo eine Schnittstelle bauen. Genau diese Schnittstelle soll die Klasse Buch darstellen.
Ich würde mal vermuten, dass man nun laut der Aufgabenstellung die Get- und Set-Methoden so umschreiben soll, damit über diese Methoden der Zugriff zur Datenbank passiert.
Um das elegant zu lösen, muss man gar nicht alle Methoden mit einem Datenbankzugriff versehen. Das würde sonst nur Performance kosten. Deswegen macht es sinn, die Datenbankzugriffe auf ein Minimum zu komprimieren. D.h. es wird an folgenden Punkten ein Datenbankzugriff benötigt:
1. im Konstruktor, um in der DB ein neues Buch anzulegen
2. in setName(...), um den Namen in der DB zu ändern
3. in setPreis(...), um den Preis in der DB zu ändern

Java: 
import java.util.*; 
public class Buch { 
   private String name; 
   private float preis; 
    
   private static Vector<Buch> buchContainer = new Vector<Buch>(); 
   private final static DBZugriff dbConnection = new DBZugriff();
 
   public Buch(String name,float preis)  { 
      this.name = name; 
      this.preis = preis; 
      // Hier legst du das neues Buch in der DB an
      // dbConnection.insert(...)
   } 
         
   public String getName() {  
      return name;  
   }

   public void setName(String name) { 
      this.name=name; 
      // Hier setzt du den neuen Namen des Buches in der DB
      // dbConnection.update(...)
   } 

   public float getPreis() { 
      return preis; 
   } 

   public void setPreis(float preis) { 
      this.preis = preis; 
      // Hier setzt du den neuen Preis des Buches in der DB
      // dbConnection.update(...)
   } 
}
 
Krass man du hast es echt drauf! Nicht nur dass du den plan hast nein du hast es echt drauf unwissenden menschen zu helfen, vielen, vielen Dank für deine ausführliche erklärung!
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück