Mahusay na Pag-unlad ng Java para sa Raspberry Pi: 11 Hakbang (na may Mga Larawan)

2025 May -akda: John Day | [email protected]. Huling binago: 2025-01-23 15:12

Inilalarawan ng Instructable na ito ang isang napakahusay na diskarte para sa pagbuo ng mga programa ng Java para sa Raspberry Pi. Ginamit ko ang diskarte upang paunlarin ang mga kakayahan ng Java mula sa mababang antas ng suporta sa aparato hanggang sa maraming programa at batay sa network na mga programa. Ang diskarte ay hindi lamang mahusay, ito ay libre!

Sa panimula, ang diskarte ay malayong pagpapaunlad gamit ang NetBeans. Ang NetBeans ay tumatakbo sa isang workstation (isang desktop o laptop computer, hindi ang Raspberry Pi) na konektado sa pamamagitan ng Wifi sa Raspberry Pi. Kapag naayos nang maayos ang lahat, maaari kang magsulat ng isang programa sa Java sa NetBeans at pagkatapos ay isang solong pag-click ang nag-iisa at nagtatayo ng programa sa workstation, na-download ang programa sa Pi, pinapatakbo ang programa sa Pi, at naghahatid ng output sa NetBeans console. Magic! Maaari mo ring i-debug ang tumatakbo na programa, magtakda ng mga breakpoint at suriin ang mga variable na halaga. Higit pang mahika!

Ang natitirang pagpapakilala na ito ay naglalarawan ng pagganyak para sa paggamit ng Java at para sa malayuang pag-unlad gamit ang NetBeans. Kung nagmamalasakit ka sa pagganyak, basahin ang. Kung wala kang pakialam, pumunta sa hakbang 1.

Bakit gagamitin ang Java sa Raspberry Pi?

Mayroong maraming mga wika ng programa na magagamit para sa Raspberry Pi, ngunit lilimitahan ko ang talakayan sa "mga propesyonal na marka" na mga wika sa programa na nagta-target ng mga standalone na programa, sinusuportahan ang multi-tasking, pinapayagan ang pag-access ng hardware at network, atbp. Nangangahulugan iyon ng Java, Python, o C / C ++. Ang pinakahuling paglabas ng Raspbian ay may kasamang pag-unlad at suporta sa runtime para sa lahat ng mga wikang ito.

Ang Python ay may bisa na "isinulong" para magamit sa Pi, kahit papaano para sa madaling pag-aaral para sa mga bagong programmer. Ako ay may karanasan na programmer at hindi ako mahilig sa Python dahil sa isang tinatanggap na hindi ayon sa paksa na ayaw sa isang bilang ng mga katangian nito, halimbawa, pabagu-bagong pagta-type. Mayroong isang katangian ng Python kung saan ang aking ayaw ay layunin - pagganap. Ipinapakita ng mapagkukunang ito na ang Java ay palaging mas mabilis kaysa sa Python 3, at sa katunayan ay maaaring magpatakbo ng daan-daang beses nang mas mabilis, depende sa gawain.

Ang C sa palagay ko, ay isang "mataas na antas ng wika ng makina", ibig sabihin, isang bagay na napakalapit sa hardware ng system, o hindi bababa sa operating system. Maaari mong magawa ang anuman, at magagawa mo ito nang mas mabilis hangga't maaari; sa katunayan, nagmumungkahi ang mapagkukunang ito na ang C ay maaaring tumakbo hanggang sa 7X na mas mabilis sa Java. Hindi rin ako mahilig sa C dahil hindi ko gusto (ayon sa paksa) ang ilan sa mga katangian nito na nakikita kong arcane, archaic, o pareho; halimbawa, mga detalyadong pahiwatig. Sa layunin, ang katotohanang makakagawa ka ng anumang bagay ay nangangahulugang ikaw ay isang nakakubli na bug (hal., Masamang pointer arithmetic o isang nagkakamali na memcpy) na malayo sa pag-o-overtake ng memorya at potensyal na pag-crash ng programa o kahit na sa buong system. Pinipigilan ng Java ang mga naturang peligro, kaya mas ligtas ang Java. Pakiramdam ko ang kaligtasan ay nagpapabuti din ng pagiging produktibo ng programmer. Isaalang-alang ko ang C ++ isang "balot" na nakatuon sa object sa paligid ng C na walang ginagawa upang maalis ang mga panganib ng C.

Sa ilalim na linya: Ang Java ay mas mabilis kaysa sa Python. Ang Java ay mas ligtas kaysa sa C.

Mayroon bang mga limitasyon kapag gumagamit ng Java?

