Java 我们可以为<；使用原始类型吗；T扩展SomeClass>；？

这是对肯定答案的答复，即：

。。。总之，新代码中不应使用原始类型。您应该始终使用参数化类型

我还不同意“你不应该使用原始类型”。我认为有些情况下你可以安全地使用它

对我来说，有三种原始类型：

“原始类型”：具有此赋值的每个类的原始实例：

class Foo

。例如：

Foo-Foo=new-Foo（）

“带扩展的原始类型”：具有此属性的每个类的原始实例：

class Foo

。例如：

Foo-Foo=new-Foo（）

“具有扩展多个边界的原始类型”：具有此属性的每个类的原始实例：

class Foo

。例如：

Foo-Foo=new-Foo（）

第二个是我认为可以安全使用的类（

classfoo

）。我想知道是否有人对此有任何问题

例如：

public class Tests {
    public static void main(String... args){
        GenericClass<SomeClassWithSomeInterface> genericClass1 = new GenericClass<>();
        genericClass1.set(new SomeClassWithSomeInterface());
        genericClass1.set(new SomeExtendClass());
        genericClass1.set(new Object()); // Compile-time error: type is safe

        GenericClass genericClass2 = new GenericClass<>();
        genericClass2.set(new SomeClassWithSomeInterface());
        genericClass2.set(new SomeExtendClass());
        genericClass2.set(new Object()); // Compile-time error: type is safe too. Or not?

    }
}

class SomeClass{    
}

interface SomeInterface{
}

class SomeClassWithSomeInterface extends SomeClass implements SomeInterface{
}

class GenericClass<T extends SomeClassWithSomeInterface>{
    private T t;

    public void set(T t){
        this.t = t;
    }
}

class SomeExtendClass extends SomeClassWithSomeInterface{
}

公共类测试{
公共静态void main（字符串…参数）{
GenericClass genericClass1=新的GenericClass（）；
set（新的SomeClassWithSomeInterface（））；
genericClass1.set（新的SomeExtendClass（））；
genericClass1.set（new Object（））；//编译时错误：类型是安全的
GenericClass genericClass2=新的GenericClass（）；
genericClass2.set（新的SomeClassWithSomeInterface（））；
genericClass2.set（新的SomeExtendClass（））；
genericClass2.set（new Object（））；//编译时错误：类型也是安全的。是否？
}
}
类SomeClass{
}
接口接口{
}
类SomeClassWithSomeInterface扩展SomeClass实现SomeInterface{
}
类泛型类{
私人T；
公共无效集（T）{
t=t；
}
}
类SomeExtendClass使用SomeInterface扩展SomeClass{
}

在上面的示例中，genericClass1对象和genericClass2都是类型安全的。我的理解正确吗

考虑一下：

class SomeExtendingClass extends SomeClassWithSomeInterface {}
class SomeOtherExtendingClass extends SomeClassWithSomeInterface {}

class Test {
    public static void main() {
        GenericClass<SomeExtendingClass> generic1 = new GenericClass<SomeExtendingClass>();
        generic1.set(new SomeExtendingClass()); // ok
        generic1.set(new SomeOtherExtendingClass()); // error (as expected)

        GenericClass generic2 = new GenericClass<SomeExtendingClass>();
        generic2.set(new SomeExtendingClass()); // ok
        generic2.set(new SomeOtherExtendingClass()); // ok (but shouldn't be!)
    }
}

class SomeExtendingClass使用SomeInterface{}扩展SomeClass
类SomeOtherExtendingClass使用SomeInterface{}扩展SomeClass
课堂测试{
公共静态void main（）{
GenericClass generic1=新的GenericClass（）；
generic1.set（新的SomeExtendingClass（））；//确定
generic1.set（new SomeOtherExtendingClass（））；//错误（如预期）
GenericClass generic2=新的GenericClass（）；
generic2.set（新的SomeExtendingClass（））；//确定
generic2.set（newsomeotherextendingclass（））；//可以（但不应该是！）
}
}

考虑一下：

class SomeExtendingClass extends SomeClassWithSomeInterface {}
class SomeOtherExtendingClass extends SomeClassWithSomeInterface {}

class Test {
    public static void main() {
        GenericClass<SomeExtendingClass> generic1 = new GenericClass<SomeExtendingClass>();
        generic1.set(new SomeExtendingClass()); // ok
        generic1.set(new SomeOtherExtendingClass()); // error (as expected)

        GenericClass generic2 = new GenericClass<SomeExtendingClass>();
        generic2.set(new SomeExtendingClass()); // ok
        generic2.set(new SomeOtherExtendingClass()); // ok (but shouldn't be!)
    }
}

class SomeExtendingClass使用SomeInterface{}扩展SomeClass
类SomeOtherExtendingClass使用SomeInterface{}扩展SomeClass
课堂测试{
公共静态void main（）{
GenericClass generic1=新的GenericClass（）；
generic1.set（新的SomeExtendingClass（））；//确定
generic1.set（new SomeOtherExtendingClass（））；//错误（如预期）
GenericClass generic2=新的GenericClass（）；
generic2.set（新的SomeExtendingClass（））；//确定
generic2.set（newsomeotherextendingclass（））；//可以（但不应该是！）
}
}

可以正确使用它们（以一种不会导致类型混淆的方式），但我不会安全地调用它。“安全”意味着编译器正在防止你犯错误，这里没有。所以，这是我的问题。第二个“扩展的原始类型”是安全的吗？因为编译阻止了我犯错误。使类泛型的目的是能够将它接受的限制为上限的子类（例如SomeExtendClass）。使用原始类型不会阻止您将SomeClassWithSomeInterface的实例添加到应该包含SomeExtendClass的GenericClass。可以正确使用它们（以不会导致类型混淆的方式），但我不会安全地调用它。“安全”意味着编译器正在防止你犯错误，这里没有。所以，这是我的问题。第二个“扩展的原始类型”是安全的吗？因为编译阻止了我犯错误。使类泛型的目的是能够将它接受的限制为上限的子类（例如SomeExtendClass）。使用原始类型不会阻止您将SomeClassWithSomeInterface的实例添加到应该包含SomeExtendClass的GenericClass。为什么不应该？我认为，我们可以将这种方法用于所有类型的SomeClassWithSomeInterface@Paulo因为，正如main方法的第一部分所示，目标是拥有一个只接受SomeExtendingClass的GenericClass实例。使用原始类型使这变得不可能。@JBNizet main方法的第一部分说“此泛型可以接受SomeExtendingClass的所有实例或子实例”。。第二部分说：“这个泛型可以接受SomeClassWithSomeInterface的所有实例和子实例”。对我来说，类型是安全的。当你省略类型时，这个泛型假设它是的泛型SomeClassWithSomeInterface@Paulo：否。第一个表示“此泛型可以接受SomeExtendingClass的所有实例或子实例”。第二个说：“我没有注意到这个类是泛型的，我把它当作原始类型使用。让可怜的维护人员猜猜我的意图是什么，这个列表应该包含什么。”。为什么你要为具体类型是上限的情况做一个特例？为什么不应该？我认为，我们可以将这种方法用于所有类型的SomeClassWithSomeInterface@Paulo因为，正如main方法的第一部分所示，目标是拥有一个只接受SomeExtendingClass的GenericClass实例。使用原始类型使这变得不可能。@JBNizet main方法的第一部分说“此泛型可以接受SomeExtendingClass的所有实例或子实例”。。第二部分说：“这个泛型可以接受所有实例和