Java Syntax: isang napakaikling panimula sa programming language

Ano ang Java Syntax?

Ang Java Syntax ay isang pangunahing ng wika, ang lahat ng mga pangunahing tuntunin, utos, mga konstruksyon upang magsulat ng mga programa na "naiintindihan" ng compiler at computer. Ang bawat programming language ay may sariling syntax pati na rin ang wika ng tao. Nakatuon ang artikulong ito sa pangunahing syntax ng Java programming language at nilayon para sa mga baguhang developer o sa mga may alam ng ibang programming language. Maaaring hindi malinaw sa mga nagsisimula ang ilang aspeto. Kung gayon, pinakamahusay na laktawan ang mga ito at tumuon sa mga halimbawa. Tulad ng sa lahat ng iba pa, ito ay mas mahusay na upang matuto ng isang programming language cyclically, unti-unting pagdating sa isang mas malalim na pag-unawa sa ilang mga konsepto. Ang bawat Java program ay isang bungkos ng mga bagay na nagsasama sa isa't isa sa data (mga variable) at pag-uugali (mga function o pamamaraan). Gayundin ang Java program ay isang klase o ilang mga klase. Ang isang bagay ay isang halimbawa ng isang klase. Maiintindihan mo ang klase bilang isang modelo, halimbawa, mga cookie cutter at mga bagay tulad ng cookies. O klase bilang abstract na "Java programmer" at object bilang "Java Programmer John" o "Java Programmer Ivy".

Bagay sa Java

Ang mga bagay sa Java ay may mga estado at pag-uugali. Halimbawa: Ang isang pusa ay may mga estado: ang pangalan nito ay Furr, ang kulay ay pula, ang may-ari ay si John; may ugali din ang pusa Ngayon natutulog si Furr. Marunong din siyang magpurr, maglakad, at iba pa. Ang isang bagay ay isang halimbawa ng isang klase.

Klase sa Java

Ang klase ay isang modelo o template o blueprint ng bagay. Inilalarawan nito ang pag-uugali at nagsasaad na sinusuportahan ng bagay ng uri nito. Halimbawa, ang klase ng Cat ay may pangalan, kulay, may-ari; Ang pusa ay mayroon ding pag-uugali tulad ng pagkain, purring, paglalakad, pagtulog.

Mga pamamaraan sa Java

Ang mga pamamaraan ay para sa paglalarawan ng mga lohika, pagmamanipula ng data at pagpapatupad ng lahat ng mga aksyon. Ang bawat pamamaraan ay tumutukoy sa pag-uugali. Ang isang klase ay maaaring maglaman ng maraming pamamaraan. Halimbawa, maaari tayong magsulat ng paraan na sleep() para sa klase ng Cat (to sleep) o purr() to purr.

Mga Variable ng Instance sa Java

Ang bawat bagay ay may natatanging hanay ng mga variable ng instance. Karaniwang nabuo ang estado ng object ng mga value na itinalaga sa mga variable na instance na ito. Halimbawa, maaaring variable ang pangalan o edad ng pusa. Magsisimula tayo sa pinakasimpleng Java program. Gamit ang halimbawang ito, mauunawaan natin ang mga pangunahing konsepto ng Java syntax, at pagkatapos ay susuriing mabuti ang mga ito.

Simpleng Java program: Hello, Java!

Narito ang isang simpleng Java program:

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

Ang program na ito ay nagpi-print ng isang string na "Hello, Java!" para aliwin. Inirerekomenda kong i-install mo ang JDK at IntelliJ IDEA at subukang isulat ang code na nakikita mo sa itaas. O sa unang pagsubok ay humanap ng online na IDE para gawin ang pareho. Ngayon, gawin natin ang programang ito nang linya sa linya, ngunit alisin ang ilang mga detalye na hindi kinakailangan para sa isang baguhan.

class HelloJava 

