Apa adalah beberapa contoh-contoh kehidupan nyata untuk memahami peran kunci dari pernyataan?
Pernyataan (dengan cara menyatakan kata kunci) yang ditambahkan di Jawa 1.4. Mereka digunakan untuk memverifikasi kebenaran dari yang lain dalam kode. Mereka tidak harus dipicu kode produksi, dan indikasi dari bug atau penyalahgunaan kode jalan. Mereka dapat diaktifkan pada saat run-time dengan cara -ea
pilihan pada jawa
perintah, tetapi tidak diaktifkan secara default.
Contoh:
public Foo acquireFoo(int id) {
Foo result = null;
if (id > 50) {
result = fooService.read(id);
} else {
result = new Foo(id);
}
assert result != null;
return result;
}
Let's asumsikan bahwa anda diharapkan untuk menulis sebuah program untuk mengontrol nuklir pembangkit listrik. Hal ini cukup jelas bahwa bahkan yang paling kecil kesalahan bisa memiliki hasil bencana, oleh karena itu anda kode harus-bug gratis (dengan asumsi bahwa JVM adalah bug-bebas demi argumen).
Java tidak dapat diverifikasi bahasa, yang berarti: anda tidak dapat menghitung hasil operasi anda akan menjadi sempurna. Alasan utama untuk ini adalah pointer: mereka dapat menunjukkan di mana saja atau di mana-mana, oleh karena itu mereka tidak dapat dihitung dari nilai yang tepat, setidaknya tidak dalam waktu yang wajar span kode. Mengingat masalah ini, tidak ada cara untuk membuktikan bahwa kode anda benar pada keseluruhan. Tapi apa yang dapat anda lakukan adalah untuk membuktikan bahwa anda setidaknya menemukan setiap bug ketika itu terjadi.
Ide ini didasarkan pada Desain-dengan-Kontrak (DbC) paradigma: pertama anda tentukan (dengan presisi matematis) apa metode anda lakukan, dan kemudian memverifikasi ini dengan mengujinya selama eksekusi yang sebenarnya. Contoh:
// Calculates the sum of a (int) + b (int) and returns the result (int).
int sum(int a, int b) {
return a + b;
}
Sementara ini cukup jelas untuk bekerja dengan baik, kebanyakan programmer tidak akan melihat serangga yang tersembunyi di dalam yang satu ini (petunjuk: Ariane V jatuh karena mirip bug). Sekarang DbC mendefinisikan bahwa anda harus always memeriksa input dan output dari sebuah fungsi untuk memverifikasi bahwa itu bekerja dengan benar. Java dapat melakukan hal ini melalui pernyataan:
// Calculates the sum of a (int) + b (int) and returns the result (int).
int sum(int a, int b) {
assert (Integer.MAX_VALUE - a >= b) : "Value of " + a + " + " + b + " is too large to add.";
final int result = a + b;
assert (result - a == b) : "Sum of " + a + " + " + b + " returned wrong sum " + result;
return result;
}
Seharusnya fungsi ini sekarang pernah gagal, anda akan melihat itu. Anda akan tahu bahwa ada masalah dalam kode anda, anda tahu di mana itu, dan anda tahu apa yang menyebabkan itu (mirip dengan Pengecualian). Dan apa yang lebih penting: anda berhenti mengeksekusi tepat ketika itu terjadi untuk mencegah kode lebih lanjut untuk bekerja dengan nilai-nilai yang salah dan berpotensi menyebabkan kerusakan apapun itu kontrol.
Jawa Pengecualian adalah konsep yang sama, tetapi mereka gagal untuk memverifikasi segalanya. Jika anda ingin lebih pemeriksaan (pada biaya kecepatan eksekusi) anda perlu menggunakan pernyataan. Melakukan hal ini akan mengasapi kode anda, tetapi anda dapat pada akhirnya menyampaikan produk yang sangat singkat waktu pengembangan (sebelumnya anda memperbaiki bug, semakin rendah biaya). Dan selain itu: jika ada bug dalam kode anda, anda akan mendeteksi itu. Tidak ada cara bug tergelincir dan menyebabkan masalah nantinya.
Ini masih bukan jaminan untuk bug-free code, tapi itu jauh lebih dekat untuk itu, dari program biasa.
Asersi adalah pengembangan alat untuk menangkap bug dalam kode anda. Mereka're dirancang untuk dapat dengan mudah dihapus, sehingga mereka tidak't ada dalam kode produksi. Jadi pernyataan yang bukan merupakan bagian dari "solusi" yang anda berikan kepada pelanggan. Mereka're pemeriksaan internal untuk memastikan bahwa asumsi anda're pembuatan yang benar. Contoh yang paling umum adalah untuk menguji null. Banyak metode yang tertulis seperti ini:
void doSomething(Widget widget) {
if (widget != null) {
widget.someMethod(); // ...
... // do more stuff with this widget
}
}
Sangat sering dalam metode seperti ini, widget harus hanya pernah menjadi null. Jadi jika itu's null, ada's bug dalam kode anda di suatu tempat yang anda butuhkan untuk melacak. Tapi kode di atas tidak akan pernah memberitahu anda ini. Jadi niat baik upaya untuk menulis "aman" kode, anda're juga menyembunyikan bug. It's jauh lebih baik untuk menulis kode seperti ini:
/**
* @param Widget widget Should never be null
*/
void doSomething(Widget widget) {
assert widget != null;
widget.someMethod(); // ...
... // do more stuff with this widget
}
Dengan cara ini, anda akan yakin untuk menangkap bug ini lebih awal. (Itu's juga berguna untuk menentukan dalam kontrak bahwa parameter ini tidak boleh null.) Pastikan untuk mengubah pernyataan pada saat anda menguji kode anda selama pengembangan. (Dan mengajak rekan anda untuk melakukan hal ini, terlalu sering sulit, yang saya temukan sangat mengganggu.)
Sekarang, beberapa rekan-rekan anda akan objek untuk kode ini, dengan alasan bahwa anda masih harus dimasukkan ke dalam null cek untuk mencegah pengecualian dalam produksi. Dalam hal ini, pernyataan ini masih berguna. Anda dapat menulis seperti ini:
void doSomething(Widget widget) {
assert widget != null;
if (widget != null) {
widget.someMethod(); // ...
... // do more stuff with this widget
}
}
Dengan cara ini, anda dan kolega anda akan senang bahwa null memeriksa apakah ada untuk kode produksi, tetapi dalam perkembangannya, anda're tidak lagi menyembunyikan bug ketika widget adalah null.
Berikut ini's dunia nyata contoh: saya pernah menulis sebuah metode yang dibandingkan dua sewenang-wenang nilai-nilai kesetaraan, di mana salah satu nilai yang bisa menjadi null:
/**
* Compare two values using equals(), after checking for null.
* @param thisValue (may be null)
* @param otherValue (may be null)
* @return True if they are both null or if equals() returns true
*/
public static boolean compare(final Object thisValue, final Object otherValue) {
boolean result;
if (thisValue == null) {
result = otherValue == null;
} else {
result = thisValue.equals(otherValue);
}
return result;
}
Kode ini delegasi pekerjaan sama dengan()
metode dalam kasus di mana thisValue tidak null. Tetapi hal ini mengasumsikan sama dengan()
metode dengan benar memenuhi kontrak sama dengan()
dengan benar penanganan null parameter.
Seorang rekan keberatan dengan kode saya, memberitahu saya bahwa banyak dari kelas kami memiliki kereta sama dengan()
metode yang don't test untuk null, jadi aku harus menempatkan itu memeriksa ke dalam metode ini. It's diperdebatkan jika ini adalah bijaksana, atau jika kita harus memaksa kesalahan, sehingga kita dapat melihat dan memperbaikinya, tapi aku tangguhan untuk rekan saya dan dimasukkan ke dalam null check, yang saya've ditandai dengan komentar:
public static boolean compare(final Object thisValue, final Object otherValue) {
boolean result;
if (thisValue == null) {
result = otherValue == null;
} else {
result = otherValue != null && thisValue.equals(otherValue); // questionable null check
}
return result;
}
Tambahan cek di sini, lainnya != null
, ini hanya diperlukan jika sama dengan()
metode gagal untuk memeriksa null seperti yang dipersyaratkan oleh kontrak.
Daripada terlibat dalam sebuah perdebatan sia-sia dengan rekan saya tentang kebijaksanaan membiarkan kereta kode menginap di kode dasar, saya hanya menempatkan dua pernyataan dalam kode. Pernyataan ini akan membiarkan saya tahu, selama tahap pengembangan, jika salah satu kelas kami gagal untuk melaksanakan sama dengan()
benar, sehingga saya bisa memperbaikinya:
public static boolean compare(final Object thisValue, final Object otherValue) {
boolean result;
if (thisValue == null) {
result = otherValue == null;
assert otherValue == null || otherValue.equals(null) == false;
} else {
result = otherValue != null && thisValue.equals(otherValue);
assert thisValue.equals(null) == false;
}
return result;
}
Poin penting untuk diingat adalah ini:
Asersi adalah pengembangan fase hanya alat.
Intinya dari pernyataan ini adalah untuk membiarkan anda tahu jika ada's bug, tidak hanya dalam kode anda, tetapi anda kode dasar. (Pernyataan-pernyataan berikut ini benar-benar akan bendera bug di kelas-kelas lain.)
Bahkan jika rekan saya yakin bahwa kami kelas yang ditulis dengan benar, pernyataan-pernyataan berikut ini masih akan berguna. Kelas baru akan ditambahkan yang mungkin gagal untuk menguji null, dan metode ini dapat bendera bug tersebut untuk kita.
Dalam pengembangan, anda harus selalu mengubah pernyataan di atas, bahkan jika kode anda've tertulis doesn't menggunakan pernyataan. Saya IDE diatur untuk selalu melakukan ini secara default untuk setiap baru eksekusi.
Pernyataan don't perubahan perilaku dari kode produksi, sehingga rekan saya senang bahwa null memeriksa ada, dan bahwa metode ini akan mengeksekusi dengan benar bahkan jika sama dengan()
metode adalah kereta. I'm aku bahagia, karena aku akan menangkap kereta sama dengan()
metode dalam pengembangan.
Juga, anda harus menguji pernyataan kebijakan dengan menempatkan dalam sementara pernyataan bahwa akan gagal, sehingga anda dapat yakin bahwa anda akan diberitahu, baik melalui log file atau stack trace output stream.
Banyak jawaban yang baik menjelaskan apa menegaskan
kata kunci tidak, tapi beberapa menjawab pertanyaan yang sebenarnya, "ketika harus menegaskan
kata kunci yang akan digunakan dalam kehidupan nyata?"
Jawaban: hampir tidak pernah.
Pernyataan, sebagai sebuah konsep, yang indah. Kode yang baik memiliki banyak if (...) membuang ...
laporan (dan kerabat mereka seperti benda-Benda.requireNonNull
dan Matematika.addExact
). Namun, keputusan desain tertentu telah sangat terbatas utilitas menegaskan
kata kunci itu sendiri.
Mengemudi ide di balik menegaskan
kata kunci dini optimasi, dan fitur utama adalah mampu dengan mudah mematikan semua pemeriksaan. Dalam kenyataannya, menegaskan
cek dimatikan secara default.
Namun, hal ini sangat penting bahwa invarian pemeriksaan terus dilakukan di produksi. Hal ini karena tes yang sempurna cakupan adalah mustahil, dan semua kode produksi akan memiliki bug yang pernyataan harus membantu untuk mendiagnosa dan mengurangi.
Oleh karena itu, penggunaan if (...) membuang ...
harus diutamakan, seperti itu diperlukan untuk memeriksa nilai-nilai parameter dari metode umum dan untuk melemparkan IllegalArgumentException
.
Kadang-kadang, satu mungkin tergoda untuk menulis sebuah invarian periksa bahwa tidak mengambil yang diinginkan waktu yang lama untuk proses (dan disebut sering cukup untuk itu untuk hal ini). Namun, pemeriksaan tersebut akan memperlambat pengujian yang juga tidak diinginkan. Seperti yang memakan waktu pemeriksaan yang biasanya ditulis sebagai unit tes. Namun demikian, hal itu mungkin kadang-kadang masuk akal untuk menggunakan menegaskan
untuk alasan ini.
Jangan gunakan menegaskan
hanya karena itu lebih bersih dan lebih cantik dari if (...) membuang ...
(dan saya mengatakan bahwa dengan rasa sakit yang hebat, karena aku suka yang bersih dan cantik). Jika anda hanya tidak dapat membantu diri anda sendiri, dan dapat mengontrol bagaimana anda meluncurkan aplikasi, maka jangan ragu untuk menggunakan menegaskan
tapi selalu mengaktifkan pernyataan di produksi. Memang, ini adalah apa yang saya cenderung melakukan. Saya mendorong untuk lombok penjelasan yang akan menyebabkan menegaskan
untuk bertindak lebih seperti if (...) membuang ...
. Vote untuk itu di sini.
(Kata-kata kasar: JVM devs adalah sekelompok mengerikan, prematur mengoptimalkan coders. Itulah mengapa anda mendengar tentang begitu banyak isu-isu keamanan di Jawa plugin dan JVM. Mereka menolak untuk menyertakan pemeriksaan dasar dan pernyataan dalam kode produksi, dan kami terus membayar harga.)
Berikut ini's penggunaan yang paling umum terjadi. Misalkan anda're switching pada enum nilai:
switch (fruit) {
case apple:
// do something
break;
case pear:
// do something
break;
case banana:
// do something
break;
}
Asalkan anda menangani setiap kasus, anda're halus. Tapi suatu hari nanti, seseorang akan menambahkan gambar ke enum dan lupa untuk menambahkannya ke pernyataan switch. Ini menghasilkan sebuah bug yang mungkin sulit untuk menangkap, karena efek won't dapat dirasakan sampai setelah anda've kiri pernyataan switch. Tapi jika anda menulis anda beralih seperti ini, anda dapat menangkapnya segera:
switch (fruit) {
case apple:
// do something
break;
case pear:
// do something
break;
case banana:
// do something
break;
default:
assert false : "Missing enum value: " + fruit;
}
Pernyataan yang digunakan untuk memeriksa pos-kondisi dan "harus tidak pernah gagal" pra-kondisi. Kode yang benar harus tidak pernah gagal pernyataan; ketika mereka memicu, mereka harus menunjukkan bug (mudah-mudahan di tempat yang lebih dekat untuk di mana sebenarnya lokus dari masalah ini).
Contoh pernyataan mungkin untuk memeriksa bahwa kelompok tertentu dari metode ini disebut dalam urutan yang benar (misalnya, bahwa hasNext()
disebut sebelum next()
dalam Iterator
).
Apa yang menegaskan kata kunci dalam Java lakukan?
Let's melihat disusun bytecode.
Kita akan menyimpulkan bahwa:
public class Assert {
public static void main(String[] args) {
assert System.currentTimeMillis() == 0L;
}
}
menghasilkan hampir sama persis bytecode sebagai:
public class Assert {
static final boolean $assertionsDisabled =
!Assert.class.desiredAssertionStatus();
public static void main(String[] args) {
if (!$assertionsDisabled) {
if (System.currentTimeMillis() != 0L) {
throw new AssertionError();
}
}
}
}
di mana Menegaskan.kelas.desiredAssertionStatus()
adalah benar
ketika -ea
dilewatkan pada baris perintah, dan false jika tidak.
Kita menggunakan Sistem.currentTimeMillis()
untuk memastikan bahwa itu tidak't mendapatkan dioptimalkan jauh (menegaskan sejati;
apa).
Sintetis bidang yang dihasilkan sehingga Jawa hanya perlu memanggil Menegaskan.kelas.desiredAssertionStatus()
sekali pada waktu beban, dan kemudian cache hasilnya ada. Lihat juga: https://stackoverflow.com/questions/5223268/what-is-the-meaning-of-static-synthetic
Kami dapat memverifikasi bahwa dengan:
javac Assert.java
javap -c -constants -private -verbose Assert.class
Dengan Oracle JDK 1.8.0_45, sintetis bidang statis dihasilkan (lihat juga: https://stackoverflow.com/questions/5223268/what-is-the-meaning-of-static-synthetic):
static final boolean $assertionsDisabled;
descriptor: Z
flags: ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC
bersama-sama dengan statis penginisialisasi:
0: ldc #6 // class Assert
2: invokevirtual #7 // Method java/lang Class.desiredAssertionStatus:()Z
5: ifne 12
8: iconst_1
9: goto 13
12: iconst_0
13: putstatic #2 // Field $assertionsDisabled:Z
16: return
dan metode utama adalah:
0: getstatic #2 // Field $assertionsDisabled:Z
3: ifne 22
6: invokestatic #3 // Method java/lang/System.currentTimeMillis:()J
9: lconst_0
10: lcmp
11: ifeq 22
14: new #4 // class java/lang/AssertionError
17: dup
18: invokespecial #5 // Method java/lang/AssertionError."<init>":()V
21: athrow
22: return
Kami menyimpulkan bahwa:
menyatakan
: itu adalah bahasa Jawa konsepmenegaskan
bisa ditiru cukup baik dengan sistem properties -Pcom.saya.menegaskan=true
untuk menggantikan -ea
pada baris perintah, dan membuang baru AssertionError()
.Pernyataan memungkinkan untuk mendeteksi cacat dalam kode. Anda dapat mengaktifkan pernyataan untuk pengujian dan debugging sementara meninggalkan mereka ketika program anda dalam produksi.
Mengapa menegaskan sesuatu ketika anda tahu itu benar? Hal ini hanya berlaku ketika semuanya bekerja dengan benar. Jika program telah cacat, itu tidak mungkin benar-benar menjadi kenyataan. Mendeteksi ini sebelumnya dalam proses memungkinkan anda tahu ada sesuatu yang salah.
Sebuah menegaskan
pernyataan berisi pernyataan ini tersedia dengan opsional String
pesan.
Sintaks untuk menegaskan pernyataan memiliki dua bentuk:
assert boolean_expression;
assert boolean_expression: error_message;
Berikut ini adalah beberapa aturan dasar yang mengatur di mana pernyataan-pernyataan yang harus digunakan, dan di mana mereka tidak harus digunakan. Pernyataan *harus *** dapat digunakan untuk:
Memvalidasi input parameter dari metode swasta. TIDAK untuk metode umum. publik
metode harus membuang biasa pengecualian ketika melewati buruk parameter.
Di mana saja dalam program untuk memastikan validitas dari suatu fakta yang hampir pasti benar.
Misalnya, jika anda yakin bahwa hal itu hanya akan 1 atau 2, anda dapat menggunakan pernyataan seperti ini:
...
if (i == 1) {
...
}
else if (i == 2) {
...
} else {
assert false : "cannot happen. i is " + i;
}
...
Asersi tidak dapat digunakan untuk:
Memvalidasi input parameter dari metode publik. Sejak pernyataan ini tidak selalu dapat dilaksanakan, biasa pengecualian mekanisme yang harus digunakan.
Memvalidasi kendala pada sesuatu yang di input oleh user. Sama seperti di atas.
Tidak boleh digunakan untuk efek samping.
Untuk contoh ini bukan merupakan penggunaan yang tepat karena di sini pernyataan ini digunakan untuk efek samping dari panggilan melakukan sesuatu()
metode.
public boolean doSomething() {
...
}
public void someMethod() {
assert doSomething();
}
Satu-satunya kasus di mana hal ini bisa dibenarkan adalah ketika anda mencoba untuk mencari tahu apakah atau tidak pernyataan diaktifkan dalam kode anda:
boolean enabled = false;
assert enabled = true;
if (enabled) {
System.out.println("Assertions are enabled");
} else {
System.out.println("Assertions are disabled");
}
Selain itu untuk semua jawaban yang diberikan di sini, resmi Java SE 7 panduan pemrograman memiliki cukup ringkas manual menggunakan menegaskan
; dengan beberapa spot-on contoh ketika itu's yang baik (dan, yang penting, buruk) ide untuk menggunakan pernyataan-pernyataan, dan bagaimana hal itu's berbeda dari melemparkan pengecualian.
Menyatakan sangat berguna ketika mengembangkan. Anda gunakan ketika sesuatu tidak bisa* terjadi jika kode anda bekerja dengan benar. It's mudah untuk digunakan, dan dapat tinggal di dalam kode untuk selama-lamanya, karena itu akan dimatikan dalam kehidupan nyata.
Jika ada kemungkinan bahwa kondisi ini dapat terjadi dalam kehidupan nyata, maka anda harus menangani hal itu.
Aku menyukainya, tapi don't tahu bagaimana untuk hidupkan dalam Eclipse/Android/ADT . Tampaknya off bahkan ketika debugging. (Ada thread ini, tapi hal ini mengacu pada 'Java vm', yang tidak muncul dalam ADT Menjalankan Konfigurasi).
Berikut ini's sebuah pernyataan yang saya tulis dalam sebuah server untuk Hibernate/SQL proyek. Entitas bean memiliki dua secara efektif-properti boolean, yang disebut isActive dan isDefault. Masing-masing bisa memiliki nilai "Y" atau "N" atau nol, yang diperlakukan sebagai "N". Kita ingin pastikan browser klien terbatas untuk tiga nilai. Jadi, saya setter untuk dua sifat, saya menambahkan pernyataan ini:
assert new HashSet<String>(Arrays.asList("Y", "N", null)).contains(value) : value;
Pemberitahuan berikut.
Pernyataan ini adalah untuk tahap pengembangan saja. Jika klien mengirimkan nilai buruk, kita akan menangkap bahwa awal dan memperbaikinya, jauh sebelum kita mencapai produksi. Pernyataan ini adalah untuk cacat yang anda dapat menangkap lebih awal.
Pernyataan ini lambat dan tidak efisien. Yang's baik-baik saja. Pernyataan bebas untuk menjadi lambat. Kami don't peduli karena mereka're pengembangan-satunya alat. Ini won't memperlambat kode produksi karena pernyataan akan dinonaktifkan. (Ada's beberapa ketidaksepakatan pada titik ini, yang saya'll mendapatkan nanti.) Ini mengarah ke titik berikutnya.
Pernyataan ini tidak memiliki efek samping. Aku bisa diuji nilai saya terhadap unmodifiable statis Set terakhir, tetapi yang membedakan akan tinggal di sekitar di produksi, di mana itu tidak akan pernah bisa digunakan.
Pernyataan ini ada untuk memverifikasi operasi yang tepat dari klien. Jadi pada saat kita mencapai produksi, kami akan pastikan bahwa klien adalah operasi dengan benar, agar kita dapat dengan aman mengubah pernyataan off.
Beberapa orang menanyakan hal ini: Jika pernyataan isn't yang diperlukan dalam produksi, mengapa tidak hanya mengambil mereka ketika anda're dilakukan? Karena anda'll masih membutuhkan mereka ketika anda mulai bekerja pada versi berikutnya.
Beberapa orang berpendapat bahwa anda harus tidak pernah menggunakan pernyataan, karena anda tidak pernah dapat yakin bahwa semua bug yang hilang, sehingga anda perlu untuk menjaga mereka di sekitar bahkan di produksi. Dan begitu ada's tidak ada gunanya menggunakan menegaskan pernyataan, karena satu-satunya keuntungan untuk menegaskan adalah bahwa anda dapat menonaktifkan mereka. Oleh karena itu, menurut pemikiran ini, anda harus (hampir) tidak pernah menggunakan menegaskan. Saya tidak setuju. It's benar bahwa jika tes termasuk dalam produksi, anda tidak harus menggunakan menegaskan. Tetapi tes ini tidak tidak termasuk dalam produksi. Yang satu ini adalah untuk menangkap bug yang's tidak mungkin untuk pernah mencapai produksi, sehingga aman dapat dimatikan bila anda'kembali dilakukan.
BTW, saya bisa menulis seperti ini:
assert value == null || value.equals("Y") || value.equals("N") : value;
Ini lebih baik untuk hanya tiga nilai, tetapi jika jumlah nilai yang mungkin akan lebih besar, HashSet versi menjadi lebih nyaman. Saya memilih HashSet versi untuk membuat titik saya tentang efisiensi.
Pernyataan yang pada dasarnya digunakan untuk men-debug aplikasi atau digunakan dalam penggantian penanganan pengecualian untuk beberapa aplikasi untuk memeriksa validitas dari sebuah aplikasi.
Pernyataan bekerja pada jangka waktu. Contoh sederhana, yang dapat menjelaskan seluruh konsep yang sangat sederhana, di sini - Apa yang tidak menegaskan kata kunci apa di Jawa? (Wikitanya).
Pernyataan yang dinonaktifkan secara default. Untuk mengaktifkannya kita harus menjalankan program dengan ea
pilihan (granularity dapat bervariasi). Misalnya, jawa -ea AssertionsDemo
.
Ada dua format untuk menggunakan pernyataan:
menegaskan 1==2; // Ini akan meningkatkan AssertionError
.menegaskan 1==2: "tidak ada jalan.. 1 tidak sama dengan 2";
Ini akan menaikkan AssertionError dengan pesan yang diberikan ditampilkan juga dan dengan demikian lebih baik. Meskipun sebenarnya sintaks menegaskan expr1:expr2
di mana expr2 dapat berupa ekspresi mengembalikan nilai, saya telah menggunakannya lebih sering hanya untuk mencetak pesan.Untuk rekap (dan ini benar dari banyak bahasa tidak hanya Jawa):
"menyatakan" ini terutama digunakan sebagai debugging bantuan oleh pengembang perangkat lunak selama proses debugging. Menyatakan-pesan harus tidak pernah muncul. Banyak bahasa memiliki compile-time opsi yang akan menyebabkan semua "menyatakan" untuk diabaikan, untuk digunakan dalam menghasilkan "produksi" kode.
"pengecualian" adalah cara yang berguna untuk menangani segala macam kondisi kesalahan, apakah atau tidak mereka mewakili kesalahan logika, karena, jika anda menjalankan ke dalam kesalahan-kondisi sedemikian rupa sehingga anda tidak dapat melanjutkan, anda hanya dapat "melemparkan mereka ke udara," dari manapun anda berada, mengharapkan orang lain di luar sana yang siap untuk "menangkap" mereka. Kontrol ditransfer dalam satu langkah, langsung dari kode yang melemparkan pengecualian, langsung ke catcher's mitt. (Dan catcher dapat melihat lengkap backtrace panggilan yang telah terjadi.)
Selain itu, penelepon itu subrutin don't harus memeriksa untuk melihat jika subrutin berhasil: "jika kita're di sini sekarang, pasti berhasil, karena jika tidak itu akan dilemparkan pengecualian dan kami tidak't akan di sini sekarang!" strategi sederhana Ini membuat kode-desain dan debugging jauh, jauh lebih mudah.
Pengecualian jika memungkinkan fatal-kondisi kesalahan untuk menjadi apa yang mereka adalah: "pengecualian untuk aturan." Dan, bagi mereka yang akan ditangani oleh kode-jalan yang juga "pengecualian untuk aturan ... "bola terbang!"
Pernyataan pemeriksaan yang mungkin bisa dimatikan. Mereka're jarang digunakan. Mengapa?
hasil != null
seperti pemeriksaan yang sangat cepat dan ada's hampir apa pun untuk menyelamatkan.Jadi, apa yang's kiri? Mahal memeriksa kondisi benar-benar diharapkan untuk menjadi kenyataan. Sebuah contoh yang baik akan menjadi invariants dari struktur data seperti RB-pohon. Sebenarnya, di ConcurrentHashMap
dari JDK8, ada beberapa yang berarti seperti menegaskan untuk TreeNodes
.
Kadang-kadang, cek tersebut tidak benar-benar mahal, tetapi pada saat yang sama, anda're cukup yakin, it'll lulus. Dalam kode saya, ada's misalnya,
assert Sets.newHashSet(userIds).size() == userIds.size();
di mana saya'm cukup yakin bahwa daftar yang saya buat memiliki elemen yang unik, tapi saya ingin dokumen dan periksa.
Pada dasarnya, "menyatakan benar" akan lulus dan "menegaskan palsu" akan gagal. Let's melihat bagaimana ini akan bekerja:
public static void main(String[] args)
{
String s1 = "Hello";
assert checkInteger(s1);
}
private static boolean checkInteger(String s)
{
try {
Integer.parseInt(s);
return true;
}
catch(Exception e)
{
return false;
}
}
menegaskan
adalah kata kunci. Saat itu diperkenalkan pada JDK 1.4. Ada dua jenis `menegaskan ini
menegaskan
pernyataanmenegaskan
pernyataan.Secara default semua menegaskan
pernyataan tidak akan dieksekusi. Jika menegaskan
menerima pernyataan palsu, maka secara otomatis akan menaikkan pernyataan kesalahan.