相关疑难解决方法(0)

交集类型允许您(有点排序)执行具有继承层次结构的枚举.您不能继承实现,但可以将其委托给辅助类.

enum Foo1 implements Bar {}
enum Foo2 implements Bar {}

class HelperClass {
   static <T extends Enum<T> & Bar> void fooBar(T the enum) {}
}

当您有许多实现某种模式的不同枚举时,这很有用.例如,许多具有父子关系的枚举对.

enum PrimaryColor {Red, Green, Blue;}
enum PastelColor {Pink, HotPink, Rockmelon, SkyBlue, BabyBlue;}

enum TransportMedium {Land, Sea, Air;}
enum Vehicle {Car, Truck, BigBoat, LittleBoat, JetFighter, HotAirBaloon;}

您可以编写通用方法,说"好的,给定一个枚举值,该值是某些其他枚举值的父级,子类型的所有可能子枚举中有多少百分比将此特定父值作为其父级？",并且全部使用类型安全,没有铸造完成.(例如:"Sea"占所有可能车辆的33%,"Green"占所有可能车辆的20%).

代码看起来像这样.特别注意"leaf"类本身非常简洁 - 但是泛型类的声明非常难看.没关系:你只写一次.一旦通用类存在,那么使用它们很容易.

下面的助手类只有一些静态方法.其他方式包括

• 提供一个返回单例的实例,但是根据父/子进行输入
• 为每个paren/child返回一个实例,适当地键入,并在每个父enum中包含一个实例

使用第二个选项,"children"对象实际上将在帮助器内,因此减少了枚举中所需的代码量.他们都会实例化一个帮助者,并将任何困难的事情委托给他们.

import java.util.EnumSet;

import javax.swing.JComponent;

public class zz extends JComponent {

    public static void main(String[] args) {
        System.out.println(PrimaryColor.Green + " " …

我试图在java中创建两个相互包含的类之间的泛型关系.这些对象基本上形成一个alernating层树.到目前为止,我发现最接近的SO问题是:泛型的Java泛型,它对我的​​问题很接近并且有些帮助,但仍然不同,我想要额外的指导.这是情况,或者更确切地说,我希望它是什么:

abstract class Group<I extends Item<Group<I>>>{
     private List<I> items;
     public List<I> getItems(){...}
     public void setItems(List<I> items){...}
}

abstract class Item<G extends Group<Item<G>>>{
     private List<G> subGroups;
     public List<G> getSubGroups(){...}
     public void setSubGroups(List<G> subGroups){...}
}

除了吸气剂和制定者之外,该类的某些方面使它们彼此明显不同,但包含应该遵循这样的方式.这背后的原因是我想强制执行,如果我有实现类,他们必须表现如下:

class AGroup extends Group<AItem>{...} //works
class AItem extends Item<AGroup>{...} //works
class BGroup extends Group<BItem>{...} //works
class BItem extends Item<BGroup>{...} //works
class MixedGroup extends Group<AItem>{...} //fails since AItem does
                                           //not extend Item<MixedGroup>

到目前为止,编译器很好用

abstract class Group<I extends Item<Group<I>>>{
     private List<I> items;
     public List<I> getItems(){...}
     public …

我有一个解析数据流的类.每个数据块称为a Box.Boxes 有很多种.我希望Parser每种类型的盒子都有不同的颜色.所以基本上我需要一个Registry或类似的东西,让我为每个提取正确的解析器Box.这是我的问题的简化版本:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class GenericsTest {
    class Box {
        private String data;

        public String getData() {
            return data;
        }
    }

    class BoxA extends Box {
        private String adata;

        BoxA( String adata ) {
            this.adata = adata;
        }

        public String getAData() {
            return adata;
        }
    }

    class BoxB extends Box {
        private String bdata;

        BoxB( String bdata ) {
            this.bdata = bdata;
        } …

我正在尝试定义泛型枚举,但有问题:

private enum Stick<T>{
    A, B, C;

    private Stack<T> disks = new Stack();

    public void print(){
        System.out.println(this.name() + ": " + disks);
    }

    public T pop(){
        return disks.pop();
    }

    public void push(T element){
        disks.push(element);
    }

};

有可能吗？