[Java] Setter, Getter Anfängerfrage

[Cpt. Subtext]

Hallo zusammen!

Wir nehmen derzeit Setter und Getter in Java durch.
Ich muss zugebend ass ich nicht der Programmierer aus Leidenschaft bin und habe den Sprung von normalen Methodenabfragen (Klassenübergreifend) auf dieses set get Zeug nicht richtig kapiert.

Deshalb folgende Fragen:

Was macht der Setter. Er setzt den Wert oder?
Was macht der Getter. Er holt sich den gesetzten Wert oder?

Wie kann ich in den folgenden zwei Klassen (class Startklasse und class Gebrauchtwagen)
dies hier bewerkstelligen:

· Erzeugen eines Objekts aus der Klasse „Gebrauchtwagen“ mit der
Bezeichnung „testwagen“
· Erfassen des Kennzeichens von „testwagen“: VS – DL - 433
· Festlegen des Verkaufspreises: 25.000 €
· Berechnen und Ausgeben des Verkaufspreises für eine Stammkundin
· Abfragen und Ausgeben des normalen Verkaufspreises

Hier mein bisheriger Code:

public class Startklasse { //Klasse noch leer
public static void main (String[] args) {
}
}

------------------------------------------------------------------------
public class Gebrauchtwagen {

String kennzeichen;
double vkpreis;

public String getKennzeichen()
{
return kennzeichen;
}

public void setKennzeichen(String kennzeichen)
{
this.kennzeichen=kennzeichen;
}

public double getVkpreis()
{
return vkpreis
}

public void setVkpreis(double vkpreis)
{
this.vkpreis=vkpreis;
}

}

---------------------------------------------------------------------------

//Soweit bin ich bisher gekommen. Wäre toll wenn mir jemand anhand der Aufgabenstellung oben erklären kann wie die Setter und Getter nun eingesetzt werden müssen um die Aufgabe zu bewältigen.
Die eigentliche Ausführung, Eingabe von Werten soll durch die Startklasse erfolgen.

 

[snotty_herry]

In der klasse gebrauchtwagen erstellst du die Variablen private. Setter sollen normal verhindern, dass du falsche werte einträgst, du kannst in einem setter z.b. abfragen ob die eingegebene zahl bei kennzeichen nicht mehr hat als 4 Buchstaben oder bei VkPreis ob der wert nicht zu gering ist oder zu groß ist

beispiel vkPreis

