Java：如何将方法的访问限制到特定类？

Question

下面是一个例子：

class A 
{
   List l = new List ();
   list.insert("x");
}

class List
{
   ...
   public void insert ()
   {
      /*insertion occurs*/
   }
   ...
}

是否可以将insert（）方法保持为公共的，但只限制对类A的访问，以便只有在从类A调用时，其他类才能访问它

Answer 1

使用访问修饰符可以做的最好的事情是使方法包私有（删除public关键字），并且只在同一个包中保留这两个类

Answer 2

如果前面答案中的所有“内部类”内容都让您感到困惑，那么还有一种更直观的方法（假设您已经了解了extends关键字和继承）。您可以简单地使insert()方法protected代替public，并使class A扩展List。例如：

public class List {
   ...
   protected void insert() {
      //insertion occurs
   }
   ...
}

public class A extends List {
   ...
}

只要没有其他类扩展List，只有类型为A和List的对象才能使用insert()方法

Answer 3

如果方法是公共的，每个人都可以访问它。像您这样访问控制的诀窍是通过接口公开一组公共操作，将辅助操作添加到实现接口的私有类中，并使用户对接口而不是类进行编程

以下是一个例子：

public interface MyList {
    Object elementAt(int i);
}
public class A {
    private static class MyListImpl implements MyList {
        public Object elementAt(int i) {
            ...
        }
        public void insert(Object element) {
            ...
        }
    }
    private final MyListImpl list = new MyListImpl();
    public MyList getList() { return list; }
    public void insert(Object o) { list.insert(o); }
}

使用场景：

A a = new A();
a.insert(123);
a.insert("quick brown fox");
MyList lst = a.getList();
System.out.println(lst.elementAt(0));
System.out.println(lst.elementAt(1));

Answer 4

package problems;

public class Problem1 {
    public static void main(String[] args) {
        B b = new B();
        b.methodInB();
        C c = new C();
        c.methodNotInB();
    }
}

class A {
    public void onlyB() {
        StackTraceElement[] stackTraceElements = Thread.currentThread()
                .getStackTrace();
        if (!problems.B.class.getCanonicalName().equals(
                stackTraceElements[stackTraceElements.length - 2]
                        .getClassName())) {
            System.err.println("You are not authorized to call me!!");
            return;
        }
        System.out.println("You are authorized to call me!!");
    }
}

class B {
    public void methodInB() {
        A a = new A();
        a.onlyB();
    }
}

class C {
    public void methodNotInB() {
        A a = new A();
        a.onlyB();
    }
}

Answer 5

我将把调用该方法的对象作为参数传递，即

list.insert("x", this);

然后检查传递的对象是否是类A的实例

 public void insert (String x, Object o)
   {
      if(o instanceof ClassA){
         /*insertion occurs*/
      }
   }

Answer 6

是的，您可以将调用对象作为参数传递，并在实际代码之前插入一个check-in insert（）方法

  public void insert(Object obj){
    if(obj instanceof A){
      //your code block
    }
  }

请注意，这将允许扩展A的所有类以及调用insert。如果只想限制A类，请添加附加检查

  public void insert(Object obj){
    if((obj instanceof A) && obj.getClass().getSimpleName().equals("A")){
      //your code block
    }
  }

我们还可以实现第二种情况，只需要条件“obj.getClass（）.getSimpleName（）.equals（“A”）”