Java: Wie kann ich das überschreiben einer Methode von einer Klasse dynamisch (Klasse ist schließlich NICHT im classpath)?

Um es kennen zu lernen, die Klasse steht (zur Laufzeit)

Setzen Sie den Einsatz in einem try-block ...

Wenn es nicht der Fall ist, überspringen Sie die ganze Sache

... und verlassen der catch-block leer ist (code smell?!).

Wie verwalte ich eine Methode überschreiben einer dynamisch geladenen Klasse

Tun Sie es einfach und stellen Sie sicher, dass der compile-time-Abhängigkeit ist zufrieden. Mischen Sie die Dinge hier. Das überschreiben erfolgt zur compile-Zeit, während die Klasse be ist eine runtime-Ding.

Für die Vollständigkeit, jede Klasse, die Sie schreiben, die dynamisch geladen werden von der Laufzeitumgebung, wenn es erforderlich ist.

Sodass Ihr code kann wie folgt Aussehen:

public static void setNimbusUI(final IMethod<UIDefaults> method)
    throws UnsupportedLookAndFeelException {

    try {
        //NimbusLookAndFeel may be now available
        UIManager.setLookAndFeel(new NimbusLookAndFeel() {

            @Override
            public UIDefaults getDefaults() {
                final UIDefaults defaults = super.getDefaults();
                method.perform(defaults);
                return defaults;
            }

        });
   } catch (NoClassDefFoundError e) {
       throw new UnsupportedLookAndFeelException(e);
   }
}

InformationsquelleAutor whiskeysierra

Der folgende code sollte dein problem lösen. Die Main Klasse simuliert Ihre main-Klasse. Klasse A simuliert die Basisklasse, die Sie erweitern möchten (und Sie keine Kontrolle haben). Klasse B ist die abgeleitete Klasse der Klasse A. Schnittstelle C simuliert "function pointer" - Funktion, die in Java nicht haben. Mal sehen, der erste code...

Folgenden ist Klasse A, die Klasse, die Sie erweitern möchten, aber keine Kontrolle haben:

/* src/packageA/A.java */

package packageA;

public class A {
    public A() {
    }

    public void doSomething(String s) {
        System.out.println("This is from packageA.A: " + s);
    }
}

Folgenden ist Klasse B die dummy-abgeleitete Klasse. Beachten Sie, dass, da es sich A es importieren muss packageA.A und Klasse A muss bei der Kompilierung der Klasse B. Ein Konstruktor mit dem parameter-C ist wichtig, aber die Umsetzung-Schnittstelle C ist optional. Wenn B implementiert C erhalten Sie die Bequemlichkeit zum Aufruf der Methode(N) auf eine Instanz von B direkt (ohne Reflexion). In B.doSomething() Aufruf super.doSomething() ist optional und hängt davon ab, ob Sie so wollen, aber das aufrufen c.doSomething() wesentlich ist (siehe unten):

/* src/packageB/B.java */

package packageB;

import packageA.A;
import packageC.C;

public class B extends A implements C {
    private C c;

    public B(C c) {
        super();
        this.c = c;
    }

    @Override
    public void doSomething(String s) {
        super.doSomething(s);
        c.doSomething(s);
    }
}

Folgenden ist die knifflige Schnittstelle C. Setzen Sie einfach alle Methoden, die Sie überschreiben möchten in dieser Schnittstelle:

/* src/packageC/C.java */

package packageC;

public interface C {
    public void doSomething(String s);
}

Folgenden ist die main-Klasse:

/* src/Main.java */

