Java中的泛型字段多态性

我真的对泛型感到困惑，请帮助我解决我的情况：

public <M extends AgeFactor> void setAgeFActor(M m){
    System.out.println("referene receiveed"+m.factor); //WHAT SHOULD IT REFER TO?? AgeFactor or type given at Runtime as young
    this.factor=m.factor;
}

层次结构是：

class AgeFactor {
    String factor;
}

class young extends AgeFactor {
    String factor = "Young";

    public String toString() {
        return " " + factor + " ";

    }
}

class experienced extends AgeFactor {
    String factor = "Experienced";

    public String toString() {
        return " " + factor + " ";

    }
}

class pro extends AgeFactor {
    String factor = "Pro";

    public String toString() {
        return " " + factor + " ";

    }
}

我想知道的是为什么

m.factor

参考

AgeFactor

的字段

factor

m.factor

应该指的是

young

或

pro

我在运行时给出的类型

如果m实际上是指AgeFactor，那么我理解m.factor总是指AgeFactor的factor，因为多态性不应用于字段。如果是这样，那么泛型的需求是什么？ Java的泛型本身是泛型的吗？

---

请帮我复习泛型。

字段不会像方法那样被重写。如果需要这种多态性，必须使用方法，而不是字段

这里，

experied

和

pro

有两个不同的字段，分别命名为

factor

，一个来自

AgeFactor

，另一个来自

experied

和

pro

。它具有相同名称的事实是完全巧合的：如果您有一个对象，并且已知它是一个

AgeFactor

，那么将使用该字段的

AgeFactor

版本

---

这种设计更合理的版本可能是只有一个名为

factor

的字段，并在每个类的构造函数中设置它。

字段不会像方法那样被重写。如果需要这种多态性，必须使用方法，而不是字段

这里，

experied

和

pro

有两个不同的字段，分别命名为

factor

，一个来自

AgeFactor

，另一个来自

experied

和

pro

。它具有相同名称的事实是完全巧合的：如果您有一个对象，并且已知它是一个

AgeFactor

，那么将使用该字段的

AgeFactor

版本

---

这种设计更合理的版本可能是只有一个名为

factor

的字段，并在每个类的构造函数中设置它。

AgeFactor是一个类，而不是一个接口。因此，它（AgeFactor）有自己的实例变量。子类（如young）有自己的实例变量。子类的实例变量完全独立于任何子/超级实例变量。如上所述，只有非静态方法参与多态性（即子类可以覆盖超类的方法）。 一种方法是使用“getFactor”方法将AgeFactor设置为接口。每个子类都将实现一个getFactor（）方法，该方法返回所需的常量

注意，在java中，C++类与CaseCasts不改变对象引用值-所以方法引用被保存在转换中。请尝试以下操作：

class Ages
{
  public static void main(String args[])
  {
    young yy = new young();
    System.out.println(yy.toString());
    System.out.println(yy.factor);
    System.out.println(((AgeFactor) yy).toString());
    System.out.println(((AgeFactor) yy).factor);
    System.out.println(cc(yy));
  }

  static <AA extends AgeFactor> String cc(AA af)
  {
    return af.factor;
  }

  static class AgeFactor {
      String factor = "unknown";
      public String toString() {
          return " " + factor + " ";

      }
  }

  static class young extends AgeFactor {
      String factor = "Young";

      public String toString() {
          return " " + factor + " ";

      }
  }

  static class experienced extends AgeFactor {
      String factor = "Experienced";

      public String toString() {
          return " " + factor + " ";

      }
  }

  static class pro extends AgeFactor {
      String factor = "Pro";

      public String toString() {
          return " " + factor + " ";

      }
  }
}

班级年龄
{
公共静态void main（字符串参数[]）
{
杨yy=新杨（）；
System.out.println（yy.toString（））；
系统输出打印项次（yy系数）；
System.out.println（（（AgeFactor）yy.toString（））；
系统输出打印项数（（（年龄因子）yy.因子）；
系统输出println（cc（yy））；
}
静态字符串cc（AA-af）
{
返回af因子；
}
静态类年龄因子{
字符串因子=“未知”；
公共字符串toString（）{
返回“+因子+”；
}
}
静态类因子{
String factor=“Young”；
公共字符串toString（）{
返回“+因子+”；
}
}
静态类参数{
String factor=“experied”；
公共字符串toString（）{
返回“+因子+”；
}
}
静态类pro扩展了AgeFactor{
字符串因子=“Pro”；
公共字符串toString（）{
返回“+因子+”；
}
}
}

---

另外请注意，在Java中，泛型完全是编译时结构。通过一个称为擦除的过程，代码在编译时没有任何“通用”参考。

AgeFactor是一个类，而不是一个接口。因此，它（AgeFactor）有自己的实例变量。子类（如young）有自己的实例变量。子类的实例变量完全独立于任何子/超级实例变量。如上所述，只有非静态方法参与多态性（即子类可以覆盖超类的方法）。 一种方法是使用“getFactor”方法将AgeFactor设置为接口。每个子类都将实现一个getFactor（）方法，该方法返回所需的常量

注意，在java中，C++类与CaseCasts不改变对象引用值-所以方法引用被保存在转换中。请尝试以下操作：

class Ages
{
  public static void main(String args[])
  {
    young yy = new young();
    System.out.println(yy.toString());
    System.out.println(yy.factor);
    System.out.println(((AgeFactor) yy).toString());
    System.out.println(((AgeFactor) yy).factor);
    System.out.println(cc(yy));
  }

  static <AA extends AgeFactor> String cc(AA af)
  {
    return af.factor;
  }

  static class AgeFactor {
      String factor = "unknown";
      public String toString() {
          return " " + factor + " ";

      }
  }

  static class young extends AgeFactor {
      String factor = "Young";

      public String toString() {
          return " " + factor + " ";

      }
  }

  static class experienced extends AgeFactor {
      String factor = "Experienced";

      public String toString() {
          return " " + factor + " ";

      }
  }

  static class pro extends AgeFactor {
      String factor = "Pro";

      public String toString() {
          return " " + factor + " ";

      }
  }
}

班级年龄
{
公共静态void main（字符串参数[]）
{
杨yy=新杨（）；
System.out.println（yy.toString（））；
系统输出打印项次（yy系数）；
System.out.println（（（AgeFactor）yy.toString（））；
系统输出打印项数（（（年龄因子）yy.因子）；
系统输出println（cc（yy））；
}
静态字符串cc（AA-af）
{
返回af因子；
}
静态类年龄因子{
字符串因子=“未知”；
公共字符串toString（）{
返回“+因子+”；
}
}
静态类因子{
String factor=“Young”；
公共字符串toString（）{
返回“+因子+”；
}
}
静态类参数{
String factor=“experied”；
公共字符串toString（）{
返回“+因子+”；
}
}
静态类pro扩展了AgeFactor{
字符串因子=“Pro”；
公共字符串toString（）{
返回“+因子+”；
}
}
}

另外请注意，在Java中，泛型完全是编译时结构。通过一个称为擦除的过程，代码被编译