Giấu tên Java: Con đường khó

Tôi có một vấn đề với ẩn tên rất khó giải quyết. Đây là một phiên bản đơn giản giải thích sự cố:

Có một lớp học: org.A

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

Sau đó, có một lớp học net.foo.X

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

Và bây giờ, đây là lớp có vấn đề kế thừa Avà muốn gọinet.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
    }
}

Như bạn thấy, điều này là không thể. Tôi không thể sử dụng tên đơn giản Xvì nó bị ẩn bởi một kiểu kế thừa. Tôi không thể sử dụng tên đủ điều kiện net.foo.Xvì netbị ẩn bởi trường kế thừa.

Chỉ có lớp Btrong cơ sở mã của tôi; các lớp net.foo.Xvà org.Alà các lớp thư viện, vì vậy tôi không thể thay đổi chúng!

Giải pháp duy nhất của tôi trông như thế này: Tôi có thể gọi một lớp khác đến lượt nó gọi X.doSomething(); nhưng lớp này sẽ chỉ tồn tại vì sự đụng độ tên, có vẻ rất lộn xộn! Không có giải pháp nào mà tôi có thể gọi trực tiếp X.doSomething()từ đó B.doSomething()?

Trong một ngôn ngữ cho phép chỉ định không gian tên toàn cục, ví dụ: global::trong C # hoặc ::trong C ++, tôi có thể chỉ cần thêm tiền tố nettoàn cục này, nhưng Java không cho phép điều đó.

Bạn có thể ép nullkiểu thành kiểu và sau đó gọi phương thức trên đó (phương thức này sẽ hoạt động, vì đối tượng đích không liên quan đến việc gọi phương thức tĩnh).

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

Điều này có lợi ích của

• không có tác dụng phụ (vấn đề với việc khởi tạo net.foo.X),
• không yêu cầu đổi tên bất kỳ thứ gì (vì vậy bạn có thể Bđặt tên cho phương thức mà bạn muốn nó có; đó là lý do tại sao a import staticsẽ không hoạt động trong trường hợp chính xác của bạn),
• không yêu cầu giới thiệu lớp đại biểu (mặc dù đó có thể là một ý kiến ​​hay…), và
• không yêu cầu chi phí cao hoặc phức tạp khi làm việc với API phản chiếu.

Nhược điểm là mã này thực sự rất kinh khủng! Đối với tôi, nó tạo ra một cảnh báo và đó là một điều tốt nói chung. Nhưng vì nó đang giải quyết một vấn đề hoàn toàn không thực tế, việc thêm

@SuppressWarnings("static-access")

tại một điểm bao quanh thích hợp (tối thiểu!) sẽ đóng trình biên dịch.

Có lẽ cách đơn giản nhất (không nhất thiết là dễ nhất) để quản lý điều này là với một lớp đại biểu:

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

và sau đó ...

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

Điều này hơi dài dòng, nhưng rất linh hoạt - bạn có thể làm cho nó hoạt động theo bất kỳ cách nào bạn muốn; cộng với nó hoạt động theo cùng một cách cả với staticcác phương thức và các đối tượng được khởi tạo

Thông tin thêm về các đối tượng đại biểu tại đây: http://en.wikipedia.org/wiki/Delegation_pattern

Bạn có thể sử dụng nhập tĩnh:

import static net.foo.X.doSomething;

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

Chú ý rằng Bvà Akhông chứa các phương thức có têndoSomething

Cách thực hiện thích hợp sẽ là nhập tĩnh, nhưng trong trường hợp xấu nhất tuyệt đối, bạn CÓ THỂ tạo một thể hiện của lớp bằng cách sử dụng phản chiếu nếu bạn biết tên đầy đủ của nó.

Java: newInstance của lớp không có hàm tạo mặc định

Và sau đó gọi phương thức trên phiên bản.

Hoặc, chỉ gọi chính phương thức với phản xạ: Gọi một phương thức tĩnh sử dụng phản xạ

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

Tất nhiên, đây rõ ràng là những phương án cuối cùng.

Không thực sự là câu trả lời nhưng bạn có thể tạo một thể hiện của X và gọi phương thức tĩnh trên đó. Đó sẽ là một cách (tôi thừa nhận là bẩn) để gọi phương pháp của bạn.

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

Không cần phải thực hiện bất kỳ truyền hoặc ngăn chặn bất kỳ cảnh báo lạ nào hoặc tạo bất kỳ phiên bản thừa nào. Chỉ là một mẹo sử dụng thực tế là bạn có thể gọi các phương thức tĩnh của lớp cha thông qua lớp con. (Tương tự với giải pháp hackish của tôi ở đây .)

Chỉ cần tạo một lớp như thế này

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

(Hàm khởi tạo riêng trong lớp cuối cùng này đảm bảo không ai có thể vô tình tạo một thể hiện của lớp này.)

Sau đó, bạn có thể thoải mái gọi X.doSomething()qua nó:

    public class B extends A {

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

Điều gì sẽ xảy ra nếu bạn thử lấy không gian gobalnames vì ​​tất cả các tệp đều nằm trong cùng một thư mục. ( 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...

         }
     }

Đây là một trong những lý do mà thành phần được ưu tiên hơn là thừa kế.

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

Tôi sẽ sử dụng mô hình Chiến lược.

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

Bây giờ bạn cũng đã tách được sự phụ thuộc của mình, vì vậy các bài kiểm tra đơn vị của bạn sẽ dễ viết hơn.