import packageC.C;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Main {
    public static void main(String[] args) {
        doSomethingWithB("Hello");
    }

    public static void doSomethingWithB(final String t) {
        Class classB = null;
        try {
            Class classA = Class.forName("packageA.A");
            classB = Class.forName("packageB.B");
        } catch (ClassNotFoundException e) {
            System.out.println("packageA.A not found. Go without it!");
        }

        Constructor constructorB = null;
        if (classB != null) {
            try {
                constructorB = classB.getConstructor(C.class);
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        }

        C objectB = null;
        if (constructorB != null) {
            try {
                objectB = (C) constructorB.newInstance(new C() {
                    public void doSomething(String s) {
                        System.out.println("This is from anonymous inner class: " + t);
                    }
                });
            } catch (ClassCastException e) {
                throw new RuntimeException(e);
            } catch (InstantiationException e) {
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }
        }

        if (objectB != null) {
            objectB.doSomething("World");
        }
    }
}

Warum ist es kompilieren und ausführen?

Sie können sehen, dass in der Main Klasse, nur packageC.C importiert, und es gibt keinen Verweis auf packageA.A oder packageB.B. Wenn es irgendeine, der class-loader wird eine exception werfen Sie auf Plattformen, die nicht packageA.A wenn er versucht zu laden.

Wie funktioniert es?

In der ersten Class.forName() Sie prüft, ob Klasse A ist auf der Plattform zur Verfügung. Wenn es so ist, Fragen Sie den class loader der class B, und speichern Sie die resultierende Class Objekt in classB. Ansonsten ClassNotFoundException ausgelöst durch Class.forName(), und das Programm geht auch ohne Klasse A.

Dann, wenn classB nicht null ist, bekommt der Konstruktor der Klasse B akzeptiert eine einzelne C - Objekt als parameter. Speichern Sie die Constructor Objekt in constructorB.

Dann, wenn constructorB ist nicht null, rufen Sie constructorB.newInstance() zu erstellen B Objekt. Da gibt es eine C - Objekt als parameter, können Sie erstellen Sie eine anonyme Klasse implementiert das interface C und übergeben Sie die Instanz, die als parameter-Wert. Das ist genau wie das, was Sie tun, wenn Sie erstellen eine anonyme MouseListener.

(In der Tat, Sie nicht trennen zu müssen die oben try Blöcke. Es wird so getan, klar zu machen, was ich Tue.)

Wenn Sie B implementiert C, können Sie werfen die B Objekt als C Referenz an diese Zeit, und dann können Sie den Aufruf der überschriebenen Methoden direkt (ohne Reflexion).

Was ist, wenn Klasse A Sie nicht "keine parameter-Konstruktor"?

Fügen Sie einfach die erforderlichen Parameter zur Klasse B wie public B(int extraParam, C c), und rufen Sie super(extraParam) statt super(). Bei der Erstellung der constructorB können, fügen Sie auch die zusätzlichen parameter, wie classB.getConstructor(Integer.TYPE, C.class).

Was passiert String s - und String -t?

t verwendet wird, die durch die anonyme Klasse direkt. Wenn objectB.doSomething("World"); genannt wird, "World" ist die s geliefert-Klasse B. Da super können nicht verwendet werden, in der die anonyme Klasse (aus offensichtlichen Gründen), der gesamte code, verwenden super sind platziert in Klasse B.

Was ist, wenn ich reden will super mehrmals verwenden?

Schreiben Sie einfach eine Vorlage in B.doSomething() wie diese:

    @Override
    public void doSomething(String s) {
        super.doSomething1(s);
        c.doSomethingAfter1(s);
        super.doSomething2(s);
        c.doSomethingAfter2(s);
    }

Natürlich, Sie haben zu ändern-Schnittstelle C zu gehören doSomethingAfter1() und doSomethingAfter2().

Wie zu kompilieren und den code auszuführen?

$ mkdir Klassen 
$ 
$ 
$ 
$ javac -cp src -d-Klassen src/Main.java 
$ java -cp classes Main 
pakeTa.Eine nicht gefunden. Ohne Sie gehen! 
$ 
$ 
$ 
$ javac -cp src -d-Klassen src/packageB/B.java 
$ java -cp classes Main 
Dies ist aus pakeTa.A: Welt 
Dies ist von anonyme innere Klasse: Hallo 

Im ersten Lauf der Klasse packageB.B wird nicht kompiliert (da Main.java keine Referenz). In der zweiten Ausführung, die Klasse wird kompiliert, und damit Sie das Ergebnis bekommen, das Sie erwartet.

Helfen Sie passt meine Lösung zu deinem problem, hier ist ein link zu den richtigen Weg, um das Nimbus Look and Feel:

Nimbus Look and Feel

InformationsquelleAutor Siu Ching Pong -Asuka Kenji-

Ähm, können Sie dann nicht die Klasse, die Sie erweitern möchten, in die compile-Zeit "class path", schreiben die Unterklasse als üblich, und zur Laufzeit explizit trigger laden der Unterklasse, und behandeln jede Ausnahme, die ausgelöst durch den linker, der angibt, dass die Oberklasse fehlt?

InformationsquelleAutor meriton