A marker interface is an interface that contains no method declarations but merely designates (or “marks”) a class that implements the interface as having some property. For example, consider the Serializable interface (Chapter 12). By implementing this interface, a class indicates that its instances can be written to an ObjectOutputStream (or “serialized”).

標記接口是一種不包含任何方法聲明的接口，它只是指定（或「標記」）一個類，該類實現了具有某些屬性的接口。例如，考慮 Serializable 接口（Chapter 12）。通過實現此接口，表示類的實例可以寫入 ObjectOutputStream（或「序列化」）。

You may hear it said that marker annotations (Item 39) make marker interfaces obsolete. This assertion is incorrect. Marker interfaces have two advantages over marker annotations. First and foremost, marker interfaces define a type that is implemented by instances of the marked class; marker annotations do not. The existence of a marker interface type allows you to catch errors at compile time that you couldn’t catch until runtime if you used a marker annotation.

你可能聽過一個說法：標記接口已經過時，更好的方式是標記注解（Item-39）。這個言論是錯誤的。與標記注解相比，標記接口有兩個優點。首先，標記接口定義的類型由標記類的實例實現；標記注解不會。 標記接口類型的存在允許你在編譯時捕獲錯誤，如果你使用標記注解，則在運行時才能捕獲這些錯誤。

Java’s serialization facility (Chapter 6) uses the Serializable marker interface to indicate that a type is serializable. The ObjectOutputStream.writeObject method, which serializes the object that is passed to it, requires that its argument be serializable. Had the argument of this method been of type Serializable, an attempt to serialize an inappropriate object would have been detected at compile time (by type checking). Compile-time error detection is the intent of marker interfaces, but unfortunately, the ObjectOutputStream.write API does not take advantage of the Serializable interface: its argument is declared to be of type Object, so attempts to serialize an unserializable object won’t fail until runtime.

Java 的序列化工具（Chapter 6）使用 Serializable 標記接口來表明一個類是可序列化的。ObjectOutputStream.writeObject 方法序列化傳遞給它的對象，它要求其參數是可序列化的。假設該方法的參數類型是 Serializable，那么在編譯時（通過類型檢查）就會檢測到對不合適的對象進行序列化的錯誤。編譯時錯誤檢測是使用標記接口的目的，但不幸的是，ObjectOutputStream.writeObject 沒有利用 Serializable 接口：它的參數被聲明為 Object 類型，因此，如果嘗試序列化一個不可序列化對象，直到運行時才會提示失敗。

譯注 1：原文 ObjectOutputStream.write 有誤，該方法的每種重載僅支持 int 類型和 byte[]，應修改為 ObjectOutputStream.writeObject，其源碼如下：

public final void writeObject(Object obj) throws IOException {
    if (enableOverride) {
        writeObjectOverride(obj);
        return;
    }
    try {
        writeObject0(obj, false);
    } catch (IOException ex) {
        if (depth == 0) {
            writeFatalException(ex);
        }
        throw ex;
    }
}

譯注 2：使用 ObjectOutputStream.writeObject 的例子

public class BaseClass implements Serializable {
    private final int id;
    private final String name;

    public BaseClass(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "id=" + id + ", name='" + name + '\'';
    }
}

public class Main {
    private void Out() throws IOException {
        BaseClass obj = new BaseClass(1, "Mark");
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("out.txt")))) {
            out.writeObject(obj);
        }
    }

    private void In() throws IOException, ClassNotFoundException {
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("out.txt")))) {
            BaseClass obj = (BaseClass) in.readObject();
            System.out.println(obj);
        }
    }
}

Another advantage of marker interfaces over marker annotations is that they can be targeted more precisely. If an annotation type is declared with target ElementType.TYPE, it can be applied to any class or interface. Suppose you have a marker that is applicable only to implementations of a particular interface. If you define it as a marker interface, you can have it extend the sole interface to which it is applicable, guaranteeing that all marked types are also subtypes of the sole interface to which it is applicable.

標記接口相對于標記注解的另一個優點是可以更精確地定位它們。 如果注解類型使用 @Target(ElementType.TYPE) 聲明，它可以應用于任何類或接口。假設你有一個只適用于特定接口來實現的標記。如果將其定義為標記接口，則可以讓它擴展其適用的惟一接口，確保所有標記的類型也是其適用的惟一接口的子類型。

