Lernen Sie Java für Android Entwicklung: Java Syntax

() translation by (you can also view the original English article)

In dieser Übungsreihe lernen Sie Java, die Programmiersprache für Android-Anwendungen, kennen. Unser Ziel ist es, diejenigen vorzubereiten, die bereits mit einer Programmiersprache wie PHP oder Objective-C vertraut sind, um mit der Programmiersprache Java vertraut zu werden und in die Entwicklung von Android-Apps einzutauchen. In diesem speziellen Lernprogramm lernen Sie die Grundlagen der Javasyntax kennen, einschließlich der Erstellung von Kommentaren, der Definition von Variablen, der Erstellung bedingter Anweisungen und der Iteration mithilfe von Schleifen. Wenn Sie neu in Java sind oder einfach nur die Details auffrischen möchten, dann ist dies die Tutorial-Serie für Sie!

Anfangen

Soweit die Voraussetzungen erfüllt sind, werden wir nicht viele Annahmen über Ihre Programmiererfahrung machen. Wir gehen davon aus, dass Sie verstehen, wie man programmiert (vielleicht in PHP oder Visual Basic oder C ++), aber dass Sie mit den Besonderheiten der Programmierung in der Sprache Java nicht vertraut sind. Wir gehen nicht auf die Details ein, warum Sie eine for-Schleife gegenüber einer while-Schleife machen möchten, aber wir zeigen Ihnen in Java die Syntax beider Arten von Schleifen. Anders gesagt, wir werden dich nicht programmieren lehren; Wir werden Ihnen klare Beispiele für häufig verwendete Java-Sprachkonstrukte und -prinzipien geben und auf einige Android-spezifische Tipps und Tricks hinweisen.

Was du brauchen wirst

Technisch benötigen Sie keine Werkzeuge, um dieses Tutorial zu absolvieren, aber Sie werden sie sicherlich brauchen, um Android-Anwendungen zu entwickeln.

Um Android-Anwendungen (oder auch Java-Anwendungen) zu entwickeln, benötigen Sie eine Entwicklungsumgebung zum Schreiben und Erstellen von Anwendungen. Eclipse ist eine sehr beliebte Entwicklungsumgebung (IDE) für Java und die bevorzugte IDE für Android-Entwicklung. Es ist frei verfügbar für Windows-, Mac- und Linux-Betriebssysteme.

Eine vollständige Anleitung zur Installation von Eclipse (einschließlich der unterstützten Versionen) und des Android SDK finden Sie auf der Android-Entwicklerwebsite.

Sehen wir uns nun eine hilfreichere Java-Syntax an.

Bemerkungen

Die meisten Programmiersprachen erlauben Kommentare und Java ist nicht anders. Sie können beliebig viele Zeilen Text kapseln, indem Sie Ihren Kommentar mit / * beginnen und Ihren Kommentar mit * / beenden. Beispielsweise:

1	/* MULTILINE
2	COMMENT */

Sie können auch Kommentare nach dem Code für einen einzelnen Tag mit // angeben. Beispielsweise:

1	int x = 7; // First variable called x equals seven
2	int y = 8; // Second variable called y equals eight
3	int result = x + y; // The result variable value should equal 15

Java hat auch einen Standardtyp von Kommentaren namens Javadoc, mit dem nicht nur Code kommentiert, sondern auch Code-Dokumentation erstellt werden kann. Dieses Thema ist ziemlich groß für sich selbst, aber hier ist ein Beispiel dafür, wie Javadoc-Kommentare aussehen:

/** This method does something interesting
 *
 * @param someValue processed and returned
 * @param option changes the type of processing done to someValue
 * @return The result of someValue being processed
 */
public int sampleMethod(int someValue, boolean option) {
    //…
}

Variablen

Eine Variable ist einfach ein Stück Daten. Java-Variablen fallen im Allgemeinen in zwei Kategorien:

Primitive Datentypen, wie int, float, double, char usw.
Java-Objekte (wie durch eine Klassendefinition definiert)

Variablen werden für verschiedene Zwecke verwendet. Manchmal werden Variablen zum Speichern von Werten verwendet, die sich im Laufe der Zeit ändern oder ändern können. Zum Beispiel könnte eine Variable namens counter gelegentlich erhöht werden. Andere Variablen, insbesondere Klassenvariablen, die für alle Instanzen einer bestimmten Klasse gleich bleiben, sollten mit dem Schlüsselwort static definiert werden. Zu anderen Zeiten können Variablen Konstanten darstellen - diese Variablen sollten das Schlüsselwort final verwenden, um zu zeigen, dass sie sich im Laufe der Zeit nicht ändern.

