IDEA: pemfaktoran semula

"Hello lagi."

"Hai!"

"Hari ini saya akan memberitahu anda tentang pemfaktoran semula. Pemfaktoran semula ialah menukar kod dalam projek tanpa mengubah fungsinya."

"Tetapi bagaimana mungkin?"

"Nah, dalam kes paling mudah, kita boleh menamakan semula pembolehubah dan/atau kaedah. Lagipun, menukar nama pembolehubah tidak akan menjadikan program berfungsi secara berbeza, bukan?"

"Sudah tentu tidak."

"Anda juga boleh memecahkan kaedah besar kepada beberapa kaedah yang lebih kecil. "

"Anda boleh menarik coretan kod berulang ke dalam kaedah yang berasingan. "

"Sesetengah fungsi boleh diisytiharkan statik dan kemudian dipindahkan ke kelas utiliti."

"Tetapi ini adalah tafsiran sempit pemfaktoran semula."

"Pemfaktoran semula kadangkala bermaksud menulis semula (memperbaiki) seni bina projek tanpa menambah fungsi baharu. Ini adalah pemfaktoran semula dalam erti kata yang luas."

"IntelliJ IDEA menjadi persekitaran pembangunan bersepadu (IDE) yang paling popular secara khusus kerana ia adalah yang pertama memperkenalkan alat pemfaktoran semula yang sangat berkuasa."

"Apakah alat ajaib ini?"

Silap mata #1: Tukar nama kaedah.

"Bayangkan bahawa kod anda mempunyai kaedah yang dipanggil dari 100-500 tempat yang berbeza. Anda telah memutuskan untuk menukar namanya kepada sesuatu yang lebih mudah difahami. Katakan ia dijalankan(), dan anda mahu ia dijalankanDownloadTaskAsync(). Sepantasnya boleh awak buat macam tu?"

"Nah, mula-mula anda perlu menukar nama kaedah, kemudian cari semua tempat dalam program di mana kaedah itu dipanggil, dan tukar nama di sana juga."

"Dan bagaimana anda boleh mencari tempat-tempat itu?"

"Saya baru sahaja menjalankan program dan IntelliJ IDEA akan menunjukkan kepada saya semua tempat di mana kaedah yang tidak wujud dipanggil."

"Baiklah. Tetapi sekarang anggap bahawa setiap kaedah mempunyai ulasan penjelasan (JavaDoc) yang menerangkan perkara yang dilakukan oleh kaedah itu — dan nama kaedah lama ditulis di sana."

"Saya juga akan menukar komen."

"Tetapi mungkin terdapat juga pembolehubah yang namanya dikaitkan dengan nama kaedah. Adalah baik untuk menukarnya juga:"

Task task = manager.run();

Task asyncTask = manager.runDownloadTaskAsync();

"Ya, adalah baik untuk menukar nama pembolehubah itu juga. Ia tidak menyakitkan."

"Nah, semua ini boleh dilakukan dalam beberapa saat sahaja menggunakan IntelliJ IDEA!"

"Anda meletakkan kursor pada nama kaedah (atau klik dengan tetikus), dan kemudian tekan Shift+F6 dan hanya mula menaip nama kaedah yang diingini."

"Berikut ialah contoh mengedit nama kaedah."

"Mula mengedit:"

"Nyatakan nama baharu:"

"Cukup masukkan nama baharu, tekan enter, dan itu sahaja. Kaedah ini akan dinamakan semula di mana-mana sahaja ia dipanggil dalam projek."

"IntelliJ IDEA juga biasanya bertanya sama ada anda ingin menamakan semula nama pembolehubah dan nama kaedah dalam ulasan. Hanya klik 'Ya' dan ia akan mengubah segala-galanya."

"Apatah lagi, jika projek itu disusun sebelum operasi pemfaktoran semula ini, maka ia dijamin untuk disusun selepas pemfaktoran semula."

"Kedengarannya sangat menjanjikan."

"Dengan cara ini, anda boleh menukar nama pembolehubah dengan cara yang sama. Selepas mengklik nama, hanya tekan Shift+F6 — Anda kemudian boleh memasukkan nama baharu dan IntelliJ akan menukar nama pembolehubah di mana sahaja ia digunakan. "

"Jika pembolehubah ialah medan dalam kelas dan mempunyai pengambil dan penetap, maka nama pemetik dan penetap juga akan ditukar agar sepadan dengan nama baharu pembolehubah itu."

