Gibt es eine Möglichkeit, Klassenvariablen in Java zu überschreiben?

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    protected static String me = "son";
}

public void doIt()
{
    new Son().printMe();
}

Die Funktion doIt gibt "dad" aus. Gibt es eine Möglichkeit, "Sohn" zu drucken?

Ja. Wenn es sich jedoch um die Variable handelt, wird sie überschrieben (Variablen einen neuen Wert zu geben. Eine neue Definition für die Funktion ist Überschreiben).Just don't declare the variable but initialize (change) in the constructor or static block.

Der Wert wird bei Verwendung in den Blöcken der übergeordneten Klasse wiedergegeben

Wenn die Variable statisch ist, ändern Sie den Wert während der Initialisierung selbst mit dem statischen Block.

class Son extends Dad {
    static { 
       me = 'son'; 
    }
}

oder sonst im Konstruktor ändern.

Sie können den Wert auch später in beliebigen Blöcken ändern. Es wird sich in der Superklasse widerspiegeln

Kurz gesagt, nein, es gibt keine Möglichkeit, eine Klassenvariable zu überschreiben.

Sie überschreiben Klassenvariablen in Java nicht, Sie verbergen sie. Überschreiben ist zum Beispiel Methoden. Das Verstecken unterscheidet sich vom Überschreiben.

In dem Beispiel, das Sie gegeben haben, verbergen Sie durch Deklarieren der Klassenvariablen mit dem Namen 'me' in class Son die Klassenvariable, die sie von ihrem übergeordneten Dad mit dem gleichen Namen 'me' geerbt hätte. Das Ausblenden einer Variablen auf diese Weise wirkt sich nicht auf den Wert der Klassenvariablen 'me' im Dad der Oberklasse aus.

Für den zweiten Teil Ihrer Frage, wie "Sohn" gedruckt werden soll, würde ich den Wert über den Konstruktor festlegen. Obwohl der folgende Code ziemlich stark von Ihrer ursprünglichen Frage abweicht, würde ich ihn in etwa so schreiben.

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void printName() {
        System.out.println(name);
    }
}

Das JLS bietet in Abschnitt 8.3 - Felddeklarationen viel mehr Details zum Verstecken

Ja, überschreiben Sie einfach die printMe()Methode:

class Son extends Dad {
        public static final String me = "son";

        @Override
        public void printMe() {
                System.out.println(me);
        }
}

Sie können einen Getter erstellen und diesen dann überschreiben. Dies ist besonders nützlich, wenn die Variable, die Sie überschreiben, eine Unterklasse von sich selbst ist. Stellen Sie sich vor, Ihre Superklasse hat ein ObjectMitglied, aber in Ihrer Unterklasse ist dies jetzt definierter als Integer.

class Dad
{
        private static final String me = "dad";

        protected String getMe() {
            return me;
        }

        public void printMe()
        {
                System.out.println(getMe());
        }
}

class Son extends Dad
{
        private static final String me = "son";

        @Override
        protected String getMe() {
            return me;
        }
}

public void doIt()
{
        new Son().printMe(); //Prints "son"
}

Wenn Sie es überschreiben wollen, sehe ich keinen gültigen Grund, diese statisch zu halten. Ich würde die Verwendung von Abstraktion vorschlagen (siehe Beispielcode). ::

     public interface Person {
        public abstract String getName();
       //this will be different for each person, so no need to make it concrete
        public abstract void setName(String name);
    }

Jetzt können wir den Vater hinzufügen:

public class Dad implements Person {

    private String name;

    public Dad(String name) {
        setName(name);
    }

    @Override
    public final String getName() {
    return name;
    }

    @Override
    public final void setName(String name) {
        this.name = name;
    }
}

der Sohn:

public class Son implements Person {

    private String name;

    public Son(String name) {
        setName(name);
    }

    @Override
    public final String getName() {
        return name;
    }

    @Override
    public final void setName(String name) {
        this.name = name;
    }
}

und Papa traf eine nette Dame:

public class StepMom implements Person {

    private String name;

    public StepMom(String name) {
        setName(name);
    }

    @Override
    public final String getName() {
        return name;
    }

    @Override
    public final void setName(String name) {
        this.name = name;
    }
}

Sieht so aus, als hätten wir eine Familie. Sagen wir der Welt ihre Namen:

public class ConsoleGUI {

    public static void main(String[] args) {
        List<Person> family = new ArrayList<Person>();
        family.add(new Son("Tommy"));
        family.add(new StepMom("Nancy"));
        family.add(new Dad("Dad"));
        for (Person person : family) {
            //using the getName vs printName lets the caller, in this case the
            //ConsoleGUI determine versus being forced to output through the console. 
            System.out.print(person.getName() + " ");
            System.err.print(person.getName() + " ");
            JOptionPane.showMessageDialog(null, person.getName());
    }
}

}}