public setVkPreis(double vkPreis)
{
if (vkpreis >500 && vkpreis <15000)
{
this.vkPreis = vkPreis;
} else
{
system.out.println("Preis zu hoch oder zu niedrig, eingegeben wurde " + vkPreis);
}

Du kannst auch einen returnwert machen (dann muss das void ausgetauscht werden), der dem hauptprogramm sagt was falsch gelaufen ist.

 

[NiThDi]

Also du musst in deiner Startklasse erst mal ein Objekt vom Typ Gebrauchtwagen erstellen.
Das kannst du in der main Methode machen:

Gebrauchtwagen testwagen = new Gebrauchtwagen();

Dann muss du dessen Attribute mit den settern setzen. Das würde aber analog auch über einen Konstruktor gehen (was sauberer wäre).

testwagen.setKennzeichen("blabla 888");
...

Dann ist dein Objekt "fertig". Die Attribute rufst du jetzt mit den gettern ab:

String testwagen_kennzeichen = testwagen.getKennzeichen();


Du rufst die setter und getter also immer auf dem erstellten Objekt auf.

Hoffe ich konnte weiterhelfen

 

[SheepShaver]

Gebrauchtwagen testwagen= new Gebrauchwagen();
testwagen.setKennzeichen("VS – DL - 433");
testwagen.setVkpreis(25000);


und über die Getter kannst du dann die Werte wieder holen und ausgeben, also über
testwagen.getKennzeichen() etc.


Wo ist dein Verständnisproblem?


P.S.: kennzeichen und vkpreis sollten als private deklariert werden.

 

[DonnyDepp]

oder du gibst die beiden sachen gleich mit in den konstruktor, der dir sowieso noch fehlt

 

[Nebuk]

Zuerst solltest du die Variablen in der Gebrauchtwagenklasse auf "private" setzten.
Du brauchst die Getter und Setter um Werte in Variablen zu speichern bzw. aufzurufen. Wenn du sie direkt per = Zuweisung setzten würdest, wäre die Gefahr grösser, dass du aus versehen Werte überschreibst oder falsch zuweist.

zu den Tipps.

In der Startklasse erstellst du dann das Objekt von der Klasse Gebrauchtwagen.

z.B.
Gebrauchtwagen gbw1 = new Gebrauchtwagen();

Dort setzt du die werte per
gbw1.setKennzeichen("VS – DL - 433");
usw.

aufrufen tust du den wert über
gbw1.getKennzeichen();

 

[honky-tonk]

hi, das prinzip von getter und setter methoden:

die idee ist, informationen in einer klasse zu speichern wie zb. verkaufspreis spitzengeschwindigkeit etc. nun ist es aber sicherer diese werte mit getter und setter methoden zu ändern.

folgendes szenario: eine klasse braucht z.b. den verkaufspreis der klasse auto und holt sich diesen mit auto.verkaufspreis und ein unvorsichtiger programmierer rechnet mit dem verkaufspreis weiter um z.b. rabatte zu ermöglichen. wenn nun wieder auf diese variable auto.verkaufspreis geschrieben wird ist diese vll unbeabsichtigt geändert worden... deshalb führt man getter methoden ein: public int getVerkaufspreis(){return verkaufspreis} und public void setVerkaufspreis(int preis){verkaufspreis=preis}
die eigentliche variable wird als private int verkaufspreis deklariert!

wenn nun einer den preis benötigt nimmt er die get methode und bekommt die zahl...diese kann er nicht unbeabsichtigt ändern, sondern nur mit der set methode

 

[Cpt. Subtext]

Also du musst in deiner Startklasse erst mal ein Objekt vom Typ Gebrauchtwagen erstellen.
Das kannst du in der main Methode machen:

Gebrauchtwagen testwagen = new Gebrauchtwagen();

Dann muss du dessen Attribute mit den settern setzen. Das würde aber analog auch über einen Konstruktor gehen (was sauberer wäre).

QUOTE]

Danke schonmal allen für die Antworten. Hat mir schonmal en bisschen weitergeholfen.

Wie würde das ganze denn alternativ mit einem Konstruktor aussehen?

 

[SheepShaver]

Der Konstruktor würde so aussehen:

public Gebrauchtwagen(String kennzeichen, double vkpreis) {
setKennzeichen(kennzeichen);
setVKPreis(vkpreis);
}



Eine Instanz wird dann so angelegt:
new Gebrachtwagen("kennzeichen", 123);

 

[NullPointer]

Es ist eigentlich ganz einfach Jedes Mal, wenn du auf einen Wert des Testwagens zugreifen willst, benutzt du den Getter (lesend) bzw. den Setter (schreibend). Also:

public class Startklasse {
public static void main (String[] args) {
Gebrauchtwagen testwagen = new Gebrauchtwagen();
testwagen.setKennzeichen("VS – DL - 433");
testwagen.setVkpreis(25000);
double vkpreis = testwagen.getVkpreis();
// etc.
}
}

Für die Teilaufgabe mit der Stammkundin fehlen da noch Informationen. Ich nehme an, ihr soll ein Rabatt gewährt werden. Den müßtest du dann halt noch aus dem Verkaufspreis berechnen. (In der Main-Methode, nicht in der Klasse Gebrauchtwagen. Die hat davon keine Ahnung.)

Stell dir am besten vor - oder, noch besser, mach es so! ^^ -, die Membervariablen kennzeichen und vkpreis wären als private deklariert, so daß du von außerhalb der Klasse da gar nicht randarfst. Das zwingt dich dann von vornherein dazu, Setter und Getter zu benutzen.

(Beginn Vorlesung )

