{"id":2370,"date":"2013-09-24T20:09:02","date_gmt":"2013-09-24T18:09:02","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=2370"},"modified":"2013-09-24T20:09:02","modified_gmt":"2013-09-24T18:09:02","slug":"eine-sich-selbst-implementierung","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2013\/09\/eine-sich-selbst-implementierung\/","title":{"rendered":"Eine Sich-Selbst-Implementierung"},"content":{"rendered":"<p><i>Der Zusammenhang zwischen inneren Klassen und \u00e4u\u00dferen Klassen und wie sie sich gegenseitig implementieren k\u00f6nnen.<\/i><\/p>\n<p>Eine Klasse kann entweder von einer Klasse erben oder eine Schnittstelle erweitern. Es ergibt sich ein Sonderfall, wenn wir eine Schnittstelle implementieren, die innerhalb der eigenen Klasse liegt, die die Schnittstelle deklariert. Das sieht etwa so aus:<\/p>\n<pre>class Outer implements Outer.InterfaceInner\n{\n  interface InterfaceInner\n  {\n  void knexDirDeineWelt();\n  }\n\n  public void knexDirDeineWelt()\n  {\n  }\n}<\/pre>\n<p>Prinzipiell spricht erst einmal nichts gegen diese Implementierung. Innere Klassen, wie <b>InterfaceInner<\/b> eine ist, werden auf eine extra Klassendateien abgebildet, da es innerer Klassen beziehungsweise Schnittstellen sowieso nicht f\u00fcr die Laufzeitumgebung gibt. In unserem Fall k\u00f6nnte der Compiler die Datei <i>Outer$InterfaceInner<\/i> erzeugen. Im n\u00e4chsten Schritt w\u00fcrde dann <b>Outer<\/b>diese Schnittstelle erweitern und wie im Beispiel eine Methode \u00fcberschreiben.<\/p>\n<p>So sch\u00f6n dies auch aussieht: Es funktioniert nicht. Fr\u00fche Compiler erlaubten diese Schreibeweise, aber sie f\u00fchrt zu zirkul\u00e4ren Abh\u00e4ngigkeiten. <\/p>\n<pre>cyclic inheritance involving Outer<\/pre>\n<p>Wenn <strong>InterfaceInner<\/strong> zuerst \u00fcbersetzt w\u00fcrde und dann <strong>Outer<\/strong>, w\u00e4re es noch zu verstehen, doch das Problem machen zum Beispiel Deklarationen in der inneren Klasse, die abh\u00e4ngig sind von der \u00c4u\u00dferen. Wir k\u00f6nnten etwa den R\u00fcckgabewert von <b>knexDirDeineWelt()<\/b> \u00e4ndern, dass es ein Outer Objekt zur\u00fcckliefert.<\/p>\n<pre>class Outer implements Outer.InterfaceInner\n{\n  interface InterfaceInner\n  {\n    Outer knexDirDeineWelt();\n  }\n\n  public void knexDirDeineWelt()\n  {\n  }\n}<\/pre>\n<p>Jetzt sehen wir: Ohne <b>InterfaceInner<\/b> kein <b>Outer<\/b>, da dies <b>knexDirDeineWelt()<\/b> vorschreibt und ohne <b>Outer<\/b> kein <b>InterfaceInner<\/b>, da sonst der R\u00fcckgabewert nicht bekannt ist. Mitunter w\u00e4re das Problem noch l\u00f6sbar, aber hier l\u00e4sst der Compiler lieber die Finger von.<\/p>\n<p><b>Innere Klasse vor der \u00e4u\u00dferen<\/b><\/p>\n<p>Dass es nicht unm\u00f6glich ist, eine innere Klasse von der \u00e4u\u00dferen Abzuleiten zeigt folgendes Beispiel:<\/p>\n<pre>interface I\n{\n  void boo();\n  interface J extends I\n  {\n  }\n\n  J foo();\n}<\/pre>\n<p>Es ist problemlos m\u00f6glich, dass die innere Schnittstelle die \u00e4u\u00dfere erweitert. Im Gegensatz zum vorherigen Beispiel ist in diesem Fall die Problematik genau umgekehrt. Es ist auch m\u00f6glich, dass eine innere Klasse eine \u00e4u\u00dfere erweitert.<\/p>\n<pre>class O\n{\n  class I extends O\n  {\n    void bar()\n    {\n    }\n  }\n\n  void bar() { }\n}<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Der Zusammenhang zwischen inneren Klassen und \u00e4u\u00dferen Klassen und wie sie sich gegenseitig implementieren k\u00f6nnen. Eine Klasse kann entweder von einer Klasse erben oder eine Schnittstelle erweitern. Es ergibt sich ein Sonderfall, wenn wir eine Schnittstelle implementieren, die innerhalb der eigenen Klasse liegt, die die Schnittstelle deklariert. Das sieht etwa so aus: class Outer implements [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[1],"tags":[],"class_list":["post-2370","post","type-post","status-publish","format-standard","hentry","category-allgemein"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2370","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=2370"}],"version-history":[{"count":1,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2370\/revisions"}],"predecessor-version":[{"id":2371,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2370\/revisions\/2371"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=2370"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=2370"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=2370"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}