Sadece sözdizimini tatmin etmek için bir return ifadesine sahip olmak kötü bir uygulama mı?

Aşağıdaki kodu göz önünde bulundurun:

public Object getClone(Cloneable a) throws TotallyFooException {

    if (a == null) {
        throw new TotallyFooException();
    }
    else {
        try {
            return a.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
    //cant be reached, in for syntax
    return null;
}

return null;Bir istisna yakalanmış olabilirler çünkü ancak biz zaten boş durumunda kontrol (ve biz klonlama destekleri aradığınız sınıfı biliyorum varsayalım sağlar) biz try deyimi başarısız asla biliyorum çünkü böyle bir durumda, gereklidir.

Yalnızca sözdizimini tatmin etmek ve derleme hatalarından kaçınmak için (buna ulaşılmayacağını açıklayan bir yorumla) ekstra return ifadesini sonuna koymak kötü bir uygulama mıdır, yoksa böyle bir şeyi kodlamanın daha iyi bir yolu var mı? return ifadesi gereksiz mi?

Ekstra bir dönüş ifadesi olmadan daha net bir yol aşağıdaki gibidir. Ben de yakalayamazdım CloneNotSupportedException, ama arayana bırak.

if (a != null) {
    try {
        return a.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
}
throw new TotallyFooException();

Başlangıçta sahip olduğunuzdan daha basit bir sözdizimi ile sonuçlanmak için sırayla uğraşmak neredeyse her zaman mümkündür.

Kesinlikle ulaşılabilir. Yığın izini yalnızca catchcümlede yazdırdığınızı unutmayın .

Senaryoda a != nullorada ve olacak bir istisna olmak return null olacaktır ulaşılabilir. Bu ifadeyi kaldırıp yerine koyabilirsiniz throw new TotallyFooException();.

Genelde ^* , eğer nullbir olduğunu geçerli bir yöntem sonucu (yani kullanıcı beklediğini ardından "veri bulunamadı" veya istisna oldu için bir sinyal olarak iade onu ve bir şey anlamına gelir) olduğu değil iyi bir fikir. Aksi halde neden geri dönmemen gerektiği konusunda bir sorun görmüyorum null.

Örneğin Scanner#ioExceptionyöntemi ele alalım :

IOExceptionBu Tarayıcının temelindeki Okunabilirlik tarafından atılan son değeri döndürür . Böyle bir istisna yoksa bu yöntem null döndürür .

Bu durumda, döndürülen değerin nullaçık bir anlamı vardır, yöntemi kullandığımda, nullyalnızca böyle bir istisna olmadığı için aldığımdan emin olabilirim ve yöntemin bir şeyler yapmaya çalışıp başarısız olmasından değil.

^* Bazen nullanlam belirsiz olsa bile geri dönmek isteyeceğinizi unutmayın . Örneğin HashMap#get:

Null dönüş değeri, eşlemenin anahtar için hiçbir eşleme içermediğini göstermez; haritanın anahtarı açıkça null olarak eşlemesi de mümkündür . containsKeyOperasyon bu iki durumu ayırt etmek için kullanılabilir.

Bu durumda null, değerin null bulunduğunu ve döndürüldüğünü veya karma eşlemin istenen anahtarı içermediğini gösterebilir .

Yalnızca sözdizimini sağlamak ve derleme hatalarını önlemek için ekstra return ifadesini sonuna koymak kötü bir uygulama mıdır (ulaşılmayacağını açıklayan bir yorumla)

bence return nullUlaşılamaz bir şubenin sonu için kötü bir uygulama . Bir şeyler çok yanlış gitti ve uygulama bilinmeyen bir durumda olduğu için o satıra ulaşmak için bir RuntimeException( AssertionErroraynı zamanda kabul edilebilir) atmak daha iyidir . Çoğu bunun gibi (yukarıdaki gibi) çünkü geliştirici bir şeyi gözden kaçırmıştır (Nesneler sıfır ve klonlanamaz olabilir).

Sanal makineden daha büyük olasılıkla hata yaptığım için InternalError, kodun erişilemez olduğundan (örneğin a'dan sonra System.exit()) çok emin olmadığım sürece, muhtemelen kullanmam .

Özel bir istisna (örneğin TotallyFooException) kullanırım, eğer bu "ulaşılamaz hatta" ulaşmak, bu istisnayı attığınız başka herhangi bir yerde olduğu gibi aynı anlama geliyorsa.

Yakaladınız, CloneNotSupportedExceptionbu da kodunuzun başa çıkabileceği anlamına geliyor. Ancak onu yakaladıktan sonra, işlevin sonuna geldiğinizde ne yapacağınız konusunda hiçbir fikriniz yok, bu da onu kaldıramayacağınız anlamına geliyor. Yani bu durumda bunun bir kod kokusu olduğu konusunda haklısınız ve benim görüşüme göre yakalamamalısınız demektir CloneNotSupportedException.

Kullanmayı tercih ederim Objects.requireNonNull()Parametre a'nın boş olup olmadığını kontrol etmek . Dolayısıyla, kodu okuduğunuzda parametrenin boş olmaması gerektiği açıktır.

Ve işaretli İstisnalardan kaçınmak için CloneNotSupportedException,RuntimeException .

Her ikisi için de bunun neden olmaması ya da böyle olmaması amacıyla güzel bir metin ekleyebilirsiniz.

public Object getClone(Object a) {

    Objects.requireNonNull(a);

    try {
        return a.clone();
    } catch (CloneNotSupportedException e) {
        throw new IllegalArgumentException(e);
    }

}

Bu tür bir durumda yazardım

public Object getClone(SomeInterface a) throws TotallyFooException {
    // Precondition: "a" should be null or should have a someMethod method that
    // does not throw a SomeException.
    if (a == null) {
        throw new TotallyFooException() ; }
    else {
        try {
            return a.someMethod(); }
        catch (SomeException e) {
            throw new IllegalArgumentException(e) ; } }
}

İlginç bir şekilde, "try ifadesinin asla başarısız olmayacağını" söylüyorsunuz, ancak yine e.printStackTrace();de asla uygulanmayacağını iddia ettiğiniz bir ifade yazma zahmetine girdiniz. Neden?

Belki inancınız o kadar sağlam değildir. Bu iyi (bence), çünkü inancınız yazdığınız koda değil, müşterinizin ön koşulu ihlal etmeyeceği beklentisine dayanıyor. Kamu yöntemlerini savunmaya göre programlamak daha iyidir

Bu arada, kodun benim için derlenmeyecek. Sen diyemezsin a.clone()türü bile aolduğunu Cloneable. En azından Eclipse'in derleyicisi öyle diyor. İfade a.clone()hata veriyor

Clone () yöntemi Cloneable türü için tanımsız

Özel durumunuz için ne yapardım

public Object getClone(PubliclyCloneable a) throws TotallyFooException {
    if (a == null) {
        throw new TotallyFooException(); }
    else {
        return a.clone(); }
}

Nerede PubliclyCloneabletanımlanır

interface PubliclyCloneable {
    public Object clone() ;
}

Veya parametre türünün mutlaka olması gerekiyorsa Cloneable, en azından aşağıdakiler derlenir.

public static Object getClone(Cloneable a) throws TotallyFooException {
//  Precondition: "a" should be null or point to an object that can be cloned without
// throwing any checked exception.
    if (a == null) {
        throw new TotallyFooException(); }
    else {
        try {
            return a.getClass().getMethod("clone").invoke(a) ; }
        catch( IllegalAccessException e ) {
            throw new AssertionError(null, e) ; }
        catch( InvocationTargetException e ) {
            Throwable t = e.getTargetException() ;
            if( t instanceof Error ) {
                // Unchecked exceptions are bubbled
                throw (Error) t ; }
            else if( t instanceof RuntimeException ) {
                // Unchecked exceptions are bubbled
                throw (RuntimeException) t ; }
            else {
                // Checked exceptions indicate a precondition violation.
                throw new IllegalArgumentException(t) ; } }
        catch( NoSuchMethodException e ) {
            throw new AssertionError(null, e) ; } }
}

Yukarıdaki örnekler geçerlidir ve çok Java'dır. Bununla birlikte, OP'nin bu geri dönüşün nasıl ele alınacağına ilişkin sorusunu şu şekilde ele alacağım:

public Object getClone(Cloneable a) throws CloneNotSupportedException {
    return a.clone();
}

aBoş olup olmadığını kontrol etmenin bir faydası yoktur . NPE'ye gidiyor. Yığın izi yazdırmak da yardımcı olmaz. Yığın izleme, nerede işlendiğine bakılmaksızın aynıdır.

Yararsız sıfır testler ve yararsız istisna işleme ile kodu gereksiz yere atmanın bir faydası yoktur. Önemsizliği kaldırarak, iade sorunu tartışılır.

(OP'nin istisna işlemede bir hata içerdiğine dikkat edin; bu nedenle geri dönüş gerekliydi. OP önerdiğim yöntemde yanlış olmazdı.)

Sadece sözdizimini tatmin etmek için bir return ifadesine sahip olmak kötü bir uygulama mı?

Başkalarının da bahsettiği gibi, sizin durumunuzda bu aslında geçerli değil.

Yine de soruyu cevaplamak için, Lint tipi programlar kesinlikle çözemedi! Bir geçiş bildirisinde iki farklı kişinin bu konuda kavga ettiğini gördüm.

    switch (var)
   {
     case A:
       break;
     default:
       return;
       break;    // Unreachable code.  Coding standard violation?
   }

Bir şikayet değil mola sahip bir kodlama standardı ihlal oldu. Diğeri , erişilemez bir kod olduğu için buna sahip olmanın bir olduğundan şikayet etti .

Bunu fark ettim çünkü iki farklı programcı, o gün hangi kod analizörünü çalıştırdıklarına bağlı olarak, arayı ekleyip kaldırıp ekleyip kaldırarak kodu yeniden kontrol etmeye devam etti.

Bu duruma düşerseniz, birini seçin ve kendinize gösterdiğiniz iyi form olan anormalliği yorumlayın. Bu en iyi ve en önemli paket servisi olan restoran.

"Sadece sözdizimini tatmin etmek" değildir. Her kod yolunun bir dönüşe veya fırlatmaya yol açması dilin anlamsal bir gereksinimidir. Bu kod uymuyor. İstisna yakalanırsa, aşağıdaki geri dönüş gereklidir.

Bunun hakkında ya da genel olarak derleyiciyi tatmin etmek hakkında 'kötü uygulama' yok.

Her durumda, sözdizimi veya anlamsal, bu konuda herhangi bir seçeneğiniz yok.

Sonunda geri dönüşü olması için bunu yeniden yazardım. Sözde kod:

if a == null throw ...
// else not needed, if this is reached, a is not null
Object b
try {
  b = a.clone
}
catch ...

return b

Henüz kimse bundan bahsetmedi, işte burada:

public static final Object ERROR_OBJECT = ...

//...

public Object getClone(Cloneable a) throws TotallyFooException {
Object ret;

if (a == null) 
    throw new TotallyFooException();

//no need for else here
try {
    ret = a.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
    //something went wrong! ERROR_OBJECT could also be null
    ret = ERROR_OBJECT; 
}

return ret;

}

Bu nedenle returniç trybloklardan hoşlanmıyorum .

Dönüş boş; Bir istisna yakalanabileceğinden gereklidir, ancak böyle bir durumda, bunun boş olup olmadığını zaten kontrol ettiğimizden (ve klonlamayı desteklediğimizi çağırdığımız sınıfı bildiğimizi varsayalım), bu nedenle try ifadesinin asla başarısız olmayacağını biliyoruz.

İfadenin tryasla başarısız olamayacağını bildiğiniz bir şekilde ilgili girdilerle ilgili ayrıntıları biliyorsanız, buna sahip olmanın anlamı nedir? tryİşlerin her zaman başarılı olacağından eminseniz , kaçının (kod tabanınızın tüm ömrü boyunca kesinlikle emin olabileceğiniz nadirdir).

Her durumda, derleyici maalesef bir akıl okuyucusu değildir. İşlevi ve girdilerini görür ve sahip olduğu bilgiler verildiğinde return, alt kısımdaki ifadeye sizinkine ihtiyaç duyar .

Yalnızca sözdizimini tatmin etmek ve derleme hatalarından kaçınmak için (buna ulaşılmayacağını açıklayan bir yorumla) ekstra return ifadesini sonuna koymak kötü bir uygulama mıdır, yoksa böyle bir şeyi kodlamanın daha iyi bir yolu var mı? return ifadesi gereksiz mi?

Tam tersine, başka bir kod satırına mal olsa bile herhangi bir derleyici uyarısından kaçınmanın iyi bir uygulama olduğunu öneririm. Buradaki satır sayısı hakkında fazla endişelenmeyin. Fonksiyonun güvenilirliğini test ederek oluşturun ve ardından devam edin. Sadece returnifadeyi atlayabileceğinizi varsayarak , bir yıl sonra o koda geri döndüğünüzü hayal edin ve ardından returnalttaki bu ifadenin, yapabileceğiniz varsayımlar nedeniyle neden atlandığına dair küçük ayrıntıların ayrıntılarını açıklayan bazı yorumlardan daha fazla kafa karışıklığına neden olup olmayacağına karar vermeye çalışın. girdi parametreleri hakkında bilgi verin. Büyük olasılıkla returnifadenin üstesinden gelmek daha kolay olacak.

Bununla birlikte, özellikle bu bölüm hakkında:

try {
    return a.clone();
} catch (CloneNotSupportedException e) {
   e.printStackTrace();
}
...
//cant be reached, in for syntax
return null;

Buradaki istisnaları ele alma zihniyetinde biraz tuhaf olduğunu düşünüyorum. Genelde, yanıt olarak yapabileceğiniz anlamlı bir şeyin olduğu bir sitede istisnaları yutmak istersiniz.

try/catchBir işlem mekanizması olarak düşünebilirsiniz . trybu değişiklikleri yapmak, başarısız olurlarsa ve catchbloğa dallanırsak catch, geri alma ve kurtarma sürecinin bir parçası olarak yanıt olarak bunu ( blokta ne varsa ) yapın.

Bu durumda, yalnızca bir yığın izleme yazdırmak ve ardından boş döndürmeye zorlanmak tam olarak bir işlem / kurtarma zihniyeti değildir. Kod, hata işleme sorumluluğunu getClonehataları manuel olarak kontrol etmek için çağıran tüm koda aktarır . Yakalamayı tercih edebilirsinizCloneNotSupportedException ve başka, daha anlamlı bir istisna biçimine çevirmeyi ve atmayı tercih edebilirsiniz, ancak istisnayı basitçe yutmak ve bu durumda bir işlem kurtarma sitesi gibi olmadığından bir boş döndürmek istemezsiniz.

Bir istisna atmak bundan kaçınırken, başarısızlıkla bu şekilde manuel olarak kontrol etme ve başa çıkma sorumluluklarını arayanlara sızdırırsınız.

Sanki bir dosya yüklerseniz, bu üst düzey işlemdir. try/catchOrada olabilir . tryingDosya yükleme işlemi sırasında nesneleri klonlayabilirsiniz. Bu üst düzey işlemin herhangi bir yerinde bir hata varsa (dosyayı yüklerken), genellikle bu üst düzey işlem try/catchbloğuna tüm yol boyunca istisnalar atmak istersiniz, böylece bir dosyanın yüklenmesindeki bir başarısızlıktan (ister klonlamadaki bir hata veya başka bir şey nedeniyle). Bu nedenle, genellikle bunun gibi granüler bir yerde bir istisnayı yutup sonra bir boş döndürmek istemeyiz, örneğin bu istisnaların birçok değerini ve amacını ortadan kaldırır. Bunun yerine, istisnaları, onunla anlamlı bir şekilde başa çıkabileceğimiz bir siteye kadar yaymak istiyoruz.

Örneğiniz, sorunuzu son paragrafta belirtildiği gibi açıklamak için ideal değildir:

Yalnızca sözdizimini tatmin etmek ve derleme hatalarından kaçınmak için (buna ulaşılmayacağını açıklayan bir yorumla) ekstra return ifadesini sonuna koymak kötü bir uygulama mıdır, yoksa böyle bir şeyi kodlamanın daha iyi bir yolu var mı? return ifadesi gereksiz mi?

Daha iyi bir örnek, klonun kendisinin uygulanması olabilir:

 public class A implements Cloneable {
      public Object clone() {
           try {
               return super.clone() ;
           } catch (CloneNotSupportedException e) {
               throw new InternalError(e) ; // vm bug.
           }
      }
 }

Burada catch cümlesi asla girilmemelidir. Yine de sözdizimi ya bir şey atmayı ya da bir değer döndürmeyi gerektirir. Bir şeyi döndürmek mantıklı olmadığından, InternalErrorciddi bir VM durumunu belirtmek için an kullanılır.