Java: ¿cómo limitar el acceso de un método a una clase específica?

Question

He aquí un ejemplo:

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

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

¿Es posible en absoluto para mantener el inserto() pública método, pero limitar el acceso solamente a la clase A de modo que ninguna otra clase puede acceder a él, sólo cuando se llama desde un?

Answer 1

Agregar un paquete a su clase y declarar el método privada

package com.my.stuff; 

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

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

En este momento creo que es necesario "protegido" si una subclase ... Lo mejor es que sea una clase interna y el uso protegido creo.

Consulte este artículo para obtener alcance: http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

Answer 2

Lo mejor que puede hacer uso de modificadores de acceso es hacer que el paquete método privado (quitar la palabra clave public) y mantener únicamente las dos clases en el mismo paquete.

Answer 3

Si el método es público, todos pueden acceder a él. El truco para acceder al control como el suyo es exponer un conjunto de operaciones públicas a través de una interfaz, agregar operaciones auxiliares a una clase privada que implementa la interfaz y hacer que los usuarios programen en la interfaz, no en una clase.

Aquí se muestra un ejemplo:

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

Escenario de uso:

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

ponerlo como clase interna en A o puede hacer otra cosa ... Let inserto toma un parámetro con el tipo de de Object y al principio del mismo, comprueba si el tipo de parámetro es A .... y cuando lo llamas envía el objeto que llama ... maby no es una buena idea pero hará lo que quieras

Answer 5

Si todas las cosas de "clases internas" en las respuestas anteriores lo confunden, hay otra manera que puede ser más intuitiva (suponiendo que haya aprendido sobre la palabra clave extends y la herencia). Puede simplemente hacer el método insert()protected en lugar de public y hacer class A ampliar List. Por ejemplo:

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

public class A extends List { 
    ... 
} 

Mientras no se extienden otras clases de lista, sólo los objetos de tipos A y List va a ser capaz de utilizar el método insert().

Answer 6

Ponlo en la clase permitida y hazlo privado.

Answer 7

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 8

Me gustaría pasar el objeto que está llamando el método como argumento, es decir

list.insert("x", this); 

Y a continuación, comprobar si el objeto pasado es una instancia de la clase A

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