Sa ngayon, nagawa ko ang lahat sa Java na magagawa ko sa Python. May mga bagay na magagawa ang isa sa C na hindi magagawa ng isa sa Java, ngunit muli, hanggang ngayon lahat ng nais kong gawin ay hinarap ng mga tagahanga ng Java sa komunidad ng Pi. Mag-aalok ako ng isang halimbawa sa susunod na hakbang. Sinabi nito, bumili ako ng mga sensor mula sa mga nagtitinda na nagtustos ng mga "driver" para sa mga sensor lamang sa Python (o C / C ++ para sa Arduino), kaya't kailangan kong isulat ang katumbas ng Java; ang labis na pagsisikap ay hindi kinakailangang produktibo, ngunit maaaring magresulta sa mas malawak na pananaw sa pagpapatakbo ng isang sensor.

Bakit malayuang pag-unlad batay sa NetBeans?

Nalaman ko na ang NetBeans-based na pag-unlad na malayo ay nagdaragdag ng pagiging produktibo kapag gumagamit ng Java para sa Raspberry Pi. Tiwala ako na magagamit mo ang diskarte upang lumikha ng mabilis at ligtas na mga programa, dahil sa mga likas na katangian ng Java, habang ang pagsusulat, pagbuo at pag-debug sa kanila nang mas mabilis kaysa sa iba pang mga diskarte na nakita ko, dahil sa malayuang pag-unlad gamit ang "propesyonal grade "NetBeans Integrated Development Environment (IDE).

Maaaring maging kapaki-pakinabang upang talakayin nang maikli ang mga "ibang diskarte". Natutugunan ng lahat ang pangunahing pamantayan na ang Raspberry Pi ay walang keyboard, mouse, o display na konektado. Maraming mga kadahilanan para sa pamantayan na ito, ngunit ang aking pangunahing dahilan ay ang pagbuo ko ng mga mobile robot, at hindi ko nais ang Pi na konektado sa anumang mga peripheral maliban sa mga robotic subsystem, kahit na sa panahon ng pag-unlad.

Ang server ng VNC na kasama sa Raspbian ay nagbibigay ng isang remote na grapiko na interface ng gumagamit (GUI) na nagbibigay-daan sa isang uri ng malayuang pag-unlad, kung saan ang remote na GUI lamang ang tumatakbo sa workstation at lahat ng iba pa, ang pagsusulat, pag-iipon at pagbuo, ay nagaganap sa Pi. Sa VNC madaling gamitin ang mga tool sa pag-unlad na may kakayahang Java na ipadala sa Raspbian, tulad ng BlueJ, Geany, at Greenfoot. Ang ilan sa mga ito ay maaaring maituring na isang IDE; gayunpaman, nahanap ko sila malayo sa marka ng propesyonal.

Posibleng teknikal na mag-install ng isang propesyonal na grade Java IDE tulad ng Eclipse o NetBeans sa Raspberry Pi at gamitin ito mula sa malayo sa pamamagitan ng VNC. Ang mga ulat, at sentido komun, ay nagmumungkahi na ang mga resulta ay magiging nakakabigo, dahil sa malaking memorya ng paa at CPU power tulad ng mga IDE na kinakailangan, pati na rin latency ng network na ipinakilala ng isang remote na GUI.

Ang parehong Eclipse at NetBeans ay tumatakbo nang mahusay sa isang workstation. Sa Eclipse, ang pagsulat ng code ay isang kaaya-ayang karanasan, subalit, ang pagbuo ng programa ay hindi; ang pag-download ng programa ay dapat maganap sa labas ng Eclipse; ang pagpapatupad ng programa sa Pi ay ganap na independiyente sa Eclipse. Ang pangkalahatang resulta ay isang multi-step, halos masakit, proseso na hindi maaaring suportahan ang remote debugging. Ang NetBeans ay may built-in na compile, build, download, remote execution, at remote debug, ginagawa itong isang superior diskarte.

Hakbang 1: I-set up ang Raspberry Pi

Upang magamit ang remote na diskarte sa pag-unlad dapat kang magsimula sa pamamagitan ng pag-set up ng target na Raspberry Pi. Mayroong maraming mga mapagkukunan, kabilang ang Mga Instructionable, na magagamit upang makatulong sa pag-set up ng isang Raspberry Pi. Tingnan ito para sa mga pangunahing kaalaman sa pag-set up ng Pi (at higit pa).

Ipinapalagay sa iyo ng Instructable na ito

• i-install ang pinakabagong Raspbian; tiyaking naitala mo ang Pi user ID at password
• i-set up ang Wifi at kumonekta sa iyong router (tingnan ito); tiyaking naitala mo ang IP address ng Pi
• paganahin ang SSH (tingnan ito) upang payagan ang malayuang pag-access sa Pi mula sa workstation

Kapag nakumpleto mo na ang pag-set up, maaari mong i-power down at idiskonekta ang display, ang keyboard, at ang mouse mula sa Pi. Ito ay isa sa mga pangunahing bentahe sa malayuang pag-unlad. Dapat mong iwanan ang anumang koneksyon sa Wifi dongle (hindi kinakailangan, syempre, para sa isang modelo ng Pi na 3 o Pi Zero W), at pagkatapos ay maaari mong paganahin ang Pi.

