Subsumieren und Programmieren - die neue Doppelnatur der prozessualen Hilfsaufrechnung

JurPC Web-Dok. 141/2020, Abs. 1 - 179

---

Viele Computerprogramme dürften aus einer Überlegung entstanden sein (oder zwei): „diese immer gleiche Abfolge von Denkschritten oder Handlungen schreite ich immer wieder ab - kann das nicht der Computer für mich tun?“, und: „Die Hälfte der Zeit rechne ich mit ‚krummen‘ Zahlen - kann der Computer das nicht ohnehin besser?“

Vielleicht kommt Ihnen ja jetzt oder während Sie weiter lesen genau diese eine juristische Tätigkeit in den Kopf, die die immer gleiche Rechnerei bedeutet? Behalten Sie sie im Kopf, vielleicht kommt Ihnen eine Idee zur Umsetzung dabei.

Die wichtigen juristischen Entscheidungen fußen auf menschlichen Wertungen aufgrund einer soliden juristischen Ausbildung, Erfahrung und nicht zuletzt komplexen kommunikativen Prozessen. Das kann einem Richter (derzeit) kein Computer abnehmen. Aber ein grundlegendes Werkzeug, das Herz des juristischen Denkens, das Subsumieren, hat mit dem Programmieren mehr als die letzen beiden Silben gemeinsam. Das möchte ich beispielhaft an zwei Themenfeldern verdeutlichen, die jedem Juristen im ersten halben Jahr seiner praktischen Ausbildung begegnet sein dürften: der Hilfsaufrechnung und der Entscheidung über die vorläufige Vollstreckbarkeit.

Zu diesem Zweck möchte ich Ihnen zunächst die typische juristische Denkabfolge beim Subsumieren unter Vorschriften zeigen (I.). Sodann möchte ich im Vergleich dazu vorführen, wie der Programmierer anhand von Algorithmen und Programmabläufen denkt, die der Computer Punkt für Punkt durchgeht (II.). Bevor ich darstellen kann, wie der Computer diese Prüfung bewältigen könnte, führe ich zunächst die juristischen Prüfungsschritte der prozessualen Hilfsaufrechnung und der Entscheidung über die vorläufige Vollstreckbarkeit eines Zivilurteils vor (III.). Es folgt der Blick in den Werkzeugkasten der Programmiersprache Java, welche Programmiertechniken bei diesen juristischen Themen helfen könnten (IV.). Die gesamte Darstellung steuert auf den Höhepunkt der Umsetzung in einem Java-Programm (V.) zu.

Der Beitrag soll keine Einführung in die Informatik oder zum Programmieren in Java (oder anderen Sprachen) sein. Vielmehr möchte ich anhand eines juristischen Themas Appetit auf das Programmieren machen. Dazu gebe ich nur einen kleinen Einblick in eine Materie, die Sie dann anhand einer der zahlreichen Einführungen in die Programmiersprache Java vertiefen können.

I. Juristisches Denken

Der Jurist denkt grundsätzlich anhand von Vorschriften. Hier möchte ich zeigen, was Subsumtion ist und wie Schemata dabei helfen können.

Wann ist eine Vorschrift, ein Rechtssatz aber anwendbar? Man wendet einen Rechtssatz an und spricht dessen Rechtsfolge aus, wenn man den konkreten Lebenssachverhalt unter den Tatbestand subsumieren kann. Subsumtion ist die Unterordnung eines bestimmten Lebenssachverhalts unter den Tatbestand einer Rechtsnorm. Mit Tatbestand ist dabei die Summe der Merkmale gemeint, von deren Verwirklichung das Gesetz eine Rechtsfolge abhängig macht.[1] Wenn ich etwa einen Anspruch in dem aus dem Studium noch hinlänglich bekannten Gutachtenstil prüfe, was mache ich dann? Ich gebe eine Vorschrift an, deren Voraussetzungen auf den Sachverhalt oder deren Rechtsfolge wenigstens dem Begehr entspricht. Sodann nenne ich die Voraussetzungen der Vorschrift und prüfe sie der Reihe nach durch. Die ein oder andere Voraussetzung muss ich gegebenenfalls verschachtelt prüfen, weil sie ihrerseits Vor-Voraussetzungen hat. Vielleicht stehen diese Vorvoraussetzungen in anderen Normen, z.B. Hilfsnormen oder Definitionsnormen.

Und auch, wenn ich keine juristischen Klausuren mehr schreibe, gehe ich gedanklich doch die tatbestandlichen Merkmale durch, bevor ich die Rechtsfolge annehme, der Klagepartei also etwa ihr zusprechendes Urteil gebe, um dieses zu begründen. Zu nicht wenigen Vorschriften habe ich irgendwann einmal ein Prüfungsschema gelernt, das ich im Kopf durchgehe. Dabei stellt das Schema mehr oder weniger die Gesetzesvorschrift dar, in Gliederungspunkte zerlegt und mit Erläuterungen versehen. Den Lebenssachverhalt betrachte ich dann nur im Hinblick auf die Tatbestandmerkmale und blende andere Aspekte aus (sofern sie nicht zu anderen Tatbeständen führen).

Zum Beispiel könnte so ein Schema aussehen, um die Wirksamkeit einer Aufrechnung zu prüfen:

1. Aufrechnungserklärung, § 388 BGB
2. Aufrechnungslage, § 387 BGB
   1. aa) Bestehen der Gegenforderung?
   2. bb) Gleichartigkeit der Leistungen?
   3. cc) Erfüllbarkeit der Klageforderung, Fälligkeit der Gegenforderung
   4. dd) Ausschlussgründe?
3. Wirkung, § 389 BGB: Erlöschen der Ansprüche, soweit sie sich decken.

II. Informatisches Denken

Wenn ich — als Fachfremder — sage, ein Informatiker (II.2.) arbeitet vor allem mit Algorithmen (II.1.), dann möchte ich diese Begriffe auch ganz kurz vorstellen. Zudem stelle ich als Parallele zum Prüfungsschema das Ablaufschema (II.3.) vor.

1. Algorithmen

Ein Algorithmus ist eine Reihe von Anweisungen, die eine Aufgabe ausführen.[2] Oder man nennt ihn allgemein eine Anleitung, um aus Eingabedaten bestimmte Ausgabedaten zu produzieren und zurückzugeben.[3] Man kann das römische Rechtssprichwort als Algorithmus lesen: „da mihi facta, dabo tibi ius“, nämlich: „gib mir die Tatsachen (Eingabedaten), dann gebe ich dir das Recht (Ausgabedaten).“ Sodann kann man sich dieses Bild vorstellen:

Anders als der allgemein gehaltene lateinische Rechtsspruch, stellt ein Algorithmus aber für ein einzelnes, eigentümliches Problem einen darauf bezogenen Lösungsweg dar. Um die Erinnerungen an den Matheunterricht zu bemühen, könnte man den Algorithmus auch einen Rechenweg nennen.

2. Informatik

Als Informatik bezeichnet man die Wissenschaft von der systematischen Darstellung, Speicherung, Verarbeitung und Übertragung von Informationen, besonders der automatischen computergestützten Verarbeitung.[4] Im angelsächsischem Raum definiert man sich über die Untersuchung von Prozessen, die mit Informationen umgehen und die sich als Programme darstellen lassen.[5] Neben ihren mathematischen Ursprüngen hat sie sich aus dem Bedarf entwickelt, schnell und automatisch Berechnungen durchzuführen.[6] Den Namen prägte Karl Steinbruchs „Informatik: Automatische Informationsverarbeitung“ aus dem Jahr 1957.[7]

3. Ablaufschema

Ein Ablaufdiagramm veranschaulicht einen Arbeitsablauf, indem es eine Abfolge von Entscheidungen und Anweisungen vorschreibt.[8] Ein Ablaufdiagramm, das die einzelnen Operationen eines Algorithmus grafisch darstellt, nennt man Programmablaufplan (PAP) oder „flow chart“.[9] Ich habe im Informatikunterricht noch von ihnen gehört. In der Praxis sind sie jedoch selten geworden: stattdessen setzt man dort eher den im vorigen Teil (dort Abs. 18) beschriebenen Pseudocode ein. Trotzdem möchte ich kurz darauf eingehen, da Bilder veranschaulichen und ich die Ähnlichkeit zum Prüfungsschema schätze.

Laut Wikipedia[10] werden hauptsächlich folgende Symbole nach DIN 66001 genutzt:

Ein Terminator (6.4.1), also der Beginn oder Abschluss eines Algorithmus oder Vorgangs: Rechteck mit abgerundeten Ecken (u.a.)

Eine Verbindung (6.3.1) zum nächstfolgenden Element: Pfeil, Linie

Operation, Tätigkeit (6.1.1): Rechteck

Unterprogramm (7.2.4) ausführen: Rechteck mit doppelten, vertikalen Linien

Eine Verzweigung, Entscheidung (6.1.3), wie ich sie unten unter (IV.4.) darstellen werde: Raute

Ein- und Ausgabe (6.2.1): Parallelogramm

Später werde ich noch einmal auf ein solches Diagramm zurückkommen.

III. Die juristische Problemstellung

Eine Behauptung fordert ein Beweisangebot. Da ich behaupte, juristische und informatische Denkweisen ähneln sich, möchte ich das anhand der bereits erwähnten zwei Beispielen aufzeigen: Die prozessuale Hilfsaufrechnung und die vorläufige Vollstreckbarkeit sind jedem Volljuristen seit Beginn des Referendariats bekannt. Und sie lassen sich zudem zwar mit einprägsamen Schema, aber doch nur mit einem gewissen Rechenaufwand lösen.

1. Die prozessuale Hilfsaufrechnung - das Doppelnatürlichste der Welt

Die Aufrechnung hat bekanntermaßen eine Doppelnatur und zwar gleich in mehrfacher Hinsicht. Sie ist Erfüllungssurrogat (sog. „Tilgungsfunktion“ hinsichtlich der Gegenforderung), und gleichzeitig Mittel der Vollstreckung (sog. „Vollstreckungsfunktion“ hinsichtlich der Hauptforderung). Erklärt der Beklagte gegenüber der Klageforderung die Aufrechnung mit einer (vermeintlich) bestehenden eigenen Forderung, so hat dies materiell-rechtliche Wirkungen wie auch prozessrechtliche: materiell-rechtlich die bekannten Wirkungen des Gestaltungsrechts, prozessrechtlich ist es eine Einrede. Die prozessuale Aufrechnung ist das „Doppelnatürlichste“ der juristischen Welt.

a. Grundsatz

Die materiell-rechtlichen Voraussetzungen wie Fälligkeit, Durchsetzbarkeit, Erfüllbarkeit möchte ich an dieser Stelle ausblenden und die Gleichartigkeit (meist sind beide Forderungen Geldforderungen) und die Wechselseitigkeit (beide Parteien sind an beiden Forderungen beteiligt, wenn auch in wechselnden Rollen) unterstellen. Es sei nur kurz erwähnt, dass die Mathematik auch materiell-rechtlich nicht zu kurz kommt.

Stattdessen möchte ich mich auf die Folge konzentrieren.

