การซ่อนชื่อ Java: วิธีที่ยาก

ฉันมีปัญหาเกี่ยวกับการซ่อนชื่อซึ่งแก้ยากมาก นี่คือเวอร์ชันที่เรียบง่ายที่อธิบายปัญหา:

มีคลาส: org.A

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

จากนั้นมีชั้นเรียน net.foo.X

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

และตอนนี้นี่คือคลาสที่มีปัญหาซึ่งสืบทอดมาจากAและต้องการโทร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
    }
}

อย่างที่คุณเห็นนี่เป็นไปไม่ได้ ฉันไม่สามารถใช้ชื่อธรรมดาได้Xเนื่องจากถูกซ่อนโดยประเภทที่สืบทอดมา ฉันไม่สามารถใช้ชื่อแบบเต็มได้net.foo.Xเนื่องจากnetถูกซ่อนโดยฟิลด์ที่สืบทอดมา

มีเพียงคลาสเท่านั้นที่Bอยู่ในฐานรหัสของฉัน ชั้นเรียนnet.foo.Xและorg.Aเป็นชั้นเรียนของห้องสมุดดังนั้นฉันจึงไม่สามารถแก้ไขได้!

ทางออกเดียวของฉันมีลักษณะดังนี้: ฉันสามารถเรียกชั้นเรียนอื่นที่จะเรียกX.doSomething(); แต่คลาสนี้จะมีอยู่เพราะการปะทะกันของชื่อเท่านั้นซึ่งดูยุ่งมาก! มีวิธีที่ฉันโดยตรงสามารถเรียกผู้ใดX.doSomething()จากB.doSomething()?

ในภาษาที่อนุญาตให้ระบุเนมสเปซส่วนกลางเช่นglobal::ใน C # หรือ::ใน C ++ ฉันสามารถขึ้นต้นnetด้วยคำนำหน้าส่วนกลางนี้ได้ แต่ Java ไม่อนุญาต

คุณสามารถส่ง a nullไปยังประเภทแล้วเรียกใช้เมธอดนั้น (ซึ่งจะใช้ได้ผลเนื่องจากวัตถุเป้าหมายไม่เกี่ยวข้องกับการเรียกใช้วิธีการคงที่)

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

นี้มีประโยชน์ของ

• ปราศจากผลข้างเคียง (ปัญหาในการสร้างอินสแตนซ์net.foo.X)
• ไม่ต้องเปลี่ยนชื่ออะไรเลย (คุณสามารถตั้งเมธอดในBชื่อที่คุณต้องการได้นั่นคือสาเหตุที่import staticไม่ได้ผลในกรณีของคุณ)
• ไม่จำเป็นต้องมีการแนะนำคลาสผู้ร่วมประชุม (แม้ว่านั่นอาจเป็นความคิดที่ดี ... ) และ
• ไม่ต้องการค่าใช้จ่ายหรือความซับซ้อนในการทำงานกับ API การสะท้อนกลับ

ข้อเสียคือรหัสนี้น่ากลัวจริงๆ! สำหรับฉันมันสร้างคำเตือนและนั่นเป็นสิ่งที่ดีโดยทั่วไป แต่เนื่องจากมันกำลังแก้ไขปัญหาที่ไม่สามารถใช้งานได้อย่างทั่วถึงจึงเพิ่มไฟล์

@SuppressWarnings("static-access")

ที่จุดปิดล้อมที่เหมาะสม (น้อยที่สุด!) จะปิดคอมไพเลอร์

อาจเป็นวิธีที่ง่ายที่สุด (ไม่จำเป็นต้องเป็นวิธีที่ง่ายที่สุด) ในการจัดการสิ่งนี้คือการใช้คลาสที่ได้รับมอบหมาย:

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

แล้ว ...

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

สิ่งนี้ค่อนข้างละเอียด แต่ยืดหยุ่นมาก - คุณสามารถทำให้มันทำงานในแบบที่คุณต้องการได้ นอกจากนี้ยังทำงานในลักษณะเดียวกันทั้งกับstaticวิธีการและวัตถุที่สร้างอินสแตนซ์

ข้อมูลเพิ่มเติมเกี่ยวกับออบเจ็กต์มอบหมายที่นี่: http://en.wikipedia.org/wiki/Delegation_pattern

คุณสามารถใช้การนำเข้าแบบคงที่:

import static net.foo.X.doSomething;

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

ระวังBและAไม่มีเมธอดที่ตั้งชื่อไว้doSomething

วิธีที่เหมาะสมในการทำสิ่งต่าง ๆ คือการนำเข้าแบบคงที่ แต่ในกรณีที่เลวร้ายที่สุดคุณสามารถสร้างอินสแตนซ์ของคลาสโดยใช้การสะท้อนกลับได้หากคุณทราบชื่อที่มีคุณสมบัติครบถ้วน

Java: newInstance ของคลาสที่ไม่มีตัวสร้างเริ่มต้น

จากนั้นเรียกใช้เมธอดบนอินสแตนซ์

หรือเพียงแค่เรียกใช้เมธอดด้วยการสะท้อนกลับ: เรียกใช้วิธีการคงที่โดยใช้การสะท้อน

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

แน่นอนว่านี่เป็นรีสอร์ทสุดท้าย

ไม่ใช่คำตอบจริงๆ แต่คุณสามารถสร้างอินสแตนซ์ของ X และเรียกวิธีการคงที่ได้ นั่นจะเป็นวิธี (ฉันยอมรับว่าสกปรก) ในการเรียกวิธีการของคุณ

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

ไม่จำเป็นต้องทำการแคสต์หรือระงับคำเตือนแปลก ๆ หรือสร้างอินสแตนซ์ที่ซ้ำซ้อน เพียงเคล็ดลับโดยใช้ข้อเท็จจริงที่ว่าคุณสามารถเรียกใช้เมธอดแบบคงที่คลาสแม่ผ่านคลาสย่อย (คล้ายกับวิธีแก้ปัญหาแฮ็กของฉันที่นี่ )

เพียงแค่สร้างคลาสแบบนี้

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

(ตัวสร้างไพรเวตในคลาสสุดท้ายนี้ทำให้แน่ใจว่าไม่มีใครสามารถสร้างอินสแตนซ์ของคลาสนี้โดยไม่ได้ตั้งใจ)

จากนั้นคุณสามารถโทรได้ฟรี X.doSomething()ผ่านได้ฟรี:

    public class B extends A {

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

จะเกิดอะไรขึ้นถ้าคุณลองรับ gobalnamespace เนื่องจากไฟล์ทั้งหมดอยู่ในโฟลเดอร์เดียวกัน ( 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...

         }
     }

นี่เป็นสาเหตุหนึ่งที่การจัดองค์ประกอบเป็นที่นิยมในการถ่ายทอดทางพันธุกรรม

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

ฉันจะใช้รูปแบบกลยุทธ์

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

ตอนนี้คุณได้แยกการพึ่งพาแล้วดังนั้นการทดสอบหน่วยของคุณจะเขียนได้ง่ายขึ้น