Welchen Sinn hat es nun, Zugriffe auf Member auf diese Art zu kapseln, statt die Member selbst einfach öffentlich zu machen? Du erhältst mehr Kontrolle darüber, welche Daten in die Member gelangen, und versteckst gleichzeitig die interne Implementation der Klasse vor dem Benutzer. Du könntest zum Beispiel einen Setter haben, der nicht nur stumpf die Eingabe in den Member hineinschreibt, sondern vorher noch validiert, oder in ein anderes Format umwandelt. Du könntest auch einen Getter haben, der nicht den Wert einer Membervariable zurückliefert, sondern einen weiteren Getter eines anderen Objekts aufruft - oder seinen Rückgabewert on-the-fly berechnet. Du könntest Membervariablen haben, die einen Getter besitzen, aber keinen Setter, weil du meinst, daß niemand außerhalb der Klasse dort hineinschreiben soll. Du kannstauch die Implementation eines Getters oder Setters irgendwann ändern, wenn es sein muß, ohne daß irgendwer außerhalb der Klasse seinen Code anpassen oder auch nur davon erfahren muß... Die Idee ist letztlich, daß derjenige, der eine Klasse benutzt, überhaupt nicht wissen muß - und nicht wissen soll -, was diese so für Membervariablen hat. Das einzige, was er benutzen soll, sind die public-Methoden der Klasse, einschließlich Gettern und Settern.

Löse dich also möglichst bald von der Vorstellung, die bei der ersten Einführung in Setter und Getter meistens vermittelt wird - daß jedes Setter/Getter-Paar zu einer Membervariable gehört und umgekehrt, und daß diese Methoden nichts anderes tun, als Werte durchzureichen. Setter und Getter sind, wie alle public-Methoden, dazu da, dem Benutzer eine Schnittstelle zur Verwendung der Klasse bzw. ihrer Instanzen zur Verfügung zu stellen. Also ist es von den Bedürfnissen dieses Benutzers - und nicht von der internen Implementation der Klasse - abhängig, welche Getter und Setter du schreibst.

(Ende Vorlesung. Sorry für den vielen Text, aber ich meine, wer OOP lernen möchte, der soll gerade so wichtige Grundprinzipien wie Kapselung und Information Hiding auch richtig erklärt bekommen )

EDIT: War ja klar, daß schon ein halbes Dutzend Leute was gepostet haben, während ich noch schrieb. Also: Die Antworten über mir sind auch nicht falsch, ich hab nur länger gebraucht

 

[glumada]

Gebrauchtwagen