Upang subukan, buksan ang isang ssh client sa iyong workstation, hal., Terminal sa MacOS o masilya sa Windows. Pagkatapos ay ipasok ang utos ng ssh (secure shell) na may sumusunod na form:

ssh the_pi_ip_address -l the_pi_user_id

Dapat kang makakuha ng isang prompt upang ipasok ang password ng iyong Pi user ID. Kung walang lilitaw na prompt, suriin upang matiyak na naipasok mo ang tamang IP address sa ssh command. Ipasok ang iyong password (maitago ito) at dapat mong makita ang prompt ng shell ng Pi na lilitaw ng isang bagay tulad nito:

pi @ raspberrypi: ~ $

Kung hindi mo nakikita ang prompt, suriin ang ginamit na ID ng gumagamit at password.

Ngayon ay dapat mong hanapin ang landas sa runtime ng Java at kumpirmahin ang default na bersyon ay Java 8 (dapat na totoo para sa pinakabagong Raspbian). Upang hanapin ang landas ng runtime ng Java, sa ssh client ipasok ang utos

sudo update-alternatives - Ipakita ang java

Dapat mong makita ang isang tugon sa unang dalawang linya na katulad ng sumusunod:

java - auto mode

ang pinakamahusay na bersyon ng link ay / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java

Ang "-8-" sa pangalawang linya ay nagpapatunay na ang default na runtime ay Java 8. Itala ang landas sa pangalawang linya dahil kakailanganin mo ito upang i-configure ang NetBeans para sa malayuang pag-unlad sa isang susunod na hakbang.

Kung ang default na runtime ay hindi Java 8, sa ssh client ipasok ang sumusunod na utos upang lumipat sa Java 8 (ipagpalagay na naka-install ito)

sudo update-alternatives --config java

Hakbang 2: I-install ang NetBeans sa Workstation

Ngayon ay kailangan mong i-install ang NetBeans sa iyong workstation. Ituro ang iyong browser ng workstation sa pahina ng pag-download ng NetBeans. Makakakita ka ng maraming mga posibleng bundle na sumusuporta sa dalawang edisyon ng Java pati na rin ang iba pang mga wika. Ang kailangan mo lang para sa pag-unlad ng Java para sa Raspberry Pi ay Java SE, ngunit maaari mong makuha ang Java EE bundle o ang All bundle. Kapag napagpasyahan mo kung aling bundle ang gusto mo i-click ang kaukulang pindutan ng Pag-download. Maaari kang makahanap ng mga karagdagang tagubilin sa pag-install para sa iyong workstation OS dito.

Kapag na-install mo ang NetBeans, simulan ito (maaari itong gawin nang awtomatiko pagkatapos ng pag-install). Dapat mong makita ang pangunahing window ng NetBeans tulad ng ipinakita sa larawan. Ang larawan ay nakunan sa isang Mac, at ang pangunahing window ay maaaring magmukhang medyo magkakaiba sa Windows.

Kapag matagumpay mong na-install at nasimulan ang NetBeans, magpatuloy sa susunod na hakbang.

Hakbang 3: I-configure ang Raspberry Pi Bilang isang Remote Platform sa NetBeans

Ang mga sumusunod na pagkilos ay nag-configure ng Raspberry Pi bilang isang remote Java SE platform para sa NetBeans. Pinapayagan nito ang NetBeans na mag-download at magpatupad ng mga programang Java sa Pi. Maaari kang makahanap ng isang medyo pangkalahatang paglalarawan dito.

TANDAAN: Sa ito at mga sumusunod na hakbang, nagpapakita ako ng mga halagang tiyak sa aking kapaligiran para sa iba't ibang mga aspeto ng pagsasaayos at pag-coding; ang iyo ay malinaw naman na magkakaiba.

Upang mai-configure ang Pi bilang isang malayuang platform:

1. Sa pangunahing menu bar ng NetBeans, piliin ang Mga Tool -> Mga Java Platform. Makikita mo ang window ng popup ng Java Platform Manager (isang larawan).
2. I-click ang Magdagdag ng Platform sa ibabang kaliwa. Makikita mo ang popup na Magdagdag ng Java Platform [uri ng platform] (larawan dalawa).
3. Piliin ang Remote na Java Standard Edition. Mag-click sa Susunod. Makikita mo ang Magdagdag ng Java Platform [i-set up ang malayuang platform] na popup (larawan tatlong ipinapakita ang popup pagkatapos kong ipasok ang wastong mga halaga para sa aking kapaligiran sa mga patlang).
4. Sa patlang ng Pangalan ng Platform maglagay ng isang pangalan para sa Pi. Maaari kang gumamit ng halos kahit ano, ngunit dapat itong maging natatangi.
5. Sa patlang ng Host ipasok ang IP address para sa Pi na matatagpuan sa hakbang 1.
6. Sa patlang ng Username ipasok ang pangalan ng gumagamit na ginamit mo sa hakbang 1.
7. Iwanan ang Paggamit ng Pagpapatotoo ng Password na napili at sa patlang ng Password ipasok ang password na iyong nilikha sa hakbang 1.
8. Sa patlang na Remote na JRE Path dapat mong ipasok ang karamihan ng mga landas sa runtime ng Java sa Pi. Sa hakbang 1, ito ay / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java. Gayunpaman dapat mong ihulog / bin / java ang halaga ng patlang.
9. Ang NetBeans ay nagda-download ng napapatakbo na programa sa isang gumaganang direktoryo sa Pi, na kinilala sa patlang ng Working Dir. Ang default ay / the_Pi_user_ID / NetBeansProjects / at perpektong katanggap-tanggap ito. Maaari kang gumamit ng ibang bagay kung nais mo, bagaman dapat itong magamit sa_Pi_user_ID (larawan tatlo).
10. I-click ang Tapusin sa kanang kanang ibaba ng popup. Pagkatapos ng pagproseso, dapat mong makita muli ang window ng popup ng Java Platform Manager. Ngayon ay dapat mong makita ang iyong remote Pi (sa ilalim ng pangalang ginamit mo sa aksyon 4 sa itaas) sa ilalim ng kategoryang Remote Java SE (larawan apat).
11. I-click ang Test Platform sa ibabang kaliwa upang masubukan ang koneksyon sa pagitan ng NetBeans at ng iyong Pi. Makikita mo muna ang isang popup na nagsasabi ng Pag-verify ng Remote Platform. Kung matagumpay, makakakuha ka ng isang pangalawang popup na nagpapahiwatig ng Koneksyon … matagumpay na naitatag. Kung hindi, kailangan mong suriin at iwasto ang impormasyong inilagay mo sa Magdagdag ng Java Platform [i-set up ang malayuang platform] na popup sa mga pagkilos 5-9 sa itaas. Maaari mo itong gawin mula sa popup ng Java Platform Manager; piliin lamang ang iyong Pi platform at pagkatapos ay i-edit ang mga patlang sa kanang bahagi ng popup.
12. Matapos ang isang matagumpay na koneksyon, i-click ang Isara sa popup ng Java Platform Manager. Makikita mo ngayon ang pangunahing window ng NetBeans.

Ngayon ay maaaring magsimula ang totoong kasiyahan!

Hakbang 4: Lumikha ng isang Java Project sa Workstation

Hindi ito inilaan upang maging isang buong paliwanag kung paano gamitin ang NetBeans, o Java, ngunit ilalarawan ko ang kaunting mga pagkilos upang magsulat ng isang programa sa NetBeans sa workstation at, sa kalaunan, patakbuhin ang program mula sa malayo sa Raspberry Pi.

Sa NetBeans dapat mo munang lumikha ng isang proyekto upang hawakan ang Java class (es) para sa programa. Dagdag dito, sa Java, ang mga klase ay naninirahan sa mga pakete upang suportahan ang samahan at seguridad. Upang likhain ang proyekto at opsyonal na lumikha ng isang pakete at isang klase ng file:

1. Sa pangunahing window ng NetBeans, i-click ang bagong icon ng proyekto (ika-2 mula sa kaliwa). Makikita mo ang Bagong Project [pumili ng proyekto] na popup (isang larawan).
2. Ang mga default (kategorya: Java, Project: Java Application) ay tama para sa halimbawang ito, kaya i-click lamang ang Susunod. Makikita mo ang popup ng Bagong Application ng Java [pangalan at lokasyon] na popup (larawan sa dalawang nagpapakita ng mga halaga para sa aking halimbawa). TANDAAN: Na-redact ko ang impormasyon ng aking gumagamit gamit ang mga may kulay na mga parihaba.
3. Sa patlang ng Pangalan ng Proyekto, maglagay ng wastong pangalan ng proyekto ng Java na iyong pinili. Ang pangalan ay dapat magsimula sa isang malaking titik, at ang kombensiyon ay nagmumungkahi ng kaso ng kamelyo kapag nagkakasabay na mga salita.
4. Kinokontrol ng patlang ng Lokasyon ng Proyekto kung saan naninirahan ang proyekto sa iyong file system. Ang default ay nag-iiba depende sa operating system, ngunit ligtas itong tanggapin.
5. Pinapayagan ka ng patlang ng Folder ng Project na kontrolin ang pangalan ng folder para sa proyekto. Mas mahusay kong nahanap na gamitin ang default, na kung saan ay isang pagsasama ng patlang ng Lokasyon at ang patlang ng Pangalan.
6. Kapag ang checkbox na Lumikha ng Pangunahing Klase ay nasuri ang NetBeans awtomatikong lumilikha ng isang pakete at isang pangunahing file ng klase (isang programa na maaaring patakbuhin mula sa linya ng utos) na may parehong pangalan ng proyekto. Sa palagay ko kadalasan dapat itong ma-check, ngunit sa kasong ito, iiwan ko itong naka-check kung saan tinatanggal ang mga tahasang aksyon kung hindi kinakailangan na gawin ito (larawan dalawa).
7. I-click ang Tapusin upang likhain ang proyekto, isang pakete at isang pangunahing file ng klase. Ngayon sa kaliwang tuktok na pane ng pangunahing window ng NetBeans ay ipinapakita ang iyong proyekto, na naglalaman ng isang solong pakete, na kung saan ay naglalaman ng isang solong file ng klase na may pangunahing () pamamaraan. Naglalaman ang kanang tuktok na pane ng default na code ng mapagkukunan para sa pangunahing klase (ang programa) na awtomatikong nabuo ng NetBeans (larawan tatlo).

