Bagaimana menyimpan data di objek Java

Terakhir diperbarui: Januari 2020

Meskipun tombol snooze mungkin merupakan tombol yang paling umum digunakan pada jam alarm, bahkan AlarmClockkelas sederhana memerlukan lebih banyak fitur. Misalnya, Anda mungkin ingin mengontrol berapa lama jam alarm akan tetap dalam mode snooze. Untuk menambahkan fitur seperti itu, Anda perlu memahami bagaimana Java mengontrol data.

Pengembang menggunakan variabel di Java untuk menyimpan data, dengan semua variabel memiliki tipe data dan nama. Jenis data menentukan nilai yang dapat dimiliki variabel. Dalam tutorial ini, Anda akan mempelajari bagaimana tipe integral menampung bilangan bulat, tipe floating point menampung bilangan real, dan tipe string menampung string karakter. Kemudian Anda akan mulai menggunakan variabel instance di kelas Java Anda.

Variabel dan tipe primitif

Disebut tipe primitif , tipe integral dan floating point adalah tipe data paling sederhana di Java. Program berikut mengilustrasikan tipe integral, yang dapat menampung bilangan bulat positif dan negatif. Program ini juga mengilustrasikan komentar, yang mendokumentasikan kode Anda tetapi tidak memengaruhi program dengan cara apa pun.

