Czy istnieje sposób na przesłonięcie zmiennych klas w Javie?

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();
}

Funkcja doIt wypisze „tato”. Czy jest sposób, aby wydrukować „syn”?

Tak. Ale jeśli chodzi o zmienną, jest ona nadpisywana (Nadanie zmiennej zmiennej nowej wartości. Nadanie nowej definicji funkcji to Zastąp).Just don't declare the variable but initialize (change) in the constructor or static block.

Wartość zostanie odzwierciedlona podczas używania w blokach klasy nadrzędnej

jeśli zmienna jest statyczna, zmień jej wartość podczas samej inicjalizacji za pomocą bloku statycznego,

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

albo zmień konstruktora.

Możesz także zmienić wartość później w dowolnych blokach. Znajdzie to odzwierciedlenie w super klasie

Krótko mówiąc, nie, nie ma możliwości przesłonięcia zmiennej klasy.

Nie zastępujesz zmiennych klasowych w Javie, ukrywasz je. Przesłanianie dotyczy na przykład metod. Ukrywanie różni się od zastępowania.

W podanym przykładzie, deklarując zmienną klasy o nazwie „ja” w klasie Syn, ukrywasz zmienną klasową, którą odziedziczyłaby po swojej superklasie Tata o tej samej nazwie „ja”. Ukrycie zmiennej w ten sposób nie wpływa na wartość zmiennej klasy „ja” w nadklasie Tata.

W drugiej części twojego pytania, jak sprawić, by wypisał "syn", ustawiłbym wartość za pomocą konstruktora. Chociaż poniższy kod bardzo różni się od pierwotnego pytania, napisałbym go mniej więcej tak;

public class Person {
    private String name;

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

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

JLS podaje dużo więcej szczegółów na temat ukrywania w sekcji 8.3 - Deklaracje pól

Tak, po prostu zastąp printMe()metodę:

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

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

Możesz utworzyć metodę pobierającą, a następnie zastąpić ją. Jest to szczególnie przydatne, jeśli zmienna, którą nadpisujesz, jest samą w sobie podklasą. Wyobraź sobie, że Twoja superklasa ma Objectczłonka, ale w Twojej podklasie jest to teraz bardziej zdefiniowane jako 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"
}

Jeśli masz zamiar go zastąpić, nie widzę żadnego uzasadnionego powodu, aby zachować to statyczne. Sugerowałbym użycie abstrakcji (patrz przykładowy kod). :

     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);
    }

Teraz możemy dodać tatę:

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;
    }
}

syn:

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;
    }
}

a tata spotkał miłą panią:

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;
    }
}

Wygląda na to, że mamy rodzinę, powiedzmy światu ich imiona:

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 Wyjście: Tommy Nancy Dad
System.err jest taki sam jak powyżej (ma tylko czerwoną czcionkę)
JOption Wyjście:
Tommy, następnie
Nancy, a następnie
Dad

To wygląda na błąd konstrukcyjny.

Usuń słowo kluczowe static i ustaw zmienną, na przykład w konstruktorze. W ten sposób Son po prostu ustawia zmienną na inną wartość w swoim konstruktorze.

Chociaż prawdą jest, że zmienne klasowe mogą być ukryte tylko w podklasach i nie mogą być nadpisywane, nadal można robić, co chcesz, bez nadpisywania printMe ()w podklasach, a odbicie jest twoim przyjacielem. W poniższym kodzie pomijam obsługę wyjątków dla przejrzystości. Zwróć uwagę, że zadeklarowanie mejako protectednie wydaje się mieć większego sensu w tym kontekście, ponieważ będzie ukryte w podklasach ...

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();
}

... wypisze „syn”.

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

Nazywa się Hiding Fields

Z linku powyżej

W ramach klasy pole, które ma taką samą nazwę jak pole w nadklasie, ukrywa pole nadklasy, nawet jeśli ich typy są różne. W ramach podklasy do pola w nadklasie nie można odwoływać się za pomocą jego prostej nazwy. Zamiast tego dostęp do pola należy uzyskać przez super, co jest omówione w następnej sekcji. Ogólnie rzecz biorąc, nie zalecamy ukrywania pól, ponieważ utrudnia to odczytanie kodu.