§ 389 BGB: Die Aufrechnung bewirkt, dass die Forderungen, soweit sie sich decken, als in dem Zeitpunkt erloschen gelten, in welchem sie zur Aufrechnung geeignet einander gegenübergetreten sind.

Denn nur „soweit sie sich decken“, erlöschen die sich gegenüber stehenden Forderungen, § 389 BGB. Also der kleinere der beiden Beträge ist der maßgebliche, sofern Hauptforderung und Gegenforderung nicht gleich hoch sind. Vom vormaligen Betrag der höheren Forderung verbleibt das Ergebnis der Subtraktion <Betrag der höheren Forderung> minus <Betrag der niedrigeren Forderung>. Ist die höhere Forderung die Klageforderung, wird der Beklagte nur in Höhe der Differenz verurteilt. Ist die Klageforderung hingegen niedriger als die Aufrechnungsforderung, wird die Klage vollständig abgewiesen: Anders als in der Mathematik ist hier keine Verurteilung zu einem negativen Betrag möglich. Dass der Beklagte mit seiner Forderung in Höhe des noch verbleibenden Betrags eine Widerklage erheben könnte, soll uns hier nicht interessieren.

Verteidigt sich der Beklagte ausschließlich mit der Aufrechnung gegen die Klageforderung, spricht man auch von einer Primäraufrechnung. Das ist aber nur der Fall, wenn der Beklagte die anspruchsbegründenden Tatsachen nicht bestreitet und keine weiteren Einreden vorbringt.[11] Der praktische Regelfall ist die Hilfsaufrechnung, d.h. neben der Aufrechnung bestreitet der Beklagte noch anspruchsbegründende Tatsachen oder bringt Einreden vor.[12] Das Zauberwort „hilfsweise“ muss nicht verwendet werden, ist aber der Regelfall. Der Beklagte kann gestaffelt mit mehreren Forderungen aufrechnen.

Eine Vorschrift aus dem Gerichtskostengesetz GKG bringt die Rechnerei in die Streitwertentscheidung und damit auch in die Kostengrundentscheidung:

§ 45 Abs. 3 GKG: Macht der Beklagte hilfsweise die Aufrechnung mit einer bestrittenen Gegenforderung geltend, erhöht sich der Streitwert um den Wert der Gegenforderung, soweit eine der Rechtskraft fähige Entscheidung über sie ergeht.

Und inwieweit ergeht eine der Rechtskraft fähige Entscheidung auch über die Hilfsaufrechnung? Auch zur Frage des Umfangs der Rechtskraft kann man das Gesetz befragen. Zu der Doppelnatur kommt hier ein Zweigespann. Das sagt nämlich wiederum die Zivilprozessordnung:

§ 322 Abs.2 ZPO: Hat der Beklagte die Aufrechnung einer Gegenforderung geltend gemacht, so ist die Entscheidung, dass die Gegenforderung nicht besteht, bis zur Höhe des Betrages, für den die Aufrechnung geltend gemacht worden ist, der Rechtskraft fähig.

Die Aufrechnungsforderung erhöht den Streitwert also nicht in jedem Fall und auch nicht immer in voller Höhe. Ist etwa schon die Klageforderung für sich betrachtet gänzlich unbegründet, so erhöht die Hilfsaufrechnung den Streitwert gar nicht. Auch aus diesem Grund ist die Klageforderung (ich nenne die ursprüngliche Höhe hier kf.wert) immer zuerst zu betrachten, bevor man sich der Hilfsaufrechnungsforderung (ich nenne deren Ausgangshöhe hier af.wert) zuwendet.

Wie berechnet man nun den Streitwert und das jeweilige Unterliegen der Parteien? Indem man Schritt-für-Schritt vorgeht, eins nach dem anderen. Die Haupt-Rechenschritte sind also folgende:

1. Zuerst errechne ich die Höhe der Klageforderung, wie ich sie ohne Aufrechnung zusprechen würde. Ich nenne das Ergebnis hier kf.erfolg.
2. Nur wenn die Summe besser als nichts ist, errechne ich die Höhe der Aufrechnungsforderung (af.wert), soweit sie sich mit der verbliebenen Klageforderung (kf.erfolg) deckt. Inwieweit decken sich die Forderungen? Das ist einfach die kleinere der beiden Werte, kf.erfolg oder af.wert.[13] Hier nenne ich das Ergebnis des Vergleichs effektiverWert. In der obigen Grafik ist es die einfarbige (gelb bis orangefarbene) Fläche des rechten Balkens.
3. Dann werde ich wieder juristisch tätig und subsumiere nach den Regeln der Kunst den Teil der Aufrechnungsforderung, wie ich sie ohne Betrachtung der Klageforderung „zusprechen“ würde. Auch hier interessiert nur der Teil der begründeten Aufrechnungsforderung, der sich mit effektiverWert deckt. Dazu gehe ich wie bei Schritt 2 vor. Diesen Teil nenne ich effektiverErfolg.

Der Streitwert erhöht sich nun um effektiverWert (die einfarbige Fläche des rechten Balkens).

Parallel dazu schaue ich nun, wie hoch die Verluste der einzelnen Partei sind.

1. Beim ersten Schritt des obigen Durchgangs ist der begründete Teil der Klageforderung (hier kf.erfolg) der Verlust des Beklagten; der übrige Teil (kf.wert-kf.erfolg) ist Verlust des Klägers.
2. Bei 2. ergeben sich keine neuen Erkenntnisse für die Verluste. Aber ich merke mir für den nächsten Schritt effektiverWert.
3. Beim dritten Schritt des obigen Durchgangs ist der begründete Teil (effektiverErfolg) der Aufrechnungsforderung (effektiverWert) der Verlust des Klägers. Der übrige Teil (effektiverWert-effektiverErfolg) ist Verlust des Beklagten.

Die zuzusprechende Klageforderung verringert sich demgegenüber um effektiverErfolg.

Dazu einmal ein Beispielsfall:[14]

Mit seiner Klage verlangt der Kläger vom Beklagten, ihm 10.000 EUR zu zahlen. Der Beklagte bestreitet erheblich und rechnet zudem mit einer Forderung von 15.000 EUR auf, die wiederum der Kläger angreift. Das Gericht prüft: beide Forderungen bestehen.

Der Streitwert zu Beginn ist wie gewohnt derjenige der Klageforderung, also 10.000 EUR.

1. Die Klageforderung ist in voller Höhe, also 10.000 EUR, begründet. Dieser Betrag stellt den Verlust des Beklagten dar. Demgegenüber hat der Kläger 0 EUR auf seinem Verlustekonto.
2. Die Aufrechnungsforderung beträgt 15.000 EUR. Allerdings deckt sie sich nur zum Teil mit der verbliebenen Klageforderung, namentlich in Höhe von 10.000 EUR. Insoweit erhöht sich der Streitwert; der beträgt nun 10.000+10.000 EUR = 20.000 EUR.
3. Auch die Aufrechnungsforderung besteht in voller Höhe, wobei uns ja nur der sich deckende Betrag interessieren darf: 10.000 EUR (effektiverErfolg) auf das Verlustkonto des Klägers. Der Verlust des Beklagten beträgt hier 0 EUR.

Bei einem Streitwert von 20.000 EUR trifft den Kläger und den Beklagten jeweils ein Verlust von 10.000 EUR. Sie tragen die Kosten je zur Hälfte, sofern das Gericht nicht die Kosten gegeneinander aufhebt (§ 92 Abs. 1 ZPO).

b. Staffelung

Ist nach dem ersten Durchgang noch etwas von der Klageforderung übrig und macht der Beklagte mehrere Hilfsaufrechnungen gestaffelt geltend, geht man die Rechenschritte mit der zweiten Hilfsaufrechnungsforderung und der verringerten Klageforderung von neuem bei 1 beginnend durch. Das kann dazu führen, dass sich der Streitwert stark erhöht.[15]

Das macht man „immer wieder“ (dazu später, merken Sie sich diesen Ausdruck), bis entweder die zuzusprechende Klageforderung aufgezehrt ist oder keine Aufrechnungsforderungen mehr im Pfeilköcher des Beklagten stecken.

Die Staffelung von Hilfsaufrechnungen ist rein sprachlich oft schwer zu vermitteln und verlangt nach grafischen Hilfsmitteln.

Abwandlung zum Beispielfall:[16] Der Kläger verlangt Zahlung von 10.000 EUR. Der Beklagte bestreitet die Klageforderung und erklärt hilfsweise die Aufrechnung mit Gegenforderungen von

1. 10.000 EUR sowie
2. 4.000 EUR,

die wiederum der Kläger bestreitet. Die Klageforderung besteht ohne Ansehung der Aufrechnung in voller Höhe. Die Gegenforderung zu a) besteht in Höhe von 5.000 EUR, die Gegenforderung zu b) in Höhe von 1.000 EUR.

Da sich hier nicht jede schematische Lösung verbietet, führe ich daran meinen Dreischritt von eben vor.

Erster Durchgang (zu Gegenforderung a)

1. Die Klageforderung und damit der anfängliche Streitwert betragen 10.000 EUR und ist vollständig begründet (blauer Balken links). Die verbleibende Klageforderung ist also 10.000. Verlust des Klägers: 0 EUR, Verlust des Beklagten: 10.000 EUR.
2. Die Gegenforderung a) (af.wert) beträgt 10.000 EUR. Da sie sich vollständig mit der verbleibenden Klageforderung deckt, ist effektiverWert auch 10.000 EUR. Der Streitwert erhöht sich auf 20.000 EUR (mehrfarbiger Balken ganz rechts).
3. Davon sind 5.000 EUR begründet (effektiverErfolg, einfarbige Fläche im roten Balken). Der Verlust des Klägers ist 5.000 EUR (rot schraffierte Fläche), der Verlust des Beklagten ist 10.000-5.000 EUR, also ebenfalls 5.000 EUR. Und um den Betrag nochmals zu nennen: die Klageforderung verringert sich 10.000-5.000 auf 5.000 EUR.

Mit der auf 5.000 EUR reduzierten Klageforderung wage ich mich in den Zweiten Durchgang mit Gegenforderung b)

1. Die Klageforderung beträgt noch 5.000 EUR. Sie wird im zweiten Durchgang nicht streitwerterhöhend berücksichtigt und ist verlust-neutral.
2. Die Gegenforderung b (af.wert, grüner Balken) beträgt 4.000 EUR. Der Betrag „soweit sie sich decken“ (effektiverWert) ist ebenfalls 4.000 EUR, da der Betrag der Gegenforderung kleiner als die verbleibende Klageforderung ist. Der Streitwert erhöht sich also um 4.000 EUR (effektiverWert) auf 24.000 EUR (mehrfarbiger Balken ganz rechts, grüne Fläche).
3. Von dieser Aufrechnungsforderung sind 1.000 EUR begründet (effektiverErfolg). Der Verlust des Klägers erhöht sich um effektiverErfolg, der Verlust des Beklagten um (4.000-effektiverErfolg ergibt) 3.000. Die Klageforderung vermindert sich um effektiverErfolg auf 4.000 EUR (zweiter Balken von rechts, grün schraffierter Teil).