/ * * Ini juga sebuah komentar. Kompilator mengabaikan semuanya mulai dari * yang pertama / * hingga "garis miring bintang" yang mengakhiri komentar. * * Berikut adalah "garis miring bintang" yang mengakhiri komentar. * / public class IntegerTest {public static void main (String [] args) {// Berikut adalah deklarasi variabel int yang disebut anInteger, // yang Anda berikan nilai awal 100. int anInteger = 100; // Deklarasikan dan inisialisasi anInteger System.out.println (anInteger); // Outputs 100 // Anda juga dapat melakukan aritmatika dengan tipe primitif, menggunakan // operator aritmatika standar. anInteger = 100 + 100; System.out.println (anInteger); // Keluaran 200}}

Java juga menggunakan tipe floating point, yang dapat menampung bilangan real, yang berarti bilangan yang menyertakan tempat desimal. Berikut contoh programnya:

public class DoubleTest {public static void main (String [] args) {// Berikut adalah deklarasi variabel ganda yang disebut aDouble. // Anda juga memberi aDouble nilai awal 5.76. ganda aDouble = 5,76; // Deklarasikan dan inisialisasi aDouble System.out.println (aDouble); // Outputs 5.76 // Anda juga dapat melakukan aritmatika dengan tipe floating point. aDouble = 5,76 + 1,45; System.out.println (aDouble); // Keluaran 7.21}}

Coba jalankan program di atas. Ingat, Anda harus mengkompilasi sebelum Anda dapat menjalankannya:

javac * .java java IntegerTest java DoubleTest 

Java menggunakan empat tipe integral dan dua tipe floating point, yang keduanya memiliki rentang angka yang berbeda dan menggunakan jumlah ruang penyimpanan yang berbeda-beda, seperti yang ditunjukkan pada tabel di bawah ini.

Tipe integral

TIPE Byte Pendek Int Panjang
SIZE (bit) 8 16 32 64
JARAK -128 hingga 127 -32.768 hingga 32.767 -2.147.483.648 hingga 2.147.483.647 -263 hingga 263-1

Jenis titik mengambang (format IEEE 754)

 
TIPE Titik mengambang presisi tunggal Titik mengambang presisi ganda
SIZE (bit) 32 64
JARAK +/- 1.18x10-38 hingga +/- 3.4x1038 +/- 2.23x10-308 hingga +/- 1.8x10308

Sebuah tipe string memegang string, dan menangani mereka berbeda dari cara integral dan tipe floating point menangani angka. Bahasa Java menyertakan Stringkelas untuk mewakili string. Anda mendeklarasikan string menggunakan type String, dan menginisialisasinya dengan string yang dikutip, urutan karakter yang terdapat dalam tanda kutip ganda, seperti yang ditunjukkan di bawah ini. Anda juga dapat menggabungkan dua string menggunakan +operator.

// Fragmen kode // Deklarasi variabel berjenis String, // dan inisialisasi dengan kutipan string "Halo." String s = "Halo"; // Penggabungan string dalam s dengan kutipan string "Dunia" String t = s + "Dunia"; System.out.println (t); // Mengeluarkan Hello World

Ruang lingkup variabel

Selain jenis, ruang lingkup juga merupakan karakteristik penting dari suatu variabel. Cakupan menetapkan kapan variabel dibuat dan dimusnahkan dan di mana pengembang dapat mengakses variabel dalam program. Tempat dalam program Anda di mana Anda mendeklarasikan variabel menentukan cakupannya.

Sejauh ini, saya telah membahas variabel lokal , yang menyimpan data sementara yang Anda gunakan dalam suatu metode. Anda mendeklarasikan variabel lokal di dalam metode, dan Anda hanya dapat mengaksesnya dari dalam metode tersebut. Ini berarti bahwa Anda hanya dapat mengambil variabel lokal anInteger, yang Anda gunakan IntegerTest, dan aDoubleyang Anda gunakan DoubleTest, dari metode utama tempat variabel tersebut dideklarasikan dan tidak di tempat lain.

Anda dapat mendeklarasikan variabel lokal dalam metode apa pun. Kode contoh di bawah ini mendeklarasikan variabel lokal dalam AlarmClock snooze()metode:

kelas publik AlarmClock {public void snooze () {// Waktu tunda dalam milidetik = 5 detik lama snoozeInterval = 5000; System.out.println ("ZZZZZ untuk:" + snoozeInterval); }}

Anda hanya bisa mendapatkan snoozeIntervaldari snooze()metode, di mana Anda menyatakansnoozeInterval, as shown here: 

kelas publik AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); aClock.snooze (); // Ini masih bagus. // Baris kode berikutnya adalah ERROR . // Anda tidak dapat mengakses snoozeInterval di luar metode snooze. snoozeInterval = 10000; }}

Parameter metode

Sebuah parameter metode , yang memiliki ruang lingkup yang mirip dengan variabel lokal, adalah jenis lain dari variabel. Parameter metode meneruskan argumen ke dalam metode. Saat Anda mendeklarasikan metode, Anda menentukan argumennya dalam daftar parameter. Anda meneruskan argumen saat memanggil metode. Parameter metode berfungsi mirip dengan variabel lokal karena berada dalam lingkup metode yang ditautkan, dan dapat digunakan di seluruh metode. Namun, tidak seperti variabel lokal, parameter metode mendapatkan nilai dari pemanggil saat memanggil metode. Berikut modifikasi jam alarm yang memungkinkan Anda lewat di snoozeInterval.

kelas publik AlarmClock {public void snooze (long snoozeInterval) {System.out.println ("ZZZZZ for:" + snoozeInterval); }}
kelas publik AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); // Lewati interval tunda saat Anda memanggil metode ini. aClock.snooze (10000); // Tunda selama 10.000 mdet. }}

Variabel anggota: Bagaimana objek menyimpan data

Variabel lokal berguna, tetapi karena mereka hanya menyediakan penyimpanan sementara, nilainya terbatas. Karena masa pakainya menjangkau panjang metode di mana mereka dideklarasikan, variabel lokal dibandingkan dengan notepad yang muncul setiap kali Anda menerima panggilan telepon, tetapi menghilang saat Anda menutup telepon. Penyiapan itu dapat berguna untuk mencatat catatan, tetapi terkadang Anda membutuhkan sesuatu yang lebih permanen. Apa yang harus dilakukan seorang programmer? Masukkan variabel anggota .

Variabel anggota - yang ada dua, instance dan statis - menjadi bagian dari kelas.

Ruang lingkup dan umur variabel

Pengembang mengimplementasikan variabel instan untuk memuat data yang berguna untuk kelas. Variabel instance berbeda dari variabel lokal dalam sifat cakupan dan masa pakainya. Seluruh kelas membentuk ruang lingkup variabel instan, bukan metode yang dideklarasikan. Dengan kata lain, developer dapat mengakses variabel instance di mana pun di dalam kelas. Selain itu, masa pakai variabel instance tidak bergantung pada metode tertentu dari kelas; artinya, masa hidupnya adalah masa hidup instance yang memuatnya.

Instance adalah objek aktual yang Anda buat dari cetak biru yang Anda desain dalam definisi kelas. Anda mendeklarasikan variabel instance dalam definisi kelas, yang memengaruhi setiap instance yang Anda buat dari cetak biru. Setiap instance berisi variabel instance tersebut, dan data yang disimpan di dalam variabel dapat bervariasi dari instance ke instance.

Pertimbangkan AlarmClockkelasnya. Meneruskan snoozeIntervalke dalam snooze()metode bukanlah desain yang bagus. Bayangkan harus mengetikkan interval tunda pada jam alarm Anda setiap kali Anda mencari tombol snooze. Sebaliknya, berikan saja seluruh jam alarm a snoozeInterval. Anda menyelesaikan ini dengan variabel instan di AlarmClockkelas, seperti yang ditunjukkan di bawah ini:

public class AlarmClock {// Anda mendeklarasikan snoozeInterval di sini. Ini menjadikannya sebagai variabel instan. // Anda juga memulainya di sini. panjang m_snoozeInterval = 5000; // Waktu tunda dalam milidetik = 5 detik. public void snooze () {// Anda masih bisa masuk ke m_snoozeInterval dalam metode AlarmClock // karena Anda berada dalam cakupan kelas. System.out.println ("ZZZZZ untuk:" + m_snoozeInterval); }}

Anda dapat mengakses variabel instan hampir di mana saja dalam kelas yang mendeklarasikannya. Untuk menjadi teknis tentang itu, Anda mendeklarasikan variabel instance dalam lingkup kelas , dan Anda dapat mengambilnya hampir dari mana saja dalam lingkup itu. Secara praktis, Anda dapat mengakses variabel di mana saja antara kurung kurawal pertama yang memulai kelas dan tanda kurung tutup. Karena Anda juga mendeklarasikan metode dalam ruang lingkup kelas, mereka juga dapat mengakses variabel instan.

Anda juga dapat mengakses variabel instance dari luar kelas, selama ada instance, dan Anda memiliki variabel yang mereferensikan instance tersebut. Untuk mengambil variabel instance melalui sebuah instance, Anda menggunakan operator titik bersama dengan instance tersebut. Itu mungkin bukan cara yang ideal untuk mengakses variabel, tetapi untuk saat ini, selesaikan dengan cara ini untuk tujuan ilustrasi:

public class AlarmClockTest {public static void main (String [] args) {// Buat dua jam. Masing-masing memiliki m_snoozeInterval AlarmClock aClock1 = new AlarmClock (); AlarmClock aClock2 = AlarmClock baru (); // Ubah aClock2 // Anda akan segera melihat bahwa ada cara yang jauh lebih baik untuk melakukan ini. aClock2.m_snoozeInterval = 10000; aClock1.snooze (); // Tunda dengan interval aClock1 aClock2.snooze (); // Tunda dengan interval aClock2}}

Cobalah program ini, dan Anda akan melihat bahwa aClock1masih memiliki interval 5.000 sedangkan aClock2interval 10.000. Sekali lagi, setiap instance memiliki data instance-nya sendiri.

Jangan lupa, definisi kelas hanyalah cetak biru, jadi variabel instans tidak benar-benar ada hingga Anda membuat instance dari cetak biru tersebut. Setiap instance kelas memiliki salinan variabel instannya sendiri, dan cetak biru menentukan apa variabel instan tersebut.

JavaWorld

Enkapsulasi

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. } } 

Bahkan program sederhana itu menunjukkan bagaimana Anda bisa tergelincir ke dalam masalah jika Anda langsung mengakses data internal kelas. Semakin besar dan kompleks programnya, enkapsulasi menjadi semakin penting. Juga ingat bahwa banyak program yang dimulai dari kecil dan kemudian berkembang untuk bertahan tanpa batas, jadi penting bagi Anda untuk mendesainnya dengan benar, langsung dari awal. Untuk menerapkan enkapsulasi AlarmClock, Anda cukup membuat metode untuk memanipulasi interval snooze.

Catatan tentang metode

Metode dapat mengembalikan nilai yang digunakan pemanggil. Untuk mengembalikan nilai, nyatakan tipe pengembalian nonvoid, dan gunakan returnpernyataan. The getSnoozeInterval()Metode ditunjukkan dalam contoh di bawah ini menggambarkan hal ini.

Tulis programnya