Sa puntong ito, maaari kang magsulat ng ilang code sa pangunahing pamamaraan at patakbuhin ito sa workstation. Maaaring kanais-nais iyan sa mga oras, ngunit hindi kinakailangan para sa Maituturo na ito, kaya magpatuloy sa susunod na hakbang.

Hakbang 5: I-configure ang NetBeans Project upang Patakbuhin ang Malayo sa Raspberry Pi

Upang mai-configure ang proyekto ng NetBeans, at isang program na naglalaman nito, upang mapatakbo nang malayuan sa Raspberry Pi, gawin ang sumusunod:

1. Pag-click sa kanan o 2-daliri (nakasalalay sa OS ng workstation) sa proyekto sa pane ng Mga Proyekto ng pangunahing window ng NetBeans upang ilabas ang menu ng proyekto at i-click ang Properties. Makikita mo ang popup ng Mga Katangian ng Proyekto (ipinapakita ng larawan ang popup na may tamang mga halaga para sa aking halimbawa).
2. Sa ilalim ng Mga Kategorya sa kaliwa, piliin ang Run.
3. Mag-click Bago sa kanan ng patlang ng Pag-configure. Sa nagresultang Lumikha ng Bagong Pag-configure na popup, magpasok ng isang pangalan para sa pagsasaayos at i-click ang OK. Ang pangalan ay maaaring maging anumang; Ginamit ko lang ulit ang pangalan ng platform ("My Pi"). Muli mong makikita ang popup ng Mga Properties ng Proyekto.
4. I-click ang dropdown na icon sa kanan ng patlang ng Runtime Platform. Mula sa listahan sa popup, piliin ang remote platform na nilikha mo nang mas maaga (sa aking kapaligiran, "My Pi").
5. Mag-click sa OK upang i-set up ang remote platform para sa proyekto. Muli mong makikita ang pangunahing window.

Handa ka na ngayon upang sumulat ng code at patakbuhin ang program mula sa malayuan.

Hakbang 6: Sumulat ng isang Programang Java sa Workstation at Patakbuhin Ito sa Raspberry Pi

Ang kanang panel sa pangunahing window ng NetBeans ay ipinapakita ang pangunahing file ng klase na nabuo ng NetBeans. Mag-type ng isang simpleng pahayag sa pag-print sa pangunahing pamamaraan ng file ng klase (larawan isa). Ngayon ay isang kumpletong programa ng Java na gumagawa ng isang bagay, kahit na isang bagay na napaka-simple.

Upang patakbuhin ang programa sa Pi, i-click ang Run icon (ang berdeng kaliwang-hintong arrow) sa pangunahing window. Pinagsasama-sama ng NetBeans ang code, nagtatayo ng isang file ng garapon, na-download ang file ng garapon sa Raspberry Pi na kinilala ng remote platform, isinasagawa ang programa sa Pi, kinukuha ang output (System.out) ng programa, at nag-echo ng output sa NetBeans Output pane sa kanang ibabang bahagi ng pangunahing window (larawan dalawa).

Napalawak mo ngayon ang iyong hanay ng kasanayan para sa pagbuo ng mga proyekto sa Raspberry Pi! Ngunit sandali…. Meron pa!

Hakbang 7: I-debug ang Program sa Java Sa Mga NetBeans

Ang isa sa pinakamakapangyarihang tampok ng isang pang-industriya na lakas Integrated Development Environment tulad ng NetBeans ay ang kakayahang i-debug ang programa habang tumatakbo. Pinapayagan ka ng NetBeans na magamit ang buong suite ng mga tool sa pag-debug habang tumatakbo nang malayuan. Kasama rito ang pagtatakda ng mga breakpoint sa "mahalagang" o "mahirap" na mga lokasyon sa programa at sinusuri ang halaga ng mga variable sa kasalukuyang estado ng pagpapatupad.

Ang simpleng programa sa huling hakbang ay masyadong simple upang maipakita ang pag-debug, kaya nagdagdag ako ng ilang karagdagang code sa programa. Ang karagdagang code ay nagdaragdag ng dalawang mga variable.

Upang magamit ang mga tool sa pag-debug, dapat mo munang magtakda ng isa o higit pang mga breakpoint. Upang magtakda ng isang breakpoint, mag-click sa linya ng numero kung saan mo nais na suspindihin ang pagpapatupad; lilitaw ang isang pulang icon na parihaba, at ang buong linya ay nakakakuha ng isang pulang background (larawan isa).

