Kako pohraniti podatke u Java objekte

Posljednje ažuriranje: siječanj 2020

Iako je gumb za odgodu vjerojatno najčešće korišten gumb na budilici, čak i jednostavna AlarmClockklasa treba još nekoliko značajki. Na primjer, možda ćete htjeti kontrolirati koliko će dugo budilica ostati u načinu odgode. Da biste dodali takvu značajku, morate razumjeti kako Java kontrolira podatke.

Programeri koriste Java varijable za držanje podataka, a sve varijable imaju tip podataka i ime. Tip podataka određuje vrijednosti koje varijabla može sadržavati. U ovom ćete tutorijalu naučiti kako integralni tipovi sadrže cijele brojeve, tipovi s pomičnim zarezom imaju stvarne brojeve, a tipovi nizova sadrže znakovne nizove. Tada ćete započeti s korištenjem varijabli instance u svojim Java razredima.

Varijable i primitivni tipovi

Nazvani primitivni tipovi , integralni i tipovi s pomičnim zarezom najjednostavniji su tipovi podataka u Javi. Sljedeći program ilustrira integralni tip koji može sadržavati pozitivne i negativne cijele brojeve. Ovaj program također ilustrira komentare koji dokumentiraju vaš kôd, ali ni na koji način ne utječu na program.

