如何避免從外界創建B類對象，並只允許通過A類

Question

如何避免從外界創建B類對象，並只允許通過A類？

我有2類

public class A { 
    B obj = null; 
    public A() { 
     obj = new B(); 
    }   
    public void methodA() { 
     obj.methodB(); 
    }   
    // other methods 
} 

public class B { 
    public void methodB() { 
     // some logic    
    } 
    //other methods 
} 

public class Client { 
    public static void main (String s[]) { 
     // Valid Call    
     A obj = new A(); 
     obj.methodA(); // Since methodB is called internally 

     // Invalid Call , How to restrict this B object creation here ? 
     B objB = new B(); 
     objB.methodB(); 

    } 
} 

Answer 1

這裏是溶液，其工作..

public class A { 

    public static boolean isFromAClass = false; 
    B obj = null; 

    public A() { 
     try { 
      isFromAClass = true; 
      obj = new B(); 
      isFromAClass = false; 
     } catch (Exception e) { 
     } 
    } 

    public void methodA() { 
     System.out.println("methodA"); 
     obj.methodB(); 
    } 
    // other methods 
} 

public class B { 

    public B() throws Exception { 
     if(!A.isFromAClass) { 
      throw new Exception(); 
     } 
    } 
    public void methodB() { 
     System.out.println("methodB"); 
     // some logic 
    } 
    //other methods 
} 

public class Client { 

    public static void main(String s[]) throws Exception { 
     // Valid Call 
     A obj = new A(); 
     obj.methodA(); // Since methodB is called internally 

     // Invalid Call , How to restrict this B object creation here ? 
     B objB = new B(); // this line throws Exception 
     objB.methodB(); 

    } 
} 

A，B，Client類可以是任何包。

using public static boolean isFromAClass = false;領域，它實現了。

只有我需要改變，而不是OD廣義例外，它應該是定製的異常爲OutSideAClassBClassInstanceShouldNotBeCreated

Answer 2

一個簡單的解決方案是將兩個A和B在示例包。然後，讓類B公開，但其構造package訪問或protected：

類A是：

package my; 
public class A {} 

和類B是：

package my; 
public class B { 
    B() {} 
} 

如果確實不需要類B外這個包，你甚至可以讓這個類本身成爲一個訪問包。

Answer 3

將B類放入與A相同的包中，並使其構造函數包受保護。只有來自同一個包的類才能夠調用它。

Answer 4

您可以使B具有私有構造函數的內部（靜態）類A。

class B { 

    public A createA() { 
     A a = new A(); 
     return a; 
    } 

    public static class A { 
     private A() {} 
    } 

} 

Answer 5

儘量讓B類作爲一個內部類A級，並指定B類的範圍，因爲私人

class A { 
    B b = null; 
    public A() { 
    b = new B();  
    } 
    public void testA() { 
     return b.methodB(); 
    } 

    private class B { 

     public void methodB() {    
        // some logic      
     } 

    } 
} 

http://docs.oracle.com/javase/tutorial/java/javaOO/innerclasses.html

Answer 6

可以使用私有靜態嵌套類：

public class A { 
     private static class B { 
      public void methodB() { 
       // some logic    
      } 
      //other methods 
     } 

     B obj = null; 

     public A() { 
      obj = new B(); 
     }   
     public void methodA() { 
      obj.methodB(); 
     }   
     // other methods 
    } 

Answer 7

我能想到的一個解決方案是使用內部靜態類A：KeyToB w ith是一個私人構造函數，B需要這個構造函數來實例化。因此，只有A可以instanciate B，它可以在不同的文件中。

public class A { 
    B obj = null; 
    public A() { 
     obj = new B(instance); 
    } 
    public void methodA() { 
     obj.methodB(); 
    } 
    // other methods .. 

    //The key to have the right to instanciate B, only visible in A 
    private static KeyToB instance = new KeyToB(); 

    public static class KeyToB{ 
     private KeyToB() { 
     } 
    } 
} 

public class B { 
    //The constructor is package visible, it need a non null instance of KeyToB . If someone use new B(null), it will get a RuntimeException 
    B(KeyToB instance) { 
     if (instance == null){ 
      throw new IllegalArgumentException("B can only be instanciated by A"); 
     } 
    } 
    public void methodB() {  
    } 
} 

Answer 8

public class A { 

    private class B{ 

     private B(){ 

     }  
    } 

    public B createB(){ 
     return new B(); 
    } 

} 

Answer 9

使用Inner Class概念。所述Outer Class（即類裏面）的

Private構件是所有Inner Class（即封閉類）內它訪問，並且反之亦然

因此，讓Class A是外部類和Class B作爲private內部類

public class A { 

     B obj; 

     public A() { 

     obj = new B(); 

     } 


     private class B { 

      public void methodB() {    

      } 

     } 
    }