Upang ma-debug ang programa na tumatakbo sa Pi, i-click ang icon ng Pag-debug (kaagad sa kanan ng icon na Run) sa pangunahing window ng NetBeans. Tulad ng normal na pagpapatupad, ang NetBeans ay nag-iipon, nagtatayo, nagda-download, nagpapatupad, nakakakuha ng output, at nag-echo ng output. Ngunit sa pag-debug, pinahinto ng NetBeans ang pagpapatupad sa mga breakpoint at pinapayagan kang suriin ang estado ng pagpapatupad (larawan dalawa, ipinapakita ang mga variable ng pane sa ibabang kanan).

Ang pagpapatupad ay humihinto sa breakpoint bago isagawa ang tagubilin sa linya na may breakpoint. Ipinapahiwatig ng berdeng background ang susunod na pahayag na naisakatuparan. Kaya sa aking halimbawa, na may isang breakpoint sa linya 9, ang variable a ay wala pa, mas kaunti ang may halaga.

I-hover ngayon ang cursor sa icon ng menu ng pag-debug sa pangunahing window (ang unang dobleng arrow-down na icon sa kanan ng icon ng Pag-debug) at i-click ang Hakbang na Over icon (mayroon itong isang asul na dokumento sa likuran at isang berdeng pabaliktad na arrow sa harapan). [TANDAAN: kung gagawin mong sapat ang malawak na pangunahing window ng iyong NetBeans, lalawak ang menu ng pag-debug at ang mga icon ng pagkilos na pag-debug ay makikita sa kanan ng icon ng Debug.] Isinasagawa ng NetBeans ang pahayag sa breakpoint at ihihinto ang pagpapatupad bago ang susunod na pahayag. Makikita mo ngayon na ang variable na mayroon at mayroong inaasahang halaga (larawan tatlo).

I-click ang Hakbang Higit sa icon ng dalawang beses. Makikita mo na ang lahat ng tatlong mga variable ay may mga halaga; tandaan na ang c ay zero pa rin (larawan apat).

I-click ang icon na Hakbang Higit sa isang beses. Makikita mo na ang variable c ngayon ay may tamang halaga, ibig sabihin, ang kabuuan ng mga variable a at b (larawan limang).

Sa wakas, sa menu ng pag-debug, i-click ang icon na Run (isang berdeng bilog na may puting arrow). Na sanhi ng pagpapatuloy na magpatuloy sa susunod na breakpoint, o sa pagtatapos ng programa, alinman ang mauna. Ngayon ang pane ng Output ay lilitaw at nagpapakita ng parehong output tulad ng sa normal na pagpapatupad, sa kasong ito ang teksto sa pahayag na naka-print.

Hakbang 8: Ipatupad ang Program Independent ng NetBeans

Maaaring dumating ang oras na nais mong ipatupad ang iyong programa sa Raspberry Pi, nang walang "tulong" o "panghihimasok" mula sa NetBeans. Ito ay napaka-simple. Una, buksan ang isang ssh client sa iyong Pi.

Tandaan mula sa hakbang 3 na inilalagay ng NetBeans ang iyong garapon ng proyekto sa isang gumaganang direktoryo sa Pi. Ang default na base ay / home / pi / NetBeansProjects para sa pi ng gumagamit. Ang tukoy na direktoryo ay may parehong pangalan sa iyong proyekto. Inilalagay ng NetBeans ang garapon sa isang subdirectory na tinatawag na dist. Para sa aking halimbawa, ang buong landas ay / home / pi / NetBeansProjects / MyRemoteProg / dist. Sa ssh client sa Pi, upang maipatupad ang programa maaari mong gamitin ang java command na may pagpipiliang 'jar':

java -jar /home/pi/NetBeansProjects/MyRemoteProg/dist/MyRemoteProg.jar

Makikita mo ang mga resulta ng pagpapatupad sa ssh client; sa aking halimbawa, ang output ay magiging

Kamusta mula sa Raspberry Pi!

Gumagana ito dahil ang impormasyon sa jar file ay tumutukoy kung aling pangunahing uri ng garapon ang naisasagawa.

Maaari mo ring baguhin ang gumaganang direktoryo (sa pamamagitan ng cd) sa lokasyon ng jar file at pagkatapos ay maglabas ng isang mas maikling utos upang makabuo ng parehong mga resulta.

java -jar MyRemoteProg.jar

Hakbang 9: Bumuo at Mag-download, Ngunit Hindi Maipatupad ang Program Sa Pamamagitan ng NetBeans

Mayroong mga sitwasyon kung saan mo nais ang NetBeans na bumuo at mag-download ng iyong programa, ngunit hindi ito isagawa. Ang isang ganoong sitwasyon ay nangyayari kapag ang iyong programa ay nangangailangan ng input ng keyboard. Kung ito ang kaso, gamit ang pamamaraan sa nakaraang hakbang, sa sandaling bumuo ka at mag-download, ang programa ay nagpapatupad sa Raspberry Pi at sa gayon ay asahan ang pag-input ng keyboard mula sa Pi, ngunit syempre, walang keyboard na nakakabit sa Pi, kaya't nabitin ang programa - hindi maganda.

