Java Adı Gizleme: Zor Yol

Ad gizlemeyle ilgili çözmesi son derece zor bir sorunum var. Sorunu açıklayan basitleştirilmiş bir versiyon:

Bir sınıf var: org.A

package org;
public class A{
     public class X{...}
     ...
     protected int net;
}

Sonra bir sınıf var net.foo.X

package net.foo;
public class X{
     public static void doSomething();
}

Ve şimdi, buradan miras alan Ave aramak isteyen sorunlu sınıf.net.foo.X.doSomething()

package com.bar;
class B extends A {

    public void doSomething(){
        net.foo.X.doSomething(); // doesn't work; package net is hidden by inherited field
        X.doSomething(); // doesn't work; type net.foo.X is hidden by inherited X
    }
}

Gördüğünüz gibi bu mümkün değil. XKalıtsal bir tür tarafından gizlendiği için basit adı kullanamıyorum . Tam adı kullanamıyorum net.foo.Xçünkü netdevralınan bir alan tarafından gizlenmiş durumda.

BKod tabanımda yalnızca sınıf var; sınıflar net.foo.Xve org.Akütüphane sınıfları, bu yüzden onları değiştiremem!

Tek çözümüm şuna benziyor: Sırayla arayan başka bir sınıfı arayabilirim X.doSomething(); ancak bu sınıf, çok dağınık görünen isim çatışması nedeniyle var olabilirdi! Ben doğrudan çağrı hangi çözüm var mı X.doSomething()gelen B.doSomething()?

Global isim alanının belirlenmesine izin veren bir dilde, örneğin global::C # veya ::C ++ 'da, basitçe netbu genel önekle önek alabilirim, ancak Java buna izin vermiyor.

Türe bir nullatayabilir ve ardından yöntemi çağırabilirsiniz (hedef nesne statik yöntemlerin çağrılmasına dahil olmadığından işe yarar).

((net.foo.X) null).doSomething();

Bunun faydaları var

• yan etkisiz olma (örneklemeyle ilgili bir sorun net.foo.X),
• herhangi bir şeyin yeniden adlandırılmasını gerektirmez (böylece yöntemi, Bsahip olmasını istediğiniz adda verebilirsiniz ; bu nedenle import static, sizin durumunuzda a çalışmaz),
• delege sınıfının tanıtılmasını gerektirmeyen (ancak bu iyi bir fikir olabilir…) ve
• yansıma API'si ile çalışmanın ek yükünü veya karmaşıklığını gerektirmez.

Olumsuz yanı, bu kodun gerçekten korkunç olmasıdır! Benim için bir uyarı yaratıyor ve bu genel olarak iyi bir şey. Ancak, aksi takdirde tamamen pratik olmayan bir sorunun etrafında çalıştığı için,

@SuppressWarnings("static-access")

uygun (minimum!) bir kapalı noktada derleyiciyi kapatır.

Muhtemelen bunu yönetmenin en basit (en kolay yolu değil) yolu bir temsilci sınıfıyla olacaktır:

import net.foo.X;
class C {
    static void doSomething() {
         X.doSomething();
    }
}

ve sonra ...

class B extends A {
    void doX(){
        C.doSomething();
    }
}

Bu biraz ayrıntılı ama çok esnektir - istediğiniz gibi davranmasını sağlayabilirsiniz; artı hem staticyöntemlerle hem de örneklenmiş nesnelerle aynı şekilde çalışır

Temsilci nesneler hakkında daha fazla bilgiyi burada bulabilirsiniz: http://en.wikipedia.org/wiki/Delegation_pattern

Statik bir içe aktarma kullanabilirsiniz:

import static net.foo.X.doSomething;

class B extends A {
    void doX(){
        doSomething();
    }
}

Buna dikkat edin Bve Aadlandırılmış yöntemler içermeyindoSomething

İşleri yapmanın doğru yolu statik içe aktarma olacaktır, ancak mutlak en kötü senaryoda, tam olarak nitelenmiş adını biliyorsanız, yansıma kullanarak sınıfın bir örneğini oluşturabilirdiniz.

Java: varsayılan kurucusu olmayan sınıfın newInstance'ı

Ve sonra örnekteki yöntemi çağırın.

Ya da sadece yansıma ile yöntemin kendisini çağırın: Yansıma kullanarak statik bir yöntemi çağırmak

Class<?> clazz = Class.forName("net.foo.X");
Method method = clazz.getMethod("doSomething");
Object o = method.invoke(null);

Tabii ki bunlar son çareler.

Gerçekten cevap değil, ancak bir X örneği oluşturabilir ve üzerinde statik yöntemi çağırabilirsiniz. Bu, yönteminizi çağırmanın bir yolu olabilir (itiraf ediyorum kirli).

(new net.foo.X()).doSomething();

Herhangi bir değişiklik yapmanıza veya garip uyarıları bastırmanıza veya gereksiz bir örnek oluşturmanıza gerek yoktur. Alt sınıf aracılığıyla üst sınıf statik yöntemlerini çağırabileceğiniz gerçeğini kullanan bir numara. ( Buradaki hile çözümüme benzer .)

Sadece bunun gibi bir sınıf oluşturun

public final class XX extends X {
    private XX(){
    }
}

(Bu son sınıftaki özel kurucu, hiç kimsenin yanlışlıkla bu sınıfın bir örneğini oluşturamayacağından emin olur.)

O zaman onun X.doSomething()üzerinden aramakta özgürsünüz :

    public class B extends A {

        public void doSomething() {
            XX.doSomething();
        }

Ya tüm dosyalar aynı klasörde olduğu için gobalnamespace'i almaya çalışırsanız ne olur? ( http://www.beanshell.org/javadoc/bsh/class-use/NameSpace.html )

    package com.bar;
      class B extends A {

       public void doSomething(){
         com.bar.getGlobal().net.foo.X.doSomething(); // drill down from the top...

         }
     }

Bu, kompozisyonun kalıtıma tercih edilmesinin nedenlerinden biridir.

package com.bar;
import java.util.concurrent.Callable;
public class C implements Callable<org.A>
{
    private class B extends org.A{
    public void doSomething(){
        C.this.doSomething();
    }
    }

    private void doSomething(){
    net.foo.X.doSomething();
    }

    public org.A call(){
    return new B();
    }
}

Strateji modelini kullanırdım.

public interface SomethingStrategy {

   void doSomething();
}

public class XSomethingStrategy implements SomethingStrategy {

    import net.foo.X;

    @Override
    void doSomething(){
        X.doSomething();
    }
}

class B extends A {

    private final SomethingStrategy strategy;

    public B(final SomethingStrategy strategy){
       this.strategy = strategy;
    }

    public void doSomething(){

        strategy.doSomething();
    }
}

Artık bağımlılığınızı da ayırdınız, böylece birim testlerinizi yazmak daha kolay olacaktır.