java中的泛型和继承

我在使用（我认为是）泛型时遇到了一个小问题。我有以下代码：

public class A{
  private String name;

  public String getName(){
    return this.name;
 }
}


public class B extends A{
  private String street;

  public String getStreet(){
    return this.street;
 }
}

public class C extends A{
  private int number;

  public int getNumber(){
    return this.number;
 }
}

我想创建如下所示的新类：

public class AChange{
  private A instance;

  public String doSomething(){
    return A.getName();
 }
}

public class BChange extends AChange{

  public String street(){
    return A.getStreet();
 }
}

public class CChange extends AChange{

  public int number(){
    return A.getNumber();
 }
}

---

当然，类没有这些方法，但是子类有。如何编写此代码，使其按我希望的方式工作？

向

a更改添加一个泛型类型参数，以用作字段
实例的类型：

class AChange<T extends A> {
    protected T instance;

    public String doSomething() {
        return instance.getName();
    }
}

将泛型类型参数添加到
AChange
以用作字段
实例的类型
：

class AChange<T extends A> {
    protected T instance;

    public String doSomething() {
        return instance.getName();
    }
}

如果没有这样的泛型，您也可以这样做

static class AChange {
    private A instance;
    public AChange(A instance) {
        this.instance = instance;
    }
    public String doSomething() {
        return instance.getName();
    }
}

static class BChange extends AChange {
    private B instance;
    public BChange(B instance) {
        super(instance);
        this.instance = instance;
    }
    public String street() {
        return instance.getStreet();
    }
}

static class CChange extends AChange {
    private C instance;
    public CChange(C instance) {
        super(instance);
        this.instance = instance;
    }
    public int number() {
        return instance.getNumber();
    }
}

不要使用泛型实例
T
，而是存储正确类型的引用
如果没有这样的泛型，也可以这样做

static class AChange {
    private A instance;
    public AChange(A instance) {
        this.instance = instance;
    }
    public String doSomething() {
        return instance.getName();
    }
}

static class BChange extends AChange {
    private B instance;
    public BChange(B instance) {
        super(instance);
        this.instance = instance;
    }
    public String street() {
        return instance.getStreet();
    }
}

static class CChange extends AChange {
    private C instance;
    public CChange(C instance) {
        super(instance);
        this.instance = instance;
    }
    public int number() {
        return instance.getNumber();
    }
}

不使用泛型实例
T
，而是存储正确类型的引用
可能会使用类似
的东西，并且泛型隐藏在哪里？为什么BChange不扩展B而CChange扩展C？泛型的使用非常有限。正如tafa所说，
BChange扩展了B
或是围绕
B
的普通包装器更简单，并且没有泛型带来的所有问题，比如爆炸式的复杂性、原始类型、擦除……考虑到这段代码，它可能更简单，但在我的情况下，它更复杂，所以我决定让代码更易于维护，但也许我错了，可能是使用了类似
的东西，你把泛型藏在哪里了？为什么BChange不扩展B而CChange扩展C？泛型的使用非常有限。正如tafa所说，
BChange扩展了B
或是围绕
B
的普通包装器更简单，并且没有泛型带来的所有问题，比如爆炸式的复杂性、原始类型、擦除……考虑到这段代码，它可能更简单，但在我的情况下，它更复杂，所以我决定让代码更易于维护，但也许我错了