System.out-Ausgabe: Tommy Nancy Dad
System.err ist das gleiche wie oben (hat nur rote Schrift).
JOption-Ausgabe:
Tommy, dann
Nancy, dann
Dad

Dies sieht aus wie ein Designfehler.

Entfernen Sie das statische Schlüsselwort und legen Sie die Variable beispielsweise im Konstruktor fest. Auf diese Weise setzt Son die Variable in seinem Konstruktor nur auf einen anderen Wert.

Obwohl es stimmt, dass Klassenvariablen möglicherweise nur in Unterklassen versteckt und nicht überschrieben werden, ist es dennoch möglich, das zu tun, was Sie wollen, ohne printMe ()in Unterklassen zu überschreiben , und Reflektion ist Ihr Freund. Im folgenden Code verzichte ich aus Gründen der Übersichtlichkeit auf die Ausnahmebehandlung. Bitte beachten Sie, dass das Deklarieren meals protectedin diesem Zusammenhang wenig sinnvoll erscheint, da es in Unterklassen versteckt wird ...

class Dad
  {
    static String me = "dad";

    public void printMe ()
      {
        java.lang.reflect.Field field = this.getClass ().getDeclaredField ("me");
        System.out.println (field.get (null));
      }
  }

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    protected static String _me = me = "son";
}

public void doIt()
{
    new Son().printMe();
}

... druckt "Sohn".

https://docs.oracle.com/javase/tutorial/java/IandI/hidevariables.html

Es heißt Hiding Fields

Über den obigen Link

Innerhalb einer Klasse verbirgt ein Feld, das denselben Namen wie ein Feld in der Oberklasse hat, das Feld der Oberklasse, auch wenn ihre Typen unterschiedlich sind. Innerhalb der Unterklasse kann das Feld in der Oberklasse nicht durch seinen einfachen Namen referenziert werden. Stattdessen muss auf das Feld über Super zugegriffen werden, was im nächsten Abschnitt behandelt wird. Im Allgemeinen empfehlen wir, Felder nicht auszublenden, da dies das Lesen von Code erschwert.

nur durch Überschreiben printMe():

class Son extends Dad 
{
    public void printMe() 
    {
        System.out.println("son");
    }
}

Der Verweis auf mein der Dad.printMeMethode verweist implizit auf das statische Feld Dad.me. Auf die eine oder andere Weise ändern Sie also, was printMein Son...

Sie können Variablen in einer Klasse nicht überschreiben. Sie können nur Methoden überschreiben. Sie sollten die Variablen privat halten, da sonst viele Probleme auftreten können.

Es gibt tatsächlich "Papa" aus, da das Feld nicht überschrieben, sondern ausgeblendet wird. Es gibt drei Ansätze, um "Sohn" zu drucken:

Ansatz 1: printMe überschreiben

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    protected static String me = "son";

    @override
    public void printMe()
    {
        System.out.println(me);
    }
}

public void doIt()
{
    new Son().printMe();
}

Ansatz 2: Verstecken Sie das Feld nicht und initialisieren Sie es im Konstruktor

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    public Son()
    {
        me = "son";
    }
}

public void doIt()
{
    new Son().printMe();
}

Ansatz 3: Verwenden Sie den statischen Wert, um ein Feld im Konstruktor zu initialisieren

class Dad
{
    private static String meInit = "Dad";

    protected String me;

    public Dad() 
    {
       me = meInit;
    }

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    private static String meInit = "son";

    public Son()
    {
        me = meInit;
    }

}

public void doIt()
{
    new Son().printMe();
}

Variablen nehmen nicht am Überbinden teil. Nur Methoden tun dies. Ein Methodenaufruf wird zur Laufzeit aufgelöst, dh die Entscheidung zum Aufrufen einer Methode wird zur Laufzeit getroffen, die Variablen werden jedoch nur zur Kompilierungszeit entschieden. Daher wird diese Variable aufgerufen, deren Referenz zum Aufrufen verwendet wird und nicht des Laufzeitobjekts.

Schauen Sie sich folgenden Ausschnitt an:

package com.demo;

class Bike {
  int max_speed = 90;
  public void disp_speed() {
    System.out.println("Inside bike");
 }
}

public class Honda_bikes extends Bike {
  int max_speed = 150;
  public void disp_speed() {
    System.out.println("Inside Honda");
}

public static void main(String[] args) {
    Honda_bikes obj1 = new Honda_bikes();
    Bike obj2 = new Honda_bikes();
    Bike obj3 = new Bike();

    obj1.disp_speed();
    obj2.disp_speed();
    obj3.disp_speed();

    System.out.println("Max_Speed = " + obj1.max_speed);
    System.out.println("Max_Speed = " + obj2.max_speed);
    System.out.println("Max_Speed = " + obj3.max_speed);
  }

}

