Kann ich überschreiben, eine private Methode in Java?

Private Methoden werden nicht vererbt und kann nicht überschrieben werden, in keiner Weise. Wer Ihnen sagte, Sie es tun können, mit Reflexion war entweder liegend oder über etwas anderes reden.

Allerdings können Sie den Zugriff auf die private Methode getInt welcher Unterklasse aufrufen printInt etwa so:

public void printInt() throws Exception {
    Class<? extends SuperClass> clazz = getClass();
    System.out.println("I am " + clazz + ". The int is " +
                       clazz.getMethod("getInt").invoke(this) );
}

Dies die Wirkung haben wird, die Unterklasse' getInt Methode aufgerufen wird, von der Oberklasse' printInt.
Natürlich, jetzt ist diese fehl, wenn die Unterklasse nicht erklären getInt, so dass Sie hinzufügen müssen, um eine überprüfung abwickeln zu können "normale" Unterklassen, die nicht versuchen, zu "überschreiben" eine private Methode:

public void printInt() throws Exception {
    Class<? extends SuperClass> clazz = getClass();

    //Use superclass method by default
    Method theGetInt = SuperClass.class.getDeclaredMethod("getInt");

    //Look for a subclass method
    Class<?> classWithGetInt = clazz;
    OUTER: while( classWithGetInt != SuperClass.class ){

        for( Method method : classWithGetInt.getDeclaredMethods() )
            if( method.getName().equals("getInt") && method.getParameterTypes().length == 0 ){
                theGetInt = method;
                break OUTER;
            }

        //Check superclass if not found
        classWithGetInt = classWithGetInt.getSuperclass();
    }

    System.out.println("I am " + classWithGetInt + ". The int is " + theGetInt.invoke(this) );
}

Haben Sie immer noch ändern Oberklasse-code, um diese Arbeit zu machen, und da haben Sie zu ändern Oberklasse-code sollten Sie nur ändern Sie den zugriffsmodifizierer auf getInt zu protected anstatt das zu tun, Reflexion hack-Lösungen.

InformationsquelleAutor trutheality

Nein, das können Sie nicht. Bauen Sie ein Programm, welches Aussehen, wie es sollte in der Lage sein, dies zu tun, mit der Tatsache, dass code, der innerhalb eines äußeren Klasse zugreifen können, die geschachtelte Klasse ist private Mitglieder. Die privaten Methoden immer noch nicht wirklich überschrieben werden. Beispiel:

public class Test {

    public static class Superclass {
        private void foo() {
            System.out.println("Superclass.foo");
        }
    }

    public static class Subclass extends Superclass {
        private void foo() {
            System.out.println("Subclass.foo");
            //Looks like it shouldn't work, but does...
            super.foo();
        }
    }

    public static void main(String[] args) throws Exception {
        Superclass x = new Subclass();
        //Only calls Superclass.foo...
        x.foo();
    }
}

Gegeben, dass dies die nur situation, in der es möglich war, zu überschreiben, eine private Methode, es ist kein großer Verlust, dass es nicht unterstützt wird.

Wenn Sie ändern möchten, auf das Verhalten der privaten Mitglied Ihrer Superklasse, Ihr design ist gebrochen, im Grunde.

InformationsquelleAutor Jon Skeet

Wenn Sie wirklich wollen, dies zu tun mit Reflexion, Sie könnten:

public class SuperClass {

    private final Method getInt;

    public SuperClass() {
        /** Find the appropriate method to call and cache it. **/
        Method getInt = null;
        try {
            getInt = getClass().getDeclaredMethod("getInt");
        }
        catch (NoSuchMethodException e) {
            try {
                getInt = SuperClass.class.getDeclaredMethod("getInt");
            } catch (NoSuchMethodException e1) {
                throw new RuntimeException(e1);
            }
        }
        getInt.setAccessible(true);
        this.getInt = getInt;
    }

    public void print() {
        int val = 0;
        try {
            val = (Integer) getInt.invoke(this);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
        System.out.println(val);
    }

    private int getInt() {
        return 1;
    }
}

public class SubClass extends SuperClass {
    public int getInt() {
        return 2;
    }

