Java szintaxis: nagyon rövid bevezetés a programozási nyelvbe

Mi az a Java szintaxis?

A Java Syntax a nyelv alapja, az összes fő szabály, parancs, konstrukció a programok írásához, amit a fordító és a számítógép „megért”. Minden programozási nyelvnek megvan a maga szintaxisa, valamint az emberi nyelv. Ez a cikk a Java programozási nyelv alapvető szintaxisára összpontosít, és kezdő fejlesztőknek vagy más programozási nyelvet ismerőknek szól. Előfordulhat, hogy néhány szempont nem egyértelmű a kezdők számára. Ha igen, a legjobb, ha kihagyja őket, és a példákra összpontosít. Mint minden másban, jobb, ha egy programozási nyelvet ciklikusan tanulunk meg, fokozatosan bizonyos fogalmak mélyebb megértéséhez. Minden Java program egy csomó objektum, amelyek egyesítik egymást adatokkal (változókkal) és viselkedéssel (függvényekkel vagy metódusokkal). A Java program is egy osztály vagy néhány osztály. Az objektum egy osztály példánya. Az osztályt modellként is értelmezheti, például sütikivágókat és olyan objektumokat, mint a cookie-k. Vagy osztályozd absztrakt „Java programozóként”, és az objektumot „Java Programmer John” vagy „Java Programmer Ivy” néven.

Objektum Java nyelven

A Java objektumainak állapota és viselkedése van. Példa: Egy macskának vannak állapotai: neve Furr, színe vörös, tulajdonosa John; macskának is van viselkedése Most Furr alszik. Tudott dorombolni, járni stb. Az objektum egy osztály példánya.

Osztály Java nyelven

Az osztály az objektum modellje vagy sablonja vagy tervrajza. Leírja a viselkedést, és kimondja, hogy a típusához tartozó objektum támogat. Például a Cat osztálynak megvan a neve, színe, tulajdonosa; a macskának olyan viselkedése is van, mint az evés, dorombol, séta, alvás.

Módszerek Java nyelven

A módszerek a logikák leírására, az adatok manipulálására és az összes művelet végrehajtására szolgálnak. Minden módszer meghatározza a viselkedést. Egy osztály sok metódust tartalmazhat. Például írhatunk egy sleep() metódust a Cat osztályhoz (to sleep) vagy a purr() to purr-hez.

Példányváltozók a Java-ban

Minden objektum egyedi példányváltozókészlettel rendelkezik. Az objektum állapotát általában az ezekhez a példányváltozókhoz rendelt értékek generálják. Például a macska neve vagy életkora lehet változó. Kezdjük a legegyszerűbb Java programmal. Ennek a példának a segítségével megértjük a Java szintaxis alapfogalmait, majd közelebbről is megvizsgáljuk őket.

Egyszerű Java program: Hello, Java!

Íme egy egyszerű Java program:

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

Ez a program kiírja a „Hello, Java!” karakterláncot. vigasztalni. Azt javaslom, hogy telepítse a JDK-t és az IntelliJ IDEA-t, és próbálja meg kiírni a fent látható kódot. Vagy először keressen egy online IDE-t, amely ugyanezt teszi. Most vegyük soronként ezt a programot, de hagyjunk ki néhány olyan részletet, ami egy kezdő számára nem szükséges.

class HelloJava 

