Java扩展通用类型参数

Brandon 发表于 Dev

布兰登

我来自C ++，正在尝试继承Java中的通用参数类型。基本上，我试图模仿以下C ++模式：

在C ++中，我可以执行以下操作：

#include <iostream>

class Node
{
        Node* next;
};


class BaseVisitor
{
    public:
        BaseVisitor(Node* ptr)
        {
            std::cout<<ptr<<"\n\n";
            delete ptr;
        }
        ~BaseVisitor() {};

    protected:
        virtual Node* Generate() = 0;
};


class DynamicVisitor : public BaseVisitor
{
    public:
        DynamicVisitor(Node* ptr) : BaseVisitor(ptr) {}

    protected:
        virtual Node* Generate()
        {
            std::cout<<"Dynamic Visitor\n";
            return new Node();
        }
};

class StaticVisitor : public BaseVisitor
{
    public:
        StaticVisitor(Node* ptr) : BaseVisitor(ptr) {}

    protected:
        virtual Node* Generate()
        {
            std::cout<<"Static Visitor\n";
            return NULL;
        }
};



template<typename T>
class TestVisitor : public T  //THIS is where the magic happens..
{
    public:
        TestVisitor() : T(this->Generate()) {} //allows me to call "Generate".
};

int main()
{
    TestVisitor<DynamicVisitor> foo = TestVisitor<DynamicVisitor>();
    TestVisitor<StaticVisitor> bar = TestVisitor<StaticVisitor>();
}

输出：

Dynamic Visitor
0x605ed0

Static Visitor
NULL

如何在Java中做同样的事情？我试过了：

public class Node {
    Node next;
}

public abstract class BaseVisitor {
    public BaseVisitor(Node n) {System.out.println(n);}

    protected abstract Node generate();
}

public class DynamicVisitor extends BaseVisitor {
    public DynamicVisitor(Node n) {
        super(n);
    }

    @Override
    protected Node generate() {
        return new Node();
    }
}

public class StaticVisitor extends BaseVisitor {

    public StaticVisitor(Node n) {
        super(n);
    }

    @Override
    protected Node generate() {
        return null;
    }
}

public class TestVisitor<T extends BaseVisitor> extends T { //error.. Cannot extend "T".. No magic happens..
    public TestVisitor() {
        super(this.generate()); //cannot call generate()..
    }
}

这个模式叫什么？我称它为“基础工厂”模式，但我不确定它的真实名称，所以我不确定要搜索什么。
在Java中，我该如何做与C ++中相同的事情？是否有“任何方式”在Java中执行相同的模式？

迪玛

不，不能在Java中执行此操作，对不起。最接近的可能是“代理模式”：

public interface NodeGenerator {  Node generate(); }
public class StaticGenerator implements NodeGenerator { 
    public Node generate() { return null; }
}
public class DynamicGenerator implements NodeGenerator {
    public Node generate() { return new Node(); }
}

public class TestVisitor extends BaseVisitor {
     public TestVisitor(NodeGenerator g) { super(g.generate()); }
}

在Java 8中，无需额外的接口和类，您可以使其看起来更好（但可能效率较低）：

public class TestVisitor extends BaseVisitor {
    public TestVisitor(Supplier<Node> g) { super(g.get()); }
}

// ... and then you can do things like

TestVisitor staticVisitor = new TestVisitor(() -> null);
TestVisitor dynamicVisitor = new TestVisitor(() -> new Node());

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。