String は Java の Object のサブタイプではありませんか?

List<String>はい、そうですが、それはのサブタイプにはなりませんList<Object>。

次の例を検討してください。

    List<String> l1 = new ArrayList<String>();
    List<Object> l2 = l1;  // This is a compilation error in real Java
    l2.add(new Integer(42));
    String oops = l1.get(0);

(仮説的List<String>に) サブタイプが の場合、最後のステートメントで変数にa をList<Object>代入することになります。要するに、静的型安全性を破っていたでしょう。IntegerString

ただし、そのようなオブジェクトを、List をパラメーターとして受け入れる関数に渡すことはできます。

はい、それは本当です。ただし、生の型を扱っているため、リストからオブジェクトを引き出すときに明示的な型キャストを使用する必要があります。たとえば、上記は次のように書き直す必要があります。

    List<String> l1 = new ArrayList<String>();
    List l2 = l1;
    l2.add(new Integer(42));
    String oops = (String) l1.get(0);

型キャストは、静的な型安全性を実行時の型安全性に置き換える必要があることを意味することに注意してください。(もちろん、この場合、インスタンスの型が間違っているため、型キャストは実行時に失敗します。)

You are confusing the parameterized type with the concrete type.

Given List<T>, T is the parameterized type.

List<String> isn't type related to List<Object> in any way, not anymore than List<String> is related to List<Number>. The type is List<String>, the entire signature is the type. But like with everything, there are exceptions; these are called Wildcard Parameterized Types.

List<?> is what is called an Unbounded Wildcard Parameterized Type, it works pretty much just like a raw type, they are semantically the same, but causes more compiler warnings about unsafe casting.

List<? extends Object> is a bounded Wildcard Parameterized Type, and would be a type that would allow you to put anything that extends Object but since every class in Java extends Object it isn't semantically any different than the first two options.

Now they would all function the same, but they would fail instanceof tests, they are not the same types.

In other words:

public void myfunction(final List<Object> list) {}

would only accept the type of List<Object>, List isn't related by type to List<Object> or List<?>, even though they all semantically function the same.

The type is either List or List<Object> or List<String>, the inheritance chain in the <> is not considered when the type of the List<T> is concerned, until you get into Wild Card Parameterized Types

Here are examples:

Collection<?> coll = new ArrayList<String>(); 
List<? extends Number> list = new ArrayList<Long>(); 

You can't instantiate a new Collection<?> only assign a concrete implementation to it.

List<Object> is the entire type.

Generics in Java aren't anything like the implementation in C++, other than the confusing name.

Java では、はのサブタイプでList<S> はありませんList<T>が、Sは のサブタイプですT。この規則は、タイプ セーフを提供します。

List<String>aを のサブタイプにできるとしましょうList<Object>。次の例を検討してください。

public void foo(List<Object> objects) {
    objects.add(new Integer(42));
}

List<String> strings = new ArrayList<String>();
strings.add("my string");
foo(strings); // this is not allow in java
// now strings has a string and an integer!
// what would happen if we do the following...??
String myString = strings.get(1);

したがって、これを強制すると型の安全性が確保されますが、柔軟性に欠けるという欠点もあります。次の例を検討してください。

class MyCollection<T> {
    public void addAll(Collection<T> otherCollection) {
        ...
    }
}

ここに のコレクションがありT、別のコレクションからすべてのアイテムを追加したいとします。Collection<S>のSサブタイプの でこのメソッドを呼び出すことはできませんT。理想的には、コレクションに要素を追加するだけで、パラメーター コレクションを変更していないため、これで問題ありません。

これを修正するために、Java は「ワイルドカード」と呼ばれるものを提供します。ワイルドカードは、共分散/反分散を提供する方法です。ここで、ワイルドカードを使用して次のことを検討してください。

class MyCollection<T> {
     // Now we allow all types S that are a subtype of T
     public void addAll(Collection<? extends T> otherCollection) {
         ...

         otherCollection.add(new S()); // ERROR! not allowed (Here S is a subtype of T)
     }
} 

現在、ワイルドカードを使用して、型 T の共分散を許可し、型安全ではない操作 (コレクションへの項目の追加など) をブロックしています。このようにして、柔軟性と型の安全性が得られます。

String is a subtype of Object, yes, but that does not mean that List is a subtype of List. That's just the way Java works. You can read more here.

上記のすべてに加えて、必要なものを許可するには、パラメーターを次のように明示的に宣言する必要がありますList<? extends T>(つまり、T を含む T のサブクラスを受け入れることを意味します)。この場合、List<? extends Object>機能するはずですがList<Object>、オブジェクト テンプレート リストに限定されます。