Java'da uygulanabilir olduğunda “son” değiştiriciyi kullanma [kapalı]

Java'da, her bir değişkeni (yerel veya sınıf), gerçekten de varsa final parametresini bildirme uygulaması vardır.

Bu, kodu çok daha ayrıntılı hale getirmesine rağmen, bu, kodun kolay okunmasına / kavranmasına yardımcı olur ve ayrıca niyet açıkça işaretlendiğinden hataları önler.

Bu konudaki düşünceleriniz neler ve neler takip ediyorsunuz?

Her şeyin iyi kodlama stiliyle ilgisi olduğunu düşünüyorum. Tabii ki, herhangi bir finalyerde çok fazla değiştirici kullanmadan iyi, sağlam programlar yazabilirsiniz , ancak düşündüğünüzde ...

Ekleme finaltüm şeyler olmamalı basitçe değiştirmek siz (veya kod üzerinde çalışan sonraki programcı,) yanlış anlaşılabilir veya kod sonuçlandı düşünce sürecini kötüye kullanılmayacağına dair olasılıklar daraltır. En azından şimdi daha önce değişmez olanı değiştirmek istediklerinde çanlar çalmalı.

İlk başta, finalkodunuzda çok sayıda anahtar kelime görmek biraz garip görünüyor , ancak kısa süre sonra kelimenin kendisini fark etmeyi bırakacaksınız ve sadece, bu noktadan asla değişmeyecek üzerinde (benden alabilirsin ;-)

Bence bu iyi bir uygulama. Her zaman kullanmıyorum, ama yapabileceğim ve bir şeyi etiketlemek mantıklı olduğunda finalbunu yapacağım.

Takıntılı:

• Son alanlar - Alanları son olarak işaretlemek, inşaat bitimine göre ayarlanmaya zorlar ve bu alan referansını değişmez kılar. Bu, alanların güvenli bir şekilde yayınlanmasını sağlar ve daha sonraki okumalarda senkronizasyon ihtiyacını önleyebilir. (Bir nesne başvurusu için yalnızca alan başvurusunun değiştirilemez olduğunu unutmayın - nesne başvurusunun başvurduğu şeyler değişebilir ve değişmezliği etkiler.)
• Son statik alanlar - Artık statik son alanları kullandığım çoğu durumda enum kullanmama rağmen.

Şunları düşünün, ancak dikkatli kullanın:

• Son sınıflar - Çerçeve / API tasarımı bunu düşündüğüm tek durum.
• Son yöntemler - Temel olarak son sınıflarla aynı. Çılgın ve işaretleme gibi final şablonu yöntem kalıpları kullanıyorsanız, muhtemelen mirasa çok fazla güveniyorsunuz ve yetki devrine yetmiyorsunuz.

Anal hissetmedikçe yoksay:

• Yöntem parametreleri ve yerel değişkenler - Tembel olduğum ve kodu kümeler bulduğu için nadiren bunu büyük ölçüde yaparım. Ben değiştirmeyeceğim işaretleme parametreleri ve yerel değişkenlerin "daha righter" olduğunu tamamen kabul edeceğim. Keşke varsayılan olsaydı. Ama değil ve her yerde finaller ile kodu anlamak daha zor buluyorum. Başkasının kodundaysam, onları dışarı çekmeyeceğim ama yeni kod yazıyorsam, onları koymayacağım. Bir istisna, erişebilmeniz için son şeyi işaretlemeniz gereken durum anonim bir iç sınıfın içinden.

Kullanmadan önce son anahtar kelimenin tam kullanımını anlamalısınız. Değişkenler, alanlar, yöntemler ve sınıflara uygulanabilir ve farklı etkileri vardır

Daha fazla ayrıntı için aşağıdaki bağlantıyla ilgili makaleye göz atmanızı tavsiye ederim.

Son Anahtar Kelimedeki Son Söz

finalÖzellikle değişkenler için modifiye edici, bir araç derleyici genellikle mantıklı bir kongre zorlamak sağlamaktır: emin (yerel ya da örnek) değişken (daha az) yalnızca bir kez tahsis olun. Bir değişkenin kullanılmadan önce kesinlikle atandığından emin olarak, aşağıdaki genel durumlardan kaçınabilirsiniz NullPointerException:

final FileInputStream in;
if(test)
  in = new FileInputStream("foo.txt");
else
  System.out.println("test failed");
in.read(); // Compiler error because variable 'in' might be unassigned

