Java-syntaxis: een zeer korte inleiding tot programmeertaal

Wat is Java-syntaxis?

Java-syntaxis is een basis van de taal, alle hoofdregels, commando's, constructies om programma's te schrijven die de compiler en de computer "begrijpen". Elke programmeertaal heeft zijn syntaxis en menselijke taal. Dit artikel richt zich op de basissyntaxis van de Java-programmeertaal en is bedoeld voor beginnende ontwikkelaars of degenen die een andere programmeertaal kennen. Sommige aspecten zijn misschien niet duidelijk voor beginners. Als dat het geval is, kunt u ze het beste overslaan en u concentreren op voorbeelden. Zoals met al het andere, is het beter om een ​​programmeertaal cyclisch te leren en geleidelijk tot een dieper begrip van bepaalde concepten te komen. Elk Java-programma is een verzameling objecten die elkaar integreren met gegevens (variabelen) en gedrag (functies of methoden). Ook het Java-programma is een klasse of een paar klassen. Een object is een instantie van een klasse. Je kunt klasse begrijpen als een model, bijvoorbeeld koekjesvormers en objecten zoals koekjes. Of classificeren als een abstracte "Java-programmeur" en object als "Java-programmeur John" of "Java-programmeur Ivy".

Voorwerp in Java

Objecten in Java hebben toestanden en gedragingen. Voorbeeld: een kat heeft staten: zijn naam is Furr, kleur is rood, eigenaar is John; kat heeft ook gedrag Nu slaapt Furr. Hij kon ook spinnen, lopen, enzovoort. Een object is een instantie van een klasse.

Klasse op Java

Klasse is een model of sjabloon of blauwdruk van het object. Het beschrijft het gedrag en stelt dat het object van zijn type ondersteunt. De klasse Cat heeft bijvoorbeeld zijn naam, kleur, eigenaar; kat heeft ook gedrag zoals eten, spinnen, lopen, slapen.

Methoden in Java

Methoden zijn voor het beschrijven van de logica, het manipuleren van gegevens en het uitvoeren van alle acties. Elke methode definieert gedrag. Een klasse kan vele methoden bevatten. We kunnen bijvoorbeeld een methode sleep() schrijven voor Cat class (to sleep) of purr() to purr.

Instantievariabelen in Java

Elk object heeft een unieke set instantievariabelen. De objectstatus wordt meestal gegenereerd door de waarden die aan deze instantievariabelen zijn toegewezen. De naam of leeftijd van de kat kan bijvoorbeeld een variabele zijn. We gaan beginnen met het eenvoudigste Java-programma. Aan de hand van dit voorbeeld zullen we de basisconcepten van de Java-syntaxis begrijpen en deze vervolgens nader bekijken.

Eenvoudig Java-programma: Hallo, Java!

Hier is een eenvoudig Java-programma:

class HelloJava {
   public static void main(String[] args) {
       System.out.println("Hello, Java!");
   }
}

Dit programma print een string "Hello, Java!" troosten. Ik raad je aan om JDK en IntelliJ IDEA te installeren en de code die je hierboven ziet uit te schrijven. Of zoek voor de eerste keer een online IDE om hetzelfde te doen. Laten we dit programma nu regel voor regel bekijken, maar enkele details weglaten die niet nodig zijn voor een beginner.

class HelloJava 

