Java 什么时候需要一些<;E扩展了一些<;E>&燃气轮机;而不是一些<;E扩展了一些>;?
注意:这个问题与枚举无关,因此它不是重复的。由于编译器生成了类型参数,而不是java递归类型参数,因此枚举只能与自身进行比较 我试图找到将类声明为的优势:Java 什么时候需要一些<;E扩展了一些<;E>&燃气轮机;而不是一些<;E扩展了一些>;?,java,generics,recursion,enums,type-parameter,Java,Generics,Recursion,Enums,Type Parameter,注意:这个问题与枚举无关,因此它不是重复的。由于编译器生成了类型参数,而不是java递归类型参数,因此枚举只能与自身进行比较 我试图找到将类声明为的优势: public class Some<E extends Some<E>> 尽管存在通用递归,我仍然可以比较狗和猫: Dog dog = new Dog(); dog.compare(new Cat()); 转盐理论: 你们知道,任何扩展了动物的类都只能和它自己比较 这是错误的-我认为这类狗是用猫来扩展动物的,而不是
public class Some<E extends Some<E>>
尽管存在通用递归,我仍然可以比较狗和猫:
Dog dog = new Dog();
dog.compare(new Cat());
转盐理论:
你们知道,任何扩展了动物的类都只能和它自己比较
这是错误的-我认为这类狗是用猫来扩展动物的,而不是它自己。它看起来像目前
一些对一些
根据与Java拥护者和创建者共同编写的:
文章承认了一些可能性/假设:
- 因为Enum是一个泛型类,所以我们只能将它与类型一起使用
- Java可能变得更加严格,原始类型可能变得非法
我认为Enum就足够了。
然而,正如Philip Wadler向我指出的,因为Enum是一个泛型
类,我们只能将其与类型结合使用。在里面
将来,Java可能会变得更加严格,原始类型可能会变得更加复杂
非法的。因此,我们可以选择编写Enum
或者Enum区别在于Some
意味着两件事:
E
是原始类型。简言之,原始类型从类中剥离了所有泛型信息,这反过来会产生意外的行为
E
可以是某些的任何类别李>
相反,使用Some
意味着:
E
已键入
E
必须与声明它的类相同
原始部分是一个问题,但更大的含义是类型界限。这段代码演示了不同之处,“B”类使用(或试图使用)A类作为泛型类型
// The raw version
interface Some<E extends Some> {
E get();
}
class SomeA implements Some<SomeA> {
public SomeA get() {
return new SomeA();
}
}
// Compiles OK
class SomeB implements Some<SomeA> {
public SomeA get() {
return new SomeA();
}
}
// The typed version
interface SomeT<E extends SomeT<E>> {
E get();
}
class SomeTA implements Some<SomeTA> {
public SomeTA get() {
return new SomeTA();
}
}
// Compile error
class SomeTB implements SomeT<SomeA> {
public SomeA get() {
return new SomeTA();
}
}
//原始版本
接口一些{
E get();
}
类SomeA实现了一些{
公共服务{
返回新SomeA();
}
}
//编译OK
类SomeB实现了一些{
公共服务{
返回新SomeA();
}
}
//打字版
接口SomeT{
E get();
}
类SomeTA实现了一些{
公共部分{
返回新的SomeTA();
}
}
//编译错误
类SomeTB实现了SomeT{
公共SomeA get(){
返回新的SomeTA();
}
}
ClassSomeB
编译良好-E的类型仅绑定到Some
,因此任何Some
类都可以,但ClassSomeTB
会引发编译错误:
类型参数SomeTA不在类型变量E的范围内
E
的类型必须与包含的类完全相同
如果希望参数和返回类型与类本身相同,这一点很重要,这通常是类型化类所需要的
由原始类型绑定的类型不太重要,因为它仍然是一个Some
,但在某些情况下可能会产生不同(我现在想不出任何区别)。很少有情况需要像类Some
这样的绑定。大多数情况下,人们写这篇文章时,代码中并没有实际使用边界,而class-Some
也可以使用
然而,在某些特定情况下,实际使用的是类some
中的边界。例如:
abstract class Some<E extends Some<E>> {
abstract E foo();
Some<E> bar() {
return foo();
}
}
抽象类{
抽象E-foo();
一些酒吧(){
返回foo();
}
}
至于你的问题——有些课怎么样?首先,最明显的问题是您使用的是原始类型。新代码中不应使用原始类型。但你不相信
具有上述类(classsome
)的原始类型编译时会出现警告(您可以忽略该警告,否则后果自负)。但是,raw类型意味着可能会使用它执行不安全的操作
需要一些努力才能拿出一个例子来证明它是不安全的。这里有一个:
abstract class Some<E extends Some> {
abstract E foo();
Some<E> bar() {
return foo();
}
}
class SomeFoo extends Some<SomeFoo> {
SomeFoo foo() { return this; }
}
class SomeBar extends Some<SomeFoo> {
SomeFoo foo() { return new SomeFoo(); }
}
class SomeBaz extends Some<SomeBar> {
SomeBar foo() { return new SomeBar(); }
}
// then in some method:
Some<SomeBar> a = new SomeBaz();
Some<SomeBar> b = a.bar();
SomeBar c = b.foo();
抽象类{
抽象E-foo();
一些酒吧(){
返回foo();
}
}
类SomeFoo扩展了一些{
SomeFoo foo(){返回此;}
}
类SomeBar扩展了一些{
SomeFoo(){返回新的SomeFoo();}
}
类SomeBaz扩展了一些{
SomeBar foo(){返回新的SomeBar();}
}
//然后用某种方法:
Some a=新SomeBaz();
一些b=a.bar();
SomeBar c=b.foo();
代码编译时带有警告但没有错误,并在运行时抛出一个ClassCastException
。关于该语句
每次我尝试删除其他错误时,都不会出现新的错误/警告
事实不应如此。它应该打印一条警告,因为您使用的是原始类型Some
,其结果是缺少类型安全性,如中所示
狗
/猫
的例子有点做作,有些缺陷。您建议声明一个类
public class Dog extends Animal<Cat> { } // Note "Cat" !!!
但从我个人的经验来看,我可以说,当你认为你需要创造这样一种类型时,你应该彻底考虑它的优点和缺点。后者主要指可读性降低。当您可以选择以下方法时:
Node<? extends Node<? extends N, ? extends T>, T> doSomething(
Node<? super Node<? extends N>, ? extends T> p,
Node<? extends Node<? super N>, ? super T> c) { ... }
Node doSomething(Node parent, Node child) { ... }
这不是类型安全的(因为原始类型,或者仅仅因为类型没有被泛化),那么我更喜欢后者。代码由人类读取 这是一样的,因为泛型是如何工作的(有些==编译后的一些)。搜索原始类型和有关泛型的信息。相关:@Pshemo:这实际上是该问题的重复;唉,这个问题没有好的答案:(从OO progra的角度来看)
public class RecurringTest {
public static void main(String[] args) {
SpecialNode sa = new SpecialNode(null);
SpecialNode sb = new SpecialNode(sa);
SpecialNode s = sa.getChildren().get(0);
}
}
abstract class Node<N extends Node<N>> {
private final List<N> children = new ArrayList<N>();
private final N parent;
protected Node(N parent) {
this.parent = parent;
if (parent != null) {
this.parent.getChildren().add(getThis());
}
}
abstract N getThis();
public N getParent() {
return parent;
}
public List<N> getChildren() {
return children;
}
}
class SpecialNode extends Node<SpecialNode> {
public SpecialNode(SpecialNode parent) {
super(parent);
}
SpecialNode getThis() {
return this;
}
}
Node<? extends Node<? extends N, ? extends T>, T> doSomething(
Node<? super Node<? extends N>, ? extends T> p,
Node<? extends Node<? super N>, ? super T> c) { ... }
Node doSomething(Node parent, Node child) { ... }