Bei einem Streitwert von 24.000 EUR spricht das Gericht dem Kläger demnach noch 4.000 EUR zu, sein Verlust ist 6.000 EUR (5.000+1.000), der Verlust des Beklagten beträgt 18.000 EUR (10.000+5.000+3.000). Die Kosten muss der Kläger demnach zu 25% (6.000 durch 24.000), der Beklagte zu 75% (18.000 durch 24.000) tragen. Und Kosten des Verfahrens können bei diesem Streitwert schon fast 6.000 EUR bedeuten (doch das ist eine andere Geschichte und soll ein anderes Mal erzählt werden).

2. Vorläufige Vollstreckbarkeit

Als zweite juristische Problemstellung möchte ich Ihnen die Entscheidung über die vorläufige Vollstreckbarkeit nahebringen. Dazu wiederhole ich die Vorschriften, rufe mir die Systematik ins Gedächtnis und ende mit einem kleinen Ablaufdiagramm.

Das Urteil ist grundsätzlich nur vollstreckbar, wenn es rechtskräftig ist, sagt § 704 ZPO. Das kann den Gläubiger u.U. über Gebühr belasten, da er das Insolvenzrisiko des Schuldners trägt, während er auf die Rechtskraft wartet.[17] Eine Ausnahme besteht deshalb, wenn das Urteil (im Tenor) für vorläufig vollstreckbar erklärt wurde.

§ 704 ZPO Vollstreckbare Endurteile: Die Zwangsvollstreckung findet statt aus Endurteilen, die rechtskräftig oder für vorläufig vollstreckbar erklärt sind.

Urteile mit vollstreckbarem Inhalt sind daher grundsätzlich für vorläufig vollstreckbar zu erklären. Eine Anordnung der vorläufigen Vollstreckbarkeit schon vor Rechtskraft eines Urteils würde ohne Weiteres aber wiederum den Schuldner unzumutbar belasten: Wenn sich das Urteil nach der Vollstreckung nämlich in höherer Instanz als falsch herausstellt, vom Gläubiger aber nichts mehr zu holen ist.[18] Deshalb ordnet das Gericht im gesetzlichen Grundfall des § 709 ZPO die vorläufige Vollstreckung nur gegen eine Pflicht zur Sicherheitsleistung an. Kann der Schuldner seine Rückforderungen nicht mehr gegen den Gläubiger richten, kann er auf die Sicherheit zurückgreifen. Nur in einzeln aufgezählten Fällen des § 708 ZPO verzichtet das Gericht auf eine Sicherheitsleistung. Der wichtigste Fall ist der Fall sogenannter Bagatellurteile.[19] Der Gläubiger kann ohne Sicherheitsleistung grundsätzlich vollstrecken. Der Schuldner ist trotzdem nicht schutzlos gestellt: wegen § 711 ZPO, aber der trifft eine andere Abwägung der Interessen: Will der Schuldner die Vollstreckung verhindern, kann er selbst Sicherheit leisten, in Höhe des gesamten Werts, der aufgrund des Urteils vollstreckbar ist. Er versetzt damit den Gläubiger in die Lage, in der er bei Anordnung der Vollstreckbarkeit gegen Sicherheitsleistung wäre: er (der Gläubiger) muss jetzt Sicherheit leisten, wenn er vollstrecken will. Trotzdem ist er in einer besseren Lage: wenn er mit der Vollstreckung wartet, besteht zu seinen Gunsten eine Sicherheit.

§ 708 Nr.11 ZPO: Für vorläufig vollstreckbar ohne Sicherheitsleistung sind zu erklären: andere Urteile in vermögensrechtlichen Streitigkeiten, wenn der Gegenstand der Verurteilung in der Hauptsache 1.250 Euro nicht übersteigt oder wenn nur die Entscheidung über die Kosten vollstreckbar ist und eine Vollstreckung im Wert von nicht mehr als 1.500 Euro ermöglicht.

§ 709 ZPO: Satz 1: Andere Urteile sind gegen eine der Höhe nach zu bestimmende Sicherheit für vorläufig vollstreckbar zu erklären. Satz 2: Soweit wegen einer Geldforderung zu vollstrecken ist, genügt es, wenn die Höhe der Sicherheitsleistung in einem bestimmten Verhältnis zur Höhe des jeweils zu vollstreckenden Betrages angegeben wird. Handelt es sich um ein Urteil, das ein Versäumnisurteil aufrechterhält, so ist auszusprechen, dass die Vollstreckung aus dem Versäumnisurteil nur gegen Leistung der Sicherheit fortgesetzt werden darf.

§ 711 ZPO: Satz 1: In den Fällen des § 708 Nr. 4 bis 11 hat das Gericht auszusprechen, dass der Schuldner die Vollstreckung durch Sicherheitsleistung oder Hinterlegung abwenden darf, wenn nicht der Gläubiger vor der Vollstreckung Sicherheit leistet. Satz 2: § 709 Satz 2 gilt entsprechend, für den Schuldner jedoch mit der Maßgabe, dass Sicherheit in einem bestimmten Verhältnis zur Höhe des auf Grund des Urteils vollstreckbaren Betrages zu leisten ist.

Auch zu § 711 ZPO besteht eine Ausnahme: Die Pflicht zur Sicherheitsleistung gemäß § 713 ZPO entfällt ohne Abwendungsbefugnis, wenn die Zulässigkeitsvoraussetzungen für ein Rechtsmittel gegen das Urteil unzweifelhaft nicht vorliegen, es aber noch nicht rechtskräftig ist. So will das Gesetz vermeiden, dass die unterlegene Partei ein aussichtsloses Rechtsmittel einlegt, um die Vollstreckung hinauszuschieben.[20] Das sind vor allem die Fälle, in denen der Rechtsmittelwert nicht erreicht ist.

§ 713 ZPO: Die in den §§ 711, 712 zugunsten des Schuldners zugelassenen Anordnungen sollen nicht ergehen, wenn die Voraussetzungen, unter denen ein Rechtsmittel gegen das Urteil stattfindet, unzweifelhaft nicht vorliegen.

Mein Vorschlag zu einer Prüfung ist, mit diesem Punkt anzufangen, da er sich leicht prüfen lässt. Der § 511 Abs. 2 Nr. 1 ZPO fordert, dass die Beschwer 600 EUR übersteigt. Dabei ist auf jeden Beteiligten gesondert abzustellen: ist für diesen die Beschwer nicht mehr als 600 EUR? Die Frage muss man für alle Parteien bejahen können, damit man insgesamt ein Rechtsmittel ausschließen kann. Einfach ist die Frage dann für alle Seiten zu bejahen, wenn der Streitwert insgesamt nicht mehr als 600 EUR beträgt. Bei einem Streitwert bis 1200 EUR besteht zudem die Möglichkeit, dass für jeden einzelnen die Beschwer die Grenze nicht überschreitet (Teilunterliegen).

Überschreitet die Beschwer auch nur für eine Partei die Rechtsmittelgrenze, so entscheidet das Gericht im nächsten Schritt, ob es die vorläufige Vollstreckbarkeit gegen Sicherheitsleistung anordnet oder stattdessen eine Abwendungsbefugnis ausspricht.

Dafür trennt es zunächst die Vollstreckungsverhältnisse. Wer kann gegen wen was vollstrecken? Da Widerklagen in diesem Beitrag außer Betracht bleiben sollen, kann in der Hauptsache lediglich der Kläger vollstrecken. Auch diese Möglichkeit entfällt, wenn das Gericht die Klage vollständig abweist. Aus der Kostenentscheidung hingegen können unter Umständen (in Kombination mit einem Kostenfestsetzungsbeschluss) beide Seiten vollstrecken.

Beispiel: Die Prüfung kann z.B. so ausgehen, dass der Kläger bei einem Streitwert von 3.000 EUR hinsichtlich der Hauptsache 1.500 EUR und der Hälfte der Kosten vollstrecken kann (ca. 460 EUR), der Beklagte die Hälfte seiner Kosten (ca. 300 EUR).

Dann fällt die Entscheidung, ob sich die vorläufige Vollstreckbarkeit bei dem jeweiligen Vollstreckungsverhältnis nach § 708 Nr.11 oder § 709 ZPO richtet. Hinsichtlich der Hauptsache ist im Beispiel die Grenze von 1.250 EUR überschritten, in der das Gericht die vorläufige Vollstreckbarkeit ohne Sicherheitsleistung aussprechen könnte. Für den Kläger richtet sich die Vollstreckbarkeit nach § 709 ZPO.

Hinsichtlich der Vollstreckung der Kosten gilt eine andere Grenze, nämlich 1.500 EUR. Da die Parteien zu diesem Zeitpunkt des Verfahrens ihre Kosten üblicherweise noch nicht vollständig angemeldet haben, kann die Höhe der Kosten nur überschlagsmäßig geschätzt werden, so auch im Beispiel oben. Da der Kläger bereits aus dem Urteil in der Hauptsache vollstrecken kann, werden seine Kosten (deutlich unter 1.500 EUR) nicht betrachtet („nur über die Kosten vollstreckbar“). Anders beim Beklagten: Er kann aus der Hauptsache nicht vollstrecken. Für sein Vollstreckungsverhältnis kommt es also darauf an, welche Kosten er vollstrecken kann. Im Beispiel sind das ca. 300 EUR, die Hälfte der üblicherweise bei einem Streitwert von 3000 EUR auf Beklagtenseite anfallenden Anwaltsvergütung (Verfahrensgebühr, Terminsgebühr und Umsatzsteuer). Dieser Betrag überschreitet 1500 EUR nicht. Für den Beklagten richtet sich die Vollstreckbarkeit nach §§ 708 Nr.11, 711 ZPO.

Als Ablaufplan möchte ich diese Prüfung einmal wie folgt darstellen: Die Bedeutung der Symbole hatte ich oben unter II.3. dargestellt.

In der Abbildung sehen Sie die vollständige Prüfung: Bei den grünen Rechtecken rufe ich Unterprogramme zur Unanfechtbarkeit und der Notwendigkeit einer Sicherheitsleistung auf. Das Ergebnis lege ich auf einen „Stapel“: Wenn der Kläger und der Beklagte vollstrecken können und sich die vorläufige Vollstreckbarkeit nach verschiedenen Vorschriften bemisst, muss ich auch zwei verschiedene Anordnungen im Tenor treffen. Die Unterprogramme stelle ich im folgenden Unterabschnitt vor.

3. Kombination: vorläufige Vollstreckbarkeit und Hilfsaufrechnung

Im Grundsatz lassen sich vorstehenden Überlegungen auch auf die Fälle übertragen, in denen eine Hilfsaufrechnung vorliegt.