Kailangan mong gumamit ng isang medyo magkaibang pamamaraan upang maipatupad ang programa. Sa panimula, lumikha ka ng isang "dummy" pangunahing file ng klase na mahalagang walang ginagawa, at kilalanin ito bilang programa na naisakatuparan pagkatapos ng pag-download. Sa kasong ito, ang "dummy" ay naisakatuparan, at pagkatapos ay maaari mong patakbuhin ang iyong "totoong" programa nang direkta sa Pi.

Upang magamit ang diskarteng ito, lumikha muna ng isang bagong pangunahing klase:

1. Ilabas ang menu ng proyekto tulad ng hakbang 5 at i-click ang Bago-> Pangunahing Klase ng Java. Makikita mo ang popup ng New Java Main Class.
2. Sa patlang ng Pangalan ng Klase maglagay ng isang pangalan. Ang pangalan ay maaaring maging anumang nais mo; Gumamit ako ng "Dummy". Pinapayagan ka ng patlang ng Package na kilalanin ang package ng klase; pipiliin mo ang package gamit ang dropdown sa kanan ng patlang. Ang klase ay maaaring nasa parehong pakete ng iyong "totoong" programa o sa ibang pakete; Inilagay ko ang bagong klase sa parehong pakete. I-click ang Tapusin. Makikita mo ngayon ang pangunahing window ng NetBeans kasama ang bagong file sa kanang tuktok na panel (isang larawan). Nagdagdag ako ng isang simpleng pahayag sa pag-print tungkol sa pagtakbo sa Pi, ngunit wala talagang kailangan.

Upang patakbuhin ang "Dummy" pagkatapos ng pag-download dapat mong gawin itong "pangunahing klase upang maipatupad bilang default" para sa proyekto:

1. Buksan ang Mga Katangian sa Proyekto tulad ng hakbang 5. Piliin ang kategorya ng Run. I-click ang Mag-browse sa kanan ng patlang ng Pangunahing Klase. Makikita mo ang pag-browse ng Pangunahing Mga Klase na popup (larawan dalawa).
2. Piliin ang klase na "Dummy". I-click ang Piliin ang Pangunahing Klase. Muli mong makikita ang Project Properties.
3. Mag-click sa OK. Babalik ka sa pangunahing window.

Ngayon kapag na-click mo ang Run icon, sumusunod ang NetBeans / binubuo ang buong proyekto, na-download ang garapon na naglalaman ng lahat ng mga file ng klase sa Pi, at ipinatupad ang klase na "Dummy" (larawan tatlong).

Upang maipatupad ang iyong totoong programa sa Pi, dapat mo na ngayong gamitin ang utos ng java na may pagpipiliang 'classpath', na hinihiling na malinaw mong kilalanin ang pangunahing klase upang maipatupad. Mula sa isang ssh client pumunta sa direktoryo ng dist para sa iyong proyekto. Ang tamang utos ay ang form:

java -cp project_name.jar package_name.class_name

Malinaw na ang proyekto_name ay tumutukoy sa proyekto; nagbabago lamang iyon kapag nakikipag-usap sa isang bagong proyekto. Ang package_name ng kurso ay tumutukoy sa package, at ang class_name ay tumutukoy sa pangunahing klase upang maipatupad. Tulad ng sinabi kanina, ang isang proyekto ay maaaring maglaman ng maraming mga pakete. Katulad nito, ang isang pakete ay maaaring maglaman ng maraming mga klase, at lahat ay maaaring pangunahing mga klase, o mga programa, na maaaring maisagawa mula sa linya ng utos. Kaya, ang diskarteng 'classpath' ay lubos na kapaki-pakinabang para sa pagbuo ng sopistikadong mga programa na may maraming mga klase, na ang ilan ay pangunahing mga klase lamang upang makatulong sa pagsubok ng yunit.

Ang sumusunod na utos ay nagpapatupad ng aking halimbawa ng programa:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Hakbang 10: Pagkuha ng Pamamahala sa NetBeans Library

Ang isa sa pinakamahirap ngunit pinakamahalagang aspeto ng sopistikadong mga programa ay ang pagharap sa mga aklatan, ibig sabihin, ang code na nakasulat na ng iba pa. Ang NetBeans ay gumagawa ng isang kahanga-hangang trabaho ng pag-alis ng karamihan sa sakit ng pamamahala ng library.

Gagamitin ko bilang isang halimbawa Pi4J, na nagbibigay sa mga program ng Java ng pag-access sa Raspberry Pi GPIO, I2C bus, at iba pang hardware na I / O. Ang Pi4J ay isang halimbawa lamang ng suporta para sa paggawa ng maraming kasiyahan sa Pi sa Java.

