Stunde # 1-5: Mehr über Variablen:
Heute werden wir weiter über Variablen reden. Ich weiß, dass dies ein sehr trockenes Thema ist, aber auf dem Weg zu unserer Android App ist dies sehr wichtig. Nehmen wir dazu unser ausgedachtes Beispiel der Lektion 2.1:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public class Phone { // Diese Variablen beschreiben den Zustand des Handys. int weight = 0; boolean turnedOn = false; String color = "blue"; // Diese Methode kontrolliert das Verhalten des Handys. void tooglePower(boolean turnedOn){ if (turnedOn == true) { turnedOn = false; } if (turnedOn == false) { turnedOn = true; } } |
Die 3 Felder bzw. 3 Variablen, die hier stehen sind: eine integer Variable namens weight, eine boolean Variable namens turnedOn und ein String Objekt namens color. Heute werden wir diese im Detail betrachten.
Es gibt 4 verschiedene Variablen (variables), diese werden auch Felder (fields) genannt. Also merken wir uns variables = fields.
Als Erstes rufen wir uns wieder ins Gedächtnis, dass classes, also Klassen, Pläne zum Herstellen von Objekten sind. Bei jedem Objekt, welches wir erstellen und welches diese Klasse beinhaltet, erstellen wir ein neues Beispiel oder eine neue Kopie der Klasse. Dies bedeutet, dass wir jedes mal, wenn wir eine Phone Klasse benutzen, um ein Phone Objekt zu erzeugen, eine neue Instanz dieser Phone Klasse erstellen.
Mit jeder Instanz der Phone Klasse werden auch alle darin befindlichen Variablen mit erstellt. Jede dieser Klassen wird ein weight-, ein turnedOn- und ein String-Feld besitzen. Wenn wir nun eine dieser Variablen verändern, zum Beispiel bei der weight Variable eine 1 hinzufügen, wird es einzig und allein nur diese eine Phone Klasse betreffen, alle anderen Kopien sind davon nicht betroffen. Das heißt, jede Phone Klasse hat ihre eigenen Felder (Variablen) und diese sind komplett unabhängig voneinander.
Das ist so, weil:
1. Instance variables (Fallbezogene Variablen): Immer, wenn wir eine Variable ohne static schreiben, wird eine fallbezogene Variable erstellt. Dies bedeutet, dass sie nur für diesen einen Fall, in dem sie aufgerufen wird, benutzt wird.
2. class variables: Wenn ich nun eine Variable haben möchte, welche in jeder Kopie meiner Phone Klasse den selben Wert annimmt, dann benötigen wir static. Also anstatt int weight = 0 nehmen wir static int weight = 0. Somit ist für alle meine Phone Objekte die Variable weight die selbe, egal wie viele Kopien es davon gibt.
Schauen wir mal auf ein anderes Beispiel, um die Sache noch klarer zu machen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class AndroidPhone { // Hier können immer Kommentare hinterlassen werden. // Deklaration und Initialisierung von Variablen. // duoble wird für alle Dezimalzahlen benutzt. // int wird für alle ganzen Zahlen benutzt. static double versionNumber = 2.2; boolean turnedOn = false; final String color = "blue"; public static void main(String[] args) { } |
Stellen wir uns mal vor, wir leben in einer perfekten Welt, in welcher wir wirklich große Sachen machen können.
Lasst uns von Folgendem ausgehen. Ein Gerätehersteller erstellt 10 Android Handys und nutzt die oben gezeigte AndroidPhone Klasse. Die 10 Geräte werden nun von 10 Leuten gekauft. Nennen wir diese mal phoneOne, phoneTwo, phoneThree und so weiter.
Wenn der Gerätehersteller nun ein Update herausbringt, möchte dieser natürlich alle 10 Geräte gleichzeitig aktualisieren. Wir sind hier gerade in Gedanken, das wird sicherlich nicht wirklich passieren.
Nun würden sie einfach wie folgt den Code der Klasse verändern:
|
1 2 3 4 5 6 |
// Diese und die nachfolgende Zeile sind Kommentare. // // Diese Methode wird das Phone updaten. static void updatePhones() { versionNumber = 2.3; } |
Hinweis: Das Gleichheitszeichen darf man hier nicht zu mathematisch sehen. Es bedeutet einfach, dass die versionNumber den Wert 2.3 annimmt.
Wir haben nun 10 Geräte mit einer Kopie der AndroidPhone Klasse, welche die Variable static double versionNumber besitzt. Wenn wir nun diese Variable einmal verändern, bedeutet das, dass alle anderen der 10 AndroidPhones auch zeitgleich geändert werden.
Es macht also Sinn, für die versionNumber eine static Variable zu erzeugen, da man möchte, dass alle gleichzeitig ein Update erhalten. Es macht jedoch keinen Sinn, für das Ein- oder Ausschalten eine static Variable zu erzeugen, denn sonst würden alle Handys ausgehen, wenn jemand seines ausschaltet.
Aber wie schaffen wir es dann, dass jedes Handy einzeln ausgeschaltet werden kann?
Es ist eigentlich einfach, wir haben jedes der 10 Handys einzeln benannt, phoneOne, phoneTwo und so weiter.
|
1 2 3 4 5 6 7 8 9 10 11 |
static void pressPowerButton{ if (phoneOne turnedOn == false) { phoneOne.turnedOn = true; } if (phoneOne turnedOn == true) { phoneOne.turnedOn = false; } // Erinnert euch an die Gleichheitszeichen. |
Kommen wir nun zu der letzten Variable, final String color = „blue“. String bedeutet Text und hier erstellen wir eine color Variable mit dem Wert von „blue“. Die “ “ bedeuteten, dass es sich hier um Text handelt. Wenn wir keine “ “ geschrieben hätten, würde die color Variable den Wert, den die Variable names blue hat, annehmen. Es gibt jedoch keine Variable namens blue und es würde eine Fehlermeldung beim Ausführen des Codes geben.
Die Farbe der 10 AndroidPhones wird sich also niemals ändern. Also gehen wir davon aus, dass es final, also endgültig ist.
Nun werden wir aber wieder zurück zu unseren 4 verschiedenen Arten von Variablen kommen.
3. Local Variables (Lokale Variable): Wenn wir eine lokale Variable erstellen, gehört diese ausschließlich zu der Methode, in welcher sie erstellt wurde. Wenn wir nun diese Variable in einer anderen Klasse benutzen wollen, wird uns Eclipse darüber informieren, dass es diese Variable nicht gibt.
Ein Beispiel:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public class localVariables { // Dies ist eine Klassenvariable. // Dadurch kann sie in jeder Methode verwendet werden. static double pi = 3.14; public static void main(String[] args) { // Dies ist eine lokale Variable. // Sie ist vom Typ double und heißt hello. double hello = 2.0; // Dies bedeutet, dass hello sich aus pi + hello ergibt. hello = pi + hello; } static void secondaryMethode() { double hello = 4.0; hello = pi + hello; } } |
Hier gibt es 3 verschiedene Variablen nicht nur 2:
1. Die Klasse mit dem Namen pi
2. Die lokale Variable namens hello in der main Methode
3. Die lokale Variable namens hello in der secondaryMethode
Dies bedeutet, wenn wir eine Variable in einer Methode schreiben, wird diese Variable nur zu dieser Methode gehören. So kann man den gleichen Namen für mehrere Variablen innerhalb verschiedener Klassen vergeben.
4. Parameters: Es ist möglich, eine lokale Variable für mehrere Methoden zu verwenden und zwar so:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
public class localVariables { // Dies ist eine Klassenvariable. // Dadurch kann sie in jeder Methode verwendet werden. static double pi = 3.14; public static void main(String[] args) { // Dies ist eine lokale Variable. // Sie ist von Typ double und heißt hello. double hello = 2.0; // Dies bedeutet, dass hello sich aus pi + hello ergibt. hello = pi + hello; // Dies ruft die secondaryMethode auf. secondaryMethod(hello); } static void secondaryMethode() { hello = hello + 5; } } |
Wenn man eine lokale Variable aus einer Methode benötigt, so schreibt man diese in die Klammern, in welcher diese verwendet werden soll, also secondaryMethod(double hello). Wenn diese Methode zusätzlich einen Parameter aus einer anderen Methode benötigt, dann reicht das allein nicht aus und wird uns immer wieder einen Fehler bringen.
Wann immer wir so eine Variable aufrufen wollen, müssen wir folgenden Code in der Main Methode einfügen:
|
1 |
secondaryMethod(hello); |
Was bewirkt aber dieser Code, wenn ich diesen Code in der main Methode aufrufe?
Es wird nun die double hello Variable von der main Methode genommen und an die secondaryMethode gesendet, wo die Variable als eine lokale Variable namens hello abgespeichert wird. Also gibt es wieder 2 Variablen mit dem Namen hello.
Was heißt das in unserem Beispiel?
In der main Methode hat hello den Wert von 5,14.
In der secondaryMethode hat hello den Wert von 10,14.
Falls dies noch nicht klar ist, lest den Text noch einmal, bis dies klar wird.
—————————————————————————————————
Um Methoden und das Aufrufen nochmal zu verdeutlichen:
In Java wird innerhalb einer Funktion der Code immer von oben nach unten gelesen. Als Programmierer tut man also folgende 2 Dinge:
1. Man stellt Dinge ein, die aufgerufen werden.
2. Man beruft Dinge dazu, aufgerufen zu werden.
Wenn wir also eine Methode erstellen und diese, sagen wir, methodName benennen, wird diese Methode solange ignoriert, bis wir sie explizit mit methodName(); aufrufen.
Man kann dies sehen, indem man die Beispiele zu den lokalen Variablen und Parametern vergleicht. In dem Beispiel der lokalen Variable ist eine secondaryMethod beschrieben, diese wurde aber nie aufgerufen. Dadurch wird in dieser Methode also nichts geschehen, wenn wir auf Play drücken.
In dem Parameter Beispiel steht: secondaryMethode(hello); Dies ruft die secondaryMethode auf und lässt diese auch durchlaufen.
Die main Methode wird immer aufgerufen, wenn Play gedrückt wird.
Man kann so viele Methoden erstellen, wie man will. Diese sind dazu da, um Ordnung und eine Struktur zu erzeugen. So kann man auch einfach Statements bearbeiten, ohne den kompletten Code ändern zu müssen.
Damit beenden wir Lektion 3. Man sieht sich dann in Lektion 4!
Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.
Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, das würde dieser Seite wirklich weiterhelfen, danke sehr. Auch ein Klick auf die Werbung hilft dabei, diese Seite am Laufen zu halten.
Quelle: Original Anleitung auf englisch von Kilobolt Studios