/ * * Ovo je ujedno i komentar. Prevoditelj ignorira sve, od * prvog / * do "kosine", koja završava komentar. * * Evo "zvjezdane crte" koja završava komentar. * / public class IntegerTest {public static void main (String [] args) {// Evo deklaracije int varijable koja se naziva anInteger, // kojoj dajete početnu vrijednost 100. int anInteger = 100; // Deklariranje i inicijalizacija anInteger System.out.println (anInteger); // Izlazi 100 // Također možete raditi aritmetiku s primitivnim tipovima, koristeći // standardne aritmetičke operatore. anInteger = 100 + 100; System.out.println (anInteger); // izlazi 200}}

Java također koristi tipove s pomičnim zarezom, koji mogu sadržavati stvarne brojeve, što znači brojeve koji uključuju decimalno mjesto. Evo primjera programa:

javna klasa DoubleTest {public static void main (String [] args) {// Evo deklaracije dvostruke varijable koja se naziva aDouble. // Također dajete aDouble početnu vrijednost 5,76. dvostruki aDvostruki = 5,76; // Deklariranje i inicijalizacija aDouble System.out.println (aDouble); // Izlazi 5.76 // Također možete raditi aritmetiku s tipovima s pomičnim zarezom. aDvostruko = 5,76 + 1,45; System.out.println (dvostruko); // izlazi 7.21}}

Pokušajte pokrenuti gornje programe. Zapamtite, morate ih kompajlirati prije nego što ih možete pokrenuti:

javac * .java java IntegerTest java DoubleTest 

Java koristi četiri integralna tipa i dva tipa s pomičnim zarezom, koji obje imaju različit raspon brojeva i zauzimaju različite količine prostora za pohranu, kao što je prikazano u donjim tablicama.

Integralni tipovi

TIP Bajt Kratak Int Dugo
VELIČINA (bitovi) 8 16 32 64
DALJINA -128 do 127 -32.768 do 32.767 -2,147,483,648 do 2,147,483,647 -263 do 263-1

Tipovi s pomičnim zarezom (format IEEE 754)

 
TIP Plutajuća točka s jednom preciznošću Plutajuća točka dvostruke preciznosti
VELIČINA (bitovi) 32 64
DALJINA +/- 1,18x10-38 do +/- 3,4x1038 +/- 2,23x10-308 do +/- 1,8x10308

Vrsta niza drži nizove i njima se rukuje drugačije od načina na koji integrirani i tipovi s pomičnim zarezom obrađuju brojeve. Java jezik uključuje Stringklasu koja predstavlja nizove. Niz deklarirate pomoću vrste Stringi inicijalizirate ga citiranim nizom, nizom znakova sadržanih u dvostrukim navodnicima, kao što je prikazano dolje. Također možete kombinirati dvije žice pomoću +operatora.

// Fragment koda // Deklaracija varijable s tipa String, // i inicijalizacija s citiranim nizom "Hello." Niz s = "Pozdrav"; // Spajanje niza u s s citiranim nizom "World" String t = s + "World"; System.out.println (t); // Izlazi Hello World

Promjenjivi opseg

Uz tip, opseg je također važna karakteristika varijable. Opseg utvrđuje kada se varijabla stvara i uništava i gdje programer može pristupiti varijabli unutar programa. Mjesto u vašem programu na kojem deklarirate varijablu određuje njezin opseg.

Do sada sam raspravljao o lokalnim varijablama koje sadrže privremene podatke koje koristite u metodi. Lokalne varijable deklarirate unutar metoda i možete im pristupiti samo unutar tih metoda. To znači da možete dohvatiti samo lokalne varijable anIntegerkoje ste koristili IntegerTesti aDoublekoje ste koristili DoubleTestiz glavne metode u kojoj su deklarirane i nigdje drugdje.

Možete deklarirati lokalne varijable unutar bilo koje metode. Primjer koda u nastavku deklarira lokalnu varijablu u AlarmClock snooze()metodi:

javna klasa AlarmClock {public void snooze () {// Vrijeme odgode u milisekundi = 5 sekundi dugo snoozeInterval = 5000; System.out.println ("ZZZZZ za:" + snoozeInterval); }}

Do njega možete doći snoozeIntervalsamo pomoću snooze()metode koja je mjesto na kojem ste se izjavilisnoozeInterval, as shown here: 

javna klasa AlarmClockTest {javna statička void glavna (String [] args) {AlarmClock aClock = novi AlarmClock (); aClock.snooze (); // Ovo je još uvijek u redu. // Sljedeći redak koda je GREŠKA . // Ne možete pristupiti snoozeInterval izvan metode snooze. snoozeInterval = 10000; }}

Parametri metode

Parametar postupak , koji ima sličnu opseg lokalnom varijabli, druga vrsta varijable. Parametri metode prosljeđuju argumente u metode. Kada deklarirate metodu, njezine argumente navodite na popisu parametara. Argumente prosljeđujete kad pozovete metodu. Parametri metode funkcioniraju slično lokalnim varijablama po tome što spadaju u opseg metode s kojom su povezane i mogu se koristiti tijekom cijele metode. Međutim, za razliku od lokalnih varijabli, parametri metode dobivaju vrijednost od pozivatelja kada poziva metodu. Evo modifikacije budilice koja vam omogućuje da uđete u snoozeInterval.

javna klasa AlarmClock {javna praznina odgoda (dugo snoozeInterval) {System.out.println ("ZZZZZ za:" + snoozeInterval); }}
javna klasa AlarmClockTest {javna statička praznina main (String [] args) {AlarmClock aClock = novi AlarmClock (); // Prođite kroz interval odgode kad pozovete metodu. aClock.snooze (10000); // Odgodi za 10000 msecs. }}

Varijable člana: Kako objekti pohranjuju podatke

Lokalne varijable su korisne, ali budući da pružaju samo privremeno skladište, njihova je vrijednost ograničena. Budući da im životni vijek obuhvaća duljinu metode u kojoj su deklarirani, lokalne se varijable uspoređuju s bilježnicom koja se pojavljuje svaki put kad primite telefonski poziv, ali nestaje kad prekinete vezu. Ta postavka može biti korisna za bilježenje bilješki, ali ponekad vam treba nešto trajnije. Što programer učiniti? Unesite varijable člana .

Varijable člana - kojih ima dvije, instance i static - čine dio klase.

Promjenjiv opseg i vijek trajanja

Programeri implementiraju varijable instance da sadrže podatke korisne za klasu. Varijabla instance razlikuje se od lokalne varijable po prirodi opsega i vijeku trajanja. Cijela klasa čini opseg varijable instance, a ne metoda u kojoj je deklarirana. Drugim riječima, programeri mogu pristupiti varijablama instance bilo gdje u klasi. Uz to, vijek trajanja varijable instance ne ovisi o bilo kojoj određenoj metodi klase; odnosno njegov životni vijek je životni vijek instance koja ga sadrži.

Primjerci su stvarni objekti koje kreirate iz plana koji dizajnirate u definiciji klase. Varijable instance deklarirate u definiciji klase, utječući na svaku instancu koju kreirate iz plana. Svaka instanca sadrži te varijable instance, a podaci koji se čuvaju unutar varijabli mogu se razlikovati od instance do instance.

Razmotrite AlarmClockrazred. Prolazak snoozeIntervalu snooze()metodi nije vrhunski dizajn. Zamislite da morate utipkati interval odgode na budilici svaki put kad ste dodirnuli gumb za odgodu. Umjesto toga, samo dajte cijeloj budilici a snoozeInterval. To dopunite varijablom instance u AlarmClockklasi, kao što je prikazano u nastavku:

public class AlarmClock { // You declare snoozeInterval here. This makes it an instance variable. // You also initialize it here. long m_snoozeInterval = 5000; // Snooze time in millisecond = 5 secs. public void snooze() { // You can still get to m_snoozeInterval in an AlarmClock method // because you are within the scope of the class. System.out.println("ZZZZZ for: " + m_snoozeInterval); } } 

You can access instance variables almost anywhere within the class that declares them. To be technical about it, you declare the instance variable within the class scope, and you can retrieve it from almost anywhere within that scope. Practically speaking, you can access the variable anywhere between the first curly bracket that starts the class and the closing bracket. Since you also declare methods within the class scope, they too can access the instance variables.

You can also access instance variables from outside the class, as long as an instance exists, and you have a variable that references the instance. To retrieve an instance variable through an instance, you use the dot operator together with the instance. That may not be the ideal way to access the variable, but for now, complete it this way for illustrative purposes:

public class AlarmClockTest { public static void main(String[] args) { // Create two clocks. Each has its own m_snoozeInterval AlarmClock aClock1 = new AlarmClock(); AlarmClock aClock2 = new AlarmClock(); // Change aClock2 // You'll soon see that there are much better ways to do this. aClock2.m_snoozeInterval = 10000; aClock1.snooze(); // Snooze with aClock1's interval aClock2.snooze(); // Snooze with aClock2's interval } } 

Isprobajte ovaj program i vidjet ćete da i aClock1dalje ima interval od 5000, a aClock2interval od 10.000. Opet, svaka instanca ima svoje podatke instance.

Ne zaboravite, definicija klase je samo nacrt, tako da varijable instance zapravo ne postoje dok ne napravite instance iz plana. Svaka instanca klase ima vlastitu kopiju varijabli instance, a nacrt definira koje će te varijable instance biti.

JavaWorld

Kapsulacija

Encapsulation is one of the foundations of object-oriented programming. When using encapsulation, the user interacts with the type through the exposed behavior, not directly with the internal implementation. Through encapsulation, you hide the details of a type's implementation. In Java, encapsulation basically translates to this simple guideline: "Don't access your object's data directly; use its methods."

That is an elementary idea, but it eases our lives as programmers. Imagine, for example, that you wanted to instruct a Person object to stand up. Without encapsulation, your commands could go something like this: "Well, I guess you'd need to tighten this muscle here at the front of the leg, loosen this muscle here at the back of the leg. Hmmm -- need to bend at the waist too. Which muscles spark that movement? Need to tighten these, loosen those. Whoops! Forgot the other leg. Darn. Watch it -- don't tip over ..." You get the idea. With encapsulation, you would just need to invoke the standUp() method. Pretty easy, yes?

Some advantages to encapsulation:

  • Abstraction of detail: The user interacts with a type at a higher level. If you use the standUp() method, you no longer need to know all the muscles required to initiate that motion.
  • Isolation from changes: Changes in internal implementation don't affect the users. If a person sprains an ankle, and depends on a cane for a while, the users still invoke only the standUp() method.
  • Correctness: Users can't arbitrarily change the insides of an object. They can only complete what you allow them to do in the methods you write.

Here's a short example in which encapsulation clearly helps in a program's accuracy:

// Bad -- doesn't use encapsulation public class Person { int m_age; } public class PersonTest { public static void main(String[] args) { Person p = new Person(); p.m_age = -5; // Hey -- how can someone be minus 5 years old? } } // Better - uses encapsulation public class Person { int m_age; public void setAge(int age) { // Check to make sure age is greater than 0. I'll talk more about // if statements at another time. if (age > 0) { m_age = age; } } } public class PersonTest { public static void main(String[] args) { Person p = new Person(); p.setAge(-5); // Won't have any effect now. } } 

Čak i taj jednostavni program pokazuje kako možete naići na probleme ako izravno pristupite internim podacima klasa. Što je program veći i složeniji, to je važnija inkapsulacija. Također imajte na umu da mnogi programi počinju s malim, a zatim rastu i traju unedogled, stoga je neophodno da ih pravilno dizajnirate, od samog početka. Da biste primijenili enkapsulaciju AlarmClock, možete samo stvoriti metode za manipulaciju intervalom odgode.

Napomena o metodama

Metode mogu vratiti vrijednosti koje pozivatelj koristi. Da biste vratili vrijednost, proglasite neizbježni tip povrata i upotrijebite returnizraz. getSnoozeInterval()Postupak prikazan u primjeru ispod ilustrira.

Napišite program