Man muss jedoch Besonderheiten beachten, wenn man die Unanfechtbarkeit prüft. Denn der Rechtsmittelstreitwert bzw. die Beschwer ist grundsätzlich vom Gebührenstreitwert zu unterscheiden, den § 45 GKG behandelt. Wann ist also die Beschwer nicht über der Rechtsmittelgrenze? Was beschwert den Kläger? Egal, wie viele Hilfsaufrechnungen gestaffelt sind: der Kläger unterliegt maximal in Höhe seiner Klageforderung, namentlich in Höhe der Differenz zwischen Klageforderung und dem zugesprochenen Betrag. Die Beschwer des Beklagten ist höher: Sie besteht zum einen aus dem Betrag, zu dessen Zahlung ihn das Gericht verurteilt hat, aus dem abgesprochenen Teil der Aufrechnungsforderungen, soweit die Entscheidung darüber der Rechtskraft fähig ist (in der Rechnung oben, III.1.a. hatte ich ihn effektiverWert genannt), denn auch insoweit hat er das Verfahren verloren. Aber auch die erfolgreiche Aufrechnung ist hinzuzurechnen, denn eigentlich hatte der Beklagte die Klageforderung in dieser Höhe vorrangig (Hilfsaufrechnung) auf andere Weise zu Fall bringen wollen.[21] Für den Rechenweg kann ich also auf die Berechnung des Streitwerts oben verweisen. Nur ist nicht der Streitwert der Klage der Ausgangspunkt, sondern allein der Verlust des Beklagten daran.[22]

1. Unanfechtbarkeit prüfen
   1. Ist der Streitwert <= 600 EUR?
   2. Ist der Streitwert <= 1200 EUR? Dann: ist einzelne Beschwer <= 600 EUR?
      1. Bei Klägern: Der Betrag von der Summe seiner Hauptklageforderungen, die nicht begründet ist.
      2. Bei Beklagten:
         • Das, wozu er verurteilt wurde
         • + begründete Aufrechnungen
         • + streitwerterhöhende, aber unbegründete Aufrechnungen
         • ⇒ Anders ausgerdrückt:
           Summe der begründeten Hauptklageforderungen
         • + Summe effektiver Wert Hilfsaufrechnung
2. 
   Prüfung Vollstreckungsverhältnis Kl → Bk
   1. Als Hauptsache: gilt hier der Betrag, zu dem der Beklagte verurteilt wird, also die verbleibende Klageforderung.
   2. Als vollstreckbare Kosten ist hier der Anteil des Beklagten an Gerichtskosten, Verfahrensgebühr und Termingebühr nach RVG für einen Termin einzusetzen.
   3. Mit diesen Werten das Schema Sicherheitsleistung §§ 708/709 durchgehen.
3. Prüfung Vollstreckungsverhältnis Bk → Kl.
   1. Eine vollstreckbare Hauptsache gibt es hierbei nicht
   2. Als vollstreckbare Kosten sind hier zwar keine Gerichtskosten, aber der Anteil des Klägers an Verfahrensgebühr und Termingebühr nach RVG einzusetzen.
   3. Mit diesen Werten das Schema Sicherheitsleistung §§ 708/709 durchgehen.

IV. Handwerkszeug des Programmierens

Um diesen Ablauf in Java™ umsetzen zu können, möchte ich einige Befehle und Techniken vorstellen. Zuerst führe ich einfache Befehle und Strukturen auf (IV.1.), dann Mehrheiten von Dingen (IV.2.), dann Wiederholungen (IV.3.) und letztlich Wenn-Dann-Sonst-Entscheidungen (IV.4.).

1. Einfache Abläufe (eins nach dem anderen)

a. Grundsätzlicher Ablauf

Der Urtyp des Programms ähnelt der Prüfung der §§ 387—395 BGB nach dem Schema unter I.: der Computer arbeitet einen Punkt nach dem anderen ab. Im Beispiel unter I. liefe zum Beispiel ein Programm so ab: erst Prüfung der Aufrechnungserklärung, dann Prüfung der Aufrechnungslage, dann Prüfung der Wirkung.

Da der Computer hier praktisch einen Befehl nach dem anderen befolgt, nennt man Programmiersprachen dieser Art „imperativ“,[23] heute meist in der Erweiterung als „prozedurale Programmierung“.[24] Eine weitere prominente Vertreterin ist die Programmiersprache C, Pionierin war Fortran. Auf diese Weise zu programmieren, nennt sich dann „imperatives Programmierparadigma“ (Wenn Sie dieses Wort auf einer Party bringen, brauchen Sie sich über Social Distancing keine Sorgen zu machen). Auch in imperativen Sprachen teilt man das Gesamtkonzept häufig in überschaubare Teilprobleme auf, die von Prozeduren (Unterprogrammen) mit vordefinierten Parametern gelöst werden. Daher der Name der „prozeduralen Programmierung“. Der Computer geht dabei ähnlich vor wie ein Jurist, wenn er eine Aufrechnung nach dem Schema nach §§ 387—395 BGB prüfen muss und hier insbesondere prüft, ob die Aufrechnungsforderung „fällig“ ist. Hier würden Sie wahrscheinlich „abzweigen“ und etwa nach § 271 Abs. 1 BGB prüfen, ob eine Leistungszeit vertraglich bestimmt ist oder sich aus den Umständen ergibt. Nach Abschluss dieser Prüfung würden Sie dann zur Prüfung der weiteren Prüfungsschritte zu den §§ 387—395 BGB zurückkehren.

Das heißt aber nicht, dass andere Programmiersprachen dies nicht unterstützen, praktisch jede Programmiersprache unterstützt auch imperatives Programmieren.[25] Auch im eigentlich Objekt-orientierten Java kann man imperativ programmieren. Die Anweisungen „tu dies, tu das, tu jenes“, muss man aber in einer Klasse unterbringen. In der Objektorientierung haben die Klassen ihre Methoden, die den Prozeduren ähneln. Diese müssen vorher in eine Klasse eingebettet werden.

b. Einzelne Befehle

Der anfänglich gewöhnungsbedürftige Befehl System.out.println gibt eine Zeichenkette in der Konsole aus und bewegt den Cursor in die nächste Zeile. Es handelt sich um eine so genannte statische Methode in der Klasse out im Paket System. „Statisch“ wiederum heißt, man kann sie aufrufen, ohne zuvor eine Instanz der Klasse System.out zu erzeugen.

System.out gehört zur Java-Standardbibliothek. Das ist sozusagen der „Lieferumfang“ der Java-Umgebung. Sie enthält zahlreiche Klassen und Methoden für alltägliche Aufgaben der Programmierung. Außer der Klasse System.out, die Methoden für die Ausgabe an die Konsole bereithält, gibt es etwa die Klasse Math für mathematische Standardmaßnahmen. Wollen Sie zum Beispiel zu zwei Forderungen wissen, inwieweit „sie sich decken“ im Sinne von § 389 BGB (oben, III.1.a), gibt Ihnen Math.min(klageforderung, aufrechnungsforderung) den kleineren der beiden Werte zurück.

In dem juristischen Beispiel zur Hilfsaufrechnung habe ich viele Platzhalter (Variablen) genutzt. Diese braucht man in der Programmierung in ungeahnter Häufigkeit, denn so reserviert der Computer Speicherbereiche. Diese muss man zwingend deklarieren: so weist man ihnen einen Typ zu. Es gibt in Java folgende sogenannte primitive Typen, also Typen, die keine Objekte sind: vor allem int für Ganzzahlen (32 Bit), long für größere Ganzzahlen (64 Bit), float und double für Dezimalbruchzahlen (Fließkommazahlen), char (16 Bit) für einzelne Zeichen, boolean für 1-Bit-Wahrheitswerte (wahr oder falsch). Daneben gibt es den Typ „String“ für Zeichenketten, der aber nicht primitiv ist. Variablen deklariert man in der Schreibweise <Typ> <Name>, also etwa:

• int i;

Es ist erlaubt, aber nicht vorgeschrieben, der Variable direkt auch einen Wert zuzuweisen:

• int i = 10;

Der Wert kann danach beliebig oft geändert werden, etwa mit Rechenoperationen. Dabei wird der Typ nicht erneut angegeben. Als Rechenoperationen gibt es + für Addition, - für Subtraktion, * für Multiplikation und / für Division:

• i = i + 10;

Dies erhöht den vorigen Wert von i um 10.

Soll der Wert unveränderlich sein, also endgültig, schreibt man das Schlüsselwort „final“ vor den Typ:

• final int i = 10;

Methoden schreiben Sie in Java in der Form <Optionen> <Rückgabetyp> <Methodenname> (<Parameter>), gefolgt von einem Anweisungsblock, etwa

• public long berechneStreitwert(Forderung[] forderungen) {
  • ...
• }

public ist die Option dafür, dass man die Methode auch überall außerhalb der Klasse aufrufen kann. Der Rückgabetyp ist hier auf long gesetzt. Soll die Methode gar nichts zurückgeben, setzt man den Typ auf „leer“, englisch: void. Als Methodenname habe ich hier berechneStreitwert gewählt. Methodennamen beginnen in Java konventionell mit Kleinbuchstaben. Als Parameter bekommt die Methode ein Array (dazu sogleich, IV.2.) mit Elementen der Klasse Forderung übergeben. Anweisungsblöcke werden in Java wie in C in geschweifte Klammern eingeschlossen: {...}. Weil ein Rückgabetyp angegeben ist, müsste ich noch mit der Anweisung return ...; einen long zurückgeben. Hätte ich mit void auf einen Rückgabetyp verzichtet, könnte ich mir das sparen.

In dem folgenden Beispielprogramm gibt es genau eine Methode „main“, die bei einem Programmstart aufgerufen wird:

• class HalloWelt {
• • private static final String HALLO = "Hallo Welt!";
  • public static void main(String[] args){
  • • int i = 42;
    • System.out.println(HALLO);
    • System.out.println(i);
    • i = i + 7;
    • System.out.println(i);
    • i = i / 7;
    • System.out.println(i);
    • i = i * 6;
    • System.out.println(i);
  • }
• }

Da Java sich in vielen Punkten an der Programmiersprache C orientiert, hat es auch einen Befehl übernommen, um den Wert einer Variablen um genau 1 zu erhöhen (sogenanntes Inkrementieren):

• i++;

Das ist das gleiche wie „i = i + 1;“, aber unschlagbar kurz. Diese Kurzschreibweise gibt es auch für i = i - 1; (Dekrementieren), nämlich: i--;. Wenn Sie mehr als 1 inkrementieren oder dekrementieren wollen, nutzen Sie die Operatoren += und -=, z.B. mit 7:

• i+=7
• i-=7

c. Klassendiagramme

Klassendiagramme sind eine schematische Darstellung einer Klasse,[26] in denen man ihre Eigenschaften (Variablen) und Methoden/Operationen (Unterprogramme) darstellt. Schon im ersten Teil hatte ich die Klassen mit solchen Schemata dargestellt, ohne sie ausdrücklich als Klassendiagramm zu bezeichnen.