tylko przez nadpisanie printMe():

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

odwołanie do mew Dad.printMemetodzie niejawnie wskazuje na pole statyczne Dad.me, więc w taki czy inny sposób zmieniasz to, co printMerobi w Son...

Nie można przesłonić zmiennych w klasie. Możesz przesłonić tylko metody. Powinieneś zachować zmienne jako prywatne, w przeciwnym razie możesz mieć wiele problemów.

Rzeczywiście drukuje „tato”, ponieważ pole nie jest nadpisane, ale ukryte. Istnieją trzy sposoby, aby wydrukować słowo „syn”:

Podejście 1: zastąp printMe

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();
}

Podejście 2: nie ukrywaj pola i inicjalizuj go w konstruktorze

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();
}

Podejście 3: użyj wartości statycznej, aby zainicjować pole w konstruktorze

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();
}

Zmienne nie biorą udziału w nadpisywaniu. Tylko metody. Wywołanie metody jest rozwiązywane w czasie wykonywania, to znaczy decyzja o wywołaniu metody jest podejmowana w czasie wykonywania, ale zmienne są ustalane tylko w czasie kompilacji. Stąd ta zmienna jest wywoływana, której odwołanie jest używane do wywoływania, a nie obiektu wykonawczego.

Spójrz na następujący fragment:

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);
  }

}

Po uruchomieniu kodu konsola pokaże:

Inside Honda
Inside Honda
Inside bike

Max_Speed = 150
Max_Speed = 90
Max_Speed = 90

Oczywiście używanie atrybutów prywatnych oraz metody pobierające i ustawiające byłoby zalecane, ale przetestowałem następujące elementy i działa ... Zobacz komentarz w kodzie

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();
    }
}

Więc ... czy właśnie przedefiniowałem zasady dziedziczenia, czy postawiłem Oracle w trudnej sytuacji? Dla mnie chroniona statyczna wartość String me jest wyraźnie nadpisywana, co widać po uruchomieniu tego programu. Nie ma też dla mnie sensu, dlaczego atrybuty nie powinny być nadrzędne.

Dlaczego miałbyś chcieć przesłonić zmienne, skoro można łatwo ponownie przypisać je w podklasach.

Podążam za tym wzorcem, aby obejść projekt języka. Załóżmy, że masz w swoim frameworku ważną klasę usług, która musi być używana w różnych smakach w wielu aplikacjach pochodnych. W takim przypadku najlepszym sposobem skonfigurowania logiki superklasy jest ponowne przypisanie jej zmiennych definiujących.

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";
   }

}

Nie. Zmienne klasowe (mają również zastosowanie do zmiennych instancji) nie mają funkcji przesłaniającej w Javie, ponieważ zmienne klasowe są wywoływane na podstawie typu wywoływanego obiektu. Dodano jeszcze jedną klasę (człowiek) w hierarchii, aby była bardziej przejrzysta. Więc teraz mamy

Syn przedłuża Tata przedłuża Człowieka

W poniższym kodzie próbujemy iterować po tablicy obiektów Human, Dad i Son, ale we wszystkich przypadkach wyświetla on wartości Human Class, ponieważ typ wywołującego obiektu to Human.

    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
        }
    }
}

Wydrukuje

• człowiek
• człowiek
• człowiek

Więc nie ma nadpisywania zmiennych klasy.

Jeśli chcemy uzyskać dostęp do zmiennej klasy rzeczywistego obiektu ze zmiennej referencyjnej jego klasy nadrzędnej, musimy wyraźnie powiedzieć o tym kompilatorowi, rzutując referencję nadrzędną (obiekt ludzki) na jego typ.

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

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

Wydrukuje

• tata
• syn

O tym, jak część tego pytania: - Jak już sugerowano, przesłonić metodę printMe () w klasie Son, a następnie wywołać

Son().printMe();

Zmienna klasy Dad „me” zostanie ukryta, ponieważ najbliższa deklaracja (z metody printme () klasy Son) elementu „me” (w klasie Son) będzie miała pierwszeństwo.

Po prostu wywołaj super.variable w konstruktorze podklasy

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());

}

}

Wyjście to 10.