Java Syntax: Isang Maikling Panimula sa Programming Language

Ano ang Java Syntax?

Ang Java syntax (Java Syntax) ay ang batayan ng wika, lahat ng mga pangunahing tuntunin, utos, at konstruksyon para sa pagsusulat ng mga programa na "naiintindihan" ng compiler at ng computer. Ang bawat programming language ay may sariling syntax, tulad ng mga natural na wika na ginagamit namin upang makipag-usap sa isa't isa. Sinasaklaw ng artikulong ito ang pangunahing syntax ng Java programming language at naglalayon sa mga nag-aaral ng Java, mga naghahangad na developer, o sa mga may alam ng ibang programming language. Maaaring hindi malinaw sa mga nagsisimula ang ilang aspeto. Kung nangyari ito sa iyo, inirerekomenda naming laktawan ang mahihirap na bahagi at tumuon sa mga halimbawa. Tulad ng lahat ng iba pa, mas mainam na matuto ng programming language nang paikot-ikot, unti-unting nagkakaroon ng mas malalim na pag-unawa sa ilang mga konsepto. Ang bawat programa ng Java ay mahalagang koleksyon ng mga bagay na may kasamang data (mga variable) at pag-uugali (mga function o pamamaraan). Gayundin, ang isang Java program ay isang klase o ilang mga klase. Ang isang bagay ay isang halimbawa ng isang klase. Ang isang klase ay isang modelo, tulad ng isang cookie cutter, at ang mga bagay ay cookies. O, sabihin nating, ang isang klase ay isang abstract na "Java programmer", at ang isang object ay "Java programmer Ivan" o "Java programmer Alice".

Mga bagay sa Java

Ang mga bagay sa Java ay may mga estado at pag-uugali. Narito ang isang halimbawa. Ang pusa ay may kayamanan: ang kanyang pangalan ay Barsik, ang kanyang kulay ay pula, ang kanyang may-ari ay si Ivan. Ang pusa ay mayroon ding pag-uugali: ngayon ay natutulog si Barsik. 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, template, o blueprint ng isang bagay. Inilalarawan nito ang pag-uugali at isinasaad kung ano ang sinusuportahan ng isang bagay ng uri nito. Halimbawa, ang klase ng Cat ay may sariling pangalan, kulay, may-ari; Ang pusa ay mayroon ding pag-uugali: kumakain, purring, paglalakad, pagtulog.

Mga pamamaraan sa Java

Ang mga pamamaraan ay inilaan upang ilarawan ang lohika, gumana sa data at isagawa ang lahat ng mga aksyon. Ang bawat pamamaraan ay tumutukoy sa isang pag-uugali. Ang isang klase ay maaaring maglaman ng maraming pamamaraan. Halimbawa, maaari tayong magsulat ng sleep() method para sa Cat class (to sleep) o purr() method para sa purring.

Mga Variable ng Instance sa Java

Ang bawat bagay ay may natatanging hanay ng mga variable ng instance. Ang estado ng isang bagay ay karaniwang nabuo sa pamamagitan ng mga halaga na itinalaga sa mga variable na ito. Halimbawa, maaaring iba-iba ang pangalan o edad ng pusa. Magsimula tayo sa pinakasimpleng Java program. Sa halimbawang ito, mauunawaan natin ang mga pangunahing bahagi ng Java syntax at pagkatapos ay titingnan ang mga ito nang mas detalyado.

Isang simpleng programa sa Java: Hello, Java!

Narito ang pinakasimpleng programa sa Java:

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

Ipinapakita ng program na ito ang string na "Hello, Java!" sa console. Inirerekomenda kong i-install mo ang JDK at IntelliJ IDEA at subukang isulat ang code mula sa halimbawang ito. O sa unang pagkakataon, humanap lang ng online IDE para gawin ito. Ngayon ay susuriin namin ang program na ito nang linya sa linya, ngunit aalisin namin ang ilang mga detalye na hindi kailangan para sa isang baguhan.

