Paano Ipapatupad ang Mga Argumento ng Command Line sa Java



Tutulungan ka ng artikulong ito sa isang detalyadong kaalaman tungkol sa iba't ibang Mga Argumento ng Command Line sa Java kasama ang mga halimbawa para sa mas mahusay na pag-unawa.

Ang argumento sa linya ng utos sa Ang Java ay ang mga pagtatalo naipasa sa isang programa sa oras na pinatakbo mo ito. Ang mga ito ay naka-imbak sa format ng string at ang String array ay naipasa sa args [] na parameter ng pangunahing () pamamaraan. Malalaman natin ang higit pa sa pamamagitan ng docket na ito sa ibaba.

Unang Program sa Java

Nais mong bumuo ng isang programa sa Java upang mai-print 'Hello World' sa screen. Anong mga hakbang ang isasaalang-alang mo?





  • I-install JDK sa iyong machine.
  • Itakda landas at classpath na magagamit sa iyong machine na Variable sa Kapaligiran.
  • Buksan ang Editor (Notepad sa kaso ng Windows) at i-type sa ibaba ang programa.
klase MyFirstJavaProgram {public static void main (String [] args) {System.out.println ('Hello World')}}
  • Ngayon ay nai-save mo ang program na ito sa isang tukoy na lokasyon sabihin halimbawa C: / javaprograms /
  • Magbubukas ka ng isang Command Prompt (cmd sa kaso ng Windows) mag-navigate sa lokasyon sa itaas.

Command Line Arguments sa Java Edureka Larawan 1

  • Pinagsasama-sama mo ang iyong programa gamit ang javac tool para sa pag-iipon MyFirstJavaProgram.java sa CMD prompt



  • Ngayon nais mong patakbuhin ang iyong unang application kaya sumulat ng java MyFirstJavaProgram

  • Ikaway makakakita Kamusta Mundo kapag pinindot mo Pasok susi

Mga Argumento ng Command Line

Ang syntax ng java utos upang maglunsad ng isang application ay

Java [options] pangunahing klase [args]

Dito, mga pagpipilian ay ang mga pagpipilian sa linya ng utos tulad ng -siya, atbp. pangunahing klase ay ang pangalan ng klase na naglalaman ng pangunahing pamamaraan. Partikular, ang klase na nais mong ilunsad.



Panghuli [args] ay ang mga argumento na naipasa sa pangunahing pamamaraan. Sa aming programa, tinukoy namin ang String array bilang isang parameter. Samakatuwid maraming mga argumento ang maaaring maipasa gamit ang mga puwang.

Bilang default, ang application ng Java ay maaaring tanggapin ang anumang bilang ng mga argumento kabilang ang walang mga argumento mula sa linya ng utos. Maaari itong magamit upang tukuyin ang impormasyon ng pagsasaayos kapag ang aplikasyon ay inilunsad. Nangangahulugan iyon na ipagpalagay na hindi namin alam ang mga detalye ng pagsasaayos bago patakbuhin ang application.

Ang mga detalyeng iyon ay maaaring magamit muli sa iyong aplikasyon na hindi na kinakailangan hard-code Gayunpaman, ang impormasyon ng pagsasaayos ay maaaring ibigay sa isang character string o sa isang file. Hahadlang ba iyon sa aking Pagganap ng application?

Ang sagot ay, Hindi . Hindi ito makakahadlang sa anumang kaso sa pangkalahatang pagganap ng application. Dahil binabasa lamang namin ang file ng pagsasaayos nang sabay-sabay lamang sa pagsisimula ng aplikasyon. Sa ganitong paraan, hindi mo na kailangang muling magkumpuni ng iyong code nang paulit-ulit.

Sabihin nating, halimbawa, mayroon tayong config.properties file na kung saan ay nagkakaroon ng lahat ng mga pag-aari ng pagsasaayos sa key-halaga format Ngunit bilang isang junior developer, hindi namin alam kung saan nananatili ang file na ito kliyente lokasyon pagkatapos naming ipadala ang application.

Ano ang maaari nating sabihin na ang client ay kailangang tukuyin ang landas bilang isang argument sa application sa ibabaw ng linya ng utos.

java MyClass 'c: //path/to/config.properties'

Kapag ang MyClass ay inilunsad ang runtime system ay pumasa sa mga argument ng linya ng utos sa pangunahing pamamaraan ng application sa pamamagitan ng isang hanay ng String dito ito ay isang buong landas.

Isaalang-alang, isang simpleng programa upang maipakita ang mga entry na ginawa ng gumagamit mula sa linya ng utos ay mai-print mismo.

pampublikong klase ang MyClass {public static void main (String [] args) {para sa (String s: args) {System.out.println (s)}}}

