Paskutinį kartą atnaujinta: 2020 m. Sausio mėn
Nors snaudimo mygtukas yra bene dažniausiai naudojamas žadintuvo mygtukas, net paprastas Žadintuvas klasei reikia dar kelių funkcijų. Pvz., Galbūt norėsite kontroliuoti, kiek laiko žadintuvas veiks snaudimo režime. Norėdami pridėti tokią funkciją, turite suprasti, kaip „Java“ valdo duomenis.
Kūrėjai naudoja kintamieji „Java“ sistemoje laikyti duomenis, o visi kintamieji turi duomenų tipą ir pavadinimą. Duomenų tipas nustato vertes, kurias gali turėti kintamasis. Šioje pamokoje sužinosite, kaip vientisieji tipai turi sveikus skaičius, slankiojo kablelio tipai - tikrus skaičius, o eilučių tipai - simbolių eilutes. Tada pradėsite naudoti egzempliorių kintamuosius savo „Java“ klasėse.
Kintamieji ir primityvūs tipai
Paskambino primityvūs tipai, integraliniai ir slankiojo kablelio tipai yra paprasčiausi „Java“ duomenų tipai. Ši programa iliustruoja integralo tipą, kuriame gali būti teigiami ir neigiami sveiki skaičiai. Ši programa taip pat iliustruoja komentarus, kurie dokumentuoja jūsų kodą, bet jokiu būdu neturi įtakos programai.
/ * * Tai taip pat komentaras. Kompiliatorius ignoruoja viską nuo * pirmojo / * iki „žvaigždės brūkšnio“, kuris baigia komentarą. * * Štai „žvaigždės brūkšnys“, kuris užbaigia komentarą. * / public class IntegerTest {public static void main (String [] args) {// Čia pateikiama int kintamojo, vadinamo anInteger, deklaracija //, kurio pradinę reikšmę nurodysite 100. int anInteger = 100; // Paskelbkite ir inicializuokite anInteger System.out.println (anInteger); // Išėjimai 100 // Taip pat galite atlikti aritmetiką su primityviais tipais, naudodami // standartinius aritmetikos operatorius. skaičiukas = 100 + 100; System.out.println (anInteger); // Išėjimai 200}} „Java“ taip pat naudoja slankiųjų kablelių tipus, kuriuose gali būti tikri skaičiai, tai yra skaičiai, nurodantys po kablelio. Štai programos pavyzdys:
public class DoubleTest {public static void main (String [] args) {// Čia pateikiama dvigubo kintamojo, vadinamo aDouble, deklaracija. // Jūs taip pat suteikiate „aDouble“ pradinę vertę 5,76. dvigubas aDvigubas = 5,76; // Paskelbkite ir inicializuokite aDouble System.out.println (aDouble); // Išėjimai 5.76 // Taip pat galite atlikti aritmetiką su slankiųjų kablelių tipais. aDvigubas = 5,76 + 1,45; System.out.println („Double“); // Išėjimai 7.21}} Pabandykite paleisti aukščiau pateiktas programas. Atminkite, kad prieš juos paleisdami turite sukompiliuoti:
javac * .java java IntegerTest java DoubleTest
„Java“ naudoja keturis integralinius tipus ir du slankiojo kablelio tipus, kurie abu turi skirtingus skaičių diapazonus ir užima skirtingą kiekį vietos, kaip parodyta toliau pateiktose lentelėse.
Integralūs tipai
| TIPAS | Baitas | Trumpas | Vid | Ilgas |
|---|---|---|---|---|
| DYDIS (bitai) | 8 | 16 | 32 | 64 |
| DIAPAZONAS | -128 iki 127 | Nuo -32 768 iki 32 767 | Nuo 2 147 483 648 iki 2 147 483 647 | -263 iki 263-1 |
Kintamojo taško tipai (IEEE 754 formatas)
| TIPAS | Vieno tikslumo plūduriuojantis taškas | Dvigubo tikslumo plūduriuojantis taškas |
|---|---|---|
| DYDIS (bitai) | 32 | 64 |
| DIAPAZONAS | +/- 1,18x10-38 iki +/- 3,4x1038 | +/- 2,23x10-308 iki +/- 1,8x10308 |
A stygos tipas laiko stygas ir jas tvarko kitaip, nei integralų ir slankiojo kablelio tipai tvarko skaičius. „Java“ kalba apima a Stygos klasės atstovauti stygoms. Jūs deklaruojate eilutę naudodami tipą Stygosir inicializuokite ją cituojamąja eilute, simbolių seka, esančia dvigubose kabutėse, kaip parodyta žemiau. Taip pat galite sujungti dvi eilutes naudodami + operatorius.
// Kodo fragmentas // String, // kintamųjų s deklaravimas // ir inicializavimas cituojama eilute „Hello“. Eilutė s = „Sveiki“; // Virvelės sujungimas s su cituojama eilute „Pasaulis“ Stygos t = s + „Pasaulis“; System.out.println (t); // Išėjimai Labas pasauli
Kintama taikymo sritis
Be tipo, taikymo sritį taip pat yra svarbi kintamojo savybė. Taikymo sritis nustato, kada kintamasis yra sukurtas ir sunaikinamas ir kur kūrėjas gali pasiekti kintamąjį programoje. Vieta jūsų programoje, kurioje deklaruojate kintamąjį, lemia jo taikymo sritį.
Iki šiol aš diskutavau vietiniai kintamieji, kuriuose saugomi laikini duomenys, kuriuos naudojate metode. Jūs deklaruojate vietinius kintamuosius metodų viduje ir prie jų galite prisijungti tik iš tų metodų. Tai reiškia, kad galite gauti tik vietinius kintamuosius anegeger, kurį naudojote Sveikasis bandymasir aDvigubas, kurį naudojote „DoubleTest“, iš pagrindinio metodo, kuriuo jie buvo deklaruoti, ir niekur kitur.
Vietinius kintamuosius galite deklaruoti naudodami bet kurį metodą. Žemiau pateiktas kodo pavyzdys deklaruoja vietinį kintamąjį „AlarmClock“ snaudimas () metodas:
viešoji klasė „AlarmClock“ {public void snooze () {// Snaudimo laikas milisekundėmis = 5 sekundės ilgas snaudimo laikotarpis = 5000; System.out.println ("ZZZZZ for:" + snaudimo trukmė); }} Jūs galite patekti į snaudimasIntervalis tik iš snausti () metodas, kurį jūs deklaravote snausti „Interval“, kaip parodyta čia:
public class AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); aClock.snooze (); // Tai vis dar gerai. // Kita kodo eilutė yra KLAIDA. // Negalite pasiekti „snaudimo laiko intervalo“ už snaudimo metodo ribų. snaudimo intervalas = 10000; }} Metodo parametrai
A metodo parametras, kurio taikymo sritis yra panaši į vietinį kintamąjį, yra dar viena kintamųjų rūšis. Metodo parametrai perduoda argumentus į metodus. Kai deklaruojate metodą, parametrų sąraše nurodote jo argumentus. Kai iškviečiate metodą, perduodate argumentus. Metodo parametrai veikia panašiai kaip vietiniai kintamieji, nes jie patenka į metodo, su kuriuo jie yra susieti, taikymo sritį ir gali būti naudojami visame metode. Tačiau, skirtingai nei vietiniai kintamieji, metodo parametrai iš skambinančiojo gauna vertę, kai jis iškviečia metodą. Čia yra žadintuvo modifikacija, leidžianti jums perduoti snaudimasIntervalis.
public class 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 (); // Praleiskite snaudimo intervalą, kai iškviečiate metodą. aClock.snooze (10000); // Snausti 10000 msek. }} Narių kintamieji: kaip objektai saugo duomenis
Vietiniai kintamieji yra naudingi, tačiau kadangi jie teikia tik laikiną saugyklą, jų vertė yra ribota. Kadangi jų gyvenimo trukmė yra metodo, pagal kurį jie deklaruojami, trukmė, vietiniai kintamieji lyginami su bloknotu, kuris pasirodo kiekvieną kartą, kai gaunate telefono skambutį, bet dingsta, kai padedate ragelį. Ta sąranka gali būti naudinga užrašyti užrašus, tačiau kartais jums reikia kažko pastovesnio. Ką daryti programuotojui? Įveskite narių kintamieji.
Narių kintamieji, kurių yra du, instancija ir statinis - sudaro dalį klasės.
Kintama taikymo sritis ir tarnavimo laikas
Kūrėjai diegia egzempliorių kintamuosius, kad juose būtų klasei naudingų duomenų. Pavyzdžio kintamasis skiriasi nuo vietinio kintamojo savo taikymo sritimi ir jo tarnavimo laiku. Visa klasė sudaro egzemplioriaus kintamojo sritį, o ne metodas, kuriuo jis buvo deklaruotas. Kitaip tariant, kūrėjai gali pasiekti egzempliorių kintamuosius bet kurioje klasės vietoje. Be to, egzemplioriaus kintamojo gyvenimo trukmė nepriklauso nuo konkretaus klasės metodo; tai yra jo gyvavimo laikas yra egzemplioriaus, kuriame jis yra, gyvenimas.
Egzemplioriai yra tikrieji objektai, kuriuos sukūrėte iš projekto apibrėžimo, kurį suprojektavote klasės apibrėžime. Deklaruojate egzempliorių kintamuosius klasės apibrėžime, turėdami įtakos kiekvienam egzemplioriui, kurį sukūrėte iš projekto. Kiekviename egzemplioriuje yra tų egzempliorių kintamųjų, o kintamuosiuose laikomi duomenys gali skirtis.
Apsvarstykite Žadintuvas klasė. Pravažiavimas snaudimasIntervalis į snausti () metodas nėra puikus dizainas. Įsivaizduokite, kad žadintuve turite įvesti snaudimo intervalą kiekvieną kartą, kai ieškote snaudimo mygtuko. Vietoj to, tiesiog duokite visam žadintuvui a snaudimasIntervalis. Tai užpildysite egzemplioriaus kintamuoju Žadintuvas klasės, kaip parodyta žemiau:
viešoji klasė „AlarmClock“ {// Čia paskelbiate „snoozeInterval“. Tai daro tai egzemplioriaus kintamuoju. // Jūs taip pat čia inicijuojate. ilgas m_snoozeInterval = 5000; // Snaudimo laikas milisekundėmis = 5 sek. public void snooze () {// Vis tiek galite patekti į „m_snoozeInterval“ naudodami „AlarmClock“ metodą //, nes esate klasės apimtyje. System.out.println ("ZZZZZ for:" + m_snoozeInterval); }} Galite pasiekti egzempliorių kintamuosius beveik bet kurioje klasėje, kuri juos deklaruoja. Jei norite būti techniškas, deklaruojate egzemplioriaus kintamąjį klasės taikymo sritis, ir jūs galite jį gauti beveik iš bet kurios srities. Praktiškai kalbant, kintamąjį galite pasiekti bet kurioje vietoje tarp pirmojo garbanotojo skliausto, kuris pradeda klasę, ir uždarymo skliaustelio. Kadangi jūs taip pat deklaruojate metodus klasės sferoje, jie taip pat gali pasiekti egzempliorių kintamuosius.
Taip pat galite pasiekti egzempliorių kintamuosius ne iš klasės, jei egzistuoja egzempliorius, ir turite kintamąjį, kuris nurodo egzempliorių. Norėdami gauti egzemplioriaus kintamąjį per egzempliorių, naudokite taškų operatorius kartu su instancija. Galbūt tai nėra idealus būdas pasiekti kintamąjį, bet kol kas užpildykite jį tokiu būdu, kad būtų aišku:
public class AlarmClockTest {public static void main (String [] args) {// Sukurkite du laikrodžius. Kiekvienas turi savo m_snoozeInterval AlarmClock aClock1 = naujas AlarmClock (); „AlarmClock“ aClock2 = naujas „AlarmClock“ (); // Pakeiskite „aClock2“ // Netrukus pamatysite, kad yra daug geresnių būdų tai padaryti. aClock2.m_snoozeInterval = 10000; aClock1.snooze (); // Snausti su aClock1 intervalu aClock2.snooze (); // Snausti naudojant „aClock2“ intervalą}} Išbandykite šią programą ir pamatysite aClock1 vis dar turi savo 5000 intervalą aClock2 turi 10 000 intervalą. Vėlgi, kiekvienas egzempliorius turi savo egzempliorių duomenis.
Nepamirškite, kad klasės apibrėžimas yra tik planas, todėl egzempliorių kintamieji iš tikrųjų neegzistuoja, kol nesudarysite egzempliorių iš projekto. Kiekvienas klasės egzempliorius turi savo egzempliorių kintamųjų kopijas, o projektas apibūdina, kokie bus šie kintamieji.
„JavaWorld“ Inkapsuliacija
Inkapsuliacija yra vienas iš objektinio programavimo pagrindų. Naudodamas inkapsuliaciją, vartotojas sąveikauja su tipu per veikiamą elgesį, o ne tiesiogiai su vidiniu įgyvendinimu. Naudodamiesi kapsulėmis, paslėpiate išsamią informaciją apie tipo įgyvendinimą. „Java“ sistemoje kapsuliavimas iš esmės reiškia šią paprastą gairę: „Negalite tiesiogiai pasiekti savo objekto duomenų; naudokite jo metodus“.
Tai yra elementari idėja, tačiau ji palengvina mūsų, kaip programuotojų, gyvenimą. Įsivaizduokite, pavyzdžiui, kad norėjote instruktuoti a Asmuo objektas atsistoti. Be kapsulės jūsų komandos galėtų būti maždaug tokios: "Na, manau, jums reikės sugriežtinti šį raumenį kojos priekyje, atlaisvinti šį raumenį kojos gale. Hmmm - reikia sulenkti juosmenį taip pat. Kurie raumenys sužadina tą judesį? Reikia juos priveržti, atlaisvinti. Oi! Pamiršau kitą koją. Darn. Žiūrėk - nenuversk ... "Jūs suprantate. Naudojant kapsulę, jums tereikės iškviesti Atsistok() metodas. Gana lengva, taip?
Keletas kapsuliavimo privalumų:
- Detalės santrauka: Vartotojas sąveikauja su aukštesnio lygio tipu. Jei naudojate
Atsistok()metodo, jums nebereikia žinoti visų raumenų, reikalingų tam judesiui inicijuoti. - Izoliacija nuo pokyčių:Vidinio diegimo pakeitimai neturi įtakos vartotojams. Jei asmuo patempia kulkšnį ir kurį laiką priklauso nuo lazdelės, vartotojai vis tiek naudojasi tik
Atsistok()metodas. - Teisingumas:Vartotojai negali savavališkai pakeisti objekto vidų. Jie gali užbaigti tik tai, ką jūs leidžiate, naudodamiesi jūsų parašytais metodais.
Pateikiame trumpą pavyzdį, kuriame kapsulės aiškiai padeda tikslinti programą:
// Blogas - nenaudoja inkapsuliacijos viešosios klasės Asmuo {int m_age; } public class PersonTest {public static void main (String [] args) {Asmuo p = naujas Asmuo (); p.m_age = -5; // Ei - kaip kam nors gali būti minus 5 metai? }} // Geriau - naudoja inkapsuliacijos viešąją klasę Asmuo {int m_age; public void setAge (int age) {// Patikrinkite, ar amžius didesnis nei 0. Aš pakalbėsiu daugiau apie // if teiginius kitu metu. if (amžius> 0) {m_age = amžius; }}} public class PersonTest {public static void main (String [] args) {Asmuo p = naujas Asmuo (); p.setAge (-5); // Dabar neturės jokio poveikio. }} Net ta paprasta programa parodo, kaip galite patekti į bėdą, jei tiesiogiai pasiekiate vidinius klasių duomenis. Kuo didesnė ir sudėtingesnė programa, tuo svarbesnė tampa kapsulė. Taip pat atminkite, kad daugelis programų prasideda nedaug, o vėliau tęsiasi neribotą laiką, todėl labai svarbu, kad jas suprojektuotumėte teisingai, nuo pat pradžių. Taikyti inkapsuliaciją Žadintuvas, galite tiesiog sukurti metodus, kaip manipuliuoti snaudimo intervalu.
Pastaba apie metodus
Metodai gali grąžinti skambinančiojo naudojamas vertes. Norėdami grąžinti vertę, deklaruokite neišvengiamą grąžinimo tipą ir naudokite a grįžti pareiškimas. getSnoozeInterval () tai iliustruoja toliau pateiktame pavyzdyje pateiktas metodas.