Bir değişkenin birden çok kez atanmasını engelleyerek aşırı genişlemeli kapsamayı engellemezsiniz. Bunun yerine:

 String msg = null;
 for(int i = 0; i < 10; i++) {
     msg = "We are at position " + i;
     System.out.println(msg);
 }
 msg = null;

Bunu kullanmanız önerilir:

 for(int i = 0; i < 10; i++) {
     final String msg = "We are at position " + i;
     System.out.println(msg);
 }

Bazı bağlantılar:

• Son hikaye ("Hardcore Java" kitabının ücretsiz bölümü)
• Bazı son kalıplar
• Kesin ödev

Olası her değişkeni bildirme konusunda oldukça dogmatikim final. Buna yöntem parametreleri, yerel değişkenler ve nadiren değer nesnesi alanları da dahildir. Son değişkenleri her yerde bildirmek için üç ana nedenim var:

1. Niyet Bildirme: Son bir değişken bildirerek, bu değişkenin yalnızca bir kez yazılması gerektiğini belirtiyorum. Diğer geliştiriciler için ince bir ipucu ve derleyiciye büyük bir ipucu.
2. Tek Kullanımlık Değişkenleri Zorlamak: Her değişkenin hayatta tek bir amacı olması gerektiği fikrine inanıyorum. Her değişkene yalnızca bir amaç vererek, hata ayıklama sırasında söz konusu değişkenin amacına ulaşmak için gereken süreyi azaltırsınız.
3. Optimizasyona İzin Verir: Derleyicinin, özellikle değişken bir referansın değişmezliğine dayanan performans artırma numaralarına sahip olduğunu biliyorum. Bu eski performans hilelerinin (veya yenilerinin) derleyici tarafından kullanılacağını düşünüyorum.

Ancak, son sınıf ve yöntemlerin son değişken referansları kadar kullanışlı olmadığını düşünüyorum. finalBu bildirimleri ile kullanıldığında anahtar kelime, sadece otomatik test ve beklenen asla olabileceğini yollarla kod kullanımına barikatlar sağlarlar.

Etkili Java'nın "Değiştirilemez nesneleri favoriler" yazan bir öğesi vardır. Alanları nihai olarak bildirmek, bu konuda bazı küçük adımlar atmanıza yardımcı olur, ancak elbette gerçekte değişmeyen nesneler bundan çok daha fazlası vardır.

Nesnelerin değişmez olduğunu biliyorsanız, senkronizasyon endişeleri olmadan birçok iş parçacığı / istemci arasında okumak için paylaşılabilirler ve programın nasıl çalıştığına karar vermek daha kolaydır.

Değişken üzerinde son bir anahtar kelimeye sahip olmamın bir hata yapmamı engellediği bir durumda bulunmadım, bu yüzden şu an için dev bir zaman kaybı.

Bunu yapmak için gerçek bir neden olmadığı sürece (içinde olduğu gibi bu değişken nihai olmak hakkında belirli bir noktaya yapmak istiyorum) Ben kodu daha az okunabilir yapar bulmak çünkü ben bunu yapmaz.

Bununla birlikte, kodun okunmasını zorlaştırır veya yazmayı daha uzun hale getirirse, elbette bunun için gidin.

Düzenleme: Bir açıklama olarak (ve aşağı oy geri kazanmak için bir girişim olarak), sabitleri nihai olarak işaretleme demiyorum, böyle şeyler yapmayın demiyorum:

public String doSomething() {
  final String first = someReallyComplicatedExpressionToGetTheString();
  final String second = anotherReallyComplicatedExpressionToGetAnother();

  return first+second;
}

Sadece kodu (bence) okumayı zorlaştırıyor.

Ayrıca, tüm finalin bir değişkeni yeniden atamanızı önlemek olduğunu, onu değişmez hale getirmediğini veya bunun gibi bir şey olmadığını hatırlamakta fayda var.

Final daima sabitler için kullanılmalıdır. Değişkeni tanımlamak için kurallar karmaşık olduğunda kısa ömürlü değişkenler için (tek bir yöntem içinde) bile yararlıdır.

Örneğin:

final int foo;
if (a)
    foo = 1;
else if (b)
    foo = 2;
else if (c)
    foo = 3;
if (d)        // Compile error:  forgot the 'else'
    foo = 4;
else
    foo = -1;

En büyük argüman biri gibi Sesler karşı son anahtar kelimeyi kullanarak "Gereksiz" olduğunu ve bu "atıklar boşluk".

Buradaki birçok harika gönderinin işaret ettiği gibi "final" in birçok faydasını kabul edersek, daha fazla yazım ve yer kapladığını kabul ederken, Java'nın varsayılan olarak "final" değişkenleri yapmış olması ve şeylerin işaretlenmesini gerektirdiğini "iddia ediyorum. kodlayıcı olmasını isterse değişebilir.