Die Klassendiagramme baue ich so auf, dass ich unter dem Namen nach der ersten Trennlinie zunächst die Eigenschaften aufführe. Entsprechend der üblichen Schreibweise nenne ich den Typ der Variable erst nach dem Variablennamen — also umgekehrt der Java-Schreibweise —, getrennt durch einen Doppelpunkt. Ein kleines Pluszeichen + vor dem jeweiligen Namen zeigt, dass die Eigenschaft auch außerhalb der Klasse zu sehen ist. Fehlt das +, ist die Eigenschaft private markiert, man kann sie also nur innerhalb der Klasse selbst abfragen oder setzen. Nach einer weiteren Trennlinie führe ich die Methoden auf, also die Unterprogramme. Auch diese können mit einem + markiert sein. Nach dem Doppelpunkt steht der Rückgabewert der Methode, sofern die Methode einen Rückgabewert hat (nicht void). Wenn eine Methode unterstrichen dargestellt ist, dann zeigt es: sie ist static (statisch). Die jeweilige Methode ohne Rückgabewert ist der Konstruktor, mit dem ich eine neue Instanz des Typs erstellen kann, etwa mit HilfsmittelKlasse hilfsmittel = new HilfsmittelKlasse();. Auf die unsichtbaren Eigenschaften der Klasse (private) kann ich über „Getter“ (die mit „get“ oder bei boolean mit „is“ beginnenden Methoden) und „Setter“ (die mit „set“ beginnenden Methoden) auch von anderen Klassen aus zugreifen.

Im folgenden Beispiel zeige ich die später benötigte Klasse HilfsmittelKlasse mit zwei Eigenschaften, eine von außen sichtbare und statische, eine private. Die Eigenschaft BERUFUNGS_GRENZE ist groß geschrieben, weil sie zusätzlich final ist, also nach der erstmaligen Wertzuweisung nicht mehr geändert werden darf. Als Methoden hat sie den Konstruktor HilfsmittelKlasse(), zwei statische Methoden zur Berechnung der angefallenen Kosten und eine normale Methode. Mit dem Konstruktor lässt sich über eine neue Instanz der Klasse erzeugen.

• HilfsmittelKlasse
• • + BERUFUNGS_GRENZE: double
  •   wirdWerden: String
• • + HilfsmittelKlasse()
  • + errechneKostenKlaeger(streitwert: double): double
  • + errechneKostenBeklagter(streitwert: double): double
  • + toString(): String

2. Arrays und Listen: Arrays, Listen und (besser) Objekte mit Struktur

Die Computerei wird auch Datenverarbeitung (EDV) genannt. Der Computer verarbeitet also Daten. Diese speichert er zum einen in Variablen, also kleinen Datenportionen, und spricht sie auch so an. Oft benötigt man aber Sammlungen von Daten. In dem Beispiel zur Hilfsaufrechnung kam etwa eine Sammlung von Forderungen vor (Klageforderung und mehrere Aufrechnungsforderungen), in dem Beispiel zur vorläufigen Vollstreckbarkeit gab es mehrere Vollstreckungsverhältnisse. Außerdem habe ich mehrere Forderungshöhen, Streitwerte und Verluste gezeigt. Datensammlungen gibt es in verschiedenen Varianten.

Die grundlegende Variante ist das Array, zu deutsch Feld oder Reihe.[27] Es speichert eine vorab bestimmte Anzahl von Daten desselben Typs, zum Beispiel 100 ganze Zahlen oder 50 Zeichenketten. Manche vergleichen ein Array mit einem Buchregal,[28] andere mit einem Setzkasten.[29] Der Programmierer ruft dann die Inhalte über den Index ab, etwa buecher[5] für das Mitglied mit dem Index 5 aus dem Array buecher. Die Zählung beginnt übrigens immer mit der 0, wenn das Array buecher also 50 Mitglieder hat, so können sie als buecher[0] bis buecher[49] angesprochen werden. Für so ein Array reserviert der Computer meist zusammenhängenden Arbeitsspeicher und legt alle Mitgliederelemente des Arrays nebeneinander ab. Das sorgt für schnellen Zugriff. Will man später ein Mitglied hinzufügen, weil man Buch Nr. 51 geschenkt bekommen hat, ist das Array zu klein. Man muss den Computer anweisen, ein neues Array mit 51 Plätzen einzulegen und die Mitglieder des bestehenden Arrays dorthin verschieben. Dann kann man Nr. 51 (mit dem Index 50) dort unterbringen. Das ist immerhin noch einfacher, als ein echtes Regal aus dem Möbelmarkt zu kaufen und aufzubauen.

Die andere Möglichkeit, mehrere Daten (Elemente) vom gleichen Typ zu sammeln, sind Listen. Ich habe sie im Informatikunterricht noch als verkettete Listen kennengelernt, in der damals beliebten Programmiersprache Turbopascal. Jedes Element besteht nicht nur aus dem eigenen Wert, sondern zeigt auch bei einer solchen Liste auf die Speicheradresse des jeweils nächsten Elements. Da der Speicherbereich nicht zusammenhängend sein muss, lassen sich neue Elemente beliebig hinzufügen: nicht nur ans Ende, sondern auch mitten darin. Im Informatikunterricht mussten die Schüler damals selbst die Zeiger biegen. In Java sind die Funktionen einfach integriert, der Programmierer merkt nichts von der Ablage in den Speicher. Er fügt ein Element mit der Methode add(Object) hinzu und bekommt es auf Wunsch mit der Methode get(int index) zurück. Ein berühmter Kobold hätte vergnügt festgestellt: add und get, das reime sich ja und müsse daher gut sein.

Java bietet sogar eine Kombination aus beidem, die ArrayList. Diese Konstruktion ist ähnlich leicht abzufragen wie ein Array, aber erweiterbar wie eine Liste. Wenn man zusätzliche Elemente benötigt, kümmert sich Java selbst um die Reservierung neuen Speicherbereichs und das Kopieren der bisherigen Werte.

Eine weitere Möglichkeit, mehrere Daten an einer Stelle zu halten, ist das Objekt. Zu Objekten und der objektorientierten Programmierung hatte ich ja schon im ersten Teil (unter III., Abs. 11) geschrieben. Ein Vorteil der Sammlung dieser Art ist, dass die Eigenschaften (also die Einzeldaten) verschiedenen Typen angehören können, also die erste Eigenschaft eine Ganzzahl (Integer oder int), die zweite ein Dezimalbruch (eine sogenannte Fließkommazahl, Float oder Double bzw. float oder double) sein kann und die dritte eine Zeichenkette. Zudem ist es möglich, jeder Eigenschaft eine besondere Bedeutung zuzuweisen. So könnte man die Höhe der Klageforderung und die Höhe des Erfolgs der Klageforderung in ein Array oder eine Liste mit der Länge 2 speichern. Der Index 0 wäre dann die Forderungshöhe und der Index 1 die Erfolgshöhe. Das müsste man sich dann nur merken. Wenn ein weiterer Programmierer den Programmcode verstehen muss, weil er das Team verstärkt, müsste man es ihm erklären. Besser ist es in so einem Fall, dass die Einzelelemente bestimmte Bedeutungen haben, ein Objekt mit Eigenschaften zu entwerfen, die man dann benennt. So könnte man eine Klasse Forderung erstellen, die die Eigenschaften wert und erfolg hat. Dann ist für jeden anderen die Bedeutung direkt ersichtlich, auch für den Programmierer selbst, nach längerer Zeit. Wenn man sich dabei ertappt, ein Programm zu entwerfen, bei dem ein Array immer eine bestimmte Länge haben muss und jedes Element eine bestimmte Bedeutung hat: entwerfen Sie lieber ein Objekt. Der Nachteil ist, dass Schleifen (dazu sogleich) die Elemente nicht ganz so leicht durchlaufen können.

Nehme ich eine Instanz (d.h. ein Exemplar) f vom Typ Forderung, dann ist auch f eine Variable, eine Objektvariable. Darüber kann ich die Eigenschaften f.wert oder f.erfolg abrufen, also mit einem Punkt mit dem Variablennamen verbunden. Auch die Methoden kann ich etwa mit f.getWert() aufrufen.

3. Schleifen

Wiederholung ist die Mutter jedes Studiums, sagt der Lateiner (Horaz). Wiederholungen gefallen nicht, sagt der Dichter (auch Horaz). Horaz hielt Wiederholungen dann wohl für unbeliebt, aber nötig.

„Immer das Gleiche“, sagt der Informatiker.[30] Erinnern Sie sich noch, wie ich oben schrieb: „immer wieder“? Bei der gestaffelten Hilfsaufrechnung bin ich dieselben 3 Schritte immer wieder durchgegangen.

In der Programmierung sagt man zu dem „immer wieder“ einfach „Schleife“. Schleifen unterscheiden sich je nach Bedürfnis und Programmiersprache. Aber sie sind grundsätzlich ähnlich aufgebaut wie die Suche nach einem freien Parkplatz in Köln-Ehrenfeld: so lange immer wieder dieselbe Runde abfahren, solange (englisch „while“) eine bestimmte Bedingung erfüllt ist (alle Parkplätze belegt).

Die einfache „while“-Schleife sieht in Java so aus:

• while (BEDINGUNG) {
• • ANWEISUNG1...;
  • ANWEISUNG2...;
  • ...
• }

Oder:

• do {
• • ANWEISUNG1...;
  • ANWEISUNG2...;
  • ...
• } while (BEDINGUNG)

Der Unterschied ist, dass der Computer bei der ersten Variante die Bedingung vor jedem Durchlauf prüft. Ist die Bedingung von Anfang an nicht erfüllt (bereits vor dem ersten Herumkurven findet man einen Parkplatz), durchläuft er die Schleife kein einziges Mal. Bei der zweiten Variante prüft der Computer die Bedingung immer am Ende eines Schleifendurchlaufs; die Schleife wird also immer mindestens einmal durchlaufen.

Häufiger nutze ich eine Erweiterung dieser Schleife, die die Durchläufe mitzählt. Denn häufig muss man genau fünf Brötchen backen, zwanzig Schäfchen zählen, 100 mal „ROMANI ITE DOMUM“ schreiben usw... Die Anweisung würde dann heißen: für (englisch „for“) 20 Male tue ... Wichtiges Merkmal ist die Zählervariable, die meist i heißt.

Die Syntax in Java, also die vorgeschriebene Befehlsfolge, ist an die Programmiersprache C angelegt und vielleicht nicht unmittelbar einleuchtend. Man behält am besten im Hinterkopf, dass die klassische for-Schleife im Grunde eine while-Schleife mit Zähler ist. „Schreibe 100 mal ‚ROMANI ITE DOMUM‘“,[31] würde als while-Schleife so aussehen:

• int i = 0;
• do {
• • System.out.println("ROMANI ITE DOMUM!");
  • i++;
• } while (i < 100)

Die Zählervariable i wird vor der Schleife mit dem Wert 0 eingeweiht. Zu Beginn der Schleife dann der Spruch an die Palastwand (bzw. den Bildschirm) geschrieben. Dann wird am Ende des Durchlaufs der Zähler um 1 erhöht (inkrementiert: i++) und im Schleifen-Fuß überprüft, ob die 100 Läufe schon durch sind. Drei der fünf Zeilen behandeln also die Zählervariable: initialisieren, inkrementieren, überprüfen. Die for-Schleife kann man sich also als Kurzschreibweise dieses Dreischritts vorstellen, also initialisieren, inkrementieren, Bedingung prüfen:

• for (int i = 0; i < 100; i++) {
• • System.out.println("ROMANI ITE DOMUM!");
• }

Will man die (fiktive) Methode „berechne“ also auf alle Elemente eines Arrays „forderungen“ anwenden, hilft die Methode length(), um die Anzahl der Elemente des Arrays zu erfahren.

• for (int i = 0; i < forderungen.length(); i++) {
• • Forderung forderung = forderungen[i];
  • berechne(forderung);
• }

Moderne Sprachen bieten noch eine erweiterte „for“-Schleife,[32] eine neue Variante der for-Schleife, die vielleicht noch deutlicher macht, worum es geht: Führe die folgenden Anweisungen „für jedes“ Element (englisch „for each“) einer Sammlung durch, etwa für alle Forderungen, also Klageforderung und alle zur Aufrechnung gestellten Gegenforderungen. Diese Schleifen dienen ausdrücklich dazu, alle Elemente einer Sammlung durchzugehen. Eine Zählervariable fehlt hier. Man kann sie „for-each“-Schleife nennen. In Java ist das Zauberwort trotz der Unterschiede für beide Varianten „for“. In der Programmiersprache Swift hat die erweiterte for-Schleife die einfache for-Schleife inzwischen sogar ganz ersetzt.

• for (Forderung forderung : forderungen) {
• • berechne(forderung);
• }

Für jeden Schleifendurchgang nimmt Java ein neues Element aus der Sammlung „forderungen“ und speichert es in der sogenannten Schleifenvariable „forderung“ (englisch loop variable). Diesen deklariert man im Schleifenkopf. Hier fällt die Zählervariable weg, die man in den meisten Fällen nicht vermissen wird. Wenn doch, muss man halt eine „normale“ for-Schleife nehmen. Java übernimmt es selbst, die Sammlung durchzugehen und das jeweilige Element als Schleifenvariable zur Verfügung zu stellen. Im Hintergrund arbeitet ein sogenannter „Iterator“.

4. Immer diese Entscheidungen: if/then/else

Nur sehr wenige Programme sollen völlig unkontrolliert vor sich hin rechnen. Ein Programm zur vorläufigen Vollstreckbarkeit sollte z.B. eine andere Entscheidung vorschlagen, wenn der Streitwert über oder bis 600 EUR liegt. Programmiersprachen halten daher Elemente bereit, mit denen man den Programmablauf steuern kann. Man nennt sie Kontrollstrukturen.[33]

Wenn-Dann-Gedankengänge sind sowohl für die Informatik, wie auch für Rechtsanwendung typisch.[34] Viele Rechtssätze beruhen auf der Vorstellung, dass ihre Rechtswirkung gerade dann eintritt, wenn ihre Voraussetzungen vorliegen.[35] Ich verweise nur auf die o.g. Überlegungen zur vorläufigen Vollstreckbarkeit: wenn das Urteil nicht mit einem Rechtsmittel angegeriffen werden kann, dann richtet sich die vorläufige Vollstreckbarkeit nach § 708, § 713 ZPO. Wenn in der Hauptsache nicht mehr als 1250 EUR vollstreckbar sind, dann richtet sich die vorläufige Vollstreckbarkeit nach § 708 Nr.11, § 711 ZPO. Ansonsten kann das Gericht die vorläufige Vollstreckbarkeit nur gegen Sicherheitsleistung anordnen, § 709 ZPO.

In der abstrakt immer noch an die englische Sprache angelehnte Programmiersprache Java dient das Schlüsselwort if für solche Kontrollen:

• if (*bedingung*) {
• • *Anweisungsblock*
• }

Wenn der „Anweisungsblock“ nur aus einem einzelnen Befehl besteht, kann man die geschweiften Klammern {} weglassen.

Die bedingung ist dabei ein so genannter Wahrheitswert oder Boole’scher Wert. Der Typ heißt in Java boolean und kannn nur die Werte „true“ oder „false“ annehmen. Zum Beispiel ist das Ergebnis der Prüfung zahl < 1250 ein Wahrheitswert: der Wert der Variable zahl ist entweder kleiner als 1250 (true) oder nicht (false). Und wollen Sie etwa prüfen, ob zahl den Wert 0 hat, nutzen Sie den Operator ==, schreiben also zahl == 00. Weitere Vergleichsoperatoren sind > (größer als), <= (kleiner oder gleich, mathematisch ≤), >= (größer oder gleich, mathematisch ≥) und != (ungleich, mathematisch ≠). Der Operator instanceof gibt zurück, ob eine Variable das Exemplar einer bestimmten Klasse ist: Also if (af instanceof Forderung) ... oder if (s instanceof String) .... Zudem können auch Methoden den Rückgabewert boolean haben.

Und sonst? Wenn der Computer dann (und nur dann), wenn die Bedingung nicht zutrifft, etwas bestimmtes ausführen soll, kann man ihm das mit dem Schlüsselwort else („sonst“) mitteilen. Wenn in der Hauptsache nicht mehr als 1250 EUR zu vollstrecken sind, nimm §§ 708, 711, sonst nimm § 709 ZPO. Unterstellt, ich habe mir eine Methode geschrieben, die den vollstreckbaren Betrag in der Hauptsache als Parameter vom Typ long erhält: hauptsache:

• if (hauptsache <= 1250) {
• • // Anweisungen zu §§ 708, 711 ZPO
• } else {
• • // Anweisungen zu § 709 ZPO
• }

Die Zeichen // leiten Kommentare ein: Java ignoriert jeglichen Text danach bis zum Ende der Zeile.

Nein, aber... Befehle, die Java ausführen soll, wenn zwar die erste Bedingung nicht zutrifft, aber eine andere, lassen sich mit einem „else if“ (wenn ansonsten) abfragen: Wenn das Urteil offensichtlich nicht mit einem Rechtsmittel angreifbar ist, nimm §§ 708, 713 ZPO, wenn ansonsten in der Hauptsache nicht mehr als 1250 EUR vollstreckbar sind, nimm §§ 708, 711 ZPO, sonst nimm § 709 ZPO.

• if ( unanfechtbar() ) {
• • //Anweisungen zu §§ 708, 713 ZPO
• } else if (hauptsache <= 1250) {
• • // Anweisungen zu §§ 708, 711 ZPO
• } else {
• • // Anweisungen zu § 709 ZPO
• }

Sie haben es sicherlich gemerkt: die zweite Bedingung, die zu § 708 Nr. 11 ZPO führt, ist unvollständig formuliert. Eigentlich müsste sie lauten: wenn in der Hauptsache nicht mehr als 1250 EUR vollstreckbar sind ODER nur Kosten vollstreckbar sind UND diese 1500 EUR nicht übersteigen.

Die Wörter, die ich da hervorhebe, nennt man logische Operatoren. Diese Operatoren haben eine schärfer abgegrenzte Bedeutung als in der alltäglichen Sprache. Sie verbinden Wahrheitswerte in klar definierter Weise.

bedingung1 ODER bedingung2 liefert „true“ zurück, wenn auch nur eine der beiden Bedingungen „true“ ist. Nur, wenn beide Bedingungen „false“ sind, wird auch das Ergebnis „false“. Es ist sozusagen ein „und/oder“ bzw. „inklusive ODER“. In Java schreibt es sich „||“. Das sind nicht zwei große „I“, sondern zweimal ein sogenanntes „Pipe“ („Röhre“). Auf PCs mit Windows oder Linux erreicht man es mit der Kombination AltGr „<“, auf Macs mit der Alt+7.

Dazu folgt ein Entscheidungsdiagramm, bei dem horizontal die Werte für bedingung1 stehen und vertikal die Werte für bedingung2:

||	false	true
false	(false || false) = false;	(false || true) = true;
true	(true || false) = true;	(true || true) = true.

(false || false) = false;

(true || false) = true;

bedingung1 UND bedingung2 liefert „true“ hingegen nur dann zurück, wenn beide Bedingungen „true“ sind. Umgekehrt reicht eine unwahre Bedingung, damit das Ergebnis „false“ wird. In Java schreibt man diesen Operator als „&&“, also als doppeltes „kaufmännisches und“.

&&	false	true
false	(false && false) = false;	(false && true) = false;
true	(true && false) = false;	(true && true) = true.

(false && false) = false;

(true && false) = false;

Nun erweitere ich mein Beispiel von eben: Meine Methode von eben erhält jetzt vollstreckbaren Betrag in der Hauptsache und in den Kosten jeweils als Parameter vom Typ long: hauptsache und kosten. Die Notwendigkeit einer Sicherheitsleistung nach § 709 ZPO in Abgrenzung zu §§ 708 Nr. 11, 711 ZPO im „else if (*bedingung2*)“-Zweig würde wie folgt prüfen, ob mehr als 1250 EUR in der Hauptsache vollstreckbar sind oder die Grenze von 1500 EUR in den vollstreckbaren Kosten überschritten ist:

• if ( unanfechtbar() ) {
• • //dat kriegen mer später
• } else if (hauptsache > 1250 || (hauptsache == 0 && kosten > 1500)) {
• • // Anweisungen zu § 709 ZPO
• }

Zu dem ersten „if“-Zweig komme ich gleich noch zurück.

Wenn man UND und ODER in einer einzigen Abfrage mischt, sollte man mit Klammern arbeiten, um keine unerwünschten Ergebnisse zu bekommen. Warum? Grundsätzlich wertet Java die Wahrheitswerte von links nach rechts aus. Aber: Java beachtet dabei eine Rangfolge der Operatoren. Was ist eine Rangfolge? Ähnlich wie die Regel „Punktrechnung vor Strichrechnung“ haben einige Operationen in Java sozusagen die „Vorfahrt“ vor anderen. „Punkt vor Strich“ bedeutet in Java, dass die Operatoren * und / einen höheren Rang als die Operatoren + und - haben. Bei der Rechnung

x = a + b * c;

führt Java zuerst die Berechnung „b * c“ aus und dann die Addition. Will man, dass Java zuerst die Addition und dann die Multiplikation berechnet, muss man Klammern setzen:

x = (a + b) * c;

Ein solches Rangverhältnis gibt es auch zwischen && und ||. Ohne die Klammern um (hauptsache == 0 && kosten > 1500) würde Java zwar trotzdem die Bedingungen in der Klammer zusammen prüfen, da ähnlich „Punkt vor Strich“ der &&-Operator einen höheren Rang als der ||-Operator hat. Es gibt bestimmt Programmierer, die das auswendig wissen, ich zähle nicht dazu und musste es nachschlagen.[36] Zur besseren Lesbarkeit empfehle ich daher die Klammern.

Als dritten Operator sollte man den Umkehrungsoperator „NICHT“ kennen, der den Wahrheitswert einer Bedingung umkehrt: NICHT bedingung. Aus „true“ wird „false“ und umgekehrt. In Java schreibt der Operator sich durch ein vorangestelltes „!“. „!true“ ist also false.

Habe ich etwa eine Methode „anfechtbar()“ mit dem Rückgabetyp boolean geschrieben, die prüft, ob das Urteil bei dem gegebenen Streitwerte und dem jeweiligen Unterliegen der Parteien einem Rechtsmittel unterliegt, so würde der erste „if“-Zweig z.B. lauten:

• if (!anfechtbar()){
• • //Anweisungen zu §§ 708, 713
• }

Also im Zusammenhang:

• if (!anfechtbar()){
• • //Anweisungen zu §§ 708, 713 ZPO
• } else if (hauptsache > 1250 || (hauptsache == 0 && kosten > 1500)) {
• • // Anweisungen zu § 709 ZPO
• } else {
• • // Anweisungen zu §§ 708, 711 ZPO
• }

V. Umsetzung in ein Programm

Darauf läuft es natürlich hinaus, dass ich zu den vorgestellten Techniken und Überlegungen noch die Umsetzung in Programmcode liefere, und zwar zunächst die Klassendiagramme (vgl. oben IV.1.c) der für die Hilfsaufrechnung nötigen Klassen Forderung, KlageForderung und AufrechnungsForderung (1.), dann den Programmcode der eigentlichen Klasse zur Berechnung der Hilfsaufrechnung AngriffsVerteidigungsmittelStaffelung (2.) und zuletzt das Klassendiagramm der Klasse Vollstreckbarkeit mit dem Programmcode der Methode, die §§ 709 und 708 Nr. 11 ZPO abgrenzt (3.).

Die eigentliche Berechnung werde ich als Programmcode wiedergeben. Daneben brauche ich aber auch Klassen, die bestimmte Daten repräsentieren, vor allem Klageforderungen und Gegenforderungen. Diese wiederzugeben, würde den Text aufblähen und Sie langweilen. Deshalb fasse ich diese Klassen als Klassendiagramm zusammen.

1. Forderung, Klageforderung, Aufrechnungsforderung

Um die Streitwerterhöhung und die Kostenquoten bei der Hilfsaufrechnung zu berechnen, brauche ich die Elternklasse Forderung und die davon abgeleiteten Kindklassen KlageForderung und AufrechnungsForderung.

• Forderung
• •   gegenforderung: boolean
  •   wert: double
  •   erfolg: double
• • + Forderung()
  • + getWert: double
  • + setWert(wert: double)
  • + getErfolg(): double
  • + setErfolg(erfolg: double)
  • + isGegenforderung(): boolean
  • + setGegenforderung(gegenforderung: boolean)

• KlageForderung (erbt von Forderung)
• •   wirtschaftlichIdentisch: boolean
• • + KlageForderung()
  • + isWirtschaftlichIdentisch: boolean
  • + setWirtschaftlichIdentisch(wirtschaftlichIdentisch: boolean)

• AufrechnungsForderung (erbt von Forderung)
• •   effektiverWert: double
  •   effektiverErfolg: double
• • + AufrechnungsForderung()
  • + getEffektiverWert(): double
  • + setEffektiverWert(effektiverWert: double)
  • + setzeEffektivenWertZurueck()
  • + getEffektiverErfolg(): double
  • + setEffektiverErfolg(effektiverErfolg: double)
  • + setzeEffektivenErfolgZurueck()

2. Hilfsaufrechnung: Hauptsache-, Kosten- und Streitwertentscheidung

• Angriffserfolg
• •   erfolg: double
  •   volleForderung: double
• • + Angriffserfolg(volleForderung: double, erfolg: double)
  • + getVolleForderung(): double
  • + getErfolg(): double

• public class AngriffsVerteidigungsmittelStaffelung {
• • private Angriffserfolg hauptsache = null;
  • private double[] kosten = null;
  • private double streitwert = -1.0;
  • private VollstreckbarkeitsListe vollstreckbarkeitsListe;

• private Angriffserfolg berechneHauptsache() {
• • double verbleibend = 0;
  • double volleForderung = 0;
  • • for (Forderung f : staffelung.forderungen) {
    • • if (f instanceof KlageForderung) {
      • • //Das Obsiegen bzgl. Klageforderungen
        • // wird zusammengerechnet
        • verbleibend += f.getErfolg();
        • // Auch der Wert, sofern nicht
        • // wirtschaftlich identisch
        • if (!((KlageForderung) f).isWirtschaftlichIdentisch())
        • • volleForderung += f.getWert();
      • } else if (f instanceof AufrechnungsForderung) {
      • • // Aufrechnungen werden abgezogen,
        • // soweit noch etwas übrig ist.
        • AufrechnungsForderung af = (AufrechnungsForderung) f;
        • // Dabei wird abgefragt, ob der
        • // effektive Erfolg schon berechnet wurde (dann ist
        • // getEffektiverErfolg nicht mehr < 0)
        • if (af.getEffektiverErfolg() < 0) {
        • • verbleibend -= berechneEffektivenErfolg(af, verbleibend);
        • } else {
        • • verbleibend -= af.getEffektiverErfolg();
        • }
      • }
    • }
  • return new Angriffserfolg(volleForderung, verbleibend);
• }

• private double berechneStreitwert() {
• • double wert = 0.0;
  • double verbleibend = 0.0;
  • for (Forderung f : staffelung.forderungen) {
  • • if (f instanceof KlageForderung) {
    • • // Das Obsiegen bzgl. Klageforderungen wird zusammengerechnet
      • verbleibend += f.getErfolg();
      • // Auch der Wert, sofern nicht wirtschaftlich identisch
      • if (!((KlageForderung) f).isWirtschaftlichIdentisch())
        • wert += f.getWert();
    • } else if (f instanceof AufrechnungsForderung) {
    • • // Aufrechnungen werden abgezogen, soweit noch etwas übrig ist.
      • AufrechnungsForderung af = (AufrechnungsForderung) f;
      • // Dabei wird abgefragt, ob der effektive Wert und der effektive
      • // Erfolg schon berechnet wurden (dann sind getEffektiverWert bzw.
      • // getEffektiverErfolg nicht mehr < 0)
      • if (af.getEffektiverWert() < 0) {
        • wert += berechneEffektivenWert(af, verbleibend)
      • } else {
        • wert += af.getEffektiverWert();
      • }
      • if (af.getEffektiverErfolg() < 0) {
        • verbleibend -= berechneEffektivenErfolg(af, verbleibend)
      • } else {
        • verbleibend -= af.getEffektiverErfolg();
      • }
    • }
  • }
  • return wert;
• }

• private double[] berechneKostenverteilung() {
  • // Streitwert nur berechnen, wenn nicht schon
  • // geschehen (vor erster Berechnung ist er < 0).
  • if (streitwert < 0) {
    • streitwert = berechneStreitwert();
  • }
  • double klaegerunterliegen = 0.0;
  • double beklagtenunterliegen = 0.0;
  • double verbleibend = 0.0;
  • for (Forderung f : staffelung.forderungen) {
    • if (f instanceof KlageForderung) {
      • // Das Obsiegen bzgl. Klageforderungen wird zusammengerechnet
      • verbleibend += f.getErfolg();
      • // Das Unterliegen bemisst sich hier allein nach Wert und Erfolg.
      • klaegerunterliegen += f.getWert() - f.getErfolg();
      • beklagtenunterliegen += f.getErfolg();
    • } else if (f instanceof AufrechnungsForderung) {
      • // Aufrechnungen werden abgezogen, soweit noch etwas übrig ist.
      • AufrechnungsForderung af = (AufrechnungsForderung) f;
      • // Das Unterliegen bemisst sich hier nach effektivem Wert
      • // und effektivem Erfolg.
      • // Dabei wird abgefragt, ob der effektive Erfolg schon
      • // berechnet wurde
      • // (dann ist getEffektiverErfolg nicht mehr < 0)
      • double effektiverErfolg;
      • double effektiverWert;
      • if (af.getEffektiverErfolg() < 0) {
        • effektiverErfolg = berechneEffektivenErfolg(af, verbleibend);
      • } else {
        • effektiverErfolg = af.getEffektiverErfolg();
      • }
      • if (af.getEffektiverWert() < 0) {
        • effektiverWert = berechneEffektivenWert(af, verbleibend);
      • } else {
        • effektiverWert = af.getEffektiverWert();
      • }
      • verbleibend -= effektiverErfolg;
      • klaegerunterliegen += effektiverErfolg;
      • beklagtenunterliegen += effektiverWert - effektiverErfolg;
    • }
  • }
  • return new double[] { klaegerunterliegen / streitwert, beklagtenunterliegen / streitwert };
• }

• public double berechneEffektivenWert(AufrechnungsForderung aufrechnung, double verbliebeneKlageforderung) {
• // Berechne die Schnittmenge, soweit sich Klageforderung
• // und Aufrechnung decken und speichere sie
• // als „effektiven Wert“ zur AufrechnungsForderung
• aufrechnung.setEffektiverWert(Math.min(verbliebeneKlageforderung, aufrechnung.getWert()));
• // Dann gibt ihn zurück
• return aufrechnung.getEffektiverWert();
• }

• public double berechneEffektivenErfolg(AufrechnungsForderung aufrechnung, double verbliebeneKlageforderung) {
• • // Berechne die Schnittmenge, soweit sich Klageforderung
  • // und Aufrechnung decken und speichere sie
  • // als „effektiven Erfolg“ zur AufrechnungsForderung
  • aufrechnung.setEffektiverErfolg(Math.min(verbliebeneKlageforderung, aufrechnung.getErfolg()));
  • // Dann gibt ihn zurück
  • return aufrechnung.getEffektiverErfolg();
• }

• private VollstreckbarkeitsListe berechneVollstreckbarkeit() {
  • VollstreckbarkeitsListe vollstreckbarkeitsListe =
  • new VollstreckbarkeitsListe();
  • Vollstreckbarkeit unanfechtbarkeit =
  • pruefeUnanfechtbarkeit();
  • vollstreckbarkeitsListe.add(unanfechtbarkeit);
  • if (unanfechtbarkeit.isB713())
    • return vollstreckbarkeitsListe;
  • // Kostenquoten nur berechnen, wenn nicht schon geschehen
  • // (vor erster Berechnung sind sie null).
  • if (kosten == null)
    • kosten = berechneKostenverteilung();
  • // Beim Kläger hinsichtlich Hauptsache einsetzen, was von seiner
  • // Hauptklageforderung begründet ist (hauptsache[1]) und hinsichtlich der
  • // Kosten die üblichen Klägerkosten, soweit sie der Beklagte tragen muss
  • // (kosten[1])
  • vollstreckbarkeitsListe.add(Vollstreckbarkeit
    • .pruefeSicherheitsleistung((long) hauptsache.getErfolg(),
      • (long) (HilfsmittelKlasse.errechneKostenKlaeger(streitwert)
      • * kosten[1])));
  • // Beim Beklagten hinsichtlich Hauptsache 0 einsetzen und hinsichtlich der Kosten
  • // die üblichen Klägerkosten, soweit sie der Kläger tragen muss (kosten[0])
  • vollstreckbarkeitsListe.add(Vollstreckbarkeit.pruefeSicherheitsleistung(0L,
    • (HilfsmittelKlasse.errechneKostenBeklagter(streitwert)
    • * kosten[0])));
  • return vollstreckbarkeitsListe;
• }

• private Vollstreckbarkeit pruefeUnanfechtbarkeit() {
  • Vollstreckbarkeit unanfechtbarkeit = new Vollstreckbarkeit();
  • // Streitwert nur berechnen, wenn nicht schon geschehen (vor
  • // erster Berechnung ist er < 0).
  • if (streitwert < 0)
    • streitwert = berechneStreitwert();
  • if (streitwert <= HilfsmittelKlasse.BERUFUNGS_GRENZE) {
    • unanfechtbarkeit = new Vollstreckbarkeit(true, false, false, false, true);
  • } else if (streitwert <= HilfsmittelKlasse.BERUFUNGS_GRENZE * 2) {
    • // Hauptsache nur berechnen, wenn nicht schon geschehen
    • if (hauptsache == null)
    • hauptsache = berechneHauptsache();
    • // Wie ist der Kläger beschwert? Das, was von seiner Klage nicht
    • // durchgedrungen ist.
    • double klaeger = hauptsache.getVolleForderung() - hauptsache.getErfolg();
    • // Wie ist der Beklagte beschwert: Das wozu er verurteilt wurde ...
    • double beklagter = hauptsache.getErfolg();
    • // ... und das, was er an Aufrechnungsforderungen „verbraten“ hat, ob mit
    • // oder ohne Erfolg.
    • for (Forderung f : staffelung.forderungen) {
      • if (f instanceof AufrechnungsForderung)
      • beklagter += ((AufrechnungsForderung) f).getEffektiverWert();
      • }
    • if (klaeger <= HilfsmittelKlasse.BERUFUNGS_GRENZE
      • && beklagter <= HilfsmittelKlasse.BERUFUNGS_GRENZE) {
      • unanfechtbarkeit = new Vollstreckbarkeit(true, false, false, false, true);
      • }
    • }
  • return unanfechtbarkeit;
• }

• }

