UML Analogy of the Holy Trinity

/** Utility entry-point class for the Trinity model demo. */
public class TrinityModelApp {
    /** Utility class; not intended for instantiation. */
    private TrinityModelApp() {
    }

    /**
     * Retrieves the singleton DivineNature and the three singleton DivinePerson instances.
     * @param args unused command-line arguments
     */
    public static void main(String[] args) {
        DivineNature oneDivineNature = DivineNature.getInstance();
        Father father = Father.getInstance();
        Son son = Son.getInstance();
        HolySpirit holySpirit = HolySpirit.getInstance();

        System.out.println("UML Analogy of the Holy Trinity");
        System.out.println("--------------------------------");
        System.out.println();
        System.out.println("One divine nature, not three gods:");
        System.out.println("- Father possesses the same DivineNature instance as Son: "
                + (father.possessesFully() == son.possessesFully()));
        System.out.println("- Son possesses the same DivineNature instance as Holy Spirit: "
                + (son.possessesFully() == holySpirit.possessesFully()));
        System.out.println();

        printPersonSummary(father);
        printPersonSummary(son);
        printPersonSummary(holySpirit);
        System.out.println();
        System.out.println("Eternal relations:");
        System.out.println("- " + father.eternallyBegets(son));
        System.out.println("- " + father.eternallySpirates(holySpirit));
        System.out.println("- " + son.eternallySpirates(holySpirit));
        System.out.println();
        System.out.println("Aitia closure (relations of origin):");
        printAitiaClosure(father);
        printAitiaClosure(son);
        printAitiaClosure(holySpirit);
        System.out.println();
        System.out.println("Missions in time:");
        System.out.println("- " + father.sendsInTime(holySpirit));
        System.out.println("- " + son.sendsInTime(holySpirit));
    }

      /**
       * Prints a concise summary of personhood and full divinity claims for one Person.
       * @param person the divine Person whose summary should be printed
       */
    private static void printPersonSummary(DivinePerson person) {
        System.out.println(person.getName() + ":");
        System.out.println("  fullyGod = " + person.isFullyGod());
        System.out.println("  distinctPerson = " + person.isDistinctPerson());
    }

      /**
       * Prints each Person's relation of origin to make personal distinctions explicit.
       * @param person the divine Person whose relation-of-origin descriptor is printed
       */
    private static void printAitiaClosure(DivinePerson person) {
        System.out.println("- " + person.getName() + ": " + person.relationOfOriginDescription());
    }
}

/** Models predicates of the one divine essence. */
      public final class DivineNature {
    private static final DivineNature INSTANCE = new DivineNature();

    private DivineNature() {
    }

    public static DivineNature getInstance() {
        return INSTANCE;
    }

    private final boolean eternal = true;
    private final boolean omnipotent = true;
    private final boolean omniscient = true;
    private final boolean simple = true;

        /** @return true in this model, expressing eternality */
    public boolean isEternal() {
        return eternal;
    }

        /** @return true in this model, expressing omnipotence */
    public boolean isOmnipotent() {
        return omnipotent;
    }

        /** @return true in this model, expressing omniscience */
    public boolean isOmniscient() {
        return omniscient;
    }

        /** @return true in this model, expressing divine simplicity */
    public boolean isSimple() {
        return simple;
    }
}

/** Abstract base class for Trinitarian personhood in the model. */
      import java.util.Objects;

      public abstract class DivinePerson {
    private final DivineNature divineNature;
    private final boolean fullyGod = true;
    private final boolean distinctPerson = true;
    private final String name;

        /**
         * @param name person designation (Father, Son, Holy Spirit)
         * @param divineNature the one divine nature fully possessed by this Person
         */
    protected DivinePerson(String name, DivineNature divineNature) {
      this.name = Objects.requireNonNull(name, "name must not be null");
      this.divineNature = Objects.requireNonNull(divineNature, "divineNature must not be null");
    }

        /** @return the one divine nature possessed fully by this Person */
    public DivineNature possessesFully() {
        return divineNature;
    }

        /** @return true, expressing full divinity for each Person */
    public boolean isFullyGod() {
        return fullyGod;
    }

        /** @return true, expressing real personal distinction in the model */
    public boolean isDistinctPerson() {
        return distinctPerson;
    }

        /** @return the person name used in textual output */
    public String getName() {
        return name;
    }

        /** @return this Person's relation-of-origin descriptor */
    public abstract String relationOfOriginDescription();
}

/** First Person of the Trinity in classical naming. */
      public final class Father extends DivinePerson {
    private static final Father INSTANCE = new Father(DivineNature.getInstance());

    private Father(DivineNature divineNature) {
        super("Father", divineNature);
    }

    public static Father getInstance() {
        return INSTANCE;
    }

        /** @return sentence describing eternal generation of the Son */
    public String eternallyBegets(Son son) {
        return getName() + " eternally begets " + son.getName() + ".";
    }

        /** @return sentence describing eternal spiration of the Holy Spirit */
    public String eternallySpirates(HolySpirit holySpirit) {
        return getName() + " eternally spirates " + holySpirit.getName() + ".";
    }

        /** @return sentence describing temporal mission of the Holy Spirit */
    public String sendsInTime(HolySpirit holySpirit) {
        return getName() + " sends " + holySpirit.getName() + " in time.";
    }

        /** @return relation-of-origin phrase for the Father */
    @Override
    public String relationOfOriginDescription() {
        return "unbegotten; principle without principle.";
    }
}

/** Second Person of the Trinity in classical naming. */
      public final class Son extends DivinePerson {
    private static final Son INSTANCE = new Son(DivineNature.getInstance());

    private Son(DivineNature divineNature) {
        super("Son", divineNature);
    }

    public static Son getInstance() {
        return INSTANCE;
    }

        /** @return sentence describing eternal spiration of the Holy Spirit */
    public String eternallySpirates(HolySpirit holySpirit) {
        return getName() + " eternally spirates " + holySpirit.getName() + ".";
    }

        /** @return sentence describing temporal mission of the Holy Spirit */
    public String sendsInTime(HolySpirit holySpirit) {
        return getName() + " sends " + holySpirit.getName() + " in time.";
    }

        /** @return relation-of-origin phrase for the Son */
    @Override
    public String relationOfOriginDescription() {
        return "eternally begotten of the Father.";
    }
}

/** Third Person of the Trinity in classical naming. */
      public final class HolySpirit extends DivinePerson {
    private static final HolySpirit INSTANCE = new HolySpirit(DivineNature.getInstance());

    private HolySpirit(DivineNature divineNature) {
        super("Holy Spirit", divineNature);
    }

    public static HolySpirit getInstance() {
        return INSTANCE;
    }

        /** @return relation-of-origin phrase for the Holy Spirit */
    @Override
    public String relationOfOriginDescription() {
        return "eternally proceeds from the Father and the Son as from one principle.";
    }
}