可能重复:
java Enum定义
更好的公式化问题,不被认为是重复的:
如果Enum声明没有递归部分,那么在Java中会有什么不同
如果语言设计师只使用Enum <E extends Enum>会对语言产生什么影响呢？
现在唯一的区别就是有人会写作
A extends Enum<B>
但是因为在java中不允许扩展枚举仍然是非法的.我也在想有人为jvm提供一个字节码,将字符串定义为扩展枚举 - 但是泛型不会影响它,因为它们都被删除了.
那么宣言的重点是什么呢？
谢谢!
编辑 为简单起见,让我们来看一个例子:
interface MyComparable<T> {
int myCompare(T o);
}
class MyEnum<E extends MyEnum> implements MyComparable<E> {
public int myCompare(E o) { return -1; }
}
class FirstEnum extends MyEnum<FirstEnum> {}
class SecondEnum extends MyEnum<SecondEnum> {}
这个类结构有什么问题？可以做些什么"MyEnum <E扩展MyEnum <E >>"会限制？
免责声明:我对Java Generics没有丰富的经验,但是我和我的同事们花了一个小时试图破解一个结构如下的界面:
interface HasAttributes<A extends HasAttributes<A, B>,
B extends HasAttributesType<B>> extends Identification<B> {
当接口泛型采用本身的类型参数时,它到底意味着什么？这是做什么的？
请参阅 Java Enum定义 和 为什么在java enum中声明为Enum <E extends Enum <E >> 进行一般性讨论.如果Enum类被定义为,我想知道究竟会破坏什么(不再是类型安全,或者需要额外的强制转换等)
public class Enum<E extends Enum>
我正在使用此代码来测试我的想法:
interface MyComparable<T> {
int myCompare(T o);
}
class MyEnum<E extends MyEnum> implements MyComparable<E> {
public int myCompare(E o) { return -1; }
}
class FirstEnum extends MyEnum<FirstEnum> {}
class SecondEnum extends MyEnum<SecondEnum> {}
有了它,我无法在这个确切的情况下找到任何好处.
PS.我不被允许做的事实
class ThirdEnum extends MyEnum<SecondEnum> {}
当使用递归定义MyEnum时
a)不相关,因为使用真实的枚举你不能仅仅因为你不能自己扩展枚举
b)不是真的 - 请在编译器中尝试它并看到它实际上是能够编译没有任何错误
PPS.我越来越倾向于相信这里的正确答案是"如果你移除递归部分,没有什么会改变" - 但我简直无法相信.
我在一个不相关的问题上看到了一些代码,但它让我很好奇,因为我从来没有看到过使用Java Generics这样的构造.创建一个可以作为类型参数本身或其自身后代的泛型类会有什么用处.这是一个例子:
abstract class A<E extends A<E>> {
abstract void foo(E x);
}
我想到的第一件事就是将列表作为参数的列表.使用这段代码感觉很奇怪,你如何声明A类型的变量？递归声明!？
这甚至有用吗？如果是这样,你们中的任何人在代码中看到了吗？怎么用？
编辑
事实上,事实证明我的问题与这个只有不同的措辞相同,但这个问题的答案也将回答我的问题.
同样感谢参考奇怪的重复模板模式,该模式给出了一些历史背景和关于该主题的进一步解释.
这篇旧博客文章可能会给我们Java家伙提供最好的解释.
现在很难在这里选择一个正确的答案,因为它们都很有用,所以我会选择最终产生最多阅读材料的那个(上面引用)
这些通用之间是否存在任何实际差异
public class SelfBounded <T extends SelfBounded<T>>{}
还有这个
public class SelfBounded <T extends SelfBounded>{}
？
如果是,那我该如何观察呢？
我遇到了以下使用泛型和继承的Java代码.我真的不明白以下代码片段的作用:
class A<B extends A<B>> {
...
}
这段代码有什么作用？
(我从MapDB中的DBMaker那里得到了这个)
我想了解以下类型的语法.
例:
public interface A < T extends A < T> > {
}
这个界面的逻辑是什么？
我找到了泛型params扩展自己的泛型(这里).我不太了解.我怀疑一开始是错的,但没有人提出来.我对此有一些疑问:
这是从(这里)挑选的泛型样式代码.
abstract class Base<T extends Base<T>> {
}
class Variant<T extends Variant<T>> extends Base<T> {
}
谢谢!
要求
我正在尝试写一对Observer/ Observable类.我想参数化,Observer以便可以进行类型安全更新调用.想象一下这个版本:
class View implements Observer<Model> {
@Override
public void update(Model model) { render(model); } // no casting:)
}
而不是需要强制转换的版本:
class View implements Observer {
@Override
public void update(Object model) { render((Model) model); } // casting:(
}
尝试
这是我到目前为止所拥有的.我的Observer界面:
public interface Observer<T extends Observable> {
public void update(T observable);
}
和我的Observable抽象类:
import java.util.List;
public abstract class Observable {
private List<Observer<? extends Observable>> observers;
public Observable() {
System.out.println(this.getClass());
}
public void …编辑：“ 我从‘埃里克森’那里收到了一个非常相关的答案，但是有一个附带问题（向上转换？），这个问题没有在我的原始示例中明确涵盖，并且没有用他的答案解决。我已将示例扩展为涵盖了另一个问题，我已将其包含在本文末尾。感谢您的帮助。
我目前面临一个 Java 泛型问题，该问题与所谓的“奇怪的重复泛型模式”有关。我想在阅读 Jon Skeet 对这个问题“java enum定义”的答案后我已经找到了解决方案。尽管如此，当我尝试将其应用到我的代码中时，我发现自己遇到了不同的问题。
我想出了一个“小”例子，其中出现了我面临的问题。我希望它足够清楚地说明我的问题。
示例描述：我想构建一个节点类型可以变化的图表。我定义了一个抽象类Node，它定义了一些基本方法，以及一个实现这些方法的具体类，即ConcreteNode。我还创建了一个名为City的 ConcreteNode 专业化。
在给定的图中，一个重要的要求是所有元素应由其相同类型或子类型组成，即ConcreteNode 图中只能有ConcreteNodes或Cities。
这些是我的类的定义：
abstract class Node<T extends Node<T>>
class ConcreteNode<T extends ConcreteNode<T>> extends Node<T>
class City extends ConcreteNode<City>
这些定义使用了在 Enum 类的定义中也可以找到的“重复通用模式”：
Class Enum<E extends Enum<E>>
问题：我在使用这些类时遇到问题。如果我必须停留在层次结构中的城市级别，即连接城市到城市，我不会有问题，但在尝试访问其他类时我遇到了巨大的问题。
在下面的代码中，我的问题可以从 GraphUtil 的方法签名中看出：
综上，我的问题是如何向上转换这些自身参数化的泛型类型？。
我将非常高兴获得关于 …
我正在阅读《Effective Java Edition 3》。在第 2 章第 14 页中，作者讨论了构建器模式并呈现了以下代码：
public abstract class Pizza {
public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
final Set<Topping> toppings;
abstract static class Builder<T extends Builder<T>> {
EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
public T addTopping(Topping topping) {
toppings.add(Objects.requireNonNull(topping));
return self();
}
abstract Pizza build();
// Subclasses must override this method to return "this"
protected abstract T self();
}
Pizza(Builder<?> builder) {
toppings = builder.toppings.clone(); // See Item 50
}
}
上述抽象类的实现：
public class …我正在尝试通过继承支持构建器模式，以允许父级和子级的设置链没有问题。为此，我需要父类知道返回子类型，以使所有方法公开以进行链接。
这是我在本文之后编写的代码示例，我认为它应该可以工作。但是，正如您将看到的，使用a1的第一个示例可以正常工作，但是如果我更改设置器的顺序，则无法识别最后一个设置器。
问题是：一旦我从父类中调用了一个方法，它将以类型而不是子类型返回自身，即使认为T被定义为子类型。
public class JavaApplication1 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
A a1 = new B<>().setAge(0).setId(0).setName("name"); //Works fine
A a2 = new B<>().setAge(0).setName("name").setId(0); //setId is not found
}
static class A<T extends A> {
private String mpName;
T setName(String name) {
mpName = name;
return (T) this;
}
}
static class B<T extends B> extends A<T> {
private int mpAge;
private …