Eine Variable ist nur in ihrem Gebiet oder Geltungsbereich gültig. Der Variablenbereich wird oft durch geschweifte Klammern {} gesteuert. Wenn eine Variable definiert ist, ist sie innerhalb dieser geschweiften Klammern gültig. Wenn Sie versuchen, auf eine Variable außerhalb der geschweiften Klammern zuzugreifen, ist sie nicht definiert. Klassenmitgliedsvariablen in objektorientierten Sprachen werden oft als Attribute bezeichnet. Sie können auch Felder oder Eigenschaften genannt werden.

Wie bei anderen gängigen Programmiersprachen haben Sie Ihren Zuweisungsoperator, das Gleichheitszeichen:

1	int i = 5;

Sie haben auch Ihre arithmetischen Operatoren wie +, -, *, /. Denken Sie daran, Klammern zu verwenden, um die Reihenfolge der Operationen nach Bedarf zu erzwingen:

1	int result = (a + b) / c;

Schließlich haben Sie Ihre typischen unären Operatoren, mit denen Sie eine einzelne Variable mit einer einfachen Anweisung modifizieren können:

1	iPositive++; // increment by one; equivalent to iPositive = iPositive + 1;
2	iPositive --; // decrement by one; equivalent to iPositive = iPositive - 1;

Beachten Sie, dass die Operatoren increment (++) und dekrement (-) Präfix oder Postfix sein können, was bedeutet, dass das Inkrement vor oder nach der Bestimmung von Bedingungen ausgeführt werden kann, wenn das Element in einer Schleife verwendet wird. Im Allgemeinen halten wir uns an Postfix-Anweisungen, so dass Code besser lesbar ist.

Primitive Datentypen

Sehen wir uns einige der primitiven Datentypen in der Programmiersprache Java an:

Byte
- Eine Bytevariable ist eine 8-Bit-Ganzzahl mit Vorzeichen zwischen -128 und 127. Wird oft für Arrays verwendet.
kurz
- Eine kurze Variable ist eine 16-Bit-Ganzzahl mit Vorzeichen zwischen -32.768 und 32.767. Auch hier oft für Arrays verwendet.
int
- Eine int-Variable ist eine 32-Bit-Ganzzahl mit Vorzeichen zwischen -2.147.483.648 und 2.147.483.647. Dies ist die am häufigsten verwendete "Zahl" Variable.
lange
- Eine Long-Variable ist eine 64-Bit-Ganzzahl mit Vorzeichen zwischen -9,223,372,036,854,775,808 und 9,223,372,036,854,775,807.
schweben
- Eine Float-Variable ist eine 32-Bit-Fließkommazahl mit einfacher Genauigkeit.
doppelt
- Eine Doppelvariable ist eine 64-Bit-Gleitkommazahl mit doppelter Genauigkeit. Verwenden Sie diesen Datentyp für Dezimalwerte.
boolesch
- Eine boolesche Variable hat nur zwei mögliche Werte: wahr und falsch. Verwenden Sie diesen Datentyp für bedingte Anweisungen.
verkohlen
- Eine char-Variable ist ein einzelnes 16-Bit-Unicode-Zeichen.

Primitive Typenvariablen können definiert werden, indem der Datentyp angegeben wird, gefolgt von dem Variablennamen, einem Gleichheitszeichen und einem Anfangswert. Alle Java-Anweisungen enden mit einem Semikolon. Zum Beispiel definiert die folgende Java-Anweisung eine Variable namens iVal mit einem Anfangswert von 1:

1	int iVal = 1;

Wie viele andere Sprachen können Sie ein nullbasiertes Array eines bestimmten Datentyps definieren. Im Folgenden wird beispielsweise ein Array mit drei ganzzahligen Werten definiert (erste vier Potenzen von 2):

int[] aiPowersOfTwo;
aiPowersOfTwo = new int[4];
aiPowersOfTwo [0] = 1;    //  2^0=1
aiPowersOfTwo [1] = 2;    //  2^1=2
aiPowersOfTwo [2] = 4;    //  2^2=4
aiPowersOfTwo [3] = 8;    //  2^3=8