class HelloJava

Ang bawat Java program ay isang klase, o mas madalas ay isang set ng mga klase. Ang linyang HelloJava ng klase ay nangangahulugan na gumagawa tayo ng bagong klase na tinatawag na HelloJava . Gaya ng nakasaad 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 ito para sa mga bagong programmer, ngunit huwag mag-alala: 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 bloke, isang pangkat ng mga programmable na pahayag na itinuturing bilang isang unit. Kung saan ang { ay nangangahulugang ang simula ng block, at } ang katapusan 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 ng 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 pamamaraan ay isang pag-uugali o pagkakasunud-sunod ng mga utos na nagpapahintulot sa isang operasyon na maisagawa sa isang programa. Halimbawa, magparami ng dalawang numero o mag-print ng string. Sa madaling salita, ang isang pamamaraan ay isang function. Sa ilang iba pang mga programming language, ang mga pamamaraan ay madalas na tinatawag na "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, ilang mga pamamaraan, o walang mga pamamaraan. pampubliko — access modifier. Maaaring ma-access ang isang variable, pamamaraan, o klase na may marka ng pampublikong modifier mula saanman sa programa. Sa Java mayroong apat sa kanila: pampubliko, pribado, protektado at default - bilang default (walang laman). Pag-uusapan natin sila mamaya. Upang magsimula, mas mainam na isapubliko ang lahat ng iyong mga pamamaraan. void ang uri ng pagbabalik ng pamamaraan. Ang walang bisa ay nangangahulugan na hindi ito nagbabalik ng anumang halaga. pangunahing kumakatawan sa panimulang punto ng programa. Ito ang pangalan ng pamamaraan. String[] args ang pangunahing argumento ng pamamaraan. Sa ngayon, sapat na na malaman na halos lahat ng Java program ay may pangunahing pamamaraan : pinapatakbo nito ang programa at idineklara bilang public static void main(String[] args) . Ang mga static na pamamaraan (static) ay idinisenyo upang gumana sa isang 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, ang linyang ito ay nagpapatupad ng println method ng out object . Ang out object ay idineklara sa OutputStream class at statically initialize sa System class . Gayunpaman, maaaring mukhang medyo mahirap para sa isang baguhan. Kung nag-aaral ka lang, sapat na na malaman na ang linyang ito ay nagpi-print ng mga salitang "Hello, Java!" sa console. Kaya kung patakbuhin mo ang programa sa iyong development environment (IDE), makakakuha ka ng output tulad nito:

Pangunahing Mga Panuntunan sa Syntax ng Java

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

• Dapat tumugma ang pangalan ng file sa pangalan ng klase;
• Kadalasan, ang bawat klase ay nasa isang hiwalay na file na may .java extension . 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 pagproseso ng isang Java program ay palaging nagsisimula sa pangunahing paraan: public static void main (String [] args) . Ang pangunahing() na 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 sa isang bagay;
• Ang pagkakasunud-sunod ng mga pamamaraan sa file ng programa ay hindi mahalaga;
• Tandaan na dapat nasa uppercase ang unang titik ng pangalan ng klase. Kung gumagamit ka ng maraming salita, i-capitalize ang unang titik ng bawat salita (halimbawa, "MyFirstJavaClass");
• Ang lahat ng mga pangalan ng 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 () );
• Ang mga file ay nai-save gamit ang pangalan ng klase at extension .java ( MyFirstJavaClass.java );
• Ang Java syntax ay may mga delimiter {...} na tumutukoy sa isang bloke ng code at isang bagong rehiyon ng code;
Ang bawat code statement ay dapat magtapos sa isang semicolon.

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. Masasabi nating ang variable ay isang nakalaan na espasyo o kahon para sa paglalagay ng variable. Ang bawat variable ay may sariling uri ng data, pangalan (identifier) ​​​​at halaga. Ang mga uri ng data ay maaaring primitive, non-primitive, o reference. Ang mga primitive na uri ng data ay maaaring:

• Mga integer: byte , short , int , long
• Mga fractional na numero: lumutang at doble
• Mga halaga ng Boolean: boolean
• Mga halaga ng character (upang kumatawan sa mga titik at numero): char

Halimbawa ng mga variable sa 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 ilagay ang value 5 dito. Ang parehong kuwento sa myChar variable . Nilikha namin ito gamit ang uri ng data ng char at tinukoy ito bilang titik a . Sa kasong ito, lumikha kami ng isang variable at nagtalaga ng isang halaga dito sa parehong oras. Pinapayagan ka ng Java syntax na gawin ito sa ganitong paraan. Ang mga uri ng sanggunian ay ilang mga bagay na naglalaman 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 na nangangahulugang walang halaga. Kasama sa mga uri ng sanggunian ang String , Arrays , at anumang Klase na gusto mo. Kung mayroon kang klase ng violin ( Violin ), maaari kang lumikha ng variable para sa klase na iyon. Halimbawa ng mga variable ng uri ng sanggunian sa 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 variable ay nagsisimula sa malalaking titik, at ang mga primitive na uri ay nagsisimula sa maliliit na titik. Halimbawa:

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

Mga array sa Java

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

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

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

Mga Enum sa Java (Java Enums)

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

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

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

Isang halimbawa ng isang enumeration sa Java (Java Enum)