Dapat mo munang i-download ang library sa iyong workstation. Tingnan ang pahina ng pag-download ng Pi4J. Dahil hindi mo mai-install ang Pi4J sa Pi, i-download ang zip sa iyong workstation. Maaari mong o hindi maikli na malinaw na mag-unzip kapag na-download na ang zip.

Ngayon ay dapat kang lumikha ng isang "pandaigdigang silid-aklatan" sa NetBeans:

1. Sa pangunahing menu ng NetBeans, i-click ang Mga Tool -> Mga Aklatan. Makikita mo ang popup ng Ant Library Manager (isang larawan).
2. Mag-click sa Bagong Library sa kaliwang bahagi sa ibaba. Makikita mo ang popup ng Bagong Library (larawan dalawa).
3. Mag-type ng isang makabuluhang pangalan na nais mong gamitin at i-click ang OK. Muli mong makikita ang popup ng Ant Library Manager. Ipinapakita nito ngayon ang bagong silid-aklatan na iyong nilikha (larawan tatlong).
4. I-click ang Magdagdag ng JAR / Folder sa kanan. Makikita mo ang Browse JAR / Folder popup (larawan apat).
5. Mag-navigate sa at pagkatapos ay piliin ang pi4j-core.jar. Pagkatapos i-click ang Magdagdag ng JAR / Folder. Babalik ka sa popup ng Ant Library Manager.
6. Sa Ant Library Manager popup popup i-click ang OK. Babalik ka sa pangunahing window ng NetBeans.

Idinagdag mo ang silid-aklatan upang maaari itong magamit sa anumang proyekto. Ngayon dapat mong idagdag ang library sa iyong proyekto:

1. Dalhin ang popup ng Mga Katangian sa Proyekto (tingnan ang hakbang 5) at piliin ang kategorya ng Mga Aklatan (larawan limang).
2. I-click ang Idagdag ang Library sa kanang bahagi ng popup. Makikita mo ang Add Library popup (larawan anim).
3. Mag-navigate sa library at piliin ito. Pagkatapos i-click ang Magdagdag ng Library. Makikita mo muli ang popup ng Mga Properties ng Proyekto. Lumilitaw ngayon ang library sa listahan ng mga Compile-time na Library sa popup.
4. Sa popup ng Mga Pag-aari ng Project i-click ang OK. Babalik ka sa pangunahing window.

Idinagdag mo ang library sa iyong proyekto upang magamit ito ng iyong programa. Maaari mong gawin ang parehong pagkakasunud-sunod ng mga aksyon para sa anumang mga aklatan na kailangan mo para sa isang programa.

Mayroong tatlong beses na kailangan mo ng silid-aklatan - pag-ipon, pagbuo, at pagpapatupad. Sa kasamaang palad, sa NetBeans, ang pagdaragdag ng library tulad ng ipinakita sa itaas ay humahawak sa lahat. Upang kumpirmahin ito, lumikha ako ng isa pang pangunahing klase na gumagawa ng ganap na minimum na kinakailangan upang magamit ang kakayahan ng I2C sa Pi4J (larawan pitong). Ang katotohanan na walang mga error na ipinapakita ay nangangahulugang ang klase ng TestPi4J ay nag-iipon. Matagumpay na nabuo at na-download ang pag-click sa Run. Ang NetBeans ay nag-download ng silid-aklatan bilang karagdagan sa jar file, kaya ang programa ay papatupad. Upang mapatunayan ang huli, maaari mong gamitin ang pamamaraan sa hakbang 9 at sa ssh client ipasok ang sumusunod na utos (mula sa dist direktoryo):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Nagtuturo ito upang maunawaan kung paano pinangangasiwaan ng NetBeans ang mga aklatan. Habang nasa dist direktoryo para sa iyong proyekto, ilista ang mga nilalaman ng direktoryo (gamitin ang ls command) at makikita mo ang isang subd subdoryory. Ilista ang mga nilalaman ng direktoryong iyon at makikita mo ang file ng jar na nakilala sa pandaigdigang silid-aklatan, na sa aking halimbawa ay pi4j-core.jar. Ang lahat ng mga library na idinagdag mo sa proyekto ay lilitaw sa lib direktoryo, at sa gayon ay magagamit sa lahat ng mga programa sa file ng jar ng proyekto.

Hakbang 11: Magpakasaya

Inilarawan ko ang isang diskarte para sa pagkamit ng napakahusay na pag-unlad ng Java para sa Raspberry Pi. Ang Raspberry Pi ay isang napakapopular na teknolohiya para sa isang malawak na spectrum ng mga proyekto. Ang Java ay isang propesyonal na wika ng programa sa grade na nag-aalok ng mga kalamangan sa pagganap kaysa sa Python at nag-aalok ng mga kalamangan sa kaligtasan sa paglipas ng C / C ++. Ang NetBeans ay isang propesyonal na grade IDE na lubos na nagdaragdag ng pagiging produktibo ng programmer.

Sa palagay ko ang kombinasyon ay medyo nakakahimok. Ngayon, magsaya gamit ang kombinasyon para sa iyong mga proyekto.