Arguably, the Set interface is just such a restricted marker interface. It is applicable only to Collection subtypes, but it adds no methods beyond those defined by Collection. It is not generally considered to be a marker interface because it refines the contracts of several Collection methods, including add, equals, and hashCode. But it is easy to imagine a marker interface that is applicable only to subtypes of some particular interface and does not refine the contracts of any of the interface’s methods. Such a marker interface might describe some invariant of the entire object or indicate that instances are eligible for processing by a method of some other class (in the way that the Serializable interface indicates that instances are eligible for processing by ObjectOutputStream).

可以說，Set 接口就是這樣一個受限的標記接口。它只適用于 Collection 的子類，但是除了 Collection 定義的方法之外，它不添加任何方法。它通常不被認為是一個標記接口，因為它細化了幾個 Collection 方法的約定，包括 add、equals 和 hashCode。但是很容易想象一個標記接口只適用于某些特定接口的子類，而不細化任何接口方法的約定。這樣的標記接口可能描述整個對象的某個不變量，或者表明實例能夠利用其他類的方法進行處理（就像 Serializable 接口能夠利用 ObjectOutputStream 進行處理一樣）。

The chief advantage of marker annotations over marker interfaces is that they are part of the larger annotation facility. Therefore, marker annotations allow for consistency in annotation-based frameworks.

相對于標記接口，標記注解的主要優勢是它們可以是其他注解功能的一部分。 因此，標記注解能夠與基于使用注解的框架保持一致性。

So when should you use a marker annotation and when should you use a marker interface? Clearly you must use an annotation if the marker applies to any program element other than a class or interface, because only classes and interfaces can be made to implement or extend an interface. If the marker applies only to classes and interfaces, ask yourself the question “Might I want to write one or more methods that accept only objects that have this marking?” If so, you should use a marker interface in preference to an annotation. This will make it possible for you to use the interface as a parameter type for the methods in question, which will result in the benefit of compile-time type checking. If you can convince yourself that you’ll never want to write a method that accepts only objects with the marking, then you’re probably better off using a marker annotation. If, additionally, the marking is part of a framework that makes heavy use of annotations, then a marker annotation is the clear choice.

那么什么時候應該使用標記注解，什么時候應該使用標記接口呢？顯然，如果標記應用于類或接口之外的任何程序元素，則必須使用標記注解，因為只有類和接口才能實現或擴展接口。如果標記只適用于類和接口，那么可以問自己這樣一個問題：「我是否可以編寫一個或多個方法，只接受具有這種標記的對象？」如果是這樣，你應該使用標記接口而不是標記注解。這將使你能夠將接口用作相關方法的參數類型，這將帶來編譯時類型檢查的好處。如果你確信自己永遠不會編寫只接受帶有標記的對象的方法，那么最好使用標記注解。此外，如果框架大量使用注解，那么標記注解就是明確的選擇。

In summary, marker interfaces and marker annotations both have their uses. If you want to define a type that does not have any new methods associated with it, a marker interface is the way to go. If you want to mark program elements other than classes and interfaces or to fit the marker into a framework that already makes heavy use of annotation types, then a marker annotation is the correct choice. If you find yourself writing a marker annotation type whose target is ElementType.TYPE, take the time to figure out whether it really should be an annotation type or whether a marker interface would be more appropriate.

總之，標記接口和標記注解都有各自的用途。如果你想要定義一個沒有與之關聯的新方法的類型，可以使用標記接口。如果你希望標記類和接口之外的程序元素，或者將標記符放入已經大量使用注解類型的框架中，那么標記注解就是正確的選擇。如果你發現自己編寫的標記注解類型有 @Target(ElementType.TYPE) 聲明（譯注：意在說明既可以用標記注解，也可以用標記接口的情況），那么請花時間弄清楚究竟應該用注解類型，還是標記接口更合適。

In a sense, this item is the inverse of Item 22, which says, “If you don’t want to define a type, don’t use an interface.” To a first approximation, this item says, “If you do want to define a type, do use an interface.”

從某種意義上說，本條目與 Item-22 的說法相反，也就是說，「如果不想定義類型，就不要使用接口。」，與本條目應用場景適應的說法是，「如果你確實想定義類型，那么就要使用接口。」

Back to contents of the chapter（返回章節目錄）

• Previous Item（上一條目）：Item 40: Consistently use the Override annotation（堅持使用 @Override 注解）
• Next Item（下一條目）：Chapter 7 Introduction（章節介紹）