Häufig verwendete Java-Objekte

Die Java-Bibliotheken stellen eine Anzahl hilfreicher Objekte zur Verwendung mit allgemeinen Datenstrukturen bereit. Alle Objekte sind von der Object-Klasse abgeleitet. Es gibt Klassengegenstücke für alle primitiven Datentypen. Beispielsweise kapselt die Integer-Klasse einen int-Wert und bietet eine Reihe hilfreicher Methoden zum Bearbeiten ganzzahliger Datenwerte. Der folgende Java-Code instanziiert zum Beispiel eine ganzzahlige Variable mit dem Namen iVal und erstellt dann ein Integer-Objekt mit einem Konstruktor, der eine ganze Zahl annimmt. Anschließend verwendet er eine in der Integer-Klasse verfügbare Handle-Methode, um eine float-Variable zu extrahieren.

1	int iVal = 1;
2	Integer integ1= new Integer(iVal);
3	float f = integ1.floatValue();

Das am häufigsten verwendete Objekt in Android-Anwendungen ist der String. Die String-Klasse wird verwendet, um lesbare Textzeichen zu kapseln, die oft auf dem Bildschirm angezeigt werden. Wenn Sie Zeichenfolgen aus kleineren Teilen ändern oder erstellen, sollten Sie auch die StringBuffer- und StringBuilder-Klassen auschecken.

1	String strHello = new String("Hello World");

Für eine Liste gängiger Java-Datentypen enthält die Android-Referenz Dokumentation für das Paket java.lang. Sie finden die allgemeinen Eingabe- / Ausgabeobjekte auch im java.io-Paket.

Für komplexere Datenstrukturen wie Listen, Warteschlangen, Stapel, Daten und Uhrzeiten sind geeignete Klassen im Paket java.util enthalten.

Schließlich basieren Android-Anwendungen auf einer Reihe nützlicher Klassen, die die häufig verwendeten Anwendungskomponenten wie Aktivität, Anwendung, Dialog und Service definieren. Diese Klassen finden Sie im Paket android.app.

Klassenberechtigungen und Zugriff

Sie können die Sichtbarkeit einer Klasse sowie deren Variablen und Methoden steuern, indem Sie die Zugriffsebene eines Elements angeben. Die Zugriffsebenen sind: öffentlich, geschützt und privat. Wenn Sie möchten, dass etwas von außerhalb einer Klasse zugänglich ist, verwenden Sie im Allgemeinen öffentlich. Wenn eine Methode oder Variable nur von der Klasse selbst zugänglich sein soll, verwenden Sie private. Verwenden Sie protected, wenn die Klasse oder eine ihrer Unterklassen Zugriff benötigen.

Die folgende SillySensor-Klassendefinition definiert beispielsweise mehrere Variablen und Methoden mit unterschiedlichen Zugriffsebenen:

Eine Klassenvariable namens sensorData, die nur innerhalb der Klasse sichtbar ist
Ein öffentlicher Konstruktor, der außerhalb der Klasse aufgerufen werden kann
Eine private Methode namens calibrate (), die nur innerhalb der Klasse aufgerufen werden kann
Eine geschützte Methode namens seedCalibration (), die von der Klasse selbst oder von einer Unterklasse aufgerufen werden kann
Eine öffentliche Methode namens getSensorData (), die von überall aufgerufen werden kann und einen schreibgeschützten Zugriff auf die sensorData-Variable ermöglicht

    public class SillySensor
    {
        private int sensorData;

        public SillySensor()
        {
            sensorData=0;
        }

        private void calibrate(int iSeed)
        {
            // Do some calibration here
        }

        protected void seedCalibration(int iSeed)
        {
            calibrate(iSeed);
        }

        public int getSensorData()
        {
            // Check sensor here

            return sensorData;
        }

    }

Bedingungen

Java enthält bedingte Anweisungen, mit denen Codefragmente nur ausgeführt werden können, wenn bestimmte Bedingungen erfüllt sind. In der Regel beinhaltet eine bedingte Anweisung zwei Seiten. Wenn die beiden Seiten äquivalent sind, ist die Aussage wahr, andernfalls ist sie falsch.

Java verfügt über alle typischen bedingten Operatoren wie:

== gleich, wie in (ein == b).
! = nicht gleich, wie in (X! = y)
> größer, wie in (Z > y)
> = größer als oder gleich, wie in (Q > = Z)
< weniger als, wie in (b < ein)
< = kleiner oder gleich, wie in (ein < = Z)

Und wenn Sie mehrere bedingte Anweisungen zu einem einzigen größeren bedingten Test kombinieren müssen, können Sie AND (&&) und OR (||) verwenden:

((a==b) && (ein == c)) / / true, wenn A gleich B und C gleich ist
((a==b) || (a==c)) nur wahr, wenn A gleich B ist oder gleich C

Java hat bitweise Operatoren (&, |, ^), Verschiebungen (>>, <<) und Komplementoperatoren (~), falls Sie sie benötigen. Weitere Informationen finden Sie in der Java-Dokumentation.

Jetzt, da Sie wissen, wie Sie eine bedingte Anweisung erstellen, können Sie bedingte Codesegmente erstellen. Die einfachste Form einer bedingten Code-Anweisung ist die if () -Anweisung:

boolean condition = true;
if(condition==true)
{
    // Execute this code only if  condition variable is true
}

Wenn Sie alternativen Code zum Ausführen bereitstellen möchten, wenn die Bedingung nicht erfüllt ist, verwenden Sie die else-Klausel mit der if () -Anweisung:

boolean condition = true;
if(condition==true)
{
    // Execute this code only if condition variable value is true
} else {
    // Execute this code only if condition variable value is false
}

Wenn Sie mehr als zwei Fälle behandeln möchten, können Sie kaskadierende if-else-if-else-Anweisungen verwenden:

if(iVar==0) {
    // variable is zero
} else if (iVar > 0) {
    // variable is a positive number
} else {
    // variable is a negative number
}

Wechseln Sie die Fallanweisungen

Wenn Sie mehrere verschiedene Codepfade haben, die von einem einzelnen Variablenwert abzweigen, können Sie eine switch () -Anweisung verwenden. Mit einer switch-Anweisung geben Sie die Variable an, nach der gesucht werden soll, und stellen zahlreiche Optionen für die Ausführung in bestimmten Fällen bereit. Sie können auch eine Standardoption angeben, die ausgeführt werden soll, wenn keine anderen Fälle zutreffen. Jeder Fall kann mit einer break-Anweisung beendet werden. Wenn keine break-Anweisung angegeben wird, wird der Code mit der nächsten case-Anweisung fortgesetzt.

        char singleChar = 'z';
        switch(singleChar) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            // singleChar is a vowel! Execute this code!
            break;
        default:
             // singleChar is a consonant! Execute this code instead!
             break;
        }

Schleifen

Wenn Sie Code wiederholt ausführen oder Rekursion verwenden wollen (heh, schauen Sie, wenn Sie nicht wissen, worüber wir sprechen), unterstützt Java verschiedene Arten von Schleifen.

Um eine Schleife zu durchlaufen, sofern eine Anweisung wahr ist, verwenden Sie eine while () -Schleife:

int numItemsToProcess = 3;
while(numItemsToProcess > 0)
{
    // process an item
    numItemsToProcess--;
}

Wenn Sie den bedingten Schleifenausdruck NACH der ersten Iteration auswerten möchten, können Sie stattdessen eine do-while-Schleife verwenden:

do
{
    // check for items to process, update numItemsToProcess as required
    // process item, updated numItemsToProcess
} while (numItemsToProcess > 0);

Wenn Sie für eine bestimmte Anzahl von Iterationen eine Schleife erstellen möchten, können Sie eine for () - Schleife verwenden. Eine for () - Schleife hat drei Parameter: den Anfangswert, den Abschlusswert und den Inkrementierungswert. Wenn Sie beispielsweise eine Schleife 100 Mal ausführen und die Zahlen 1 bis 100 drucken möchten, können Sie die folgende Schleife für () verwenden:

1	for(int i = 1; i <=100; i++)
2	{
3	// print i
4	}

Hinweis: Sie können auch eine break-Anweisung verwenden, um bei Bedarf eine while () -, do-while () - oder for () - Schleife zu verlassen. Sie können auch eine continue-Anweisung verwenden, um den Rest einer aktuellen Iteration einer Schleife zu überspringen und zur nächsten Iteration überzugehen (natürlich unter Auswertung des Bedingungsausdrucks).

