Von Main Klasse aus auf andere Klassen zugreifen?
Ich habe zwei Klassen im selben package in eclipse. Wie kann ich von der Main Klasse aus auf die andere zugreifen? (bin Anfänger)
2 Antworten
Du erstellst ein Objekt der Klasse Eigenschaften:
Eigenschaften e = new Eigenschaften();
Dann legst du über deine Setter die Attribute fest. (Umgehen kannst du das, indem du einen Konstruktor festlegst, dem du die nötigen Attribute mitgibst)
Die Methoden rufst du dann so auf (am Beispiel getFab):
e.getFab();
Das kannst du dir doch selbst herleiten:
die Methode setFab bekommt einen String übergeben und speichert ihn in das Attribut "Fabrikat"
Also kannst du die Methode z.B. so aufrufen:
e.setFab("BMW");
oder alternativ:
String s = "BMW"; e.setFab(s);
So ein Eigenschaftenobjekt müsste ich ja dann für jedes einzelne Auto das ich speichern will erstellen... nagut wenns nur so geht :)
Genau. Aber über die Objekte kannst du für jedes Auto dann eigene Eigenschaften festlegen, ohne jeweils eine eigene Klasse erstellen zu müssen.
Btw es wäre namenstechnisch sinnvoller, die Klasse "Auto" oder "Car" statt Eigenschaften zu nennen zudem den vorhin erwähnten Konstruktor einzubauen
Mmh, hab die so genannt weil da drinnen halt die Eigenschaften +Getter&Setter festgelegt sind aber du hast Recht, das macht mehr Sinn :D
Objekte haben die Attribute als Eigenschaften und die Methoden legen fest, wie das Objekt sich verhält. Es macht kein Sinn, Objekte generell "Eigenschaften" zu nennen
natürlich könnte er es über Schleifen nutzen und über eine Methode Autos erzeugen und danach alle setter aufrufen.
Übersichtlicher und schöner wäre der Objekt-Konstruktor in der entsprechenden Klasse. Dann wäre die Objekterzeugung ein Einzeiler, der auch in Schleifen kann
Das macht in meinem Fall kein Sinn, da ich eine Art Nachschlagewerk erzeugen will. Durch den Scanner wird der User am Ende den Namen eines Automodells eingeben und bekommt die Eigenschaften des Modells genannt. Daher macht eine Schleife hier keinen Sinn (zeige mir wie es doch Sinn macht :D)
Du brauchst eine Schleife, wenn das Programm nicht sofort nach dem ersten Durchlauf enden soll. z.B.:
while(!input.equals(exit)){
//suche Auto und gebe entsprechende Daten aus
}
Zudem brauchst du eine Schleife, die über alle Daten iteriert (wenn du keine Datenbank nutzt, was sinnvoller wäre), um das passende Auto zu finden.
Mir fällt gerade noch was ganz anderes ein... Könnte ich nicht eigentlich die Eigenschaften (oder was auch immer) .java in ein neues Package tun und dann einfach in meine Main Klasse importieren?
das Iterieren über alle Daten kannst du btw z.B. so realisieren, wenn deine Klasse Auto heißt, alle Objekte in einer ArrayList<Auto> cars gespeichert sind, das Modell eindeutig ist und vom Scanner in die variable "temp" gespeichert wird:
Auto a;
for(Auto auto : cars){
if (auto.getMod().equals(temp)){
a = auto;
break;
}
}
if(a != null){
//Attribute von a ausgeben, am besten über eine extra Methode, die alle getter aufruft
}Haha mega gute Idee!!👍🏻 werde ich dann wahrscheinlich so machen :)
bedenke aber, dass eine Datenbank bei großen Datenmengen sinnvoller wäre als eine "normale" Java-Klasse und deren Instanzen (Objekte)
Wie kann ich von der Main Klasse aus auf die andere zugreifen?
Indem du einfach eine Instanz der anderen Klasse erzeugst. Du kannst die Methode setFab nicht anwenden, da du eine Instanz der Klasse Auto und nicht der Klasse Eigenschaften nutzt. Aber warum nennst du eine Klasse Eigenschaften? Das ergibt für mich keinen Sinn.
Kann man bestimmt cleverer machen, aber bin wie gesagt noch Anfänger :)
Kann man bestimmt cleverer machen
Das hat nichts damit zu tun, ob es clever ist oder nicht, sondern das sind fundamentale Prinzipien der Objektorientierung. Klassen dienen nicht zur Auslagerung, sondern dafür, Baupläne für Objekte darzustellen. Nun können wir überlegen: Ist ein Auto ein Objekt? Ja. Sind Eigenschaften ein Objekt? Nein.
Deshalb solltest du die Klasse Eigenschaften stattdessen Auto nennen und die andere einfach Main, weil sie ja nur zur Ausführung des Programms dient. Denn du erstellst ja ein Auto und nicht Eigenschaften. Hast du das soweit verstanden? Wenn nicht, frag bitte nach, denn das ist sehr wichtig.
Außerdem sollte man nicht für jede Variable Getter und Setter einsetzen, so wie in deinem Beispiel. Das tut man nur in folgenden Fällen:
- Man möchte eine Variable nur lesbar, aber nicht schreibbar machen, also erstellt man nur einen Getter.
- Umgekehrter Fall: nur schreibbar, also erstellt man nur einen Setter. Allerdings kommt das nur sehr selten vor.
- Man möchte beim Setzen oder Lesen einer Variable noch mehr tun, als sie nur zu setzen oder zu lesen. D.h. im Getter/Setter steht mehr als nur eine Zeile. So kann man z.B. überprüfen, ob der Wert, auf den die Variable gesetzt werden soll, korrekt ist. Außerdem kann man auch Umrechnungen durchführen, falls man intern in anderen Einheiten rechnet, aber nach außen hin auch andere zulassen möchte. Es können ebenfalls Methoden zur Aktualisierung aufgerufen werden (dies wird oft beim Zeichnen angewandt, wenn man die Zeichenfläche aktualisieren will, nachdem man neue Zeichenelemente hinzugefügt hat).
- ...
Darüber hinaus solltest du irgendwann auch mal in Erwägung ziehen, vollständig auf Englisch zu programmieren. Für den Anfang kann aber auch Deutsch verständlicher sein.
Ich hoffe, ich habe mich einigermaßen verständlich ausgedrückt. Wenn nicht, frag gerne nach.
Danke, das war echt gut verständlich, auch wenn ich manches 2-3x lesen musste ^^
ich nutze die private Methode, weil ich später einzelne Eigenschaften abfragen, aber nicht verändern können möchte. Die Setter dienen außerdem ja nur dazu, dass ich einmalig (im Programm) Autos und deren Eigenschaften abspeichern kann, nicht um sie generell zu nutzen.
Achso, nur die Sache, dass man mit Gettern und Settern noch mehr tun kann (3. Punkt) habe ich nicht so genau verstanden, das kannst du mir gerne nochmal erklären :)
Die Setter dienen außerdem ja nur dazu, dass ich einmalig (im Programm) Autos und deren Eigenschaften abspeichern kann, nicht um sie generell zu nutzen.
Aber wenn sie zur Verfügung stehen, könnte man sie generell nutzen. Du musst dir einfach immer vorstellen, dass jemand Anderes deine Klassen mal benutzen wird. Dann darf es nicht passieren, dass beim Benutzen der Methoden ein nicht nachvollziehbarer Fehler entsteht. Wenn du etwas nur einmalig setzen willst, dann kannst du dafür den Konstruktor nutzen.
Achso, nur die Sache, dass man mit Gettern und Settern noch mehr tun kann (3. Punkt) habe ich nicht so genau verstanden, das kannst du mir gerne nochmal erklären :)
Gerne :)
Also einmal Schritt für Schritt:
Man möchte beim Setzen oder Lesen einer Variable noch mehr tun, als sie nur zu setzen oder zu lesen.
Normalerweise dient ein Getter nur zum Lesen:
public int getNumber() {
return number;
}
Ein Setter dient nur zum Setzen:
public void setNumber(int number) {
this.number = number;
}
In diesem Fall sind die Getter und Setter unnötig, da man die Variable auch public machen könnte. Es gibt aber auch Fälle, bei denen man noch mehr als nur das obige tun möchte. Du wirst das später schon selbst merken, denke ich. Dennoch hier ein paar Bespiele, um es klar zu stellen.
So kann man z.B. überprüfen, ob der Wert, auf den die Variable gesetzt werden soll, korrekt ist.
Beispiel: Du hast eine Variable, die - aus welchen Gründen auch immer - nicht negativ sein darf. Ansonsten tritt ein Fehler auf:
public void setNumber(int number) {
if (number < 0) {
// Hier würde man irgendeine Exception werfen
} else {
this.number = number;
}
}
Außerdem kann man auch Umrechnungen durchführen, falls man intern in anderen Einheiten rechnet, aber nach außen hin auch andere zulassen möchte.
Beispiel: Man hat eine Klasse, die bestimmte Berechnungen mit Winkeln durchführt. Intern wird dabei mit dem Bogenmaß gerechnet. Für den Anwender intuitiver ist allerdings das Gradmaß. Man bietet also nach außen hin beides an:
public void setAngle(double radians) {
// als Bogenmaß
angle = radians;
}
// derselbe Setter, nur dass man den Winkel im Gradmaß angeben kann
public void setAngleInDegrees(double degrees) {
// kein direktes Setzen, sondern erst Umrechnen ins Bogenmaß
angle = 2*Math.pi/360 * degrees;
}
Es können ebenfalls Methoden zur Aktualisierung aufgerufen werden (dies wird oft beim Zeichnen angewandt, wenn man die Zeichenfläche aktualisieren will, nachdem man neue Zeichenelemente hinzugefügt hat).
Beispiel: Man hat eine Methode, die in einen Container entweder einen Kreis zeichnet (draw = 0) oder ein Rechteck (draw = 1) oder ein Dreieck (draw = 2). Wie das in Java gemacht wird, kannst du dir später mal anschauen, wenn du etwas weiter bist (Tipp: Graphics2D). Letztendlich kann man diese Methode nicht direkt aufrufen, sondern sie wird über die Methode component.repaint() aufgerufen.
Nun möchte man von außen mit einem Setter anbieten, zu entscheiden, was im Container zu sehen sein soll. Das Aktualisieren (= Neuzeichnen) soll direkt im Setter erfolgen:
public void setDraw(int i) {
if (draw > 2 || draw < 0) {
// Fehler
} else {
draw = i;
// Nach dem Ändern der Variable soll sofort neu gezeichnet werden
component.repaint();
}
}
All das soll letztendlich dazu dienen, dass jeder deine Klasse von außen möglichst einfach bedienen kann, ohne zu wissen, wie sie intern funktioniert. D.h. möglichst viele Dinge sollen dem Anwender abgenommen werden.
Dadurch muss sich dieser nicht so sehr einarbeiten, was bei komplexen Programmen zeitaufwendig wäre, sondern kann schnell beginnen. Er muss nicht auf den korrekten Wertebereich achten, sondern wird darüber informiert - über Exceptions. Er muss auch keine Umrechnungen durchführen und keine Schritte, die sowieso jedes Mal erforderlich wären (wie das Aktualisieren).
Diese einfache Einarbeitung bei geringer Komplexität ist ein essentielles Prinzip der Objektorientierung, welches es ermöglicht, auch an hochkomplexen Projekten mit mehreren Entwicklern effizient zu arbeiten.
Solltest du noch Fragen haben, melde dich natürlich gerne ;)
Danke, ich verstehe was du meinst 👍🏻
Aber kannst du mir die eine Zeile für setFab nochmal aufschreiben ich weiß den Syntax nicht mehr :(