了解 Java 包和工厂

Question

我正在阅读 Bruce Eckel 的 Thinking in Java，其中有一个练习我没有得到：

页码。 161：练习 8：(4) 跟随 示例Lunch.java的形式， 创建一个名为 ConnectionManager 管理固定的 Connection 对象的数组。 的 客户端程序员一定不能 显式创建 Connection 对象， 但只能通过静态获取它们 连接管理器中的方法。当 ConnectionManager 对象耗尽， 它返回一个空引用。测试 main() 中的类。

我想出了以下解决方案：

// TestConnection.java
import java.util.*;

public class TestConnections {
    public static void main( String[] args ) {
        Connection cn = Connection.makeConnection();

        for (int i = 0; i != 6; ++i) {
            Connection tmp = ConnectionManager.newConnectiton();
            if ( tmp == null )
                System.out.println("Out of Connection objects");
            else {
                System.out.println("Got object: " + tmp );
            }
        }
    }
}

同一目录中的第二个文件意味着所有内容最终都在同一个默认包中：

// ConnectionManager.java
class Connection { 
    private Connection() {}

    static Connection makeConnection() {
        return new Connection();
    }
}

public class ConnectionManager {
    static private Connection[] _connections = new Connection[5];

    private ConnectionManager() {}

    static public Connection newConnectiton() {
        for ( int i = 0; i != _connections.length; ++i ) {
            if ( _connections[i] == null ) {
                _connections[i] = Connection.makeConnection();
                return _connections[i];
            }
        }
        return null;
    }
}

问题是客户端程序可以通过静态 Connection.makeConnection 工厂，这似乎违反了演习目标。然而，如果我将 ConnectionManager.java 作为一个单独的包然后导入，它会抱怨找不到 Connection 的定义。

我觉得有些事情超出了我的想象，但我不确定是什么。

这是问题中引用的 Lunch.java 的代码：

//: access/Lunch.java
// Demonstrates class access specifiers. Make a class
// effectively private with private constructors:

class Soup1 {
  private Soup1() {}
  // (1) Allow creation via static method:
  public static Soup1 makeSoup() {
    return new Soup1();
  }
}

class Soup2 {
  private Soup2() {}
  // (2) Create a static object and return a reference
  // upon request.(The "Singleton" pattern):
  private static Soup2 ps1 = new Soup2();
  public static Soup2 access() {
    return ps1;
  }
  public void f() {}
}

// Only one public class allowed per file:
public class Lunch {
  void testPrivate() {
    // Can't do this! Private constructor:
    //! Soup1 soup = new Soup1();
  }
  void testStatic() {
    Soup1 soup = Soup1.makeSoup();
  }
  void testSingleton() {
    Soup2.access().f();
  }
} ///:~

Answer 1

每个类都有一个范围。在您的代码中，Connection 类具有包 范围（即，它只能由同一包内的类访问）。这意味着将 ConnectionManager 类移动到另一个包会将其移出可以看到 Connection 类的范围；这就是你所看到的失败。这些连接必须与其工厂位于同一地点。

实际上，您实际上要做的是创建一个公共接口来定义Connection上的操作，以及ConnectionManager内该接口的私有实现;然后 newConnection 方法可以只声明它返回接口的实例，并且包保护机制可以阻止任何人窥探该接口的背后（好吧，不是不使用反射的更时髦的部分）。

Answer 2

技巧：连接不应该是一个具体的类，而应该是一个接口。第二个类 (ConnectionImpl) 提供此接口的实现。

只有 ConnectionManager 可以实例化这个具体类的实例并返回接口。

示例（简化以显示访问修饰符）：

public interface Connection() {
}

---

public class ConnectionManager {
  private static class ConnectionImpl implement Connection {
    private ConnectionImpl() {
    }
  }
  public static Connection createConnection() {
    return new ConnectionImpl();
  }
}

Answer 3

另一种方法是将 Connection 设为 ConnectionManager 内的公共嵌套类。但你可能不想要这样。确实，Andreas_D 和 Donal 的建议更好、更实用。

public class ConnectionManager {
    private static Connection[] _connections = new Connection[5];

    private ConnectionManager() {}

    public static Connection newConnectiton() {
        for ( int i = 0; i != _connections.length; ++i ) {
            if ( _connections[i] == null ) {
                _connections[i] = new Connection();
                return _connections[i];
            }
        }
        return null;
    }

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

}

进行编辑以显示TestConnections的外观，

public class TestConnections {

    public static void main(String[] args) {
        Connection conn = ConnectionManager.newConnectiton();
    }
}

Answer 4

从某种意义上说，这是通过将某些类放置在具有适当访问修饰符的不同类下来完成的。假设本书的学生/读者尚未了解界面。

// File cm.Connection.java
package cm;

public class Connection {
    // The constructor has package access and so is available to 
    // ConnectionManager, but not to any class outside package cm
    Connection() { }
}

// File cm.ConnectionManager.java
package cm;

public class ConnectionManager {
    static private Connection[] _connections = new Connection[5];

    private ConnectionManager() {}

    static public Connection newConnectiton() {
        for ( int i = 0; i != _connections.length; ++i ) {
            if ( _connections[i] == null ) {
                _connections[i] = new Connection();
                return _connections[i];
            }
        }
        return null;
    }
}

Connection 和 ConnectionManager 都在同一个包cm中。

// File different.TestConnections.java
package different;

import cm.*;

public class TestConnections {

    public static void main(String[] args) {
        Connection conn = ConnectionManager.newConnectiton();
    }
}

注意，TestConnections位于不同包中。

Answer 5

你说

问题是客户端程序可以直接通过静态Connection.makeConnection工厂创建Connection对象

我认为如果是通过静态方法，则不是直接的。

另外，回顾一下任务

客户端程序员不得显式创建 Connection 对象

您的解决方案隐藏了创建新连接的事实。您可以通过将“newConnection”重命名为“getConnection”或其他名称来强调这一点。

也许预期的解决方案应该重用连接对象，但练习中并没有这么说。 （而且对于连接来说没有多大意义）。

Answer 6

通过 ConnectionManager 获取连接的目的是将资源相关的东西放在一个单独的类中。在这种情况下，您可以在编写单元测试时模拟连接。

Answer 7

makeConnection() 方法具有默认可见性，这意味着它不能被不同包中的代码直接使用。 （实际上 Connection 类本身也是如此，我认为您不想要它）。

请注意，客户端程序员可以通过将代码放在同一个包中来解决这个问题；但代码可见性通常应被视为帮助客户端程序员查看 API 而不是实现细节的辅助工具，而不是防止故意愚蠢或恶意的方法。不过，如果您确实需要运行不受信任的代码，可以通过对 JAR 进行签名来防止将代码注入到您的包中。