Passing By Value Vs. Unter Bezugnahme

In Java gibt es keine Zeiger. Ok, ok, mach weiter und atme erleichtert auf. Das Leben ist hart genug, ohne dass man irgendwelche Dinge muckt, oder?

Ok, jetzt ist es wieder an der Zeit, aufmerksam zu sein. In Java werden Methodenparameter als Wert übergeben. Wenn ein Methodenparameter jedoch ein Objekt ist (also alles außer einem primitiven Typ), wird nur eine Referenz auf dieses Objekt in die Methode übergeben [ähnlich wie Zeiger, sorry!]. Um das an eine bestimmte Methode übergebene Objekt zu modifizieren, übergeben Sie daher im Allgemeinen die Objektreferenz und handeln danach, wodurch die zugrunde liegenden Daten des übergebenen Objekts geändert werden. Sie können das Objekt jedoch nicht selbst austauschen ... Hier ein kurzes Beispiel:

Hier haben wir eine Klasse namens Cat:

public class Cat {
    private String mCatName;

    Cat(String name) {
        mCatName=name;
    }

    public String getName() {
        return mCatName;
    };

    public void setName(String strName) {
        mCatName = strName;
    };
}

Versuchen wir nun, diese Klasse zu verwenden und ein Cat-Objekt in einige Funktionen zu übergeben, um zu sehen, was passiert:

    void messWithCat(Cat kitty) {
        kitty = new Cat("Han");
    }

    void changeKitty(Cat kitty) {
        kitty.setName("Wookie");
    }

    Cat haveKitten()
    {
        Cat kitten = new Cat("Luke");
        return kitten;
    }

Schließlich wollen wir diese Methoden aufrufen und sehen, wie sie auf Cat-Objektinstanzen wirken:

Cat cat1 = new Cat("Jabba");
Cat cat2 = new Cat("Leia");

cat1.getName();    // Returns Jabba
cat2.getName();    // Returns Leia
messWithCat(cat1);
changeKitty(cat2);
Cat cat3 = haveKitten();
cat1.getName();    // Returns Jabba – Note that object remains unchanged!
cat2.getName();    // Returns Wookie
cat3.getName();    // Returns Luke

Aufwickeln

Sie haben gerade einen Crash-Kurs der Programmiersprache Java abgeschlossen. Während Sie möglicherweise nicht bereit sind, Ihre erste Java-App zu schreiben, sollten Sie in der Lage sein, die einfachsten Java-Klassen der Android-Beispielanwendung zu verwenden und zu bestimmen, was sie tun, zumindest in Bezug auf die Java-Syntax der Dinge. Die erste Klasse, die Sie sich für die Android-Entwicklung ansehen wollen, ist die Aktivitätsklasse. Eine Android-Anwendung verwendet Aktivitäten, um verschiedene Laufzeitaufgaben zu definieren.Daher müssen Sie eine Aktivität definieren, die als Einstiegspunkt für Ihre Anwendung dient Nun, da Sie die Java-Syntax im Griff haben, empfehlen wir dringend, dass Sie ein Anfänger-Android-Tutorial durcharbeiten.

Sie haben nur die Oberfläche der Java-Entwicklung für Android-Entwicklung gekratzt. Sehen Sie sich die anderen großartigen Tutorials auf Mobiletuts + an, um tiefer in die Entwicklung von Java und Android einzutauchen. Wir empfehlen die folgenden ersten Android-Tutorials: Einführung in die Android-Entwicklung von Gyuri Grell und Anfang Android: Erste Schritte mit Fortune Crunch, um mit der Android-Entwicklung zu beginnen. Viel Glück!

Über die Autoren

Die mobilen Entwickler Lauren Darcey und Shane Conder haben mehrere Bücher zur Android-Entwicklung verfasst: ein ausführliches Programmierbuch mit dem Titel Android Wireless Application Development und Sams TeachYourself Android Application Development in 24 Stunden. Wenn sie nicht schreiben, verbringen sie ihre Zeit damit, mobile Software in ihrem Unternehmen zu entwickeln und Beratungsdienste anzubieten. Sie können per E-Mail an androidwirelessdev+mt@gmail.com, über ihren Blog unter androidbook.blogspot.com und über Twitter @androidwireless erreicht werden.