Pēdējo reizi atjaunināts: 2020. gada janvāris
Kaut arī atlikšanas poga, iespējams, ir modinātāja pulksteņa visbiežāk izmantotā poga, pat vienkārša Modinātājs klasei ir nepieciešamas vēl dažas funkcijas. Piemēram, jūs varētu vēlēties kontrolēt, cik ilgi modinātājs paliks atlikšanas režīmā. Lai pievienotu šādu funkciju, jums ir jāsaprot, kā Java kontrolē datus.
Izstrādātāji izmanto mainīgie Java, lai turētu datus, un visiem mainīgajiem ir datu tips un nosaukums. Datu tips nosaka vērtības, kuras mainīgais var turēt. Šajā apmācībā jūs uzzināsiet, kā integrālie tipi satur veselus skaitļus, peldošo punktu tipi - reālos skaitļus un virkņu tipi - rakstzīmju virknes. Tad jūs sāksit izmantot instances mainīgos Java klasēs.
Mainīgie un primitīvie veidi
Zvanīja primitīvie veidi, integrālie un peldošā komata veidi ir vienkāršākie Java datu tipi. Šī programma ilustrē neatņemamo tipu, kurā var būt gan pozitīvi, gan negatīvi veseli skaitļi. Šī programma arī ilustrē komentārus, kas dokumentē jūsu kodu, bet nekādā veidā neietekmē programmu.
/ * * Šis ir arī komentārs. Sastādītājs ignorē visu, sākot no * pirmā / * līdz “zvaigznītes slīpsvītrai”, kas beidz komentāru. * * Šeit ir "zvaigznītes slīpsvītra", kas beidz komentāru. * / public class IntegerTest {public static void main (String [] args) {// Šeit ir norādīta int mainīgā lielums, ko sauc par anInteger, // kuram sākotnējā vērtība ir 100. int anInteger = 100; // Deklarēt un inicializēt anInteger System.out.println (anInteger); // Rezultāti 100 // Aritmētiku var veikt arī ar primitīviem tipiem, izmantojot // standarta aritmētiskos operatorus. vesels skaitlis = 100 + 100; System.out.println (anInteger); // Izejas 200}} Java izmanto arī peldošā komata tipus, kuros var ievietot reālus skaitļus, kas nozīmē skaitļus, kas ietver komatu. Šeit ir programmas piemērs:
public class DoubleTest {public static void main (String [] args) {// Lūk, dubultā mainīgā deklarācija aDouble. // Jūs arī dodat aDouble sākotnējo vērtību 5,76. dubultā aDubultā = 5,76; // Deklarēt un inicializēt aDouble System.out.println (aDouble); // Rezultāti 5.76 // Aritmētiku var veikt arī ar peldošo punktu tipiem. aDivkāršs = 5,76 + 1,45; System.out.println (aDouble); // Izejas 7.21}} Mēģiniet palaist iepriekš minētās programmas. Atcerieties, ka pirms to palaišanas jums ir jāapkopo:
javac * .java java IntegerTest java DoubleTest
Java izmanto četrus neatņemamus veidus un divus peldošā komata tipus, kas abi satur dažādus skaitļu diapazonus un aizņem dažādu daudzumu atmiņas, kā parādīts tālāk esošajās tabulās.
Neatņemami tipi
| VEIDS | Baits | Īss | Int | Garš |
|---|---|---|---|---|
| SIZE (biti) | 8 | 16 | 32 | 64 |
| Diapazons | -128 līdz 127 | -32 768 līdz 32 767 | No 2 147 483 648 līdz 2 147 483 647 | -263 līdz 263-1 |
Peldošo punktu veidi (IEEE 754 formāts)
| VEIDS | Vienas precizitātes peldošs punkts | Divkāršas precizitātes peldošs punkts |
|---|---|---|
| SIZE (biti) | 32 | 64 |
| Diapazons | +/- 1,18x10-38 līdz +/- 3,4x1038 | +/- 2,23x10-308 līdz +/- 1,8x10308 |
A virknes tips tur virknes un rīkojas ar tām atšķirīgi no tā, kā integrālie un peldošie punkti rīkojas ar skaitļiem. Java valoda ietver a Stīga klases pārstāvēt stīgas. Jūs deklarējat virkni, izmantojot veidu Stīgaun inicializējiet to ar citētu virkni - divkāršās pēdiņās iekļauto rakstzīmju secību, kā parādīts zemāk. Izmantojot kombināciju, varat arī apvienot divas virknes + operators.
// Koda fragments // String, // mainīgā s deklarācija // un inicializēšana ar citētu virkni "Hello". Virkne s = "Sveiki"; // Virknes savienojums s ar citētu virkni "Pasaule" Stīga t = s + "Pasaule"; System.out.println (t); // Izejas Sveika pasaule
Mainīga darbības joma
Papildus tipam, darbības joma ir arī svarīga mainīgā īpašība. Darbības joma nosaka, kad mainīgais tiek izveidots un iznīcināts un kur izstrādātājs var piekļūt mainīgajam programmas ietvaros. Vieta jūsu programmā, kur deklarējat mainīgo, nosaka tā darbības jomu.
Līdz šim esmu apspriedis vietējie mainīgie, kas satur pagaidu datus, kurus jūs izmantojat kādā metodē. Jūs deklarējat vietējos mainīgos metožu iekšienē, un tiem varat piekļūt tikai no šīm metodēm. Tas nozīmē, ka jūs varat izgūt tikai lokālos mainīgos anegeger, kuru izmantojāt IntegerTest, un aDivkāršs, kuru izmantojāt DoubleTest, no galvenās metodes, kādā tie tika deklarēti, un nekur citur.
Vietējos mainīgos varat deklarēt jebkurā metodē. Tālāk redzamais koda piemērs deklarē vietējo mainīgo AlarmClock atlikšana () metode:
publiskā klase AlarmClock {public void snooze () {// Atlikt laiku milisekundēs = 5 sekundes ilgi snaudas intervāls = 5000; System.out.println ("ZZZZZ priekš:" + atliktInterval); }} Jūs varat nokļūt atliktInterval tikai no atlikt () metodi, kurā jūs deklarējāt atliktInterval, kā parādīts šeit:
public class AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); aClock.snooze (); // Tas joprojām ir labi. // Nākamā koda rindiņa ir KĻŪDA. // Jūs nevarat piekļūt snaudas intervālam ārpus atlikšanas metodes. atliktInterval = 10000; }} Metodes parametri
A metodes parametrs, kura darbības joma ir līdzīga lokālajam mainīgajam, ir cita veida mainīgais. Metodes parametri nodod argumentus metodēs. Deklarējot metodi, parametru sarakstā norādiet tās argumentus. Jūs izsaucat argumentus, izsaucot metodi. Metodes parametri darbojas līdzīgi lokālajiem mainīgajiem, jo tie ietilpst tās metodes darbības jomā, ar kuru tie ir saistīti, un tos var izmantot visā metodē. Tomēr, atšķirībā no lokālajiem mainīgajiem, metodes parametri iegūst vērtību no zvanītāja, kad tas izsauc metodi. Šeit ir modinātāja modifikācija, kas ļauj jums ievadīt atliktInterval.
publiskā klase AlarmClock {public void snooze (long snoozeInterval) {System.out.println ("ZZZZZ for:" + snoozeInterval); }} public class AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); // Ievadiet atlikšanas intervālu, kad izsaucat metodi. aClock.snooze (10000); // Atlikt 10000 msec. }} Dalībnieku mainīgie: kā objekti glabā datus
Vietējie mainīgie ir noderīgi, taču, tā kā tie nodrošina tikai pagaidu glabāšanu, to vērtība ir ierobežota. Tā kā viņu dzīves ilgums ir deklarēšanas metodes garums, vietējie mainīgie tiek salīdzināti ar bloknotu, kas parādās katru reizi, kad saņemat tālruņa zvanu, bet pazūd, kad noliekat klausuli. Šī iestatīšana var būt noderīga piezīmju pierakstīšanai, taču dažreiz jums ir nepieciešams kaut kas pastāvīgāks. Ko darīt programmētājs? Enter locekļu mainīgie.
Dalībnieku mainīgie - no kuriem ir divi, instancē un statisks - veido daļu no klases.
Mainīga darbības joma un kalpošanas laiks
Izstrādātāji ievieš instances mainīgos, lai saturētu klasei noderīgus datus. Piemēra mainīgais atšķiras no lokālā mainīgā pēc darbības jomas un kalpošanas laika rakstura. Visa klase veido instances mainīgā darbības jomu, nevis metode, kādā tas tika deklarēts. Citiem vārdiem sakot, izstrādātāji var piekļūt instances mainīgajiem jebkur klasē. Turklāt instances mainīgā ilgums nav atkarīgs no kādas konkrētas klases metodes; tas ir, tā kalpošanas laiks ir tās instances mūžs, kurā tā atrodas.
Gadījumi ir faktiskie objekti, kurus jūs izveidojat, izmantojot klases definīcijā izstrādāto projektu. Jūs deklarējat instances mainīgos klases definīcijā, kas ietekmē katru gadījumu, kuru izveidojat, izmantojot plānu. Katrā instancē ir šie gadījumu mainīgie, un mainīgajos esošie dati katrā instancē var atšķirties.
Apsveriet Modinātājs klasē. Iet garām atliktInterval iekšā atlikt () metode nav lielisks dizains. Iedomājieties, ka modinātājā ir jāievada atlikšanas intervāls katru reizi, kad meklējat pogu Atlikt. Tā vietā vienkārši dodiet visu modinātāju atliktInterval. Jūs to pabeidzat ar instances mainīgo Modinātājs klase, kā parādīts zemāk:
public class AlarmClock {// Jūs šeit paziņojat par snoozeInterval. Tas padara to par instances mainīgo. // Jūs to arī inicializējat šeit. garš m_snoozeInterval = 5000; // Atlikt laiku milisekundēs = 5 sekundes. public void snooze () {// Jūs joprojām varat piekļūt m_snoozeInterval AlarmClock metodē //, jo jūs esat klases darbības sfērā. System.out.println ("ZZZZZ priekš:" + m_snoozeInterval); }} Varat piekļūt gadījumu mainīgajiem gandrīz visur klasē, kas tos deklarē. Lai būtu tehniski, jūs deklarējat instances mainīgo klases darbības joma, un jūs varat to iegūt gandrīz no jebkuras vietas. Praktiski runājot, mainīgajam var piekļūt jebkurā vietā starp pirmo cirtaino iekavu, ar kuru sākas klase, un noslēguma iekavu. Tā kā jūs deklarējat metodes arī klases darbības jomā, arī viņi var piekļūt instances mainīgajiem.
Varat arī piekļūt instances mainīgajiem ārpus klases, ja vien eksemplārs pastāv, un jums ir mainīgais, kas atsaucas uz instanci. Lai izgūtu instances mainīgo caur instanci, izmantojiet punktu operators kopā ar instanci. Tas, iespējams, nav ideāls veids, kā piekļūt mainīgajam, taču pagaidām ilustratīviem nolūkiem pabeidziet to šādā veidā:
public class AlarmClockTest {public static void main (String [] args) {// Izveidojiet divus pulksteņus. Katram ir savs m_snoozeInterval AlarmClock aClock1 = new AlarmClock (); AlarmClock aClock2 = jauns AlarmClock (); // Mainīt aClock2 // Drīz jūs redzēsiet, ka tam ir daudz labāki veidi. aClock2.m_snoozeInterval = 10000; aClock1.snooze (); // Atlikt ar aClock1 intervālu aClock2.snooze (); // Atlikt ar aClock2 intervālu}} Izmēģiniet šo programmu, un jūs to redzēsiet aClock1 joprojām ir 5000 intervāls, kamēr aClock2 ir 10 000 intervāls. Katram gadījumam atkal ir savi instances dati.
Neaizmirstiet, ka klases definīcija ir tikai projekts, tāpēc eksemplāru mainīgie faktiski nepastāv, kamēr jūs no projekta neizveidojat eksemplārus. Katram klases gadījumam ir sava eksemplāru mainīgo kopija, un projekts nosaka, kādi būs šie mainīgie.
JavaWorld Iekapsulēšana
Iekapsulēšana ir viens no objektorientētās programmēšanas pamatiem. Izmantojot iekapsulēšanu, lietotājs mijiedarbojas ar veidu, izmantojot pakļauto uzvedību, nevis tieši ar iekšējo ieviešanu. Izmantojot iekapsulēšanu, jūs paslēpjat informāciju par tipa ieviešanu. Java valodā iekapsulēšana būtībā nozīmē šo vienkāršo vadlīniju: "Nepiekļūstiet tieši sava objekta datiem; izmantojiet tā metodes."
Tā ir elementāra ideja, taču tā atvieglo mūsu kā programmētāju dzīvi. Iedomājieties, piemēram, ka jūs gribējāt instruēt a Persona objekts piecelties. Bez iekapsulēšanas jūsu komandas varētu notikt apmēram šādi: "Nu, es domāju, ka jums vajadzētu sasprindzināt šo muskuli šeit kājas priekšpusē, atlaidiet šo muskuli šeit kājas aizmugurē. Hmmm - vajag saliekties plkst. arī jostasvieta. Kuri muskuļi izraisa šo kustību? Nepieciešams tos pievilkt, atslābināt. Bēdas! Aizmirsāt otru kāju. Spārns. Skatieties to - neapgāžaties ... "Jums rodas ideja. Izmantojot iekapsulēšanu, jums vienkārši jāizsauc piecelties() metodi. Diezgan viegli, jā?
Dažas priekšrocības iekapsulēšanai:
- Detalizētas informācijas abstrakcija: Lietotājs mijiedarbojas ar tipu augstākā līmenī. Ja izmantojat
piecelties()metodi, jums vairs nav jāzina visi muskuļi, kas nepieciešami šīs kustības uzsākšanai. - Izolācija no izmaiņām:Iekšējās ieviešanas izmaiņas neietekmē lietotājus. Ja cilvēks sastiepis potīti un kādu laiku ir atkarīgs no niedres, lietotāji joprojām izmanto tikai
piecelties()metodi. - Pareizība:Lietotāji nevar patvaļīgi mainīt objekta iekšpusi. Viņi var pabeigt tikai to, ko jūs viņiem atļaujat, izmantojot jūsu rakstītās metodes.
Šeit ir īss piemērs, kurā iekapsulēšana skaidri palīdz uzlabot programmas precizitāti:
// Slikti - neizmanto iekapsulēšanas publisko klasi Person {int m_age; } public class PersonTest {public static void main (String [] args) {Persona p = jauna Persona (); p.m_age = -5; // Hei - kā kādam var būt mīnus 5 gadi? }} // Labāk - izmanto iekapsulēšanu publiskā klase Persona {int m_age; public void setAge (int age) {// Pārbaudiet, vai vecums ir lielāks par 0. Es runāšu vairāk par // if paziņojumiem citā laikā. if (vecums> 0) {m_age = vecums; }}} public class PersonTest {public static void main (String [] args) {Persona p = jauna Persona (); p.setAge (-5); // Tagad tam nebūs nekādas ietekmes. }} Pat šī vienkāršā programma parāda, kā jūs varat nokļūt nepatikšanās, ja tieši piekļūstat klašu iekšējiem datiem. Jo lielāka un sarežģītāka programma, jo svarīgāka kļūst iekapsulēšana. Atcerieties arī to, ka daudzas programmas sākas ar nelielu izmēru un pēc tam turpinās darboties bezgalīgi, tāpēc ir svarīgi, lai tās veidotu pareizi, no paša sākuma. Lai piemērotu iekapsulēšanu Modinātājs, varat vienkārši izveidot metodes, kā manipulēt ar atlikšanas intervālu.
Piezīme par metodēm
Metodes var atgriezt vērtības, kuras zvanītājs izmanto. Lai atgrieztu vērtību, paziņojiet par atgriešanās veidu nenovēršamu un izmantojiet a atgriešanās paziņojums, apgalvojums. The getSnoozeInterval () piemērā parādītā metode to ilustrē.
