Restricting access to an object in the same package.

[Landon Blake]

This may be totally obvioius, so please bear with me.

I've got two objects that are in the same package. I want a method in one of those objects to only be called by the second object, but no other objects in the package.

For example, I have a FairTales package that contains a Dragon class and a KnightInShiningArmor class. I only want the slayDragon() method of the Dragon class to be called by KnightInShiningArmor objects, but no other objects in the FairyTales package.

Is their an access specifier/keyword that will do this, or is there another technique that I might be missing?

Thanks a bunch.

Landon

[Garrett Rowe]

This may or may not be what you're looking for. But one way to limit the public interface of a class is by referencing it through the interfaces it implements. For example:

interface Fooable
{
   void foo();
}
 
interface Barable
{
   void bar();
}
 
public class ScopeTest implements Fooable, Barable
{
   private ScopeTest(){}
 
   public void foo()
   {
      System.out.println("In foo() method");
   }
 
   public void bar()
   {
      System.out.println("In bar() method");
   }
 
   public static Fooable getFooableView()
   {
      return new ScopeTest();
   }
 
   public static Barable getBarableView()
   {
      return new ScopeTest();
   }
 
   public static ScopeTest getFullView()
   {
      return new ScopeTest();
   }
 
   public static void main(String[] args)
   {
      Fooable fooTest = ScopeTest.getFooableView();
      fooTest.foo();
      //fooTest.bar(); //error won't compile
   }
}

[Edwin Dalorzo]

May I suggest the use of nested clasess. Make the KnightInShiningArmor class a public static nested class of the Drangon class, and make private the slayDragon method of the Dragon class.

This code snippet shows how to get what you want. KnightInShiningArmor can slay a dragon, but no other class could.

public class Dragon {

private void slayDragon(){
System.out.println("Dragon is dead");
}

public static class KnightInShiningArmor {

private Dragon theDragon;

public KnightInShiningArmor(Dragon theDragon){
this.theDragon = theDragon;
}
public void killAwsomeCreature(){
theDragon.slayDragon(); //nested class can access private members
}
}
}

For instance, King class cannot slay a dragon

ublic class King {
public void tryToKillADragon(Dragon theDragon){
theDragon.slayDragon(); //compile time error
}
}

But, I knight can always kill a dragon

public static void main(){
Dragon aDragon = new Dragon();
Dragon.KnightInShiningArmor knight = new Dragon.KnightInShiningArmor(aDragon);
knight.killAwsomeCreature()
}

I hope this helps!

[ May 23, 2006: Message edited by: Edwin Dalorzo ]
[ May 23, 2006: Message edited by: Edwin Dalorzo ]

[Adam Richards]

Or, just put it in the same file as the other class definition, but don't make it public.

[Tony Morris]

Originally posted by Landon Blake:
This may be totally obvioius, so please bear with me.

I've got two objects that are in the same package. I want a method in one of those objects to only be called by the second object, but no other objects in the package.

For example, I have a FairTales package that contains a Dragon class and a KnightInShiningArmor class. I only want the slayDragon() method of the Dragon class to be called by KnightInShiningArmor objects, but no other objects in the FairyTales package.

Is their an access specifier/keyword that will do this, or is there another technique that I might be missing?

Thanks a bunch.

Landon

Yes, declare a private nested interface. You're touching on one of the little known realities that private methods (in Java) violate encapsulation. I can give you examples in open source projects if you like.