Warum kann die innere Klasse die private final-Methode überschreiben?

Ich habe mich gefragt, ob es sinnvoll ist, eine private Methode auch als final zu deklarieren, und ich dachte, es macht keinen Sinn. Aber ich stellte mir vor, dass es eine exklusive Situation gibt, und schrieb den Code, um es herauszufinden:

public class Boom {

    private void touchMe() {
        System.out.println("super::I am not overridable!");
    }

    private class Inner extends Boom {

        private void touchMe() {
            super.touchMe();
            System.out.println("sub::You suck! I overrided you!");
        }
    }

    public static void main(String... args) {
        Boom boom = new Boom();
        Boom.Inner inner = boom.new Inner();
        inner.touchMe();
    }
}

Es hat kompiliert und funktioniert. “Ich sollte touchMe() final machen” dachte ich und tat es:

public class Boom {

    private final void touchMe() {
        System.out.println("super::I am not overridable!");
    }

    private class Inner extends Boom {

        private void touchMe() {
            super.touchMe();
            System.out.println("sub::You suck! I overrided you!");
        }
    }

    public static void main(String... args) {
        Boom boom = new Boom();
        Boom.Inner inner = boom.new Inner();
        inner.touchMe();
    }
}

und es funktioniert auch und sagt mir

chicout@chicout-linlap:~$ java Boom
super::I am not overridable!
sub::You suck! I overrided you!

warum?

Private Methoden können nicht überschrieben werden (private Methoden werden nicht vererbt!) Tatsächlich macht es keinen Unterschied, ob Sie eine private Methode final deklarieren oder nicht.

Die beiden Methoden, die Sie deklariert haben, Boom.touchMe und Boom.Inner.touchMe sind zwei völlig getrennte Methoden die zufällig dieselbe Kennung haben. Die Tatsache, dass super.touchMe bezieht sich auf eine andere Methode als touchMeist nur weil Boom.Inner.touchMe Schatten Boom.touchMe (und nicht, weil es sie überschreibt).

Dies kann auf verschiedene Weise nachgewiesen werden:

• Wie Sie selbst festgestellt haben, wird sich der Compiler beschweren, wenn Sie die Methoden auf öffentlich ändern sind versucht plötzlich, eine endgültige Methode zu überschreiben.

• Wenn Sie die Methoden privat halten und die hinzufügen @Override Anmerkung, der Compiler wird sich beschweren.

• Wie Alpian betont, wenn Sie die werfen Boom.Inner widersprechen a Boom Objekt (((Boom) inner).touchMe()) das Boom.touchMe aufgerufen wird (wenn es tatsächlich überschrieben wurde, spielt die Besetzung keine Rolle).

Verwandte Frage:

• Private Methoden endgültig machen?

Ich denke, die Tatsache, dass es hier wirklich zwei getrennte Methoden gibt, wird gut demonstriert, indem Sie Ihre main wie folgt ändern:

public static void main(String... args) {
    Boom boom = new Boom();
    Boom.Inner inner = boom.new Inner();
    inner.touchMe();
    System.out.println("And now cast it...");
    ((Boom)(inner)).touchMe();
}

Das druckt jetzt:

super::I am not overridable!
sub::You suck! I overrided you!
And now cast it...
super::I am not overridable!

Und der Grund, dass der Anruf an super arbeitet in Inner liegt daran, dass Sie nach einer Methode mit dem Namen suchen touchMe in deiner Superklasse (Boom), die tatsächlich existiert und für die sichtbar ist Inner wie es in der gleichen Klasse ist.

Private Methoden sind für Unterklassen oder tatsächlich jede andere Klasse unsichtbar, sodass sie denselben Namen haben können, sich aber nicht gegenseitig überschreiben.

Versuchen Sie, die Annotation @Override hinzuzufügen – Sie erhalten einen Compilerfehler.

Sie können die Methode überschreiben, da dies der Fall ist private zu jeder Klasse.

Sie haben gerade eine andere Methode mit demselben Namen deklariert. Sie können privates Mitglied der Klasse aufrufen, da die innere Klasse selbst Mitglied der Klasse ist. Hoffe, diese Modifikation wird es im Detail erklären.

public class Boom {

    private final void touchMe() {
        System.out.println("super [touchMe] ::I am not overridable!");
    }

    public void overrideMe(){
        System.out.println("super [overrideMe]::I am overridable!");
    }

    private class Inner extends Boom {

        private void touchMe() {
            super.touchMe();
            System.out.println("sub [touchMe]::You suck! I overrided you!");
        }

        public void overrideMe(){
            System.out.println("sub [overrideMe] ::I overrided you!");
        }
    }

    public static void main(String... args) {
        Boom boom = new Boom();
        Boom.Inner inner = boom.new Inner();

        inner.touchMe();

        Boom newBoom = inner;
        newBoom.touchMe();
        newBoom.overrideMe();
    }
}



super [touchMe] ::I am not overridable!
sub [touchMe]::You suck! I overrided you!
super [touchMe] ::I am not overridable!
sub [overrideMe] ::I overrided you!