Java 泛型类型和对象与通配符之间的区别

目前我正在学习通用编程。我不明白他为什么出生。当我们有

对象类（数据类型）

时。 在代码下面，我已经通过了

HashCodeclass1

作为参数。两者都需要将传递的参数强制转换为特定的类，并且操作的输出将是相同的。那么，为什么会出现泛型呢

package know.generic;

import knowl.collection.hashcodeInternal.HashCodeclass1;

public class ClassGeneric {
    public <T> void functioF1(T arg) {
        System.out.println(arg.getClass().getName());
        System.out.println("val1 " + arg);
        HashCodeclass1 hCC = (HashCodeclass1) arg;
    }

    public void functioF21(Object arg) {
        System.out.println(arg.getClass().getName());
        System.out.println("val2 " + arg);
        HashCodeclass1 hCC = (HashCodeclass1) arg;
    }
}

public class TestGeneric {
    public static void main(String arg[]) {
        ClassGeneric cg = new ClassGeneric();
        cg.functioF1(new HashCodeclass1());
        cg.functioF21(new HashCodeclass1());
    }
}

package know.generic；
导入knowl.collection.hashcodeInternal.HashCodeclass1；
公共类类泛型{
公共无效函数1（T参数）{
System.out.println（arg.getClass（）.getName（））；
系统输出打印项次（“val1”+arg）；
HashCodeclass1 hCC=（HashCodeclass1）arg；
}
公共无效函数21（对象参数）{
System.out.println（arg.getClass（）.getName（））；
系统输出打印项次（“val2”+arg）；
HashCodeclass1 hCC=（HashCodeclass1）arg；
}
}
公共类TestGeneric{
公共静态void main（字符串arg[]）{
ClassGeneric cg=新的ClassGeneric（）；
functioF1（新的HashCodeclass1（））；
cg.functioF21（新的HashCodeclass1（））；
}
}

请参阅相同的内容。 来自网站的一些相关文本：-

与非泛型代码相比，使用泛型的代码有许多好处：

1.在编译时进行更强的类型检查。 Java编译器对泛型代码应用强类型检查，并在代码违反类型安全性时发出错误。修复编译时错误比修复运行时错误更容易，因为运行时错误可能很难找到

2.消除铸型。 以下不带泛型的代码段需要强制转换： 列表=新的ArrayList（）； 添加（“你好”）； 字符串s=（字符串）list.get（0）； 当重新编写以使用泛型时，代码不需要强制转换： 列表=新的ArrayList（）； 添加（“你好”）； 字符串s=list.get（0）；//无演员阵容

3.使程序员能够实现通用算法。 通过使用泛型，程序员可以实现在不同类型的集合上工作、可以自定义、类型安全且易于阅读的泛型算法

如果集合通过多个类传递，则消除强制转换和类型实际上是很重要的。它避免了意外的类类型转换问题，并提供了更好的可维护性。

您可以参考，Panther也指出了同样的问题

您还可以参考的源代码。同时想想，如果你不得不在不使用泛型的情况下重写这段代码，你将面临哪些使用泛型克服的挑战

我只是在重写你的代码。你可以检查一下优势

public class ClassGeneric {
    public <T> T functioF1(T arg) { // changed return type from void
        System.out.println(arg.getClass().getName());
        System.out.println("val1 " + arg);
        // HashCodeclass1 hCC = (HashCodeclass1) arg;
        return arg; 
    }

    public Object functioF21(Object arg) { // changed return type from void
        System.out.println(arg.getClass().getName());
        System.out.println("val2 " + arg);
        // HashCodeclass1 hCC = (HashCodeclass1) arg;
        return arg;
    }
}

public class TestGeneric {
    public static void main(String arg[]) {
        ClassGeneric cg = new ClassGeneric();

        //no casting required and compile time check of type
        HashCodeclass1 f1OutputObj = cg.functioF1(new HashCodeclass1());

        // you need to use casting
        HashCodeclass1 f2OutputObj = (HashCodeclass1) cg.functioF21(new HashCodeclass1());
    }
}

公共类ClassGeneric{
公共T functionf1（T arg）{//已从void更改了返回类型
System.out.println（arg.getClass（）.getName（））；
系统输出打印项次（“val1”+arg）；
//HashCodeclass1 hCC=（HashCodeclass1）arg；
返回arg；
}
公共对象functioF21（对象arg）{//已从void更改返回类型
System.out.println（arg.getClass（）.getName（））；
系统输出打印项次（“val2”+arg）；
//HashCodeclass1 hCC=（HashCodeclass1）arg；
返回arg；
}
}
公共类TestGeneric{
公共静态void main（字符串arg[]）{
ClassGeneric cg=新的ClassGeneric（）；
//不需要强制转换和类型的编译时检查
HashCodeclass1 f1OutputObj=cg.functioF1（新的HashCodeclass1（））；
//你需要使用铸造
HashCodeclass1 f2OutputObj=（HashCodeclass1）cg.functioF21（新的HashCodeclass1（））；
}
}

首先，您将看到一些东西，它消除了强制转换。您已经成功创建了一个坏的非泛型和坏（勉强）泛型代码示例。我会先删除你正在显示的代码，它只会给你错误的想法。