A Java-ban minden program egy osztály vagy gyakrabban több osztály. A HelloJava sorosztály azt jelenti, hogy itt létrehozunk egy új osztályt, melynek neve HelloJava. Ahogy fentebb definiáltuk, az osztály egyfajta sablon vagy tervrajz, leírja az osztály objektumainak viselkedését és állapotait. Kezdő programozók számára nehéz lehet, ezt a koncepciót egy kicsit később tanulják meg. Egyelőre a HelloJava osztály csak a program kezdete. Lehet, hogy észrevetted a göndör kapcsos zárójelet { ugyanabban a sorban és az egész szövegben. A göndör kapcsos zárójelpár {} egy blokkot jelöl, programozási utasítások csoportját, amelyet egyetlen egységként kezelünk. Ahol { az egység elejét jelenti és a }a vége. A blokkok egymásba ágyazhatók, vagy lehetnek szekvenciálisak. A fenti programban két egymásba ágyazott blokk található. A külső tartalmazza a Hello osztály törzsét . A belső blokk tartalmazza a main() metódus törzsét .

public static void main (String args []) {

Itt van a fő módszer kezdete. A metódus egy viselkedés, vagy parancsok sorozata, amely lehetővé teszi egy művelet végrehajtását egy programban. Például szorozzon meg 2 számot, vagy nyomtasson ki egy karakterláncot. Más szóval a metódus egy függvény. Néhány más programozási nyelvben a módszereket gyakran "függvényeknek" nevezik. A metódusok, akárcsak a Java programok minden eleme, egy osztályon belül találhatók. Minden osztálynak lehet egy, több vagy egyetlen metódusa sem. public egy hozzáférés módosító. A nyilvános módosítóval jelölt változó, metódus vagy osztály a program bármely pontjáról elérhető. Négy van belőlük a Java-ban: nyilvános, privát, védett és alapértelmezett (üres). Egy kicsit később beszélünk róluk. Első lépésként jobb, ha minden módszerét nyilvánossá teszi. üresa metódus visszatérési típusa. Az üresség azt jelenti, hogy nem ad vissza semmilyen értéket. A fő a program kiindulópontját jelenti. Ez a módszer neve. A string[] args a fő metódus argumentuma. Egyelőre elég annyit tudni, hogy szinte minden Java programnak megvan a main metódusa, elindítja a programot és kiadja pl. public static void main(String[] args) A statikus metódusok azok, amelyek az osztállyal működnek. Azok a módszerek, amelyek deklarációjukban a static kulcsszót használják, csak közvetlenül helyi és statikus változókkal működhetnek.

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

Formálisan ez a sor végrehajtja az out objektum println metódusát. Az out objektumot az OutputStream osztályban deklarálják , és statikusan inicializálják a System osztályban. Ez azonban egy kicsit bonyolult egy teljesen újonc számára. Egy kezdőnek elég, ha tudja, hogy ez a sor a "Hello, Java!" a konzolhoz. Tehát ha az IDE-ben futtatja a programot, a kimenetet a konzolon kapja meg:

Java alapvető szintaktikai szabályok

Java nyelven történő programozáskor be kell tartani néhány fő szintaktikai szabályt:

• a fájlnévnek meg kell egyeznie az osztálynévvel;
• leggyakrabban minden osztály külön fájlban van .java kiterjesztéssel. Az osztályfájlok általában mappákba vannak csoportosítva. Ezeket a mappákat csomagoknak nevezzük;
• a karakterek megkülönböztetik a kis- és nagybetűket. A karakterlánc nem egyenlő a karakterlánccal ;
• A Java programfeldolgozás kezdete mindig a main metódussal kezdődik: public static void main (String [] args) . A main () metódus minden Java program kötelező része;
• A metódus (eljárás, függvény) parancsok sorozata. Metódusok határozzák meg a viselkedését az objektumon;
• A metódusok sorrendje a programfájlban nem releváns;
• Ne feledje, hogy az osztály nevének első betűje nagybetűs. Ha több szót használ, használjon nagybetűt minden szó első betűjeként ("MyFirstJavaClass");
• a Java szintaxis összes metódusának neve kisbetűvel kezdődik. Több szó használatakor a következő betűket nagybetűvel írjuk ("public void myFirstMethodName ()");
• a fájlok osztálynévvel és .java kiterjesztéssel kerülnek mentésre ("MyFirstJavaClass.java");
• A Java szintaxisban vannak "{...}" elválasztók, amelyek egy kódblokkot és egy új kódterületet jelölnek;
• Minden kód utasításnak pontosvesszővel kell végződnie.

Java-változók és adattípusok A változók az adatok tárolására használt speciális entitások. Bármilyen adat. A Java-ban minden adat változóban van tárolva. Azt mondhatjuk, hogy egy változó egy lefoglalt hely vagy egy doboz, amelybe változót helyezhetünk el. Minden változónak megvan a maga adattípusa, neve (azonosítója) és értéke. Az adattípusok lehetnek primitívek és nem primitívek vagy referencia. A primitív adattípusok a következők lehetnek:

• Egész számok: byte, short, int, long
• Törtszámok: úszó és dupla
• Logikai értékek: logikai érték
• Szimbolikus értékek (betűk és számok ábrázolásához): char

Példa Java változókra:

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

Ebben a kódban létrehoztunk egy s egész változót (egy üres tárolót), majd 5-ös értéket tettünk bele. Ugyanez a történet a myChar nevű változóval . Egy char adattípussal hoztuk létre, és egy a betűként definiáltuk . Ebben az esetben létrehoztunk egy változót, és ezzel egyidejűleg értéket adtunk hozzá. A Java szintaxis lehetővé teszi ezt így. A hivatkozástípusok olyan objektumok, amelyek értékekre vagy más objektumokra hivatkoznak. Tartalmazhatnak hivatkozást a nullára is. A nulla egy speciális érték, amely az érték hiányát jelzi. A referenciatípusok közé tartozik a String, a Arrays és az összes kívánt osztály. Ha van hegedűosztálya, létrehozhat ennek az osztálynak egy változóját. Példa Java hivatkozási típusú változókra:

String s = “my words”; 
Violin myViolin; 

Később többet megtudhat róluk. Ne feledje, hogy a nem primitív típusú változók nagybetűkkel kezdődnek, míg a primitívek - kisbetűkkel. Példa:

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

Java tömbök

A tömbök olyan objektumok, amelyek több azonos típusú változót tárolnak. Azonban egy tömb maga egy objektum a kupacban. A következő fejezetekben megvizsgáljuk, hogyan deklarálhatunk, szerkeszthetünk és inicializálhatunk. Példa tömbre:

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

Itt van egy tömb, amely a három egész számból (1, 7 és 5) tartalmazza

Java Enums

A primitív adattípusokon kívül a Java-nak van olyan típusa is, mint az enum vagy a enumeration. A felsorolások logikailag kapcsolódó állandók gyűjteményét képviselik. A felsorolás deklarálása az enum operátorral történik, amelyet a felsorolás neve követ. Ezután jön a felsorolási elemek vesszővel elválasztott listája:

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

A felsorolás tulajdonképpen egy új típust képvisel, így definiálhatunk egy ilyen típusú változót és használhatjuk. Íme egy példa a felsorolás használatára.

Java Enum példa

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
}

Ha futtatja a programot, a PÉNTEK ki van nyomtatva a konzolon. Az Enum és a MyNum osztály kódját egy fájlba helyezheti, de jobb, ha két külön fájlt hoz létre: egyet a MyNum osztályhoz és egyet a Day enumhoz. Az IntelliJ IDEA lehetővé teszi az enum kiválasztását létrehozás közben.

Változók deklarálása Java nyelven

Valójában fentebb deklaráltunk néhány változót, és még azonosítottuk is őket. A deklaráció egy bizonyos típusú változó memóriafoglalásának és elnevezésének folyamata. Valami hasonló:

int i; 
boolean boo; 

Azt is deklarálhatjuk, hogy inicializáljunk egy változót hozzárendelési operátor (=) használatával. Ez azt jelenti, hogy egy adott értéket helyezünk el a lefoglalt memóriába. Megtehetjük egy nyilatkozattal vagy később.

változó példa deklarálása

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

Ha egy változót inicializálás nélkül deklarálsz, akkor is kap valamilyen alapértelmezett értéket. Az int esetében ez az érték 0, a String vagy bármely más hivatkozási típus esetében ez egy speciális null azonosító.

Java azonosítók

Az azonosítók csak a Java összetevők nevei – osztályok, változók és metódusok. Minden Java összetevőnek neve kell, hogy legyen.

Class Violin {
int age; 
String masterName;  
}

A hegedű az osztályazonosító. Az age és a masterName változók azonosítói. Íme néhány Java azonosító szabály:

• Minden azonosító latin betűvel (A-tól Z-ig vagy a-tól z-ig), pénznem karakterrel ($) vagy aláhúzással (_) kezdődik.
• Az első karakter után az azonosítók bármilyen karakterkombinációt tartalmazhatnak.
• A Java kulcsszó nem lehet azonosító (a kulcsszavakat egy kicsit később találja meg).
• Az azonosítók megkülönböztetik a kis- és nagybetűket.

Példa az azonosítókra

Jogi azonosítók: java, $mySalary, _valami Illegális azonosítók: 1stPart, -one

Java módosítók

A módosítók a Java nyelv speciális szavai, amelyek segítségével elemeket (osztályokat, metódusokat, változókat) módosíthatunk. A Java módosítóinak két kategóriája van: hozzáférési és nem hozzáférési módosítók.

Példa a hozzáférés-módosítókra

A Java-ban 4 hozzáférés-módosító található:

• nyilvános . Nyilvános elem Elérhető az osztályból, az osztályon kívül, a csomagon belül és kívül
• Az alapértelmezett (üres) módosítóval rendelkező elem csak a csomagon belül érhető el
• A védett módosító a csomagon belül és kívül a gyermekosztályon keresztül érhető el
• privát elem csak az általa deklarált osztályon belül érhető el.

Példa a hozzáférést nem igénylő módosítókra

7 db van

• statikus
• végső
• absztrakt
• szinkronizálva
• átmeneti
• illó
• anyanyelvi

Java kulcsszavak

A Java kulcsszavak a Java nyelvben használt speciális szavak, amelyek kulcsként működnek a kódhoz. Fenntartott szavakként is ismertek: nem használhatja őket változók, metódusok, osztályok stb. azonosítóira. Itt vannak:

• abstract : kulcsszó az absztrakt osztály deklarálásához.
• logikai érték : Java logikai kulcsszó egy változó logikai típusként való deklarálásához. Az ilyen változók csak igazak és hamisak lehetnek.
• break : használja a Java break kulcsszót a ciklus vagy a switch utasítás megszakításához.
• byte : Java byte kulcsszó egy bájtos egész szám változó deklarálásához.
• case : a switch utasításokkal szokott szövegblokkok megjelölésére.
• catch : a try blokk utáni kivételek elkapására szolgál .
• char : Java char kulcsszó karakteres változóhoz. Előjel nélküli 16 bites Unicode karaktereket tartalmazhat.
• class : Java class kulcsszó egy osztály deklarálásához.
• Tovább : Java kulcsszó a ciklus folytatásához.
• default : Java alapértelmezett kulcsszó az alapértelmezett kódblokk megadásához a switch utasításban.
• do : a do-while huroképítésben használatos.
• double : A Java double kulcsszó egy számváltozó deklarálására szolgál. 8 bájtos lebegőpontos számokat tud tárolni.
• else : használhatod else-if feltételes utasításokban.
• enum : állandó konstanskészlet meghatározására szolgál.
• expands : A Java kiterjeszti a kulcsszót, jelezve, hogy egy osztály kiterjeszt egy másik osztályt (a másik osztály gyermekosztálya).
• final : kulcsszó, amely jelzi, hogy egy változó konstans.
• végül : egy kódblokkot jelöl, amely annak ellenére végrehajtásra kerül, hogy a kivételt kezelték-e vagy sem.
• float : olyan változó, amely egy 4 bájtos lebegőpontos számot tartalmaz.
• for : egy kulcsszó a for ciklus elindításához. Egy utasításkészlet ismételt végrehajtására szolgál, miközben bizonyos feltételek teljesülnek.
• if : kulcsszó a feltétel ellenőrzésére. Akkor hajtja végre a blokkot, ha a feltétel igaz.
• implements : a kulcsszó egy interfész megvalósításához.
• import : Java import kulcsszó csomag, osztály vagy interfész importálásához.
• instanceof : ellenőrzi, hogy az objektum egy adott osztály vagy interfész példánya-e.
• int : olyan változó, amely 4 bájtos előjelű egész számot tartalmazhat.
• interfész : A Java interface kulcsszó egy interfész deklarálására szolgál.
• long : olyan változó, amely 8 bájtos előjelű egész számot tartalmazhat.
• natív : azt határozza meg, hogy a metódus natív kódban valósul meg a JNI (Java Native Interface) használatával.
• new : Java új kulcsszó új objektumok létrehozásához.
• csomag : Java-csomagot (mappát) deklarál a Java osztályok fájljaihoz.
• private : a hozzáférés-módosító azt jelzi, hogy egy metódus vagy változó csak abban az osztályban látható, amelyben deklarálták.
• védett : a hozzáférés módosító azt jelzi, hogy egy metódus vagy változó elérhető a csomagon belül és kívül a gyermekosztályon keresztül.
• public : a hozzáférés módosító azt jelzi, hogy egy elem bárhonnan elérhető.
• return : egy metódus végrehajtásának eredményét adja vissza.
• short : olyan változó, amely 2 bájtos előjelű egész számot tartalmazhat.
• statikus : azt jelzi, hogy egy változó vagy metódus osztály, nem objektum, metódus.
• strictfp : korlátozza a lebegőpontos számításokat.
• super : szülő osztály objektumra utal.
• kapcsoló : kiválasztja a végrehajtandó kódblokkot (vagy sokat közülük).
• szinkronizált : egy nem hozzáférési módosító. Meghatározza, hogy a metódust egyszerre csak egy szál érheti el.
• this : az aktuális objektumra hivatkozik egy metódusban vagy konstruktorban.
• throw : egy kivétel kifejezett dobására szolgál.
• dob : A kivételt hirdet.
• tranziens : egy tranziens adatdarab nem sorosítható.
• try : elindít egy kódblokkot, amely kivételeket keres.
• void : megadja, hogy a metódus nem ad vissza értéket.
• volatile : azt jelzi, hogy egy változó aszinkron módon változhat.
• while : elindít egy while ciklust. a program egy részét többször ismétli, miközben a feltétel igaz.

Megjegyzések Java nyelven

A Java támogatja az egysoros és többsoros megjegyzéseket. Minden karakter elérhető bármely megjegyzésben, és a Java fordító figyelmen kívül hagyja őket. A fejlesztők arra használják őket, hogy elmagyarázzák a kódot vagy felidézzenek valamit. Példák megjegyzésekre:

//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);
   }
}