Upang patakbuhin ang program na ito ang gumagamit ay maaaring maglagay ng input tulad ng sa ibaba.

java MyClass ' Nilikha ko ang aking unang programa. '' Ito ay kahanga-hanga . '

// Output:

Nilikha ko ang aking unang programa.
Ito ay kahanga-hanga.

Ito ay upang tandaan na ang bawat String na nakapaloob sa marka ng panipi at pinaghiwalay ng puwang ay itinuturing na isang bagong argumento. Ang bawat pagtatalo ay inilalagay sa bagong linya sanhi ng println

Paano kung nais kong pumasa ang Numero bilang mga argumento sa linya ng utos?

Upang mabasa ang mga numero dapat nating mai-parse Mga Pangangatuwiran sa Linya ng Command-Line . Ito ay sapagkat ang java ay tumatagal lamang ng isang hanay ng mga Strings bilang isang argument sa pangunahing pamamaraan nito. Samakatuwid, dapat naming baguhin ang String argument na kumakatawan sa isang bilang tulad ng '10' sa numerong halaga nito.

Kumuha tayo ng isang halimbawa sa pamamagitan ng pagbuo ng isang programa.

class SquareCalculator {public static void main (String [] args) {int firstArg if (args.length> 0) {try {firstArg = Integer.parseInt (args [0])} catch (NumberFormatException nfe) {System.out.println (“Mga Argumento” + args [0] + “dapat ay isang integer.”) System.exit (1)} System.out.println (“Square is” + firstArg * firstArg)}}}

Upang patakbuhin ang application na ito ginagamit namin sa ibaba linya

java SquareCalculator 10

kung paano gumawa ng kapangyarihan sa sawa

// Output:

Ang parisukat ay 100

Mga Argumento ng Command Line sa isang IDE

Ang kagandahan ay nakasalalay sa parse Int na pamamaraan sa klase ng Integer. Ang bawat mga klase sa Bilang tulad ng Integer, Float, Double at iba pa ay mayroon parseXXX pamamaraan na nagko-convert sa String sa kani-kanilang bagay ng kanilang uri.

Tulad ng alam nating lahat na ang array ay nagsisimula sa index nito na may zero. Samakatuwid args [0] ay ang unang index dito String [] array na kung saan ay kinuha mula sa console. Katulad din args [1] pangalawa, args [2] ang pangatlong elemento at iba pa.

Kapag ang isang application ay inilunsad, ang run-time ipinapasa ng system ang mga argumento ng linya ng utos sa pangunahing pamamaraan ng aplikasyon sa pamamagitan ng isang hanay ng Mga String.

Paano namin ipinapasa ang Command Line Argument gamit ang eclipse IDE?

  • Lumikha ng isang klase dito na pinangalanan ko ang aking klase bilang Pangunahin
  • Ngayon mag-right click at mag-click sa Patakbuhin ang Configuration
  • Pumili ka Mga Pangangatwiran Tab at ipasok halaga sa ilalim Mga Argumento ng Programa tab
  • Ipasok ang anumang halagang naisulat ko Kamusta Mundo upang paghiwalayin ang dalawang argument na ginamit ko puting-puwang.
  • Mag-click sa mag-apply at pagkatapos ay sa Takbo
  • Ang iyong output ay magiging

// Output:

Kamusta Mundo

Narito ang mga bagay na dapat tandaan ay ang puting-puwang ay upang paghiwalayin ang dalawang mga pagtatalo sa bawat isa at hindi para sa layuning representasyon.

Ito ang pangunahing paggamit ng mga argument ng linya ng utos para sa mas advanced na paggamit ng CLA maaari naming itong magamit sa pamamahala ng Diagnostic para sa Hot-Spot Virtual Machine. Maaari ring ibigay ang Virtual Machine na may Mga Argumento ng Command Line gamit ang Opsyon ng Virtual Machine para sa Hot-Spot Diagnostic na maaaring magamit kapag nais mong humingi ng anumang bean mula sa Koneksyon ng Server. Iyon ay pagkain para sa pag-iisip!

Sa pamamagitan nito, natapos namin ang artikulong 'Mga linya ng Command Line sa Java' na artikulo. Inaasahan kong naiintindihan mo ang mga argumento ng Command Line sa Java at ang pagpapatupad nito sa pamamagitan ng ilang mga halimbawa ng real-time.

Ngayon na naintindihan mo Mga argumento ng Command Line mga pangunahing kaalaman sa pamamagitan ng artikulong ito suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang mga kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring .

May tanong ba sa amin? Nabanggit ito sa seksyon ng mga komento ng artikulong 'Command Line arguments in Java' na artikulo at babalikan ka namin sa lalong madaling panahon.