java - 考虑添加静态接口(interface)方法以为对象创建提供单一入口点

Question

是否“实现”below是指一个对象的实例？也许他们指的是实现代码。

Consider adding static interface methods, to allow the client code to create (potentially specialized) objects that implement the interface. For example, if we have an interface Point with two methods int x() and int y(), then we can expose a static method Point.of(int x, int y) that produces a (hidden) implementation of the interface.

So, if x and y are both zero, we can return a special implementation class PointOrigoImpl (with no x or y fields), or else we return another class PointImpl that holds the given x and y values. Ensure that the implementation classes are in another package that are clearly not a part of the API (e.g. put the Point interface in com.company. product.shape and the implementations in com.company.product.internal.shape).

Do This:

Point point = Point.of(1,2);

Don't Do This:

Point point = new PointImpl(1,2);

这样做的好处是强制封装？但是，如果实现是包私有(private)的而不是 API 的一部分，那会不会产生访问问题？如果客户端，“世界”如下:

https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

无法访问 Point 的实现，那么它怎么可能像上面那样为“执行此操作”实例化一个新的 Point？

Answer 1

For example, if we have an interface Point with two methods int x() and int y(), then we can expose a static method Point.of(int x, int y) that produces a (hidden) implementation of the interface.

1) 请注意，从 Java 8 开始，您可以在接口(interface)中添加静态方法，但在此之前您不能。

2) 我很难理解这个建议:

So, if x and y are both zero, we can return a special implementation class PointOrigoImpl (with no x or y fields), or else we return another class PointImpl that holds the given x and y values. Ensure that the implementation classes are in another package that are clearly not a part of the API (e.g. put the Point interface in com.company. product.shape and the implementations in com.company.product.internal.shape).

这是一个与您引用的文本相匹配的 Point 类示例:

package com.company.product.shape;

import com.company.product.internal.shape.PointOrigoImpl;
import com.company.product.internal.shape.PointImpl;

public interface Point{
   int x();
   int y();     
   static Point of(int x, int y) {
      if (x == 0 && y == 0){
         return new PointOrigoImpl();
      }
      return new PointImpl(x, y);
  }
}

如果 Point 接口(interface)被提供给客户端并且它声明了工厂方法，为了编译正常，Point 接口(interface)必须对 可见PointOrigoImpl 和 PointImpl 类，以便实例化它们。

由于 Point 接口(interface)和子类位于两个不同的包中(com.company.product.shape 和 com.company.product.internal.shape ),这意味着 PointImpl 和 PointOrigoImpl 应该有一个公共(public)构造函数，否则 Point 无法实例化它们。
最后，操作 Points 的客户端也可以实例化 PointImpl 和 PointOrigoImpl 子类的构造函数。

它违背了不想公开实现的工厂自己选择要返回的实现的目的。

一个接口(interface)是公共(public)的，被设计成完全可以被客户端访问。
因此，作为一般规则，它不应包含我们不想向客户公开的实现。

3) 这里:

The advantage being that this enforces encapsulation? However, if the implementation is package private and not part of the API, would that not create access problems? If the client, "world" as here: doesn't have access to the implementation of Point then how can it possibly instantiate a new Point as above for "do this"?

我想你想知道为什么文字说: 确保实现类位于另一个显然不是 API 一部分的包中。

在您提到的文本中，作者想让Point 客户端知道该接口(interface)，但他不想让Point 的子类知道，因为他想根据工厂Point中使用的参数来决定返回的Point子类。

点客户端将只知道这个接口(interface)。

在 Java 中，为了不提供对实现类的访问，您可以使用公共(public)类、接口(interface)和内部私有(private)类:

• 公开类给客户调用返回实现的工厂方法
• 接口(interface)类是众所周知的，与实现没有耦合。
• 内部私有(private)类构成公共(public)类的一部分。客户看不到它，但工厂看到它并返回合适的实现。

用你提到的例子，它会是直的。

点(接口(interface)):

public interface Point{
   int x();
   int y();            
}

点工厂(包含私有(private)类的公共(public)类):

public final class PointFactory {

    // private classes
    private class PointImpl implements Point {

        private int x;
        private int y;

        private PointImpl(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int x() {
            return x;
        }

        public int y() {
            return y;
        }
    }

    private class PointOrigoImpl implements Point {

        public int x() {
            return 0;
        }

        public int y() {
            return 0;
        }
    }

    // end private classes

    public Point of(int x, int y) {
        if (x == 0 && y == 0) {
            return new PointOrigoImpl();
        }
        return new PointImpl(x, y);
    }

}