finalNesne nitelikleri için her zaman kullanıyorum .

finalNesne niteliklerini kullanıldığında anahtar kelime görünürlüğü anlambilim vardır. Temel olarak, son nesne özniteliğinin değerinin ayarlanması, kurucu dönmeden önce olur. Bu, thisbaşvurunun kurucudan kaçmasına izin vermediğiniz ve tüm öznitelikleriniz finaliçin kullandığınız sürece , nesnenizin (Java 5 anlambilimi altında) düzgün bir şekilde inşa edileceği garantisi ve aynı zamanda değişmez olduğu için güvenli bir şekilde yayınlanabilir diğer konulara.

Değişmez nesneler sadece iş parçacığı güvenliği ile ilgili değildir. Ne uzay çünkü onlar da, sizin programa durum geçişi hakkında nedenden büyük kolaylık olabilir sürekli kullanıldığında değiştirmek iyice yalnızca şeylerin sınırlı, kasten ve gerektiği değiştirin.

Bazen yöntemleri de son haline getiriyorum ama sık değil. Dersleri nadiren bitiririm. Bunu genelde yaparım çünkü çok az ihtiyacım var. Genellikle miras fazla kullanmıyorum. Bunun yerine arayüzleri ve nesne kompozisyonunu kullanmayı tercih ediyorum - bu da kendini test etmenin daha kolay olduğunu düşündüğüm bir tasarıma sahip. Somut sınıflar yerine arayüzlere kod yazdığınızda, jMock gibi çerçevelerle, sınıfa dayalı nesneler oluşturmak için, somut sınıflardan çok daha kolay bir şekilde test ederken kalıtım kullanmanız gerekmez .

Sanırım sınıflarımın çoğunu final yapmalıyım, ama henüz alışkanlığa girmedim.

İşim için çok fazla kod okumak zorundayım. Örnek değişkenleri üzerinde eksik final, beni rahatsız eden en önemli şeylerden biridir ve kodu anlamayı gereksiz yere zorlaştırır. Param için, yerel değişkenler üzerindeki final netlikten daha fazla dağınıklığa neden oluyor. Dil, bunu varsayılan yapmak için tasarlanmış olmalı, ancak hatayla yaşamak zorundayız. Bazen özellikle döngüler ve if-else ağacı olan kesin atamalarda yararlıdır, ancak çoğunlukla yönteminizin çok karmaşık olduğunu gösterir.

final , sabitler üzerinde ve değişmezliği zorlamak için açık bir şekilde kullanılmalıdır, ancak yöntemlerde başka bir önemli kullanım daha vardır.

Etkili Java , bu konuda (Madde 15) istenmeyen kalıtımın tuzaklarını gösteren bir öğeye sahiptir. Sınıfınızı kalıtım için tasarlamadıysanız ve belgelemediyseniz, ondan miras almak beklenmedik sorunlara neden olabilir (öğe iyi bir örnek verir). Bu nedenle öneri, miras alınması amaçlanmamış herhangi bir sınıf ve / veya yöntemde final kullanmanızdır .

Bu acımasız görünebilir, ama mantıklı. Başkaları tarafından kullanılmak üzere bir sınıf kütüphanesi yazıyorsanız, bunun için tasarlanmamış şeylerden miras almasını istemezsiniz - kendinizi geri uyumluluk için sınıfın belirli bir uygulamasına kilitleyeceksiniz. Eğer bir takımda kod yazıyorsanız, takımın başka bir üyesinin, eğer gerçekten yapmaları gerekiyorsa finali çıkarmasını engelleyecek hiçbir şey yoktur . Ancak anahtar kelime, ne yaptıklarını düşünmelerini sağlar ve miras aldıkları sınıfın bunun için tasarlanmadığı konusunda uyarır, bu yüzden ekstra dikkatli olmaları gerekir.

Başka bir uyarı, birçok insanın finali karıştırmasıdır, bu durumda örnek değişkeninin içeriğinin, referansın değişememesi yerine değişemeyeceği anlamına gelir.

Yerel değişkenler için bile, son olarak bildirildiğini bilmek, referansın daha sonra değiştirilmesinden endişe etmem gerekmediği anlamına gelir. Bu, hata ayıklama ve daha sonra bu değişkeni gördüğümde, aynı nesneye atıfta bulunduğundan emin olduğum anlamına gelir. Bu, bir hata ararken endişelenmem gereken daha az şey. Bonus, eğer değişkenlerin% 99'u nihai olarak bildirilirse, gerçekten değişken olan birkaç değişken daha iyi gözükür. Ayrıca, final, derleyicinin aksi takdirde fark edilmeyebilecek daha olası bazı aptal hataları bulmasını sağlar.

