Inleiding tot de basissyntaxis in Java

1. Overzicht

Java is een statisch getypeerde, objectgeoriënteerde programmeertaal. Het is ook platformonafhankelijk: Java-programma's kunnen worden geschreven en gecompileerd op het ene type machine, zoals een Windows-systeem, en worden uitgevoerd op een ander, zoals MacOS, zonder enige wijziging van de broncode.

In deze zelfstudie gaan we de basisprincipes van de Java-syntaxis bekijken en begrijpen.

2. Gegevenstypen

Er zijn twee brede categorieën gegevenstypen in Java: primitieve typen en objecten / referentietypes.

Primitieve typen zijn de basisgegevenstypen waarin eenvoudige gegevens worden opgeslagen en vormen de basis van datamanipulatie. Java heeft bijvoorbeeld primitieve typen voor gehele getallen (int, lang,byte, kort), drijvende-kommawaarden (vlotter en dubbele), tekenwaarden (char) en logische waarden (boolean).

Aan de andere kant, referentietypes zijn objecten die verwijzingen naar waarden en / of andere objecten bevatten, of op de speciale waarde nul om de afwezigheid van waarde aan te duiden.

De Draad class is een goed voorbeeld van een referentietype. Een instantie van de klasse, een object genaamd, vertegenwoordigt een reeks tekens, zoals "Hallo wereld".

3. Variabelen declareren in Java

Om een ​​variabele in Java te declareren, moeten we specificeer de naam (ook wel een identifier genoemd) en het type. Laten we een eenvoudig voorbeeld bekijken:

int een; int b; dubbele c;

In het bovenstaande voorbeeld ontvangen de variabelen standaard beginwaarden op basis van hun gedeclareerde typen. Omdat we hebben verklaard dat onze variabelen zijn int en dubbele, hebben ze een standaardwaarde van respectievelijk 0 en 0,0.

Alternatief, we kunnen de toewijzingsoperator (=) gebruiken om variabelen te initialiseren tijdens het declareren:

int a = 10;

In het bovenstaande voorbeeld declareren we een variabele met een identifier eenom van te zijn type int en wijs een waarde van 10 toe eraan gebruik de toewijzingsoperator (=) en beëindig de instructie met een puntkomma (;).In Java is het verplicht dat alle instructies eindigen met een puntkomma.

Een ID is een naam van elke lengte, bestaande uit letters, cijfers, onderstrepingstekens en dollarteken, dat voldoet aan de volgende regels:

  • begint met een letter, een onderstrepingsteken (_) of een dollarteken ($)
  • mag geen gereserveerd trefwoord zijn
  • kan niet zijn waar, vals, of nul

Laten we ons bovenstaande codefragment uitbreiden met een eenvoudige rekenkundige bewerking:

int a = 10; int b = 5; dubbele c = a + b; System.out.println (a + "+" + b + "=" + c);

We kunnen de eerste drie regels van het codefragment hierboven lezen als “Wijs de waarde van 10 toe aan een, wijs de waarde van 5 toe aan b, som de waarden van een en b en wijs het resultaat toe aan c ". In de laatste regel voeren we het resultaat van de bewerking uit naar de console:

10 + 5 = 15.0

Declaratie en initialisatie van variabelen van andere typen volgen dezelfde syntaxis die we hierboven hebben getoond. Laten we bijvoorbeeld verklaren Draad, char, en boolean variabelen:

String name = "Baeldung Blog"; char toggler = 'Y'; boolean isVerified = true;

Ter wille van de nadruk, het belangrijkste verschil in het weergeven van letterlijke waarden van char en Draad is het aantal aanhalingstekens rond de waarden. Daarom 'een' is een char terwijl "een" is een Draad.

4. Arrays

Een array is een referentietype dat een verzameling waarden van een specifiek type kan opslaan. De algemene syntaxis voor het declareren van een array in Java is:

type [] identifier = nieuw type [lengte];

Het type kan elk primitief of referentietype zijn.

Laten we bijvoorbeeld eens kijken hoe we een array kunnen declareren die maximaal 100 gehele getallen kan bevatten:

int [] nummers = nieuwe int [100];

Om naar een specifiek element van een array te verwijzen, of om een ​​waarde aan een element toe te wijzen, gebruiken we de variabelenaam en de bijbehorende index:

getallen [0] = 1; getallen [1] = 2; getallen [2] = 3; int thirdElement = nummers [2];

In Java, array-indexen beginnen bij nul. Het eerste element van een array bevindt zich op index 0, het tweede element op index 1, enzovoort.

Bovendien kunnen we de lengte van de array achterhalen door aan te roepen nummers.lengte:

int lengthOfNumbersArray = numbers.length;

5. Java-trefwoorden

Trefwoorden zijn gereserveerde woorden die een speciale betekenis hebben in Java.