    public static void main(String[] args) throws Exception {
        new SubClass().print();
    }
}

Ich vermute, Sie möchten Ihr Programm entwerfen, anders, anstatt mit diesem Ansatz. Es ist nicht performant, und es wird auf jeden Fall fangen wer extends SuperClass überraschen.

Beachten Sie, dass die Unterklasse die Methode getInt () - Methode kann privat sein, wenn Sie mithilfe von reflektion auf diese Weise. Wieder, wobei dieser Ansatz ist fast definitiv eine Schlechte Idee, zumindest für die zwei genannten Gründen. Chancen sind, können Sie Ihre Ziele zu erreichen einen anderen Weg. Paket Schutz ist nicht wirklich eine option?

InformationsquelleAutor Michael Bosworth

Nein, sind wir nicht ändern können Private Methoden, aber es gibt einen Fall, wo wir außer Kraft setzen können private Methoden zu, d.h. die Innere Klasse

class PrivateTest { 

private String msg = "OuterAndInner";

private void fun() {
     System.out.println("Outer fun()");
}

class Inner extends PrivateTest {
    private void fun()  {
          System.out.println("Accessing Private Member of Outer: " + msg);
    }
}
public static void main(String args[])  {
     PrivateTest o = new PrivateTest();
     Inner  i   = o.new Inner();
     i.fun();
     //o.fun() calls Outer's fun (No run-time polymorphism).
     o = i; 
     o.fun();
}

}

InformationsquelleAutor Rahul Maurya

Können Sie nicht überschreiben Sie eine private Methode.

Eine überschreibende Methode kann nur existieren in der Unterklasse die überschriebene Methode. Wenn die Methode, die Sie überschreiben möchten markiert ist private, überschreiben, es ist nicht möglich, da die Unterklasse Erben nicht alles markiert private, also dem Kappen der verbindungen zwischen privaten Methode und alles, was in der Unterklasse, einschließlich der Unterklasse Methoden.

Zu "überschreiben" bedeutet, dass die JVM zu bestimmen, welche Methode zu verwenden, basierend auf der Instanz geben, die Sie aufrufen, es mit. Die Theorie des Polymorphismus erklärt, was dies möglich macht. Um für die JVM in der Lage sein zu sagen "mit diesen Methoden verbunden sind, die eine überschreibt den anderen", die JVM muss in der Lage sein, um anzeigen der überschrieben Methode innerhalb der Unterklasse enthält die überschreiben Methode.

Dass gesagt wird, die Klassen in dem Fall werden noch kompilieren, aber weder von den Methoden aufgerufen werden, die auf der Grundlage der JVMs, die unabhängig voneinander laufen, Instanz-basierten Aufruf. Sie werden lediglich unterschiedliche Methoden zusammen, die nicht anerkannt werden von der JVM als außer Kraft gesetzt oder überschreiben.

Außerdem, wenn Sie eine IDE wie NetBeans, mit der @Override-annotation weist den compiler, dass Sie das überschreiben der Methode mit der gleichen Signatur in der Unterklasse. Wenn Sie dies nicht tun, erhalten Sie eine Warnung, die darauf hindeutet, dass Sie die annotation. Sie erhalten einen Kompilierungsfehler, wenn Sie jedoch gelten diese Anmerkung, wenn:

• es gibt keine Methode mit passender Signatur in der Oberklasse

ODER

• die Methode in der Superklasse, in der Sie versuchen, zu überschreiben markiert ist private oder letzten

Finden Sie in der offiziellen Oracle Dokumentation https://docs.oracle.com/javase/tutorial/java/IandI/override.html
für den folgenden Auszug:

Instanz-Methoden

...Die Fähigkeit einer Unterklasse zu überschreiben einer Methode erlaubt einer Klasse zu Erben
aus
eine Superklasse, deren Verhalten ist "nahe genug" und dann zu ändern
Verhalten nach Bedarf....
Beim überschreiben einer Methode, die Sie möchten möglicherweise verwenden Sie das @Override
Anmerkung, weist den compiler, dass Sie beabsichtigen, Sie zu überschreiben
Methode in der Superklasse. Wenn, aus irgendeinem Grund, der compiler erkennt
dass die Methode nicht vorhanden ist in einer der Oberklassen, dann ist es
wird ein Fehler erzeugt.

Überschreiben kann sehr verwirrend sein, weil es sich um die JVM handeln scheinbar unabhängig. Denken Sie daran, dass ohne Zugriff auf die Methode[s] in der Oberklasse (in anderen Worten, für alle Methoden markiert private), die Unterklasse kann nicht aufrufen oder überschreiben dieser Methode[s], denn es können nicht Erben, Sie zu tun.

InformationsquelleAutor We_are_the_Borg_