Elk programma in Java is een klasse of vaker meerdere klassen. De lijnklasse HelloJava betekent dat we hier een nieuwe klasse maken en de naam is HelloJava. Zoals we hierboven hebben gedefinieerd, is klasse een soort sjabloon of blauwdruk, het beschrijft het gedrag en de toestanden van de objecten van de klasse. Het kan moeilijk zijn voor beginnende programmeurs, dit concept leer je later wel. Voor nu is klasse HelloJava nog maar het begin van je programma. Het is je misschien opgevallen dat de accolade { op dezelfde regel en in de hele tekst staat. Een paar accolades {} geeft een blok aan, een groep programmeeropdrachten die als één geheel wordt behandeld. Waarbij { het begin van de eenheid betekent en }zijn einde. Blokken kunnen in elkaar genest zijn, of ze kunnen opeenvolgend zijn. Er zijn twee geneste blokken in het bovenstaande programma. De externe bevat de body van de klasse Hello . Het binnenste blok bevat de hoofdtekst van de methode main() .

public static void main (String args []) {

Hier is het begin van de hoofdmethode. Een methode is een gedrag, of de reeks opdrachten waarmee u een bewerking in een programma kunt uitvoeren. Vermenigvuldig bijvoorbeeld 2 getallen of print een string uit. Met andere woorden, een methode is een functie. In sommige andere programmeertalen worden methoden vaak "functies" genoemd. Methoden bevinden zich, net als alle elementen van een Java-programma, binnen een klasse. Elke klasse kan één, veel of geen methoden hebben. public is een toegangsmodificator. Een variabele, methode of klasse gemarkeerd met de public modifier is overal in het programma toegankelijk. Er zijn er vier in Java: openbaar, privé, beschermd en standaard (leeg). We praten er later over. Voor de eerste stap is het beter om al je methoden openbaar te maken. leegteis het retourtype van de methode. Void betekent dat het geen waarde retourneert. main vertegenwoordigt het startpunt van het programma. Dit is de naam van de methode. String[] args is een hoofdmethodeargument . Voor nu is het voldoende om te weten dat bijna elk Java-programma de main- methode heeft, het start het programma en declareert zoals public static void main(String[] args) Statische methoden zijn degenen die met de klasse werken. Methoden die het statische trefwoord in hun declaratie gebruiken, kunnen alleen rechtstreeks werken met lokale en statische variabelen.

 System.out.println("Hello, Java!"); 

Formeel voert deze regel de methode println van het out-object uit. Het out-object wordt gedeclareerd in de klasse OutputStream en statisch geïnitialiseerd in de klasse System . Het is echter een beetje ingewikkeld voor een totale newbie. Het is voor een beginner voldoende om te weten dat deze regel de woorden "Hallo, Java!" naar de console. Dus als u het programma in uw IDE uitvoert, krijgt u de uitvoer in de console:

Java-basissyntaxisregels

Er zijn enkele belangrijke syntaxisregels die u moet volgen bij het programmeren in Java:

• de bestandsnaam moet identiek zijn aan de klassenaam;
• meestal bevindt elke klasse zich in een apart bestand met de extensie .java. Klassebestanden zijn meestal gegroepeerd in mappen. Deze mappen worden pakketten genoemd;
• tekens zijn hoofdlettergevoelig. String is niet gelijk aan string ;
• Het begin van de verwerking van Java-programma's begint altijd in de main- methode: public static void main (String [] args) . De methode main () is een verplicht onderdeel van elk Java-programma;
• Methode (procedure, functie) is een reeks opdrachten. Methoden definiëren het gedrag van een object;
• De volgorde van de methoden in het programmabestand is niet relevant;
• Houd er rekening mee dat de eerste letter van een klassenaam een ​​hoofdletter is. Als u meerdere woorden gebruikt, gebruik dan een hoofdletter voor de eerste letter van elk woord (“MyFirstJavaClass”);
• de namen van alle methoden in de Java-syntaxis beginnen met een kleine letter. Bij gebruik van meerdere woorden worden de volgende letters met een hoofdletter geschreven ("public void myFirstMethodName ()");
• bestanden worden opgeslagen met klassenaam en .java-extensie ("MyFirstJavaClass.java");
• In de Java-syntaxis zijn er scheidingstekens "{...}" die een codeblok en een nieuw codegebied aangeven;
• Elke code-instructie moet eindigen met een puntkomma.

Java-variabelen en gegevenstypen Variabelen zijn speciale entiteiten die worden gebruikt om gegevens op te slaan. Alle gegevens. In Java worden alle gegevens opgeslagen in variabelen. Je zou kunnen zeggen dat een variabele een gereserveerde plaats is of een vak om een ​​variabele in te plaatsen. Elke variabele heeft zijn gegevenstype, naam (identificatie) en waarde. Gegevenstypen kunnen primitief en niet-primitief of referentie zijn. Primitieve gegevenstypen kunnen zijn:

• Integers: byte, kort, int, lang
• Breuken: zweven en verdubbelen
• Logische waarden: booleaans
• Symbolische waarden (voor weergave van letters en cijfers): char

Voorbeeld van Java-variabelen:

int s;
s = 5;  
char myChar = ‘a’; 

In deze code hebben we een integer-variabele s (een lege container) gemaakt en er vervolgens een waarde 5 in gezet. Hetzelfde verhaal met een variabele genaamd myChar . We hebben het gemaakt met een gegevenstype char en gedefinieerd als een letter a . In dit geval hebben we een variabele gemaakt en er tegelijkertijd een waarde aan toegewezen. Met de Java-syntaxis kunt u het op deze manier doen. Referentietypen zijn sommige objecten die verwijzingen naar waarden of andere objecten behouden. Ze kunnen ook een verwijzing naar de nul bevatten. Null is een speciale waarde om de afwezigheid van waarde aan te geven. Tot de referentietypen behoren String, Arrays en elke gewenste klasse. Als je een vioolklas hebt, kun je een variabele van deze klas maken. Voorbeeld van variabelen van het Java-referentietype:

String s = “my words”; 
Violin myViolin; 

U zult later meer over hen te weten komen. Onthoud dat niet-primitieve soorten variabelen beginnen met hoofdletters terwijl primitief - met kleine letters. Voorbeeld:

int i = 25;
String s = “Hello, Java!”; 

Java-arrays

Arrays zijn objecten die meerdere variabelen van hetzelfde type opslaan. Een array zelf is echter een object op de heap. In de komende hoofdstukken zullen we bekijken hoe we kunnen declareren, construeren en initialiseren. Voorbeeld matrix:

int[] myArray = {1,7,5};

Hier hebben we een array die de drie gehele getallen bevat (1,7 en 5)

Java-opsommingen

Naast primitieve gegevenstypen kent Java zo'n type als opsomming of opsomming. Opsommingen vertegenwoordigen een verzameling logisch gerelateerde constanten. Een opsomming wordt gedeclareerd met behulp van de enum-operator, gevolgd door de naam van de opsomming. Dan komt een door komma's gescheiden lijst met opsommingselementen:

enum DayOfWeek {
     MONDAY,
     TUESDAY,
     WEDNESDAY,
     THURSDAY,
     FRIDAY,
     SATURDAY,
     SUNDAY
}

Een opsomming vertegenwoordigt eigenlijk een nieuw type, dus we kunnen een variabele van dat type definiëren en gebruiken. Hier is een voorbeeld van het gebruik van opsomming.

Java Enum-voorbeeld

public class MyNum{      
    public static void main(String[] args) {
          
        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//print a day from the enum     
}
}
enum DayOfWeek{
  
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Als u het programma uitvoert, wordt VRIJDAG afgedrukt in de console. U kunt uw Enum- en MyNum-klassecode in één bestand plaatsen, maar het is beter om twee afzonderlijke bestanden te maken: een voor de MyNum-klasse en een voor Day-enum. Met IntelliJ IDEA kunt u enum kiezen tijdens het maken.

Variabelen declareren in Java

Eigenlijk hebben we hierboven enkele variabelen gedeclareerd en zelfs geïdentificeerd. Declaratie is een proces van het toewijzen van geheugen voor een variabele van een bepaald type en het benoemen ervan. Zoiets:

int i; 
boolean boo; 

We kunnen ook declareren om een ​​variabele te initialiseren met behulp van de toewijzingsoperator (=). Dat betekent dat we een bepaalde waarde hebben gestoken in het geheugen dat we hebben toegewezen. We kunnen het goed doen in een moment van aangifte of later.

een variabel voorbeeld declareren

String str; 
int i = 5; 
Str = “here is my string”; 

Als u een variabele zonder initialisatie declareert, krijgt deze toch een standaardwaarde. Voor int is deze waarde 0, voor String of een ander referentietype is het een speciale null- ID.

Java-identificatoren

Identifiers zijn slechts namen van Java-componenten - klassen, variabelen en methoden. Alle Java-componenten moeten namen hebben.

Class Violin {
int age; 
String masterName;  
}

Viool is de klasse-identificatie. age en masterName zijn variabelen-ID's. Hier enkele Java-identificatieregels:

• Alle identifiers beginnen met een Latijnse letter (A tot Z of a tot z), valutateken ($) of een underscore (_).
• Na het eerste teken kunnen identifiers elke combinatie van tekens hebben.
• Een Java-trefwoord kan geen identifier zijn (de trefwoorden kom je later achter).
• ID's zijn hoofdlettergevoelig.

Identificaties voorbeeld

Juridische identificatiecodes: java, $mySalary, _something Illegale identificatiecodes: 1stPart, -one

Java-modificaties

Modifiers zijn speciale woorden van de Java-taal die u kunt gebruiken om elementen (klassen, methoden, variabelen) te wijzigen. Java heeft twee categorieën modifiers: toegangs- en niet-toegangsmodifiers.

Access modifiers voorbeeld

Er zijn 4 toegangsmodifiers in Java:

• publiek . Een openbaar element Het is toegankelijk vanuit de klas, buiten de klas, binnen en buiten het pakket
• Element met standaard (lege) modifier is alleen toegankelijk binnen het pakket
• beschermde modifier is binnen en buiten het pakket toegankelijk via de onderliggende klasse
• private element alleen beschikbaar binnen de klasse die het heeft gedeclareerd.

Voorbeeld van non-access modifiers

Het zijn er 7

• statisch
• laatste
• abstract
• gesynchroniseerd
• vergankelijk
• vluchtig
• oorspronkelijk

Java-trefwoorden

Java-sleutelwoorden zijn de speciale woorden die in Java worden gebruikt en die fungeren als een sleutel tot een code. Ze staan ​​ook wel bekend als gereserveerde woorden: u kunt ze niet gebruiken voor identifiers van variabelen, methoden, klassen, enz. Hier zijn ze:

• abstract : trefwoord om abstracte klasse aan te geven.
• boolean : Java boolean sleutelwoord om een ​​variabele te declareren als een boolean type. Dergelijke variabelen kunnen alleen waar en onwaar zijn.
• break : gebruik het sleutelwoord Java break om de lus of switch-instructie te onderbreken.
• byte : Java-bytesleutelwoord voor declaratie van een variabele met een geheel getal van één byte.
• case : wordt gebruikt om met de switch-instructies tekstblokken te markeren.
• catch : wordt gebruikt om de uitzonderingen na het try- blok op te vangen.
• char : Java char-sleutelwoord voor een karaktervariabele. Het kan niet-ondertekende 16-bits Unicode-tekens bevatten.
• class : Java-klassleutelwoord om een ​​klasse te declareren.
• continue : Java-sleutelwoord om de lus voort te zetten.
• default : Java default sleutelwoord om het standaard codeblok in een switch statement te specificeren.
• do : wordt gebruikt in de constructie van een do-while-lus.
• double : Java double keyword wordt gebruikt om een ​​getalsvariabele te declareren. Het kan 8 bytes drijvende-kommagetallen bevatten.
• else : u kunt het gebruiken in else-if voorwaardelijke statements.
• enum : wordt gebruikt om een ​​vaste set constanten te definiëren.
• extends : Java breidt het sleutelwoord uit om aan te geven dat een klasse een andere klasse uitbreidt (is een onderliggende klasse van de andere klasse).
• final : trefwoord om aan te geven dat een variabele een constante is.
• tenslotte : markeert een codeblok dat zal worden uitgevoerd ongeacht of een uitzondering wordt afgehandeld of niet.
• float : een variabele die een getal met drijvende komma van 4 bytes bevat.
• for : een trefwoord om een ​​for-lus te starten. Het wordt gebruikt om een ​​reeks instructies herhaaldelijk uit te voeren terwijl aan bepaalde voorwaarden wordt voldaan.
• if : trefwoord voor het controleren van de conditie. Het voert het blok uit als de voorwaarde waar is.
• implementeert : het sleutelwoord om een ​​interface te implementeren.
• import : Java-importsleutelwoord om een ​​pakket, klasse of interface te importeren.
• instanceof : controleert of het object een instantie is van een bepaalde klasse of interface.
• int : een variabele die een geheel getal van 4 bytes met teken kan bevatten.
• interface : Java-interfacesleutelwoord wordt gebruikt om een ​​interface te declareren.
• long : een variabele die een geheel getal van 8 bytes met teken kan bevatten.
• native : geeft aan dat een methode wordt geïmplementeerd in native code met behulp van JNI (Java Native Interface).
• nieuw : Java nieuw trefwoord om nieuwe objecten te maken.
• pakket : declareert een Java-pakket (map) voor bestanden van Java-klassen.
• private : een toegangsmodificator geeft aan dat een methode of variabele mogelijk alleen zichtbaar is in de klasse waarin deze is gedeclareerd.
• beschermd : een toegangsmodificator geeft aan dat een methode of variabele toegankelijk is binnen en buiten het pakket via een onderliggende klasse.
• public : een toegangsmodificator geeft aan dat een element overal toegankelijk is.
• return : retourneert een resultaat van de uitvoering van een methode.
• kort : een variabele die een geheel getal van 2 bytes met teken kan bevatten.
• statisch : geeft aan dat een variabele of methode een klasse is, geen object, methode.
• strictfp : beperkt de berekeningen met drijvende komma.
• super : verwijst naar het object van de bovenliggende klasse.
• schakelaar : selecteert een codeblok (of veel ervan) om uit te voeren.
• gesynchroniseerd : een non-access modifier. Het geeft aan dat de methode slechts door één thread tegelijk toegankelijk is.
• this : verwijst naar het huidige object in een methode of constructor.
• throw : wordt gebruikt om expliciet een uitzondering te genereren.
• gooit : De verklaart een uitzondering.
• tijdelijk : een tijdelijk gegevensstuk kan niet worden geserialiseerd.
• try : start een codeblok dat wordt gecontroleerd op uitzonderingen.
• void : geeft aan dat een methode geen waarde retourneert.
• vluchtig : geeft aan dat een variabele asynchroon kan veranderen.
• while : start een while-lus. herhaalt een deel van het programma meerdere keren terwijl de voorwaarde waar is.

Opmerkingen in Java

Java ondersteunt enkelregelig en meerregelig commentaar. Alle tekens die beschikbaar zijn in een opmerking en ze worden genegeerd door de Java-compiler. Ontwikkelaars gebruiken ze om de code uit te leggen of om iets te onthouden. Commentaar voorbeelden:

//single-line comment 
/*here we have a multi-line comment. As you can see it uses slash and asterisks from both sides of it.*/   

public class HelloJava {
   /* this program was created to demonstrate comments in Java. This one is a multi-line comment.
   You can use such comments anywhere in your programs*/
   public static void main(String[] args) {
       //here is a single-line comment
       String j = "Java"; //This is my string
       int a = 15; //here I have an integer
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

Letterwoorden op Java

Literals in Java zijn enkele constante waarden die aan de variabele zijn toegewezen. Dit kunnen cijfers of teksten zijn of iets anders om een ​​waarde weer te geven.

• Integrale letterlijke woorden
• Letterlijke getallen met drijvende komma
• Letterlijke tekens
• Letterlijke tekenreeksen
• Booleaanse letterlijke waarden

Java letterlijke voorbeelden

 int i = 100; //100 is an integral  literal 
double d = 10.2;//10.2 is a floating point literal 
char c = ‘b’; //b is a char literal 
String myString = “Hello!”; 
boolean bool = true; 

Opmerking: null is ook letterlijk.

Basisoperatoren in Java

Er zijn verschillende soorten operatoren: Rekenen

• + (optellen van getallen en samenvoegen van tekenreeksen)
• – (minus of aftrekken)
• * (vermenigvuldiging)
• / (divisie)
• % (modulus of rest)

Vergelijking

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

Logisch

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

We hebben al geleerd over gegevenstypen, variabelen, methoden en operatoren. Laten we een eenvoudig voorbeeld van de code nemen, maar iets ingewikkelder dan het allereerste Java-programma. Laten we een klasse maken met de naam NumberOperations

public class NumbersOperations {
   int a;
   int b;
   public static int add(int a,int b){
       return a+b;
   }
   public static int sub (int a, int b){
       return a-b;
   }
   public static double div (double a, int b){
       return a/b;
   }
}

Hier hebben we een klasse met boommethoden om met 2 getallen te manipuleren. Je kunt proberen de 4e methode int mul (int a, int b) te schrijven om 2 getallen te vermenigvuldigen binnen dit programma. Laten we ook een klasse maken om NumberOprations -werk te demonstreren:

public class NumberOperationsDemo {
   public static void main(String[] args) {
       int c = NumbersOperations.add(4,5);
       System.out.println(c);
       double d = NumbersOperations.div(1,2);
       System.out.println(d);
   }
}

Als u NumberOperationsDemo uitvoert , krijgt u de volgende uitvoer:

Conclusies

Dit zijn slechts de basisprincipes van de Java-taal en veel dingen kunnen verwarrend zijn. Er is veel programmeerwerk voor nodig om erachter te komen wat wat is. Dit is de enige manier waarop je deze taal leert - door te oefenen. Begin nu met coderen, probeer de eerste zoektocht van CodeGym Praktische Java-cursus te voltooien . Veel succes met het leren van Java!