Wie kann ich get benutzen?
public class Main {
public static double main(String[] args) {
if (
get.minlandelaenge <= get.landebahnlaenge
)
}
}
---------------------------------------------------------------
public class Flugzeug {
public int maxPassagiere = 250;
public int minlandelaenge = 2;
public String standort = "flug";
}
----------------------------------------------------------------
public class Flughafen {
public int landebahnlaenge = 3;
public int Tag = 1;
Also ich habe zwei Klassen erstellt und in einer ist die mindestlandlaenge drin welche kleiner sein soll als die Landebahnlaenge von einer anderen Klasse.wie kann ich jetzt die Werte aus beiden bekommen und vergleichen. probiert iin Ja
5 Antworten
Also generell hast du da einen Denkfehler, weil es sich bei Klassen in Java um Abstrakte Datentypen und nicht Abstrakte Datenobjekte handelt.
Soll heißen, du hast dort deine Klassen Flugzeug & Flughafen, und musst zuerst konkrete Instanzen (Objekte) von diesen erstellen.
Hast du das gemacht, dann kannst du entweder durch direkten Zugriff mit dem Punkt oberator, oder über eine getter Methode darauf zugreifen (ist auch das wie man es eigentlich machen sollte).
Ohne die Objekte müsstes du hier die membervariablen als abstrakt markieren, aber ich bin mir Recht sicher dass das nicht gedacht ist.
Lg
Du hast vermutlich Objektorientierung noch nicht ganz verstanden.
Eine Klasse ist der "Bauplan" eines Objektes. Die Klasse Flugzeug ist der Bauplan für ein Flugzeug-Objekt. Sie enthält Attribute wie maxPassagiere, minlandelaenge und standort, nicht aber deren konkrete Werte für ein konkretes Flugzeug. Die Klasse selbst steht erstmal für ein allgemeines Flugzeug - konkrete Flugzeuge (= Objekte) erstellen wir gleich.
public class Flugzeug {
// Attribute
public int maxPassagiere;
public int minlandelaenge;
public String standort;
// Konstruktor
public Flugzeug(int maxPassagiere, int minlandelaenge, String standort) {
this.maxPassagiere = maxPassagiere;
this.minlandelaenge = minlandelaenge;
this.standort = standort;
}
}
Im unteren Teil der Klasse findest du noch den Konstruktor, der festlegt, wie ein konkretes Objekt konstruiert werden soll. In unserem Fall lassen wir uns einfach die drei Attributwerte als Parameter mitgeben und weisen diese den Attributen zu.
Genauso verfahren wir mit der Klasse Flughafen:
public class Flughafen {
// Attribute
public int landebahnlaenge;
public int Tag;
// Konstruktor
public Flughafen(int landebahnlaenge, int Tag) {
this.landebahnlaenge = landebahnlaenge;
this.Tag = Tag;
}
}
Warum das ganze? Weil es mehrere Flugzeuge geben kann, aber nur eine Klasse (ein "Bauplan" reicht schließlich).
In der main-Methode können wir schließlich einen konkreten Flughafen und ein konkretes Flugzeug erstellen (und übrigens: es muss public static void main heißen):
public class Main {
public static void main(String[] args) {
Flugzeug boeing747 = new Flugzeug(250, 2, "flug");
Flughafen mucAirport = new Flughafen(3, 1);
if (boeing747.minlandelaenge <= mucAirport.landebahnlaenge) {
// Flugzeug kann hier landen
} else {
// Landebahn zu kurz
}
}
}
So sieht Objektorientierung aus ;-) damit kannst du jetzt auch mehrere Flugzeuge und mehrere Flughäfen erstellen.
Noch sauberer wäre natürlich Kapselung und ein Getter-Setter-Schema, aber das würde den Kern verkomplizieren, den ich rüberbringen möchte und alles weniger verständlich machen. Aber das Beschäftigen mit Kapselung, Gettern und Settern sollte auf deiner To Do-Liste stehen :-)
Also du brauchst erstmal eine Instanz von deinem Objekt.
Das geht einfach:
Flughafen superFlughafen = new Flughafen()
Der getter ist am Ende nur eine "normale" Methode die halt den Wert aus einer nicht-public-Variable zurückgibt. In dem Fall würde dein getter in der Klasse Flughafen vermutlich getLandebahnlaenge heißen. In der Klasse Flughafen musst du den natürlich erstellen:
public int getLandebahnlaenge() {
return this.landebahnlaenge;
}
Damit wäre das Nutzen des Getters
System.out.println(superFlughafen.getLandebahnlaenge()); //schreibt den Wert in die Konsole
superFlughafen.getLandebahnlaenge();
//ist der reine Zugriff ohne Sinn
Das ist Java Code, oder?
Du musst getter-Methoden schreiben:
public class Flugzeug {
private int maxPassagiere = 250;
private int minlandelaenge = 2;
private String standort = "flug";
public int getMaxPassagiere() {
return maxPassagiere;
}
public int getMinlandelaenge() {
return minlandelaenge;
}
public Sting getStandort() {
return standort ;
}
}
Und aufrufen kannst du die Getter dann so:
public class Main {
public static double main(String[] args) {
Flugzeug flugzeug = new Flugzeug();
Flughafen flughafen = new Flughafen();
if (flugzeug.getMinlandelaenge() <= flughafen.getLandebahnlaenge()) {
...
}
}
}
Vielleicht hast du gesehen, dass ich die Variablen private gemacht habe. Wenn du getter-Methoden hast, dann ist es häufig üblich, die Variablen private zu machen, da man dann ja nicht mehr direkt auf die Variable zugreifen muss.
Wenn die Variable public ist, könntest du auch direkt auf die Variable zugreifen (ohne getter-Methode). Also so z.B. "flugzeug.minlandelaenge". Das ist aber eher verpöhnt und man sollte ehre die getter und setter methoden verwenden.
Wenn du keine Instanz von Flugzeug und Flughafen erstellen willst, sondern wenn die Werte immer gültig sind, dann wäre es vielleicht denkbar, statische Variablen zu verwenden.
get.minlandelaenge
wird es sowieso nicht geben. Was soll denn "get." sein?
Getter sind Funktionen, die du selbst erstellen musst. Beispielsweise in deiner Klasse Flugzeug:
public int getMinlandelaenge() {
return this.minlandelaenge;
}
Für den Aufruf dieser Methode brauchst du auch eine Instanz deiner Klasse. Dir fehlen hier also wirklich grundlegende Denkansätze für die Programmierung
Du solltest dir definitiv vorher anschauen, wie Instanzen und Objekte funktionieren. Wenn du das verstanden hast, wirst du auch verstehen, wie du deine gewünschte if-Abfrage umsetzt.
Top Danke. hilft immer so eine erklärung