finalHer yöntemdeki her parametre için yazmayı seçmek, hem kodlayıcılar hem de kod okuyucuları için çok fazla tahrişe neden olacaktır.

Tahriş makul bir şekilde ötesinde, argümanların varsayılan olarak nihai olduğu Scala'ya geçer.

Veya, bunu sizin için otomatik olarak yapacak kod oluşturma araçlarını her zaman kullanabilirsiniz. Tüm IDE'ler bunları uygular veya eklenti olarak kullanır.

Java'da değişkenlerle kullanıldığında final, C ++ 'da sabitin yerine geçer. Böylece bir değişken için nihai ve statik kullanıldığında değişmez olur. Aynı zamanda taşınan C ++ programcılarını oldukça mutlu ediyor ;-)

Referans değişkenlerle birlikte kullanıldığında, nesneye müdahale edilmesine rağmen nesneye yeniden başvurmanıza izin vermez.

Final bir yöntemle kullanıldığında, yöntemin alt sınıflar tarafından gereğinden fazla kullanılmasına izin vermez.

Kullanım çok netleştikten sonra dikkatli kullanılmalıdır. Esas olarak, yöntemin nihai olarak kullanılması polimorfizme yardımcı olmayacağı için tasarıma bağlıdır.

Değişkenler için değişkenin değerinin asla değiştirilmeyeceğinden / değiştirilmemesinden emin olduğunuzda değişkenler için kullanılmalıdır. Ayrıca SUN tarafından teşvik edilen kodlama kuralına uyduğunuzdan emin olun. Örneğin: final int COLOR_RED = 1; (Büyük harf alt çizgi ile ayrılır)

Bir referans değişkeni ile, sadece belirli bir nesneye değişmez bir referansa ihtiyaç duyduğumuzda kullanın.

Okunabilirlik kısmıyla ilgili olarak, son değiştiriciyi kullanırken yorumların çok önemli bir rol oynadığından emin olun.

Onları hiçbir zaman yerel değişkenler üzerinde kullanmıyorum, eklenen ayrıntı düzeyinin çok az anlamı var. Değişkenin yeniden atanması gerektiğini düşünmeseniz bile, aksi düşünen kodu değiştiren bir sonraki kişi için çok az fark yaratacaktır ve kod değiştirildiği için, onu son haline getirmek için herhangi bir orijinal amaç artık geçerli olmayabilir. Sadece netlik içinse, ayrıntıların olumsuz etkileri nedeniyle başarısız olduğuna inanıyorum.

Aynı durum üye değişkenleri için de geçerlidir, çünkü sabitler haricinde çok az fayda sağlarlar.

Aynı zamanda değişmezlik üzerinde hiçbir etkisi yoktur, çünkü değişmez bir şeyin en iyi göstergesi, bu şekilde belgelenmesi ve / veya nesneyi değiştirebilecek hiçbir yönteminin olmamasıdır (bu, sınıfın final yapılması ile birlikte bunu garanti etmenin tek yoludur. değişmez).

Ama hey, bu sadece benim görüşüm :-)

Eclipse'i değiştirilmemiş tüm alanlara ve niteliklere final eklemek için ayarladım. Bu, dosyayı kaydederken bu son değiştiricileri (diğer şeylerin yanı sıra) ekleyen Eclipse "kaydetme eylemleri" kullanılarak harika çalışır.

Şiddetle tavsiye edilir.

Eclipse Save Eylemler blog gönderime göz atın .

Tartışmalar için bence gerekli değiller. Çoğunlukla okunabilirliğe zarar verirler. Bir argüman değişkenini yeniden atamak o kadar aptalca ki yine de sabit olarak değerlendirilebileceğinden oldukça emin olmalıyım.

Eclipse renklerinin nihai kırmızı olması, kodda değişken bildirimleri tespit etmeyi kolaylaştırıyor.

Ben herhangi bir ve tüm değişkenlerin kesin olması gerektiği kuralı uygulamaya çalışıyorum. "Bu değişken nedir?" Diye cevaplamak çok daha kolay sadece başlatmayı bulmanız ve bunun olduğundan emin olmanız gerekir.

Aslında artık bir gün içinde nihai olmayan değişkenler konusunda oldukça tedirgin oluyorum. Kafanın üstünde bir ipte asılı bir bıçağa sahip olmak ya da sadece mutfak çekmecesine sahip olmak arasındaki fark gibi ...

