class Role {...};
class PersonalRole : public Role {...};
class GroupRole : public Role {...};

class Assignment
{
   User * m_pUser;
   Group * m_pGroup;
   Role * n_pRole;
};

class Approval
{
   Document * m_pDocument;
   Role * m_pRole;
   Group * m_pGroup;
};

class Node {
    private ParentNode parentField;
    public Operation() {
        parentField.AddChild(...);
    }
}

class ParentNode extends Node {
    private List<Node> children;
    ...
    public void AddChild(Node arg) {
        children.Add(arg);
    }
    ...
}

void Method()
{
    if (this is Obj1)
       ((Obj1).Method2();
    else
       ((Obj2).Method3();
}

GZ>void Method()
GZ>{
GZ>    if (this is Obj1)
GZ>       ((Obj1).Method2();
GZ>    else
GZ>       ((Obj2).Method3();
GZ>}
GZ>

class Obj
{
    virtual void Method()
    { 
    }
}

class Obj1 : Obj
{
    override void Method()
    { 
        // тело Method2
    }
}

class Obj2 : Obj
{
    override void Method()
    { 
        // тело Method3
    }
}

GZ>>void Method()
GZ>>{
GZ>>    if (this is Obj1)
GZ>>       ((Obj1).Method2();
GZ>>    else
GZ>>       ((Obj2).Method3();
GZ>>}
GZ>>

K>даа, плохо.. только опять недопёр, что значит неявное поведение?..

K>class Obj
K>{
K>    virtual void Method()
K>    { 
K>    }
K>}

K>class Obj1 : Obj
K>{
K>    override void Method()
K>    { 
K>        // тело Method2
K>    }
K>}

K>class Obj2 : Obj
K>{
K>    override void Method()
K>    { 
K>        // тело Method3
K>    }
K>}
K>

В случае наследования, наследуемый класс предоставляет некоторый интерфейс поведения который должен быть реализован/дополнен его наследниками.

GZ>>>void Method()
GZ>>>{
GZ>>>    if (this is Obj1)
GZ>>>       ((Obj1).Method2();
GZ>>>    else
GZ>>>       ((Obj2).Method3();
GZ>>>}
GZ>>>

if (this is Obj1)
    ((Obj1).Method2();
else if (this is Obj2)
    ((Obj2).Method3();

GZ>А если это последовательность вызовов методов как базового класса так и наследников?

class Obj
{
    virtual void Method()
    {
    ExtractedMethod1();
    ExtractedMethod2():
    }

    virtual void ExtractedMethod1()
    {
    ...
    }

    abstract void ExtractedMethod2()
    {
    ...
    }
}

class Obj1 : Obj
{
    override void Method()
    { 
        // тело Method2
    }

    override void ExtractedMethod1()
    {
    ...
    }

    void ExtractedMethod2()
    {
    ...
    }

}

class Obj2 : Obj
{
    override void Method()
    { 
        // тело Method3
    }

    void ExtractedMethod2()
    {
    ...
    }

}

GZ>Не понял вышесказанное.

K>>хитрый уход от ответа

Но я считаю Domain Model — моделью данных, а не логики — ведь все-же она состоит из POJO.
Так вот прав-ли я?

Действитель-но ли можно считать такой не объектно ориентированный дизайн — вполне приемлемым для модели данных?

Что можно почитать из теории по этому поводу?

Assignment theAssignment = new Assignment();
User theUser = new User(some_data);
//...
Role theRole = theAssignemt.GetRole(theUser);

User theUser = new User(some_data);
//...
Role theRole = theUser.GetRole(theUser);

Approval theApproval = new Approval();
//...
Approver theApprover = theApproval.GetNextApprover();
// где theApprover - это либо User, либо Role.