Bijvoorbeeld, public, static, class, main, new, instanceof, zijn sleutelwoorden in Java, en als zodanig, we kunnen ze niet gebruiken als identifiers (variabelenamen).

6. Operatoren in Java

Nu we de toewijzingsoperator (=) hierboven hebben gezien, gaan we eens kijken naar enkele andere typen operatoren in de Java-taal:

6.1. Rekenkundige operatoren

Java ondersteunt de volgende rekenkundige operatoren die kunnen worden gebruikt voor het schrijven van wiskundige, computationele logica:

  • + (plus of toevoeging; wordt ook gebruikt voor het samenvoegen van tekenreeksen)
  • - (min of aftrekken)
  • * (vermenigvuldiging)
  • / (divisie)
  • % (modulus of rest)

We hebben de plus (+) operator gebruikt in ons vorige codevoorbeeld om twee variabelen op te tellen. De andere rekenkundige operatoren worden op dezelfde manier gebruikt.

Een ander gebruik van plus (+) is voor het aaneenschakelen (samenvoegen) van strings om een ​​geheel nieuwe string te vormen:

Stringuitvoer = a + "+" + b + "=" + c;

6.2. Logische operators

Naast rekenkundige operatoren ondersteunt Java de volgende logische operatoren voor het evalueren van booleaanse expressies:

  • && (EN)
  • || (OF)
  • ! (NIET)

Laten we eens kijken naar de volgende codefragmenten die de logische EN- en OF-operators demonstreren. Het eerste voorbeeld toont een print-instructie die wordt uitgevoerd wanneer de aantal variabele is deelbaar door 2 EN door 3:

int nummer = 6; if (nummer% 2 == 0 && nummer% 3 == 0) {System.out.println (nummer + "is deelbaar door 2 EN 3"); }

Terwijl de tweede wordt uitgevoerd wanneer aantal is deelbaar door 2 OF door 5:

if (nummer% 2 == 0 || nummer% 5 == 0) {System.out.println (nummer + "is deelbaar door 2 OF 5"); }

6.3. Vergelijkingsoperatoren

Als we de waarde van de ene variabele met die van een andere moeten vergelijken, kunnen we de vergelijkingsoperatoren van Java gebruiken:

  • < (minder dan)
  • <= (kleiner dan of gelijk aan)
  • > (groter dan)
  • > = (groter dan of gelijk aan)
  • == (gelijk aan)
  • ! = (NIET gelijk aan)

We kunnen bijvoorbeeld een vergelijkingsoperator gebruiken om te bepalen of een kiezer in aanmerking komt:

openbare boolean canVote (int age) {if (age <18) {return false; } retourneren waar; }

7. Java-programmastructuur

Nu we hebben geleerd over gegevenstypen, variabelen en een paar basisoperatoren, gaan we kijken hoe we deze elementen kunnen samenvoegen in een eenvoudig, uitvoerbaar programma.

De basiseenheid van een Java-programma is een Klasse. EEN Klasse kan een of meer velden hebben (ook wel eigenschappen genoemd), methoden, en zelfs andere klasleden die innerlijke klassen worden genoemd.

Voor een Klasse om uitvoerbaar te zijn, moet het een hoofd methode. De hoofd methode geeft het startpunt van het programma aan.

Laten we een eenvoudig uitvoerbaar bestand schrijven Klasse om een ​​van de codefragmenten uit te oefenen die we eerder hebben besproken:

openbare klasse SimpleAddition {openbare statische leegte hoofd (String [] args) {int a = 10; int b = 5; dubbele c = a + b; System.out.println (a + "+" + b + "=" + c); }}

De naam van de klas is SimpleAddition, en binnenin hebben we een hoofd methode die onze logica huisvest. Het codesegment tussen een openende en een sluitende accolade wordt een codeblok genoemd.

De broncode van een Java-programma wordt opgeslagen in een bestand met de extensie .Java.

8. Compileren en uitvoeren van een programma

Om onze broncode uit te voeren, moeten we deze eerst compileren. Dit proces genereert een binair bestand met de klas bestandsextensie. We kunnen het binaire bestand uitvoeren op elke computer waarop een Java Runtime Environment (JRE) is geïnstalleerd.

Laten we onze broncode uit het bovenstaande voorbeeld opslaan in een bestand met de naam SimpleAddition.java en voer deze opdracht uit vanuit de map waar we het bestand hebben opgeslagen:

javac SimpleAddition.java

Om het programma uit te voeren, voeren we eenvoudigweg het volgende uit:

java SimpleAddition

Dit zal dezelfde uitvoer naar de console produceren als hierboven weergegeven:

10 + 5 = 15.0

9. Conclusie

In deze zelfstudie hebben we enkele van de basissyntaxis van Java bekeken. Net als elke andere programmeertaal, wordt het eenvoudiger door constant te oefenen.

De volledige broncode voor deze tutorial is beschikbaar op Github.