Son değişken, değerleri etikelleştirmenin güzel bir yoludur.

Nihai olmayan bir değişken bazı hata eğilimli algoritmanın bir kısmına bağlıdır.

Bir güzel özellik, bir değişken için bir algoritma için bir değişkenin kullanılması seçeneği olduğunda, çoğu zaman çözüm, genellikle kodu önemli ölçüde geliştiren bir yöntem yazmaktır.

Bir süredir kod yazıyorum ve elimden geldiğince final kullanıyorum. Bunu bir süre yaptıktan sonra (değişkenler, yöntem parametreleri ve sınıf öznitelikleri için), değişkenlerimin% 90'ının (veya daha fazlasının) gerçekten son olduğunu söyleyebilirim. Ben istemediğinizde DEĞİŞTİRİLMİŞ DEĞİŞTİRİLMEMEK yararını düşünüyorum (daha önce gördüm ve bazen bir ağrı) kodunuzda ekstra yazarak ve ekstra "son" anahtar kelimeler için öder.

Bununla birlikte, eğer bir dil tasarlarsam, başka bir anahtar kelime tarafından değiştirilmediği sürece her değişkeni sonlandıracağım.

Finali sınıflar ve yöntemler için fazla kullanmıyorum, diye düşündüm. Sınıfınız bir yardımcı sınıf olmadığı sürece, bu az çok karmaşık bir tasarım seçeneğidir (bu durumda yalnızca bir özel kurucunuz olmalıdır).

Ben de gerektiğinde değiştirilemez listeleri oluşturmak için Collections.unmodifiable ... kullanın.

Olay dinleyicileri için anonim yerel sınıflar kullanmak, Java'da yaygın bir kalıptır. Son anahtar kelimenin en yaygın kullanımı, kapsamdaki değişkenlerin çift dinleyici tarafından erişilebilir olmasını sağlamaktır.

Ancak, kodunuza çok fazla son ifade koymanız gerektiğini düşünüyorsanız. Yanlış bir şey yaptığınız için iyi bir ipucu olabilir.

Yukarıda yayınlanan makale bu örneği vermektedir:

public void doSomething(int i, int j) {
    final int n = i + j; // must be declared final

    Comparator comp = new Comparator() {
        public int compare(Object left, Object right) {
            return n; // return copy of a local variable
        }
    };
}

İç ve dış yöntemlerde sabitler için kullanıyorum.

Ben sadece bazen bir alt sınıf verilen bir yöntemi (herhangi bir nedenle) geçersiz kılmak istemeyeceğini bilmiyorum çünkü yöntemler için kullanın.

Sınıflara gelince, sadece bazı altyapı sınıfları için son sınıfı kullandım.

IntelliJ IDEA, bir fonksiyonun içine bir fonksiyon parametresi yazılırsa sizi uyarır. Yani, işlev argümanları için final kullanmayı bıraktım. Java Runtime kütüphanesinde de görmüyorum.

Finalleri yöntem veya sınıflarda pek kullanmıyorum çünkü insanların bunları geçersiz kılmalarına izin vermeyi seviyorum.

Aksi takdirde, sonunda sadece bir public/private static final type SOME_CONSTANT;

Sınıfın son olarak işaretlenmesi, bazı yöntem bağlarının çalışma zamanı yerine derleme zamanında gerçekleşmesini de sağlayabilir. Aşağıdaki "v2.foo ()" öğesini düşünün - derleyici B'nin bir alt sınıfa sahip olamayacağını bilir, bu nedenle foo () geçersiz kılınamaz, bu nedenle çağrılacak uygulama derleme zamanında bilinir. B sınıfı final olarak işaretli DEĞİLSE, gerçek v2 türünün B'yi genişleten ve foo () değerini geçersiz kılan bir sınıf olması mümkündür.

class A {
    void foo() {
        //do something
    }
}
final class B extends A {
    void foo() {
    }
}
class Test {
    public void t(A v1, B v2) {
        v1.foo();
        v2.foo();
    }
}

Sabitler için final kullanımı şiddetle teşvik edilir. Ancak, yöntem veya sınıflar için kullanmam (veya en azından bir süre düşünün), çünkü imkansız olmasa bile testi daha da zorlaştırır. Bir sınıfı veya yöntemi kesin olarak sonlandırmanız gerekiyorsa, bu sınıfın bazı arabirimi uyguladığından emin olun, böylece aynı arabirimi uygulayan bir alay edebilirsiniz .