继承和转换：这是好的java吗？

看看这段代码（从）

对于父类和关联类，有两个并行继承树。问题在于第23行：

（（assocaccrete）myA.sallet（）

这是一种痛苦，我的代码中到处都是这种东西。尽管这一行是实体的具体实现的一部分，但我需要提醒它，我想使用AssocA的具体实现，Assocacute

是否有某种注释来声明这种关系？还是有更好、更通俗的Java方式来表达这种设计？谢谢


这是对@Dave的回应，因为我想在

有趣！因此，调用将如下所示：

AssocAConcrete myAssoc = new Assoca();
EnitityA<T extends AssocA> myEntity = new EntityA<AssocAConcrete>();
myEntity.setAssoc(myAssoc);
myAssoc.salute();

assocaccrete myAssoc=new Assoca（）；
EnitityA myEntity=新实体a（）；
myEntity.setAssoc（myAssoc）；
myAssoc.sallet（）；

是吗？那真的很酷。我想我会用它的
 在我看来很可疑。施法没有什么可怕的，但是在这种情况下，您可以通过将
sallet
方法引入
AssocA
来解决问题。
AssocA
的子类可以提供它们的实现；这是继承的一部分好处

您现在所做的是说所有
EntityA
实例都有一个
AssocA
实例，但是在
meet
方法中，您基本上强制
AssocA
实例成为一个
assocaccrete
实例。这是可疑的部分；如果您确实需要一个
assocaccrete
，为什么存在
AssocA

另一个选项（基于您的评论）是在
greet
方法中调用
sallet
。这样，特定的子类指定了超类中定义的行为
greet
，并执行它想要的操作。在这种情况下，
sallet
可能成为私有的或受保护的。另一个实现可以很容易地做一些不同的事情，比如
runLikeHell
 并行类层次结构的问题非常现实，而且非常糟糕。
assocaccrete
始终与
entityaccrete
配合的逻辑耦合不能用类型系统表示

如果不对超类隐藏，则无法将
entityacontrace
中的
myA
类型专门化为
assocacontrace
。我认为解决这个问题的最接近的工作是“”，但这不是主流
 如果有很大一部分代码使用引用“myA”，则可以声明另一个类似这样的引用：

public AssocAConcrete myAConcrete = (AssocAConcrete)myA;

现在，您可以使用新的参考
myacocrete
并访问
assocacrete
类的函数

如果你需要像HVGOTC这样做很多，你应该考虑把方法移到<代码> AsCOCA类。
 < P>我认为这是很多用泛型……
abstract class EntityA<T extends AssocA> {

    // Basically, this means myA is at least an AssocA but possibly more...
    T myA;
    abstract void meet();
}

abstract class AssocA {
    int something;
    abstract void greet();
}

class AssocAConcrete extends AssocA {
    void greet() {
        System.out.println("hello");
    }
    void salute() {
        System.out.println("I am saluting.");
    }
}

class EntityAConcrete extends EntityA<AssocAConcrete> {
    void meet() {
        System.out.println("I am about to meet someone");
        myA.salute();
    }
}

然后

// Again, won't work.  T is only declaring the type inside your class/method.
// When using it to declare a variable, you have to say EXACTLY what you're making,
// or at least something as exact as the methods you're trying to invoke
EnitityA<T extends AssocA> myEntity = new EntityA<AssocAConcrete>();

//Instead do this...
EnitityA<AssocAConcrete> myEntity = new EntityAConcrete();

// Or this...
EntityAConcrete myEntity = new EntityAConcrete();

如果您编写
assocamya而不是
AssocA myA（第2行），它会解决这个问题。但是这会破坏代码的其余部分吗？是的，整个想法是可能会有不同的Assocacute变体，EntityA的客户不希望依赖于此。请注意，仅使用AssocA和EntityA的代码从不知道或提及一个或另一个具体类。只有两个具体的“A”类知道实现细节。类族之间的这种逻辑耦合非常常见。唉，类型系统不支持表达它。@nwgotcodes-实际上不是一回事。我想隐藏两个具体的“A”类的实现知识，这样它们彼此都知道对方，但只有具体的才知道如何打招呼。AssocXConcrete可能不知道怎么做。然后在你的greet方法中调用
sallet
。我希望我能给你+2。这正是泛型的用途；我不明白为什么有些人会回避他们。哦，我是会责怪你用铸造来解决一个问题的人之一，这个问题用泛型来解决会更好。啊，很有趣。我会像这样实例化它们？实例化的方式会有所不同。您当前用于实例化的代码在哪里？你能更新你的问题来举个例子吗。我想给你们看代码，但我不能自我回答，我不能把代码放在评论中。。。这是一个尝试…也许我会更新这个问题。。。有趣！所以调用看起来像这样：assocaccrete myAssoc=newassoca（）；EnitityA myEntity=新实体a（）；myEntity.setAssoc（myAssoc）；myAssoc.sallet（）；对那真的很酷。我想我会用它的！我喜欢这个答案，但问题是他可能有另一个子类，而这个子类在基类上没有指定另一个方法……那么呢？关键是无论你是否使用泛型，都需要有一个遵守的契约。。。。
//Won't work...can't call 'new' on abstract class AssocA
AssocAConcrete myAssoc = new Assoca();

//Instead, do this...
AssocAConcrete myAssoc = new AssocAConcrete();

// Again, won't work.  T is only declaring the type inside your class/method.
// When using it to declare a variable, you have to say EXACTLY what you're making,
// or at least something as exact as the methods you're trying to invoke
EnitityA<T extends AssocA> myEntity = new EntityA<AssocAConcrete>();

//Instead do this...
EnitityA<AssocAConcrete> myEntity = new EntityAConcrete();

// Or this...
EntityAConcrete myEntity = new EntityAConcrete();

// Assuming this is defined as `public void setAssoc(T newAssoc) {this.myA = newAssoc;}`
myEntity.setAssoc(myAssoc);
myAssoc.salute();