Wenn Sie den Code ausführen, zeigt die Konsole Folgendes an:

Inside Honda
Inside Honda
Inside bike

Max_Speed = 150
Max_Speed = 90
Max_Speed = 90

Natürlich wird empfohlen, private Attribute sowie Getter und Setter zu verwenden, aber ich habe Folgendes getestet, und es funktioniert ... Siehe den Kommentar im Code

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    protected static String me = "son";

    /* 
    Adding Method printMe() to this class, outputs son 
    even though Attribute me from class Dad can apparently not be overridden
    */

    public void printMe()
    {
        System.out.println(me);
    }
}

class Tester
{
    public static void main(String[] arg)
    {
        new Son().printMe();
    }
}

Sooo ... habe ich gerade die Vererbungsregeln neu definiert oder Oracle in eine schwierige Situation gebracht? Für mich ist der geschützte statische String me eindeutig überschrieben, wie Sie sehen können, wenn Sie dieses Programm ausführen. Außerdem macht es für mich keinen Sinn, warum Attribute nicht überschreibbar sein sollten.

Warum sollten Sie Variablen überschreiben, wenn Sie sie in den Unterklassen leicht neu zuweisen können?

Ich folge diesem Muster, um das Sprachdesign zu umgehen. Angenommen, Sie haben eine gewichtige Serviceklasse in Ihrem Framework, die in mehreren abgeleiteten Anwendungen in verschiedenen Varianten verwendet werden muss. In diesem Fall können Sie die Superklassenlogik am besten konfigurieren, indem Sie ihre definierenden Variablen neu zuweisen.

public interface ExtensibleService{
void init();
}

public class WeightyLogicService implements ExtensibleService{
    private String directoryPath="c:\hello";

    public void doLogic(){
         //never forget to call init() before invocation or build safeguards
         init();
       //some logic goes here
   }

   public void init(){}    

}

public class WeightyLogicService_myAdaptation extends WeightyLogicService {
   @Override
   public void init(){
    directoryPath="c:\my_hello";
   }

}

Nein. Klassenvariablen (gelten auch für Instanzvariablen) weisen in Java keine übergeordnete Funktion auf, da Klassenvariablen auf der Grundlage des Typs des aufrufenden Objekts aufgerufen werden. Es wurde eine weitere Klasse (Mensch) in der Hierarchie hinzugefügt, um dies klarer zu machen. Also jetzt haben wir

Sohn erweitert Vater erweitert Mensch

Im folgenden Code versuchen wir, über ein Array von Human-, Dad- und Son-Objekten zu iterieren, aber es gibt in allen Fällen die Werte der Human Class aus, da der Typ des aufrufenden Objekts Human war.

    class Human
{
    static String me = "human";

    public void printMe()
    {
        System.out.println(me);
    }
}
class Dad extends Human
{
    static String me = "dad";

}

class Son extends Dad
{
    static String me = "son";
}


public class ClassVariables {
    public static void main(String[] abc)   {
        Human[] humans = new Human[3];
        humans[0] = new Human();
        humans[1] = new Dad();
        humans[2] = new Son();
        for(Human human: humans)   {
            System.out.println(human.me);        // prints human for all objects
        }
    }
}

Wird gedruckt

• Mensch
• Mensch
• Mensch

Also kein Überschreiben von Klassenvariablen.

Wenn wir von einer Referenzvariablen der übergeordneten Klasse auf die Klassenvariable des tatsächlichen Objekts zugreifen möchten, müssen wir dies dem Compiler explizit mitteilen, indem wir die übergeordnete Referenz (menschliches Objekt) in ihren Typ umwandeln.

    System.out.println(((Dad)humans[1]).me);        // prints dad

    System.out.println(((Son)humans[2]).me);        // prints son

Wird gedruckt

• Papa
• Sohn

Wie Teil dieser Frage: - Wie bereits vorgeschlagen, überschreiben Sie die printMe () -Methode in der Son-Klasse und rufen Sie sie dann auf

Son().printMe();

Die Klassenvariable "me" von Dad wird ausgeblendet, da die nächste Deklaration (von der son class printme () -Methode) des "me" (in der Son-Klasse) Vorrang hat.

Rufen Sie einfach super.variable im Unterklassenkonstruktor auf

public abstract class Beverage {

int cost;


int getCost() {

    return cost;

}

}`

public class Coffee extends Beverage {


int cost = 10;
Coffee(){
    super.cost = cost;
}


}`

public class Driver {

public static void main(String[] args) {

    Beverage coffee = new Coffee();

    System.out.println(coffee.getCost());

}

}

Die Ausgabe ist 10.