Ang bawat programa sa Java ay isang klase o mas madalas maraming klase. Ang line class na HelloJava ay nangangahulugan na dito tayo lumikha ng isang bagong klase at ang pangalan nito ay HelloJava. Tulad ng tinukoy namin sa itaas, ang klase ay isang uri ng template o blueprint, inilalarawan nito ang pag-uugali at estado ng mga bagay ng klase. Maaaring mahirap para sa mga baguhang programmer, malalaman mo ang konseptong ito sa ibang pagkakataon. Sa ngayon ang klase ng HelloJava ay simula pa lamang ng iyong programa. Maaaring napansin mo ang curly brace { sa parehong linya at sa buong teksto. Ang isang pares ng curly braces {} ay tumutukoy sa isang block, isang pangkat ng mga programming statement na itinuturing bilang isang unit. Kung saan ang { ay nangangahulugang simula ng yunit at }pagtatapos nito. Ang mga bloke ay maaaring ilagay sa loob ng isa't isa, o maaari silang sunud-sunod. Mayroong dalawang nested block sa programa sa itaas. Ang panlabas ay naglalaman ng katawan ng klase Hello . Ang panloob na bloke ay naglalaman ng katawan ng pangunahing() na pamamaraan.

public static void main (String args []) {

Narito ang simula ng pangunahing pamamaraan. Ang isang pamamaraan ay isang pag-uugali, o ang pagkakasunud-sunod ng mga utos na nagbibigay-daan sa iyong magsagawa ng isang operasyon sa isang programa. Halimbawa, magparami ng 2 numero o mag-print ng isang string. Sa madaling salita, ang isang pamamaraan ay isang function. Sa ilang iba pang mga programming language, ang mga pamamaraan ay madalas na tinutukoy bilang "mga function". Ang mga pamamaraan, tulad ng lahat ng elemento ng isang Java program, ay matatagpuan sa loob ng isang klase. Ang bawat klase ay maaaring magkaroon ng isa, marami, o walang pamamaraan. public ay isang access modifier. Maaaring ma-access ang isang variable, pamamaraan, o klase na may marka ng pampublikong modifier mula saanman sa programa. Mayroong apat sa kanila sa Java: pampubliko, pribado, protektado at default (walang laman). Mamaya na lang natin sila pag-usapan. Para sa unang hakbang, mas mainam na isapubliko ang lahat ng iyong pamamaraan. walang bisaay ang uri ng pagbabalik ng pamamaraan. Ang ibig sabihin ng void ay hindi ito nagbabalik ng anumang halaga. pangunahing kumakatawan sa panimulang punto ng programa. Ito ang pangalan ng pamamaraan. Ang string[] args ay isang pangunahing paraan ng argumento. Sa ngayon ay sapat na na malaman na halos lahat ng Java program ay may pangunahing pamamaraan, sinisimulan nito ang programa at idineklara nito tulad ng public static void main(String[] args) Ang mga static na pamamaraan ay ang gumagana sa klase. Ang mga pamamaraan na gumagamit ng static na keyword sa kanilang deklarasyon ay maaari lamang gumana nang direkta sa mga lokal at static na variable.

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

Pormal na ipinapatupad ng linyang ito ang println method ng out object. Ang out object ay idineklara sa OutputStream class at statically initialize sa System class. Gayunpaman ito ay medyo kumplikado para sa isang kabuuang baguhan. Sapat na para sa isang baguhan na malaman na ang linyang ito ay nagpi-print ng mga salitang "Hello, Java!" sa console. Kaya kung patakbuhin mo ang program sa iyong IDE, makukuha mo ang output sa console:

Java basic syntax rules

Mayroong ilang mga pangunahing panuntunan sa syntax na dapat sundin kapag nagprograma sa Java:

• ang pangalan ng file ay dapat na magkapareho sa pangalan ng klase;
• kadalasan ang bawat klase ay nasa isang hiwalay na file na may extension na .java. Ang mga file ng klase ay karaniwang nakagrupo sa mga folder. Ang mga folder na ito ay tinatawag na mga pakete;
• case sensitive ang mga character. Ang string ay hindi katumbas ng string ;
• Ang simula ng pagpoproseso ng Java program ay palaging nagsisimula sa pangunahing paraan: public static void main (String [] args) . Ang pangunahing () pamamaraan ay isang kinakailangang bahagi ng anumang Java program;
• Ang pamamaraan (procedure, function) ay isang pagkakasunod-sunod ng mga utos. Tinutukoy ng mga pamamaraan ang pag-uugali ng sa bagay;
• Ang pagkakasunud-sunod ng mga pamamaraan sa file ng programa ay hindi nauugnay;
• Tandaan na ang unang titik ng pangalan ng klase ay nasa uppercase. Kung gumagamit ka ng maraming salita, gumamit ng malalaking titik para sa unang titik ng bawat salita (“MyFirstJavaClass”);
• ang mga pangalan ng lahat ng mga pamamaraan sa Java syntax ay nagsisimula sa isang maliit na titik. Kapag gumagamit ng maraming salita, ang mga kasunod na titik ay naka-capitalize ("public void myFirstMethodName ()");
• nai-save ang mga file gamit ang pangalan ng klase at .java extension ("MyFirstJavaClass.java");
• Sa Java syntax, may mga delimiter na "{...}" na tumutukoy sa isang bloke ng code at isang bagong lugar ng code;
• Ang bawat code statement ay dapat magtapos sa isang semicolon.

Ang mga variable ng Java at mga uri ng data Ang mga variable ay mga espesyal na entity na ginagamit upang mag-imbak ng data. Anumang data. Sa Java, ang lahat ng data ay nakaimbak sa mga variable. Maaari mong sabihin na ang variable ay isang nakalaan na lugar o isang kahon na paglalagayan ng variable. Ang bawat variable ay may uri ng data, pangalan (identifier) ​​at halaga nito. Ang mga uri ng data ay maaaring primitive at non-primitive o reference. Ang mga primitive na uri ng data ay maaaring:

• Mga integer: byte, maikli, int, mahaba
• Fractionals: lumutang at doble
• Mga lohikal na halaga: boolean
• Mga simbolikong halaga (para sa kumakatawan sa mga titik at numeral): char

Halimbawa ng mga variable ng Java:

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

Sa code na ito gumawa kami ng integer variable s (isang walang laman na lalagyan) at pagkatapos ay naglagay ng value na 5 dito. Ang parehong kuwento na may isang variable na pinangalanang myChar . Ginawa namin ito gamit ang isang uri ng data ng char at tinukoy ito bilang isang titik a . Sa kasong ito lumikha kami ng isang variable at sabay-sabay na nagtalaga ng isang halaga dito. Hinahayaan ka ng Java syntax na gawin ito sa ganitong paraan. Ang mga uri ng sanggunian ay ilang mga bagay na nagpapanatili ng mga sanggunian sa mga halaga o iba pang mga bagay. Maaari rin silang maglaman ng reference sa null. Ang Null ay isang espesyal na halaga upang tukuyin ang kawalan ng halaga. Kabilang sa mga uri ng sanggunian ay String, Arrays at bawat Klase na gusto mo. Kung mayroon kang klase ng Violin, maaari kang lumikha ng variable ng Klase na ito. Halimbawa ng mga variable ng uri ng reference ng Java:

String s = “my words”; 
Violin myViolin; 

Malalaman mo ang higit pa tungkol sa kanila sa ibang pagkakataon. Tandaan na ang mga hindi primitive na uri ng mga variable ay nagsisimula sa malalaking titik habang primitive — mula sa maliliit na titik. Halimbawa:

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

Mga Array ng Java

Ang mga array ay mga bagay na nag-iimbak ng maraming variable ng parehong uri. Gayunpaman, ang isang array mismo ay isang bagay sa heap. Titingnan natin kung paano magdeklara, bumuo, at magsisimula sa mga paparating na kabanata. Halimbawa ng array:

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

Narito mayroon kaming isang array na naglalaman mula sa tatlong integer (1,7 at 5)

Mga Java Enum

Bilang karagdagan sa mga primitive na uri ng data, ang Java ay may uri ng enum o enumeration. Ang mga enumerasyon ay kumakatawan sa isang koleksyon ng mga lohikal na nauugnay na mga constant. Ang isang enumeration ay idineklara gamit ang enum operator, na sinusundan ng pangalan ng enumeration. Pagkatapos ay darating ang isang listahan ng mga elemento ng enumeration na pinaghihiwalay ng kuwit:

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

Ang isang enumeration ay aktwal na kumakatawan sa isang bagong uri, kaya maaari naming tukuyin ang isang variable ng ganoong uri at gamitin ito. Narito ang isang halimbawa ng paggamit ng enumeration.

Halimbawa ng Java Enum

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
}

Kung patakbuhin mo ang programa, ang FRIDAY ay naka-print sa console. Maaari mong ilagay ang iyong Enum at MyNum class code sa isang file, ngunit ito ay mas mahusay na gumawa ng dalawang magkahiwalay na file: isa para sa MyNum class at isa para sa Day enum. Hinahayaan ka ng IntelliJ IDEA na pumili ng enum habang gumagawa.

Pagdedeklara ng mga Variable sa Java

Sa totoo lang, nagdeklara kami ng ilang mga variable sa itaas at nakilala pa ang mga ito. Ang deklarasyon ay isang proseso ng paglalaan ng memorya para sa isang variable ng isang tiyak na uri at pagpapangalan dito. Isang bagay na tulad nito:

int i; 
boolean boo; 

Maaari din naming ideklara na magsisimula ng variable gamit ang assignment operator (=). Nangangahulugan iyon na naglalagay kami ng isang partikular na halaga sa memorya na aming inilaan. Magagawa natin ito nang tama sa isang sandali ng deklarasyon o mamaya.

pagdedeklara ng variable na halimbawa

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

Kung idedeklara mo ang isang variable nang walang inisyal ay nakakakuha pa rin ito ng ilang default na halaga. Para sa int ang value na ito ay 0, para sa String o anumang iba pang uri ng reference ito ay isang espesyal na null identifier.

Mga Tagatukoy ng Java

Ang mga identifier ay mga pangalan lamang ng mga bahagi ng Java — mga klase, variable, at pamamaraan. Ang lahat ng mga bahagi ng Java ay dapat may mga pangalan.

Class Violin {
int age; 
String masterName;  
}

Ang byolin ay ang pagkakakilanlan ng klase. age at masterName ay mga variable identifier. Narito ang ilang mga panuntunan sa Java identifier:

• Ang lahat ng mga identifier ay nagsisimula sa isang latin letter (A hanggang Z o a to z), currency character ($) o underscore (_).
• Pagkatapos ng unang character, maaaring magkaroon ng anumang kumbinasyon ng mga character ang mga identifier.
• Ang isang Java keyword ay hindi maaaring maging isang identifier (malalaman mo ang mga keyword sa ibang pagkakataon).
• Case sensitive ang mga identifier.

Halimbawa ng mga identifier

Mga legal na identifier: java, $mySalary, _something Illegal na identifier: 1stPart, -one

Mga Modifier ng Java

Ang mga modifier ay mga espesyal na salita ng wikang Java na maaari mong gamitin upang baguhin ang mga elemento (mga klase, pamamaraan, variable). Ang Java ay mayroong dalawang kategorya ng mga modifier: access at non-access Modifiers.

Halimbawa ng mga access modifier

Mayroong 4 na access modifier sa Java:

• pampubliko . Isang pampublikong elemento Maaari itong ma-access mula sa klase, sa labas ng klase, sa loob at labas ng package
• Ang elementong may default (walang laman) modifier ay maa-access lamang sa loob ng package
• maa-access ang protektadong modifier sa loob at labas ng package sa pamamagitan ng child class
• magagamit lamang ang pribadong elemento sa loob ng klase na idineklara nito.

Halimbawa ng mga non-access na modifier

Mayroong 7 sa kanila

• static
• pangwakas
• abstract
• naka-synchronize
• lumilipas
• pabagu-bago ng isip
• katutubo

Mga Keyword ng Java

Ang Java Keywords ay ang mga espesyal na salita na gagamitin sa Java na nagsisilbing susi sa isang code. Kilala rin ang mga ito bilang mga reserbang salita: hindi mo magagamit ang mga ito para sa mga identifier ng mga variable, pamamaraan, klase, atbp. Narito ang mga ito:

• abstract : keyword upang magdeklara ng abstract na klase.
• boolean : Java boolean na keyword upang ideklara ang isang variable bilang isang uri ng boolean. Ang ganitong mga variable ay maaari lamang maging totoo at mali.
• break : gumamit ng Java break na keyword upang masira ang loop o switch statement.
• byte : Java byte na keyword para sa deklarasyon ng one byte whole number variable.
• case : ay ginagamit sa mga pahayag ng switch upang markahan ang mga bloke ng teksto.
• catch : ay ginagamit upang mahuli ang mga exception pagkatapos ng try block.
• char : Java char na keyword para sa isang variable ng character. Maaari itong humawak ng mga unsigned na 16-bit na Unicode na character.
• class : Java class na keyword para magdeklara ng klase.
• magpatuloy : Java keyword upang ipagpatuloy ang loop.
• default : Java default na keyword upang tukuyin ang default na bloke ng code sa isang switch statement.
• do : ay ginagamit sa do-while loop construction.
• double : Ang Java double keyword ay ginagamit upang magdeklara ng variable ng numero. Maaari itong humawak ng 8 byte na mga floating-point na numero.
• else : maaari mo itong gamitin sa else-if conditional statements.
• enum : ay ginagamit upang tukuyin ang isang nakapirming hanay ng mga constants.
• extends : Ang Java ay nagpapalawak ng keyword upang ipahiwatig na ang isang klase ay nagpapalawak ng isa pang klase (ay isang klase ng Bata ng kabilang klase).
• final : keyword upang ipahiwatig na ang isang variable ay pare-pareho.
• sa wakas : nagmamarka ng isang bloke ng code na isasagawa sa kabila ng kung ang isang pagbubukod ay pinangangasiwaan o hindi.
• float : isang variable na mayroong 4-byte na floating-point na numero.
• para sa : isang keyword upang magsimula ng para sa loop. Ito ay ginagamit upang isagawa ang isang set ng mga tagubilin nang paulit-ulit habang ang ilang mga kundisyon ay totoo.
• if : keyword para sa pagsuri sa kundisyon. Isinasagawa nito ang block kung totoo ang kundisyon.
• nagpapatupad : ang keyword upang ipatupad ang isang interface.
• import : Java import keyword para mag-import ng package, klase o interface.
• instanceof : sinusuri kung ang object ay isang instance ng isang partikular na klase o interface.
• int : isang variable na maaaring maglaman ng 4-byte na naka-sign integer na numero.
• interface : Ang keyword ng Java interface ay ginagamit upang magdeklara ng isang interface.
• long : isang variable na maaaring maglaman ng 8-byte signed integer number.
• native : tumutukoy na ang isang pamamaraan ay ipinatupad sa native code gamit ang JNI (Java Native Interface).
• bago : bagong keyword ng Java upang lumikha ng mga bagong bagay.
• package : nagdedeklara ng Java package (folder) para sa mga file ng mga klase ng Java.
• private : ang isang access modifier ay nagpapahiwatig na ang isang paraan o variable ay maaaring makita lamang sa klase na idineklara nito.
• protected : ang isang access modifier ay nagpapahiwatig na ang isang paraan o variable ay maaaring ma-access sa loob at labas ng package sa pamamagitan ng child class.
• public : ang isang access modifier ay nagpapahiwatig na ang isang elemento ay naa-access kahit saan.
• return : nagbabalik ng resulta ng execution ng isang method.
• maikli : isang variable na maaaring maglaman ng isang 2-byte na naka-sign integer na numero.
• static : ay nagpapahiwatig na ang isang variable o pamamaraan ay isang klase, hindi isang bagay, paraan.
• strictfp : nililimitahan ang mga kalkulasyon ng floating-point.
• super : tumutukoy sa parent class object.
• switch : pumipili ng code block (o marami sa kanila) na isasagawa.
• naka-synchronize : isang non-access na modifier. Tinutukoy nito na ang pamamaraan ay maaari lamang ma-access ng isang thread sa isang pagkakataon.
• ito : tumutukoy sa kasalukuyang bagay sa isang pamamaraan o tagabuo.
• throw : ay ginagamit upang tahasang magtapon ng exception.
• throws : Nagdedeklara ng exception.
• lumilipas : ang isang lumilipas na piraso ng data ay hindi maaaring i-serialize.
• subukan : magsisimula ng isang bloke ng code na susuriin para sa mga pagbubukod.
• void : tumutukoy na ang isang pamamaraan ay hindi nagbabalik ng halaga.
• pabagu-bago ng isip : nagpapahiwatig na ang isang variable ay maaaring magbago nang asynchronously.
• while : magsisimula ng while loop. inuulit ang isang bahagi ng programa nang maraming beses habang totoo ang kundisyon.

Mga komento sa Java

Sinusuportahan ng Java ang single-line at multi-line na mga komento. Ang lahat ng mga character ay magagamit sa loob ng anumang komento at sila ay hindi pinansin ng Java compiler. Ginagamit ng mga developer ang mga ito upang ipaliwanag ang code o para maalala ang tungkol sa isang bagay. Mga halimbawa ng komento:

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

Mga literal sa Java

Ang mga literal sa Java ay ilang pare-parehong halaga na itinalaga sa variable. Ang mga ito ay maaaring mga numero o teksto o iba pang kumakatawan sa isang halaga.

• Mga integral na literal
• Mga literal na floating point
• Char literals
• Mga literal na string
• Boolean literals

Mga halimbawa ng Java literal

 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; 

Tandaan: ang null ay literal din.

Mga pangunahing operator sa Java

Mayroong iba't ibang uri ng mga operator: Arithmetic

• + (pagdaragdag ng mga numero at pagsasama-sama ng String)
• – (minus o pagbabawas)
• * (pagpaparami)
• / (dibisyon)
• % (modulus o natitira)

Paghahambing

• < (mas mababa sa)
• <= (mas mababa sa o katumbas ng)
• > (mas malaki kaysa)
• >= (mas malaki sa o katumbas ng)
• == (katumbas ng)
• != (HINDI katumbas ng)

Lohikal

• && (AT)
• || (O)
• ! (HINDI)
• ^ (XOR)

Natutunan na natin ang tungkol sa mga uri ng data, variable, pamamaraan at operator. Magkaroon tayo ng isang simpleng halimbawa ng code ngunit medyo mas kumplikado kaysa sa pinakaunang Java program. Gumawa tayo ng klase na tinatawag na 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;
   }
}

Narito mayroon kaming isang klase na may mga pamamaraan ng puno upang manipulahin gamit ang 2 numero. Maaari mong subukang isulat ang ika-4 na paraan int mul (int a, int b) upang i-multiply ang 2 numero sa loob ng program na ito. Gumawa din tayo ng klase upang ipakita ang gawain ng NumberOprations :

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

Kung nagpapatakbo ka ng NumberOperationsDemo , makukuha mo ang susunod na output:

Mga konklusyon

Ito ang mga pangunahing kaalaman lamang ng wikang Java, at maraming bagay ang maaaring nakalilito. Kailangan ng maraming programming para malaman kung ano. Ito ang tanging paraan upang matutunan mo ang wikang ito - sa pamamagitan ng pagsasanay. Simulan ang coding ngayon, subukang kumpletuhin ang unang quest ng CodeGym Practical Java course . Good luck sa iyong pag-aaral ng Java!