"Saya mencubanya menggunakan pembolehubah. Semuanya berfungsi seperti yang anda katakan, Ellie. Pemfaktoran semula adalah hebat!"

"Adakah anda fikir itu sahaja yang ada untuk pemfaktoran semula? Refractoring adalah topik yang begitu luas - kami tidak pernah menconteng permukaannya."

"Wah. Ada apa lagi?"

Silap mata #2: Ekstrak pembolehubah.

"Kadangkala ungkapan tertentu diulang begitu kerap dalam kod sehingga anda mahu mengalihkannya ke pembolehubah yang berasingan. Contohnya:"

public void printInfo(User user)
{
 System.out.println(user.getProfile().getName());
 System.out.println(user.getProfile().getAddress().getState());
 System.out.println(user.getProfile().getAddress().getCity());
 System.out.println(user.getProfile().getAddress().getStreet());
 System.out.println(user.getProfile().getAddress().getHomeNumber());
}

public void printInfo(User user)
{
 Address address = user.getProfile().getAddress();

 System.out.println(user.getProfile().getName());
 System.out.println(address.getState());
 System.out.println(address.getCity());
 System.out.println(address.getStreet());
 System.out.println(address.getHomeNumber());
}

"Ah."

"Dan kod boleh menjadi lebih rumit, dengan banyak bahagian berulang."

"Pengaturcara tidak menulisnya seperti itu dengan sengaja. Tetapi anda selalunya perlu menambah sesuatu pada kaedah, kemudian sesuatu yang lain - dan dari masa ke masa bilangan ulangan melalui bumbung."

"Dengan mencipta pembolehubah yang berasingan, kami boleh memberikannya nama yang betul dan meningkatkan kebolehbacaan kod."

"Sebagai contoh, dalam contoh di atas, mungkin kita tidak bercakap tentang alamat rumah. Mungkin kita bercakap tentang alamat kenalan kecemasan. Kemudian anda boleh menghubungi emergencyContactAddress berubah ini, bukannya hanya alamat. Kemudian, seorang pengaturcara melihat kod ini buat kali pertama akan memahami apa yang berlaku di sini."

"Ya, saya setuju. Menambah pembolehubah sedemikian masuk akal."

"Jadi, macam mana nak buat?"

"Menggerakkan ungkapan ke dalam pembolehubah yang berasingan adalah sangat mudah."

Langkah 1: Gunakan tetikus untuk memilih ungkapan.

Langkah 2: Tekan Ctrl+Alt+V

"Tetingkap terbuka di mana IntelliJ IDEA bertanya kepada kami sama ada kami mahu menggantikan hanya ungkapan yang dipilih atau semua contoh ungkapan (4 kejadian)?"

"Pilih pilihan kedua untuk menggantikan semua kejadian (Ganti semua 4 kejadian)"

Langkah 3: Tekan Enter.

"IntelliJ IDEA akan menggesa anda untuk memasukkan nama pembolehubah. Ia juga akan membuat cadangannya sendiri untuk nama itu. Not bad, eh?"

"Uh-huh. Betul. Kami juga merancang untuk menamakan 'alamat' pembolehubah itu. Bagaimana ia tahu?"

"Dengan menggunakan nama kaedah terakhir dalam ungkapan, yang mengembalikan alamat. Oleh itu, kemungkinan pembolehubah akan digunakan untuk menyimpan alamat."

"Itu berjaya dengan baik. Perkara yang hebat, Ellie."

Silap mata #3: Ekstrak kod ke dalam kaedah yang berasingan.

"Tetapi kami boleh melakukan sesuatu yang lain. Kami boleh mengisytiharkan kaedah baharu, contohnya printAddress (), dan memindahkan semua kod ini ke dalamnya."

"Mari cuba lakukan itu."

Langkah 1: Pilih 4 baris kod yang menggunakan pembolehubah alamat:

Langkah 2: tekan Ctrl+Alt+M

"IntelliJ IDEA menentukan pembolehubah mana yang diperlukan oleh kaedah dan mencadangkan rupa yang sepatutnya. "Satu-satunya perkara yang tinggal ialah memasukkan nama untuk kaedah itu."

Langkah 3: Masukkan printAddress sebagai nama kaedah dan tekan Enter.

"Macam mana awak suka?"

"Ia hebat. IntelliJ IDEA bukan sahaja mengekstrak kod ke dalam kaedah berasingan, ia juga menambahkan semua pembolehubah yang diperlukan. Lebih-lebih lagi, ia meneka semua nama dengan betul."