3. Vollstreckbarkeit

Die Klasse Vollstreckbarkeit stelle ich mit einer Besonderheit dar: Erst zeige ich Ihnen das Klassendiagramm, denn diese Klasse dient vor allem der Datenhaltung. Eine Methode stelle ich aber im Anschluss ausführlich dar, denn sie enthält den Programmcode, um §§ 709 von 708 Nr. 11 ZPO zu trennen. Sie gibt hier eine Instanz der Klasse zurück, deren Werte sie je nach Prüfungsergebnis setzt. Sie werden sehen, dass die Variablennamen den Paragraphen entsprechen, also steht b713 z.B. dafür, dass sich die Vollstreckbarkeit nach § 713 ZPO richtet. Der Vollständigkeit halber stelle ich zum Schluss noch die Klasse VollstreckbarkeitsListe als Klassendiagramm dar.

• Vollstreckbarkeit
• •   b708: boolean
  •   b709s1: boolean
  •   b709s2: boolean
  •   b711: boolean
  •   b713: boolean
• • + Vollstreckbarkeit()
  • + Vollstreckbarkeit(b708: boolean, b709s1: boolean, b709s2: boolean, b711: boolean, b713: boolean)
  • + pruefeSicherheitsleistung(hauptsache: long, kosten: long): Vollstreckbarkeit
  • + isB708(): boolean
  • + setB708(b708: boolean)
  • + isB709s1(): boolean
  • + setB709s1(b709s1: boolean)
  • + isB709s2(): boolean
  • + setB709s2(b709s2: boolean)
  • + isB711(): boolean
  • + setB711(b711: boolean)
  • + isB713(): boolean
  • + setB713(b713: boolean)
  • + hatEintraege(): boolean
  • + checkePlausisbilitaeten(): boolean

• public class Vollstreckbarkeit {

• public static Vollstreckbarkeit pruefeSicherheitsleistung(long hauptsache, long kosten){
• • if (hauptsache == 0 && kosten == 0) {
  • • // Dann alles false, leeres Objekt zurückgeben
    • return new Vollstreckbarkeit();
  • } else if (hauptsache > 1250 || (hauptsache == 0 && kosten > 1500)) {
  • • // § 709 ZPO
    • return new Vollstreckbarkeit(false, true, true, false, false);
  • } else {
  • • // § 708, 709 S. 2, 711 ZPO
    • return new Vollstreckbarkeit(true, false, true, true, false);
  • }
• }

• }

• VollstreckbarkeitsListe (erweitert ArrayList)
• •   (keine Eigenschaften)
• • + sindAlle708iVm713(): boolean
  • + sindAlle708iVm711(): boolean
  • + sindAlle709(): boolean
  • + add(element: Vollstreckbarkeit): boolean

VI. Zusammenfassung

Ich hoffe, Sie können mir nun zustimmen, dass Juristen und Programmierer durchaus ähnlich denken. Sei es, dass sie Denkschritte verschachelten, einige Schritte immer wieder ausführen und Wenn-Dann-Konstruktionen lieben. Vielleicht stimmen Sie mir nun auch darin zu, dass viele juristische Denkschritte sich gut als Programm umsetzen lassen, vor allem die rechenlastigen. Vielleicht haben Sie sogar Lust bekommen, Ihr meist geliebtes juristisches Problem als Programm umzusetzen. Die Bereiche der ZPO, die ich hier vorstelle, sind auch Teil eines Java-Programms, das Sie sich unter https://www.kostentenor.de herunterladen können.

Fußnoten

* Fortsetzung des Beitrags in jurPC Web-Dok 189/2014. Dr. iur. Peter Felix Schuster ist Richter am Landgericht in Düsseldorf und derzeit abgeordnet zum Ministerium der Justiz des Landes Nordrhein-Westfalen. Der Verfasser dankt Herrn Prof. Dr. Maximilian Herberger für die Anregung zu diesem Artikel sowie seiner Frau, Ri.inAG Dr. Agnes Schuster, und RiLG Dr. Daniel Lübcke für wertvolle Hinweise und Anregungen. Der Artikel gibt nur die persönliche Meinung des Verfassers wieder.

[1] Musielak, GK BGB, Rn 19-20.

[2] Vgl. Bhargava, Algorithmen kapieren, 2019, S. 19; Anschaulich nennt Herberger (jurPC 1989, S. 2—7, S. 6) den Algorithmus: einen „Weg vom ‚Problem‘ zur ‚Lösung‘“.

[3] Vgl. Boockmeyer u.a., Fit fürs Studium Informatik, 2017, S. 28.

[4] Vgl. de.wikipedia.org/wiki/Informatik, Abruf vom 02.08.2020; Herberger (a.a.O., S. 4) fasst den Arbeitsbereich zusammen als „Datenstrukturen und deren Verarbeitung“.

[5] Vgl. en.wikipedia.org/wiki/Computer_science, Abruf vom 02.08.2020.

[6] Vgl. de.Wikipedia, ebenda.

[7] Vgl. de.wikipedia.org, ebda.

[8] Vgl. de.wikipedia.org/wiki/Ablaufdiagramm, Abruf vom 02.08.2020.

[9] Vgl. de.wikipedia.org/wiki/Programmablaufplan, Abruf vom 02.08.2020.

[10] Vgl. de.wikipedia.org/wiki/Programmablaufplan, Abruf vom 02.08.2020.

[11] Vgl. Anders/Gehle, Das Assessorexamen im Zivilrecht (im Folgenden: Anders/Gehle), 12. Auflage, Rn. G-15.

[12] Vgl. Vgl. Anders/Gehle, Rn. G-16.

[13] Vgl. etwa LG Lübeck, Beschl. vom 07.07.2015, Az. 7 T 335/15: Klageforderung von 880,60 EUR, Aufrechnung mit 5.148,28 EUR, Streitwert 1.761,20 EUR (zweimal 880,60 EUR).

[14] Nach Anders/Gehle, G-22.

[15] Vgl. dazu etwa OLG Düsseldorf, Beschl. vom 21.08.2009, Az. 5 W 58/08, III.2.c: Streitwert 23.000,00 EUR bei einer Klagesumme von 11.000,00 EUR; auch OLG München, Beschl. vom 11.12.2017, Az. 9 W 1897/17, Rn. 5.

[16] Nach Anders/Gehle, G-22, G-23.

[17] Vgl. Oberheim, Zivilprozessrecht für Referendare, 11. Auflage, Rn. 546.

[18] Vgl. Oberheim, Rn. 546.

[19] Oberheim, Rn. 549.

[20] Vgl. Oberheim, Rn. 552.

[21] Vgl. BGH, Beschl. vom 09.07.2009, Az. IX ZR 135/08; Oberheim, Rn. 1219; Eicker, JA 2020, S. 48, 55; Zöller/G. Vollkommer, ZPO, § 322, Rn. 17; hinsichtlich vollständigen Nichtbestehens der Aufrechnungsforderung BGH, Urteil vom 01.06.1967, Az. II ZR 130/65, Rn. 8 bei juris; Rosenberg/Schwab/Gottwald, Zivilprozessrecht, § 135 Rn. 33.

[22] Vgl. Thomas/Putzo/Reichold, ZPO, 37. Aufl., 2016, § 511, Rn16.

[23] Lat. imperare = befehlen, vgl. de.wikipedia.org/wiki/Imperative_Programmierung, Abruf vom 02.08.2020.

[24] Vgl. de.wikipedia.org/wiki/Prozedurale_Programmierung, Abruf vom 02.08.2020.

[25] Vgl. Wikipedia a.a.O.

[26] Vgl. Ullenboom, Java ist auch eine Insel, Kap. 3.3.2.

[27] Vgl. Ullenboom, Java ist auch eine Insel, Kap. 3.8.

[28] Vgl. Broockmeyer u.a., Fit fürs Studium Informatik, Kap. 3.

[29] Vgl. Ullenboom, Java ist auch eine Insel, Kap. 3.8.

[30] Vgl. Ullenboom, Java ist auch eine Insel, Kap. 2.6.

[31] Wer den Film „Das Leben des Brian“ nicht kennt, sei an dieser Stelle eingeladen, ihn sich anzusehen.

[32] Vgl. Ullenboom, Java ist auch eine Insel, Kap. 2.6.

[33] Vgl. Habelitz, Programmieren lernen mit Java, 1. Aufl. 2012, Kap. 3 Einleitung.

[34] Vgl. auch Schwintowski, Rethinking Law 2020 (1), 54ff., Digitalisierung des rechtlichen Subsumtionsprozesses: „Rechtssätze haben eine spezifische Wenn-Dann-Architektur“, dort für § 433 BGB; L. Philipps, „Rechtssätze in einem Expertensystem - am Beispiel der Willenserklärung eines Minderjährigen“, in: Fiedler et.al., Automatisierung im Recht, 1986, S. 96—114, 98: „Der Wenn-Dann-Satz ist die typische Form Naturgesetzes und nach vorherrschender Meinung auch die des Rechtssatzes“.

[35] Gmür, Rechtswirkungsdenken in der Privatrechtsgeschichte, Bern, 1981, Seiten 26, 66.

[36] Ullenboom, gibt in Java ist auch eine Insel, Kap. 2.4.9, eine vollständige Rangliste, streitet aber ebenfalls ab, diese auswendig zu kennen.