public class Gebrauchtwagen {

private String kennzeichen;//private
private double vkpreis;//private
private boolean stammkunde;
private double stammkundenRabattInProzent;

public Gebrauchtwagen(String kennzeichen, double vkpreis) {
   this.kennzeichen=kennzeichen;
   this.vkpreis=vkpreis;
}

public String getKennzeichen()
{
return kennzeichen;
}

public void setKennzeichen(String kennzeichen)
{
this.kennzeichen=kennzeichen;
}

public double getVkpreis()
{
return vkpreis;//; vergessen
}

public setVkPreis(double vkPreis)
{
if (vkpreis >500 && vkpreis <15000)
{
this.vkPreis = vkPreis;
} else
{
system.err.println("Preis zu hoch oder zu niedrig, eingegeben wurde " + vkPreis);//lieber err statt out, damit werden Fehler rot ausgegeben.
}

public double berechnePreis(){

if(stammkunde)//brauchst kein ==true oder false, da stammkunde ein bool ist und das im if reicht
{
return stammkundenpreis-stammkundenpreis*stammkundenRabattInProzent;
}
else{
return stammkundenpreis;
}
}

public String toString(){
if(stammkunde)
  return "Der Stammkunde bezahlt:"+berechnePreis();

else
return "Der normale Kunde bezahlt +berechnePreis();
}

}

main

public class Startklasse { //Klasse noch leer
public static void main (String[] args) {

Gebrauchtwagen testwagen=new Gebrauchtwagen("VS – DL - 433", 25000.0)

System.out.println(testwagen.toString());
}
}

so müsste es passen

 

[NullPointer]

Da muß ich mich doch noch mal melden, denn dieser Code ist hier - in der Klasse Gebrauchtwagen - völlig fehl am Platz:

public double berechnePreis(){

if(stammkunde)//brauchst kein ==true oder false, da stammkunde ein bool ist und das im if reicht
{
return stammkundenpreis-stammkundenpreis*stammkundenRabattInProzent;
}
else{
return stammkundenpreis;
}
}

Wieso sollten stammkunde und stammkundenRabattInProzent Eigenschaften der Klasse Gebrauchtwagen sein? Diese Zuordnung paßt vorne und hinten nicht. stammkunde wäre eine Eigenschaft einer (hypothetischen) Klasse Kunde, und der Rabattsatz gehört zum Geschäft selbst (einmal vorausgesetzt, daß er für alle Stammkunden gleich ist). Die Wagen an sich haben mit der Frage, ob sie von einem Stammkunden gekauft werden und wieviel Rabatt dieser bekommt, absolut nichts zu schaffen.

Wenn wir eine vollständige Anwendung hätten - mit Klassen für Kunden, Rechnungen und so weiter -, dann gehörte das Berechnen des Preises in das verwaltende Shop-Objekt, z. B.:

double berechnePreis(Gebrauchtwagen wagen, Kunde kunde) {
double preis = wagen.getVkpreis();
if (kunde.isStammkunde()) {
preis *= this.getStammkundenRabattInProzent();
}
return preis;
}

Da es in dieser Aufgabe aber nur die Gebrauchtwagen-Klasse und die main-Methode gibt, gehört die Preisberechnung - wie alles andere, was nicht Wagen ist - in letztere.

 

[CPU]

Hey,

Du darfst das nicht zu ernst nehmen! Das ist einfach nur eine Art Kodex in Java ... genauso, als ob ich anstatt "tueWas()" "tue_was()" als Methodennamen schreiben würde ... man hat sich überlegt, wie könnten wir eine unverbindliche Form entwickeln, denen der Code folgen soll ...

Dein Programm funktioniert auch ohne getter und setter es soll lediglich beim Lesen/Verstehen des Quelltextes helfen ...

Keep cool!

Gruß,
CPU

 

[computerbase123]

ich wuerde es weniger einen codecs sondern eher ein paradigma nennen ...
dadurch lernen die schueler/studenten den umgang mit private und public deklarierten attributen und den umgang in der objektorientierung ...

du kannnst mit eclipse und der definition der variablen uebrigens die setter und getter automatisch erstellen .. einfach mal im rechtsklick context suchen.. habs jetzt net vor ort


und falls es noch nicht besprochen wurde sollte der rabattsatz nicht in dem gebrauchtwaren hinterlegt werden sondern eher wohl im kunde selbst.. oder nochmals in einer untergliederung der kunden und kundengruppen ... aber das lernst du sicherlich im spaeteren verlauf oder der datenbank vorlesung

 

[Cpt. Subtext]

Jetzt blick ichs langsam. Wie sieht das ganze aus wenn ichvkpreis und kennzeichen via Tastatureinleser, also scanner einlesen möchte bei den get und set methoden?

 

[computerbase123]

schreibst nen scanner und schreibst die variable nach dem scanner dann in den methodenaufruf..schaetze ich mal

 

[Cpt. Subtext]

Wie sieht das anhand meines Beispiels im Code aus?

so?

Scanner test1 = new Scanner();
test1 = setVkpreis();

 

[NullPointer]

Eher so (siehe auch Doku zu Scanner):

Scanner scanner = new Scanner(System.in);
double preis = scanner.nextDouble();
testwagen.setVkpreis(preis);

Und @CPU, ich sag's nur ungern, aber da liegst du komplett daneben. Getter und Setter dienen der Datenkapselung - einem der Kernkonzepte der objektorientierten Programmierung. Das ist weder "nur der Verständlichkeit halber" noch irgendwie an die Sprache Java geknüpft. Klar könnte man auch ohne arbeiten, aber es gibt gute Gründe, weshalb man sie einsetzen sollte - und die liegen nicht in der Lesbarkeit des Quellcodes, sondern in seiner Wart- und Erweiterbarkeit, der Möglichkeit späterer Veränderungen. Leider wird in Einführungskursen oft nur vermittelt, man müsse halt Getter und Setter verwenden, weil es sich nun mal so gehöre und public-Member pfui sind

 

[Cpt. Subtext]

hm... das einlesen mache ich doch in der main. wozu brauche ich im fall des einlesens über tastatur dann überhaupt noch ne klasse gebrauchtwagen außer vielleicht für die rabatt berechnung für stammkunden? vielleicht steh ich grad auch eifnach aufm schlauch O_o

 

[NullPointer]

Ich war jetzt davon ausgegangen, daß du vorhattest, die eingelesenen Daten dann an ein Gebrauchtwagen-Objekt weiterzugeben. Wenn das nicht der Fall ist, brauchst du tatsächlich kein solches Objekt - für die Rabattberechnung am allerwenigsten.