Menyembunyikan Nama Jawa: Cara yang Sulit

Saya punya masalah dengan penyembunyian nama yang sangat sulit dipecahkan. Berikut adalah versi sederhana yang menjelaskan masalahnya:

Ada kelas: org.A

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

Lalu ada kelas net.foo.X

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

Dan sekarang, inilah kelas bermasalah yang mewarisi dari Adan ingin dipanggilnet.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
    }
}

Seperti yang Anda lihat, ini tidak mungkin. Saya tidak dapat menggunakan nama sederhana Xkarena disembunyikan oleh tipe yang diwariskan. Saya tidak dapat menggunakan nama yang sepenuhnya memenuhi syarat net.foo.X, karena netdisembunyikan oleh bidang warisan.

Hanya kelas yang Bada di basis kode saya; kelas net.foo.Xdan kelas org.Aperpustakaan, jadi saya tidak bisa mengubahnya!

Solusi saya satu-satunya terlihat seperti ini: Saya dapat memanggil kelas lain yang pada gilirannya memanggil X.doSomething(); tapi kelas ini hanya akan ada karena nama bentrok, yang nampaknya sangat berantakan! Apakah tidak ada solusi di mana saya bisa langsung menghubungi X.doSomething()dari B.doSomething()?

Dalam bahasa yang memungkinkan untuk menentukan namespace global, misalnya, global::di C # atau ::di C ++, saya bisa mengawali netdengan awalan global ini, tetapi Java tidak mengizinkannya.

Anda bisa mentransmisikan a nullke tipe dan kemudian memanggil metode itu (yang akan bekerja, karena objek target tidak terlibat dalam pemanggilan metode statis).

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

Ini memiliki manfaat

• bebas efek samping (masalah dengan contoh net.foo.X),
• tidak memerlukan penggantian nama apa pun (sehingga Anda dapat memberikan metode dalam Bnama yang Anda inginkan; itulah mengapa a import statictidak akan berfungsi dalam kasus Anda yang sebenarnya),
• tidak memerlukan pengenalan kelas delegasi (meskipun itu mungkin ide yang bagus…), dan
• tidak memerlukan overhead atau kompleksitas bekerja dengan API refleksi.

Sisi negatifnya adalah kode ini benar-benar mengerikan! Bagi saya, ini menghasilkan peringatan, dan itu hal yang baik secara umum. Tetapi karena ini mengatasi masalah yang sebaliknya sama sekali tidak praktis, menambahkan file

@SuppressWarnings("static-access")

pada titik penutup yang sesuai (minimal!) akan menutup kompilator.

Mungkin cara paling sederhana (belum tentu yang termudah) untuk mengelola ini adalah dengan kelas delegasi:

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

lalu ...

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

Ini agak bertele-tele, tetapi sangat fleksibel - Anda bisa membuatnya berperilaku sesuka Anda; ditambah itu bekerja dengan cara yang sama baik dengan staticmetode dan objek yang dipakai

Lebih lanjut tentang objek delegasi di sini: http://en.wikipedia.org/wiki/Delegation_pattern

Anda dapat menggunakan impor statis:

import static net.foo.X.doSomething;

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

Hati-hati Bdan Ajangan mengandung metode bernamadoSomething

Cara yang tepat untuk melakukan sesuatu adalah impor statis, tetapi dalam skenario kasus terburuk absolut, Anda BISA membuat instance kelas menggunakan refleksi jika Anda mengetahui nama yang sepenuhnya memenuhi syarat.

Java: newInstance kelas yang tidak memiliki konstruktor default

Dan kemudian aktifkan metode pada instance.

Atau, panggil saja metode itu sendiri dengan refleksi: Memanggil metode statis menggunakan refleksi

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

Tentu saja, ini jelas merupakan resor terakhir.

Tidak benar-benar jawaban THE tetapi Anda dapat membuat instance X dan memanggil metode statis di atasnya. Itu akan menjadi cara (saya akui kotor) untuk memanggil metode Anda.

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

Tidak perlu melakukan cast atau menyembunyikan peringatan aneh atau membuat instance yang berlebihan. Hanya trik menggunakan fakta bahwa Anda dapat memanggil metode statis kelas induk melalui sub-kelas. (Mirip dengan solusi hackish saya di sini .)

Buat saja kelas seperti ini

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

(Konstruktor privat di kelas terakhir ini memastikan tidak ada yang bisa membuat instance kelas ini secara tidak sengaja.)

Kemudian Anda bebas menelepon X.doSomething()melalui:

    public class B extends A {

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

Bagaimana jika Anda mencoba mendapatkan gobalnamespace mengingat semua file berada di folder yang sama. ( 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...

         }
     }

Inilah salah satu alasan komposisi lebih disukai daripada pewarisan.

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();
    }
}

Saya akan menggunakan pola Strategi.

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();
    }
}

Sekarang Anda juga telah memisahkan ketergantungan Anda, sehingga pengujian unit Anda akan lebih mudah untuk ditulis.