Literálok Java nyelven

A Java-ban a literálok néhány állandó érték, amelyek a változóhoz vannak rendelve. Lehetnek számok vagy szövegek, vagy valami más, ami egy értéket képvisel.

• Integrál literálok
• Lebegőpontos literálok
• Char literálok
• String literálok
• Logikai literálok

Java literals példák

 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; 

Megjegyzés: a null szó szerinti is.

Alap operátorok a Java nyelven

Különféle típusú operátorok léteznek: Aritmetika

• + (számok összeadása és karakterlánc összefűzése)
• – (mínusz vagy kivonás)
• * (szorzás)
• / (osztály)
• % (modulus vagy maradék)

Összehasonlítás

• < (kevesebb mint)
• <= (kisebb vagy egyenlő)
• > (nagyobb mint)
• >= (nagyobb vagy egyenlő)
• == (egyenlő)
• != (NEM egyenlő)

Logikus

• && (ÉS)
• || (VAGY)
• ! (NEM)
• ^ (XOR)

Az adattípusokról, változókról, metódusokról és operátorokról már tanultunk. Vegyünk egy egyszerű példát a kódra, de kicsit bonyolultabb, mint a legelső Java program. Hozzunk létre egy osztályt NumberOperations néven

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;
   }
}

Itt van egy fa metódusokkal rendelkező osztály, amelyet 2 számmal lehet manipulálni. Megpróbálhatja felírni a 4. metódust int mul (int a, int b) 2 szám szorzásához ebben a programban. Hozzunk létre egy osztályt is a NumberOprations munkájának bemutatására :

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);
   }
}

Ha a NumberOperationsDemo programot futtatja , a következő kimenetet kapja:

Következtetések

Ezek csak a Java nyelv alapjai, és sok minden zavaró lehet. Sok programozásra van szükség ahhoz, hogy kitaláljuk, mi az. Csak így tanulhatod meg ezt a nyelvet – gyakorlással. Kezdje el a kódolást most, és próbálja meg teljesíteni a CodeGym Practical Java tanfolyam első küldetését . Sok sikert a Java tanuláshoz!