public class MyNum{
    public static void main(String[] args) {

        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//напечатать день из enum
}
}
enum DayOfWeek{

    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Kung patakbuhin mo ang program, ipapakita ng console ang FRIDAY. Maaari mong ilagay ang code para sa mga klase ng Enum at MyNum sa isang file, ngunit mas mainam na lumikha ng dalawang magkahiwalay na file: isa para sa klase ng MyNum at isa para sa paglilista ng mga araw ng linggo (Araw). Pinapayagan ka ng IntelliJ IDEA na pumili ng isang enum kapag nililikha ito.

Pagdedeklara ng mga Variable sa Java

Sa katunayan, nagdeklara kami ng ilang variable sa itaas at natukoy pa ang mga ito. Ang deklarasyon ay ang proseso ng paglalaan ng memorya para sa isang variable ng isang partikular na uri at pagbibigay nito ng pangalan. Isang bagay na tulad nito:

int i;
boolean boo;

Maaari din nating ideklara ang variable initialization gamit ang assignment operator ( = ). Nangangahulugan ito na naglalagay kami ng isang tiyak na halaga sa inilalaan na memorya. Magagawa natin ito nang tama sa oras ng anunsyo o mamaya.

Halimbawa ng Variable Declaration

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

Kung magdedeklara ka ng variable nang walang initialization, makakakuha pa rin ito ng ilang default na value. Para sa int ang value na ito ay 0, para sa String o anumang iba pang uri ng sanggunian ito ang espesyal na identifier null .

Mga Identifier sa Java

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

Class Violin {
int age;
String masterName;
}

Violin - identifier ng klase. ang edad at masterName ay mga variable identifier. Narito ang ilang panuntunan sa Java identifier:

• lahat ng mga identifier ay nagsisimula sa isang Latin na titik (A hanggang Z o a hanggang z), isang simbolo ng pera ($) o isang underscore (_);
• pagkatapos ng unang character, ang mga identifier ay maaaring magkaroon ng anumang kumbinasyon ng mga character;
• ang isang Java keyword ay hindi maaaring maging isang identifier (matututo ka tungkol sa mga keyword sa ibang pagkakataon);
• case sensitive ang mga identifier.

Mga halimbawa ng mga identifier

Mga wastong identifier: java, $mySalary, _something Mga di-wastong identifier: 1stPart, -one

Mga Modifier sa Java

Ang mga modifier ay mga espesyal na salita sa wikang Java na magagamit mo upang baguhin ang mga elemento (mga klase, pamamaraan, variable). Mayroong dalawang kategorya ng mga modifier sa Java: mga access modifier at iba pang mga modifier.

Mga halimbawa ng mga modifier ng access

Mayroong apat na access modifier sa Java:

• pampubliko _ Buksan ang elemento. Maaari itong ma-access mula sa loob ng klase, sa labas ng klase, sa loob at labas ng package;
• Ang isang elemento na may default na modifier - default (walang laman) - ay maaari lamang ma-access sa loob ng package;
• protektadong modifier - maaaring ma-access sa loob at labas ng package sa pamamagitan ng klase ng bata;
• pribado - ang elemento ay maa-access lamang sa loob ng klase na idineklara nito.

Mga halimbawa ng iba pang mga modifier

Mayroong pitong iba pang mga modifier (para sa mga klase, field, pamamaraan, interface, at iba pa):

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

Mga Keyword ng Java

Ang mga keyword ng Java ay mga espesyal na salita para gamitin sa Java na nagsisilbing susi sa code. Ang mga ito ay kilala rin bilang mga reserbang salita: hindi magagamit ang mga ito para sa mga identifier ng mga variable, pamamaraan, klase, atbp. Narito ang mga ito:

• abstract : keyword para sa pagdedeklara ng abstract class;
• boolean : Ang boolean na keyword sa Java ay kailangan para magdeklara ng variable ng boolean type. Ang ganitong mga variable ay maaari lamang maging totoo o mali;
• break : Ang break na keyword sa Java ay ginagamit upang masira ang loop o switch statement ;
• byte : Ang byte na keyword sa Java ay kailangan para magdeklara ng one-byte integer variable;
• case : ginamit kasama ng mga switch statement para markahan ang mga bloke ng text;
• catch: используется для перехвата исключений после блока try;
• char: ключевое слово char в Java используетсядля символьной переменной. Может содержать 16-битные символы Unicode без знака;
• class: ключевое слово class в Java нужно для объявления класса;
• continue: ключевое слово в Java для продолжения цикла;
• default: ключевое слово default в Java используется, чтобы указать блок codeа по умолчанию в операторе switch;
• do: используется в конструкции цикла do-while;
• double: ключевое слово double в Java нужно, чтобы объявить числовую переменную. Может содержать 8-byteовые числа с плавающей запятой;
• else: можно использовать в условных операторах else-if;
• enum: используется для определения фиксированного набора констант;
• extends: ключевое слово extends в Java нужно для указания на то, что класс расширяет другой класс (является дочерним классом другого класса);
• final: ключевое слово, чтобы указать, что переменная является константой;
• finally: отмечает блок codeа, который будет выполняться независимо от того, обрабатывается исключение or нет;
• float: переменная, которая содержит 4-byteовое число с плавающей запятой;
• for: ключевое слово для запуска цикла for. Он используется для многократного выполнения набора инструкций, пока выполняются некоторые условия;
• if: ключевое слово для проверки условия. Он выполняет блок, если condition истинно;
• implements: ключевое слово для реализации интерфейса;
• import: ключевое слово import в Java используется для импорта пакета, класса or интерфейса;
• instanceof: проверяет, является ли an object экземпляром определенного класса or интерфейса;
• int: переменная, которая может содержать 4-byteовое целое число со знаком;
• interface: ключевое слово interface в Java используется для объявления интерфейса;
• long: переменная, которая может содержать 8-byteовое целое число со знаком;
• native: указывает, что метод реализован в нативном codeе с использованием JNI (Java Native Interface);
• new: ключевое слово new используется в Java для создания новых an objectов;
• package: объявляет пакет (папку) Java для файлов классов Java;
• private: модификатор доступа указывает, что метод or переменная могут быть видны только в классе, в котором они объявлены;
• protected : isang access modifier na tumutukoy na ang isang paraan o variable ay maaaring ma-access sa loob at labas ng package sa pamamagitan ng child class;
• public : ang access modifier ay nagpapahiwatig na ang elemento ay naa-access kahit saan;
• return : ibinabalik ang resulta ng pamamaraan ng pagpapatupad;
• maikli : isang variable na maaaring magkaroon ng 2-byte signed integer;
• static : nagpapahiwatig na ang variable o pamamaraan ay isang klase sa halip na isang bagay o pamamaraan;
• strictfp : nililimitahan ang mga kalkulasyon ng floating point;
• super : tumutukoy sa isang bagay ng parent class;
• switch : pumipili ng isang bloke ng code (o ilan sa mga ito) na isasagawa;
• naka-synchronize : isa pang uri ng modifier. Tinutukoy nito na ang pamamaraan ay maaari lamang ma-access ng isang thread sa isang pagkakataon;
• ito : ay tumutukoy sa kasalukuyang bagay sa isang paraan o constructor;
• throw : ginagamit upang tahasang magtapon ng exception;
• throws : nagdedeklara ng exception;
• hindi maaaring serialized ang transient data fragment;
• try : nagpapatakbo ng isang bloke ng code na sinusuri para sa mga pagbubukod;
• void : ay nagpapahiwatig na ang pamamaraan ay hindi nagbabalik ng isang halaga;
• pabagu-bago ng isip : nagsasaad na ang variable ay maaaring baguhin nang asynchronously;
• habang : nagsisimula ng isang habang loop . Umuulit ng 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 hindi pinapansin ng Java compiler. Ginagamit ng mga developer ang mga ito upang ipaliwanag ang code o matandaan ang isang bagay. Mga halimbawa ng komento:

//однострочный комментарий
/*а вот многострочный комментарий. Как видите, в нем используются слеши и звездочки в начале и в конце.*/

public class HelloJava {
   /* эта программа создана для демонстрации комментариев в Java. Это многострочный комментарий.
   Вы можете использовать такие комментарии в любом месте вашей программы*/
   public static void main(String[] args) {
       //а вот однострочный комментарий
       String j = "Java"; //Это моя строка
       int a = 15; //Здесь у меня целое число
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

Literal sa Java

Ang mga literal sa Java ay mga pare-parehong halaga na itinalaga sa isang variable. Ang mga ito ay maaaring mga numero, teksto, o anumang bagay na kumakatawan sa kahulugan.

• Mga literal na integer
• Mga literal na floating point
• Mga literal na karakter
• Mga literal na string
• Boolean literals

Mga halimbawa ng literal sa Java

int i = 100; //100 – целочисленный литерал
double d = 10.2;//10.2 – литерал с плавающей точкой
char c = ‘b’; //b – символьный литерал
String myString = “Hello!”;
boolean bool = true;

Pakitandaan: literal din ang null .

Mga Pangunahing Operator sa Java

Mayroong iba't ibang uri ng mga operator: Arithmetic:

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

Mga paghahambing:

• < (mas mababa sa)
• <= (mas mababa sa o katumbas ng)
• > (higit sa)
• >= (mas malaki sa o katumbas ng)
• == (katumbas)
• != (Hindi pantay)

Panunukso ng utak:

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

Natutunan na natin ang tungkol sa mga uri ng data, variable, pamamaraan at operator. Tingnan natin ang 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 para sa pagtatrabaho sa dalawang numero. Maaari mong subukang magsulat ng pang-apat na paraan int mul(int a, int b) upang i-multiply ang dalawang numero sa program na ito. Gumawa din tayo ng klase upang ipakita kung paano gumagana ang 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 makakakuha ka ng output tulad nito:

Mga resulta

Ito ay mga pangunahing kaalaman lamang ng wikang Java, at maaari itong maging nakalilito sa simula. Kakailanganin mo ng maraming kasanayan sa programming upang makuha ito. At ito ang pinakamahusay na paraan upang matuto ng programming language - sa pamamagitan ng pagsasanay. Simulan ang programming ngayon: subukan ang unang paghahanap ng kursong JavaRush . Magsaya sa pag-aaral ng Java!