Share
In deze tutorialserie leert u Java kennen, de programmeertaal die wordt gebruikt om Android-applicaties te ontwikkelen. Ons doel is om degenen die al bekend zijn met één programmeertaal, zoals PHP of Objective-C, voor te bereiden op het comfortabel werken met de Java-programmeertaal en een duik nemen in de ontwikkeling van Android-apps. In deze specifieke tutorial leer je de basisprincipes van de Java-syntaxis, inclusief het maken van opmerkingen, het definiëren van variabelen, het maken van voorwaardelijke instructies en het herhalen van het gebruik van loops. Als je nieuw bent bij Java, of als je alleen maar de details wilt opfrissen, dan is dit de tutorialserie voor jou!
Voor zover de vereisten gaan, zullen we niet veel aannames doen over je programmeerervaring. Wij zijn ga ervan uit dat je begrijpt hoe je moet programmeren (misschien in PHP, of Visual Basic of C ++), maar dat je niet bekend bent met de details van programmeren in de Java-taal. We gaan niet in op de details van waarom je zou een for-loop versus een while-loop willen doen, maar we zullen je in Java de syntax van beide soorten loops laten zien. Op een andere manier gezegd, we gaan je niet leren programmeren; we gaan u voorzien van duidelijke voorbeelden van veelgebruikte constructies en principes van de Java-taal, terwijl we u wijzen op enkele Android-specifieke tips en trucs.
Technisch gezien heb je geen tools nodig om deze tutorial te voltooien, maar je zult ze zeker nodig hebben om Android-applicaties te ontwikkelen.
Om Android-applicaties (of welke Java-applicaties dan ook) te ontwikkelen, hebt u een ontwikkelomgeving nodig om applicaties te schrijven en te bouwen. Eclipse is een zeer populaire ontwikkelomgeving (IDE) voor Java en de geprefereerde IDE voor Android-ontwikkeling. Het is gratis beschikbaar voor Windows-, Mac- en Linux-besturingssystemen.
Zie de Android-ontwikkelaarswebsite voor volledige instructies over het installeren van Eclipse (inclusief welke versies worden ondersteund) en de Android SDK.
Laten we nu eens kijken naar wat meer nuttige Java-syntaxis.
De meeste programmeertalen staan reacties toe en Java is niet anders. U kunt een willekeurig aantal regels tekst inkapselen door uw opmerking te beginnen met / * en uw opmerking te eindigen met * /. Bijvoorbeeld:
/ * MULTILINE COMMENT * /
Je kunt ook commentaar achter code geven op een single met //. Bijvoorbeeld:
int x = 7; // Eerste variabele genaamd x is gelijk aan zeven int y = 8; // Tweede variabele genaamd y is gelijk aan acht int resultaat = x + y; // De waarde van de resultaatvariabele moet gelijk zijn aan 15
Java heeft ook een standaard type opmerkingen, genaamd Javadoc, dat kan worden gebruikt om niet alleen commentaarcode te geven, maar ook om eenvoudig codedocumentatie te maken. Dit onderwerp is vrij groot op zichzelf, maar hier is een voorbeeld van hoe Javadoc-opmerkingen eruit zien:
/ ** Deze methode doet iets interessants * * @param someValue verwerkt en geretourneerd * @param optie verandert het type verwerking gedaan naar someValue * @return Het resultaat van someValue wordt verwerkt * / public int sampleMethod (int someValue, Boolean option) // ...
Een variabele is eenvoudigweg een gegeven. Java-variabelen vallen over het algemeen in twee categorieën:
Variabelen worden voor verschillende doeleinden gebruikt. Soms worden variabelen gebruikt om waarden op te slaan die in de loop van de tijd kunnen veranderen of worden aangepast. Bijvoorbeeld, een variabele genaamd teller kan bij gelegenheid worden verhoogd. Andere variabelen, met name klassevariabelen die voor alle exemplaren van een bepaalde klasse hetzelfde blijven, moeten worden gedefinieerd met behulp van het statische zoekwoord. Andere tijden kunnen variabelen constanten vertegenwoordigen - deze variabelen moeten het trefwoord definitief gebruiken om te laten zien dat ze niet veranderen in de loop van de tijd.
Een variabele is alleen geldig binnen zijn territorium, of strekking. Variabele scope wordt vaak bepaald door accolades . Wanneer een variabele is gedefinieerd, is deze geldig binnen die accolades. Als u probeert een variabele buiten de accolades te gebruiken, is deze ongedefinieerd. Klasse-lidvariabelen in objectgeoriënteerde talen worden vaak genoemd attributen. Ze kunnen ook velden of eigenschappen worden genoemd.
Net als andere veel voorkomende programmeertalen, heb je je toewijzingsoperator, het gelijkteken:
int i = 5;
Je hebt ook je rekenkundige operatoren zoals +, -, *, /. Vergeet niet om haakjes te gebruiken om de volgorde van bewerkingen te dwingen zoals nodig:
int resultaat = (a + b) / c;
Ten slotte hebt u uw typische unaire operatoren, waarmee u één enkele variabele kunt aanpassen met een eenvoudige verklaring:
iPositive ++; // verhogen met één; gelijk aan iPositive = iPositive + 1; iPositive -; // verlagen met één; gelijk aan iPositive = iPositive - 1;
Merk op dat de increment (++) en decrement (-) operatoren prefix of postfix kunnen zijn, wat betekent dat de increment kan worden uitgevoerd voor of na het bepalen van conditionaliteiten, als het item in een lus wordt gebruikt. Over het algemeen houden we ons aan postfix-instructies, zodat code leesbaarder is.
Laten we eens kijken naar enkele van de primitieve gegevenstypen die beschikbaar zijn in de programmeertaal Java:
Primitieve typevariabelen kunnen worden gedefinieerd door het gegevenstype op te geven, gevolgd door de variabelenaam, vervolgens een gelijkteken en een beginwaarde. Alle Java-instructies eindigen met een puntkomma. De volgende Java-instructie definieert bijvoorbeeld een variabele met de naam iVal, met een beginwaarde van 1:
int iVal = 1;
Net als veel andere talen, kunt u een op nul gebaseerde array van een specifiek gegevenstype definiëren. Het volgende definieert bijvoorbeeld een array van drie gehele getallen (eerste vier machten van 2):
int [] aiPowersOfTwo; aiPowersOfTwo = nieuwe 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
De Java-bibliotheken bieden een aantal nuttige objecten voor gebruik met gemeenschappelijke gegevensstructuren. Alle objecten zijn afgeleid van de klasse Object. Er zijn klasse-tegenhangers voor alle primitieve gegevenstypen. De klasse Integer kapselt bijvoorbeeld een int-waarde in en biedt een aantal nuttige methoden voor het manipuleren van integer-gegevenswaarden. Met de volgende Java-code wordt bijvoorbeeld een integer-variabele met de naam iVal geconverteerd, vervolgens een object met geheel getal gemaakt met een constructor die een geheel getal bevat en vervolgens een handle-methode die beschikbaar is in de klasse Integer om een vlottervariabele-equivalent te extraheren.
int iVal = 1; Integer integ1 = new Integer (iVal); float f = integ1.floatValue ();
Misschien is het meest voorkomende object dat u in Android-toepassingen gebruikt de String. De klasse String wordt gebruikt voor het inkapselen van voor mensen leesbare teksttekens, die vaak worden weergegeven op het scherm. Als u snaren uit kleinere delen aanpast of bouwt, wilt u ook de klassen StringBuffer en StringBuilder bekijken.
Accentsconagua
String strHello = new String ("Hello World"); Voor een lijst met veelgebruikte Java-gegevenstypen, bevat de Android-referentie documentatie voor het pakket java.lang. U kunt ook de gemeenschappelijke invoer- / uitvoerobjecten in het pakket java.io vinden.
Voor complexere gegevensstructuren zoals lijsten, wachtrijen, stapels, datums en tijden, zijn de juiste klassen in het pakket java.util.
Ten slotte vertrouwen Android-toepassingen op een aantal nuttige klassen die de veelgebruikte toepassingscomponenten definiëren, zoals Activiteit, Toepassing, Dialoogvenster en Service. Deze klassen zijn te vinden in het pakket android.app.
U kunt de zichtbaarheid van een klasse, evenals de variabelen en methoden regelen door het toegangsniveau van een item op te geven. De toegangsniveaus zijn: openbaar, beschermd en privé. Over het algemeen, als je wilt dat iets van buiten de klas toegankelijk is, gebruik dan publiek. Als een methode of variabele alleen toegankelijk moet zijn vanuit de klas zelf, gebruik dan privé. Gebruik beschermd wanneer de klasse of een van zijn subklassen toegang nodig heeft.
De volgende SillySensor-klassendefinitie definieert bijvoorbeeld verschillende variabelen en methoden met verschillende toegangsniveaus:
publieke klasse SillySensor private int sensorData; public SillySensor () sensorData = 0; private void calibrate (int iSeed) // Voer hier enige kalibratie beschermd ongeldige seedCalibration (int iSeed) calibrate (iSeed); public int getSensorData () // Controleer sensor hier return sensorData;
Java bevat voorwaardelijke instructies, die kunnen worden gebruikt om codefragmenten uit te voeren als en alleen als aan bepaalde voorwaarden is voldaan. Typisch, een voorwaardelijke verklaring heeft twee kanten. Als de twee zijden gelijkwaardig zijn, is de verklaring waar, anders is deze onjuist.
Java heeft alle typische conditionele operatoren, zoals:
En wanneer u meerdere voorwaardelijke uitspraken moet combineren in één grotere, voorwaardelijke test, kunt u AND (&&) en OF (||) gebruiken:
Java heeft bitsgewijze operatoren (&, |, ^), verschuivingen (>>, <<), and complement (~) operators as well, should you need them. See the Java documentation for more details.
Nu u weet hoe u een voorwaardelijke verklaring moet opstellen, kunt u voorwaardelijke codesegmenten maken. De eenvoudigste vorm van een voorwaardelijke codeverklaring is de if () -instructie:
boolean condition = true; if (voorwaarde == true) // Voer deze code alleen uit als de voorwaarde-variabele waar is
Als u alternatieve code wilt uitvoeren om uit te voeren als niet aan de voorwaarde wordt voldaan, gebruikt u de else-component met de instructie if ():
boolean condition = true; if (voorwaarde == true) // Voer deze code alleen uit als de waarde voor de voorwaarde-variabele true is else // Voer deze code alleen uit als de waarde van de voorwaarde-variabele false is
Als u meer dan twee gevallen wilt afhandelen, kunt u cascading if-else-if-else-instructies gebruiken, zoals dit:
if (iVar == 0) // variabele is nul else if (iVar> 0) // variabele is een positief getal else // variabele is een negatief getal
Als u een aantal verschillende codepaden mogelijk hebt die vertakken van een enkele variabelewaarde, kunt u een instructie switch () gebruiken. Met een instructie switch geeft u de variabele op die moet worden gecontroleerd en biedt deze een groot aantal uit te voeren opties voor specifieke gevallen. U kunt ook een standaardoptie opgeven om uit te voeren als er geen andere gevallen van toepassing zijn. Elke zaak kan worden beëindigd met een break-statement. Als er geen break-statement is opgegeven, wordt de code voortgezet in de volgende case-instructie.
char singleChar = 'z'; switch (singleChar) case 'a': case 'e': case 'i': case 'o': case 'u': // singleChar is een klinker! Voer deze code uit! breken; default: // singleChar is een medeklinker! Voer in plaats daarvan deze code uit! breken;
Wanneer u code herhaaldelijk wilt uitvoeren of recursie wilt gebruiken (heh, zoek die op als u niet weet waar we het over hebben), heeft Java ondersteuning voor verschillende soorten loops.
Als u continu wilt doorlopen op voorwaarde dat een instructie waar is, gebruikt u een while () -lus:
int numItemsToProcess = 3; while (numItemsToProcess> 0) // een item verwerken numItemsToProcess--;
Als u de conditionele lusuitdrukking NA de eerste iteratie wilt evalueren, kunt u in plaats daarvan een do-while-lus gebruiken:
doe // controleren op te verwerken items, update numItemsToProcess naar behoefte // procesitem, bijgewerkte numItemsToProcess while (numItemsToProcess> 0);
Als u tenslotte voor een specifiek aantal iteraties wilt lussen, kunt u een for () - lus gebruiken. Een for () -lus heeft drie parameters: de beginwaarde, de beëindigingswaarde en de incrementeringswaarde. Als u bijvoorbeeld een lus 100 keer wilt uitvoeren en de getallen 1 tot 100 wilt afdrukken, kunt u de volgende lus met () gebruiken:
voor (int i = 1; i <=100; i++) // print i
Opmerking: je kunt ook een break-statement gebruiken om uit een while (), do-while () of for () lus te komen als dat nodig is. U kunt ook een instructie continue gebruiken om de rest van een huidige iteratie van een lus over te slaan en door te gaan naar de volgende iteratie (uiteraard opnieuw evalueren van de voorwaardelijke uitdrukking).
Er zijn geen aanwijzingen in Java. Ok, ok, ga je gang en adem een zucht van opluchting. Het leven is al moeilijk genoeg zonder aanwijzingen die de zaken opjutten, goed?
Oké, nu is het tijd om opnieuw op te letten. In Java worden de parameters van de methode per waarde doorgegeven. Wanneer een parameter van een methode echter een object is (dat wil zeggen, alles behalve een primitief type), wordt alleen een verwijzing naar dat object in de methode doorgegeven [net zoals pointers, sorry!]. Daarom, om het object door te geven dat is doorgegeven aan een gegeven methode, geef je in het algemeen de objectreferentie door, en handel je daarop, die de onderliggende gegevens van het object dat je passeert wijzigt. Je kunt het object zelf echter niet uitwisselen ... Hier is een snel voorbeeld:
Hier hebben we een klas genaamd Cat:
public class Cat private String mCatName; Cat (String-naam) mCatName = name; public String getName () return mCatName; ; public void setName (String strName) mCatName = strName; ;
Laten we nu proberen deze klasse te gebruiken en een Cat-object in sommige functies door te geven en te zien wat er gebeurt:
void messWithCat (Cat kitty) kitty = new Cat ("Han"); ongeldig veranderenKitty (Cat kitty) kitty.setName ("Wookie"); Cat haveKitten () Cat kitten = new Cat ("Luke"); kitten terugbrengen; Laten we tot slot deze methoden noemen en zien hoe ze reageren op instanties van Cat-objecten:
Cat cat1 = new Cat ("Jabba"); Cat cat2 = nieuwe Cat ("Leia"); cat1.getName (); // Retourneert Jabba cat2.getName (); // Retourneert Leia messWithCat (cat1); changeKitty (CAT2); Cat cat3 = haveKitten (); cat1.getName (); // Geeft Jabba terug - Let op dat het object ongewijzigd blijft! cat2.getName (); // Retourneert Wookie cat3.getName (); // Geeft Luke terug U hebt zojuist een spoedcursus Java-programmeertaal voltooid. Hoewel je misschien nog niet klaar bent om je eerste Java-app te schrijven, zou je in staat moeten zijn om de eenvoudigste Java-klassen van de Android-toepassingsapplicatie te doorlopen en te bepalen wat ze van plan zijn, althans wat betreft de Java-syntaxis van dingen. De eerste klas waar je naar wilt kijken voor Android-ontwikkeling is de klasse Activiteit. Een Android-toepassing gebruikt activiteiten om verschillende runtime-taken te definiëren en daarom moet u een activiteit definiëren die fungeert als het toegangspunt voor uw toepassing. Nu u de Java-syntaxis onder controle hebt, raden we u ten zeerste aan een Android-zelfstudie voor beginners te volgen.
U hebt alleen de oppervlakte van Java-ontwikkeling voor Android-ontwikkeling gekrast. Bekijk alle andere geweldige tutorials over Mobiletuts + om dieper in Java en Android te duiken. We raden ten zeerste de volgende beginnende Android-zelfstudies aan: Inleiding tot Android-ontwikkeling door Gyuri Grell en het begin van Android: Aan de slag gaan met Fortune Crunch om te beginnen met de ontwikkeling van Android. Succes!
Mobiele ontwikkelaars Lauren Darcey en Shane Conder hebben samen meerdere boeken geschreven over Android-ontwikkeling: een diepgaand programmeerboek getiteld Android Wireless Application Development en Sams TeachYourself Android Application Development binnen 24 uur. Wanneer ze niet schrijven, besteden ze hun tijd aan het ontwikkelen van mobiele software bij hun bedrijf en het leveren van consultingservices. Ze zijn te bereiken via e-mail naar [email protected], via hun blog op androidbook.blogspot.com, en op Twitter @androidwireless.
