Java'da sınıf değişkenlerini geçersiz kılmanın bir yolu var mı?

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

"Baba" işlevi yazdırılacaktır. "Oğul" baskısı yapmanın bir yolu var mı?

Evet. Ancak değişken söz konusu olduğunda, üzerine yazılır (Değişkene yeni değer verilmesi. İşleve yeni tanım verilmesi Geçersiz kıl).Just don't declare the variable but initialize (change) in the constructor or static block.

Üst sınıf bloklarında kullanıldığında değer yansıtılır

değişken statik ise statik blok ile başlatma sırasında değeri değiştirin,

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

veya kurucudaki değişiklik.

Değeri daha sonra herhangi bir blokta da değiştirebilirsiniz. Süper sınıfa yansıyacak

Kısacası, hayır, bir sınıf değişkenini geçersiz kılmanın bir yolu yoktur.

Gizlediğiniz Java'da sınıf değişkenlerini geçersiz kılmazsınız. Geçersiz kılma, örneğin yöntemlerdir. Gizleme geçersiz kılmadan farklıdır.

Verdiğiniz örnekte, Son sınıfında 'ben' adıyla sınıf değişkenini bildirerek, üst sınıf Baba'dan miras alacağı sınıf değişkenini 'ben' adıyla gizlersiniz. Bir değişkeni bu şekilde gizlemek, üst sınıf Baba'daki 'ben' sınıf değişkeninin değerini etkilemez.

Sorunuzun ikinci kısmı için, nasıl "oğul" yazdırmak için, ben yapıcı aracılığıyla değeri ayarlamak istiyorum. Aşağıdaki kod orijinal sorunuzdan çok fazla olsa da, ben böyle bir şey yazmak istiyorum;

public class Person {
    private String name;

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

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

JLS, bölüm 8.3 - Alan Beyannameleri'nde gizleme hakkında çok daha fazla ayrıntı vermektedir.

Evet, printMe()yöntemi geçersiz kıl :

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

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

Bir alıcı oluşturabilir ve ardından bu alıcıyı geçersiz kılabilirsiniz. Özellikle geçersiz kıldığınız değişken kendi başına bir alt sınıfsa yararlıdır. Süper sınıfınızın bir Objectüyesi olduğunu düşünün, ancak alt sınıfınızda bu artık bir olarak tanımlanmıştır 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"
}

Bunu geçersiz kılacaksanız, bu durumu sabit tutmak için geçerli bir neden görmüyorum. Soyutlama kullanımını öneririm (bkz. Örnek 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);
    }

Şimdi Baba'yı ekleyebiliriz:

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

oğul:

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

ve baba iyi bir bayanla tanıştı:

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

Bir ailemiz var gibi görünüyor, dünyaya isimlerini söyleyelim:

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 Çıktı: Tommy Nancy Dad
System.err yukarıdakiyle aynı (sadece kırmızı yazı tipi var)
JOption Çıktı:
Tommy sonra
Nancy sonra
Dad

Bu bir tasarım hatası gibi görünüyor.

Statik anahtar kelimeyi kaldırın ve değişkeni örneğin yapıcıda ayarlayın. Bu şekilde Son, değişkeni yapıcısında farklı bir değere ayarlar.

Sınıf değişkenlerinin yalnızca alt sınıflarda gizlenebileceği ve geçersiz kılınamayacağı doğru olsa da, alt sınıflarda geçersiz kılmadan istediğinizi yapmak hala mümkündür printMe ()ve yansıma arkadaşınızdır. Aşağıdaki kodda, açıklık sağlamak için istisna işlemeyi atladım. İlan O notu Lütfen meolarak protectedo alt sınıflarda gizli olacak şekilde, bu bağlamda çok mantıklı olması gibi görünmüyor ...

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

... "oğul" yazdıracak.

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

Adı Gizleme Alanları

Yukarıdaki bağlantıdan

Bir sınıf içinde, üst sınıftaki bir alanla aynı ada sahip bir alan, türleri farklı olsa bile üst sınıfın alanını gizler. Alt sınıf içinde, üst sınıftaki alana basit adıyla başvurulamaz. Bunun yerine, alana bir sonraki bölümde kapsanan süper ile erişilmelidir. Genel olarak, kodun okunmasını zorlaştırdığı için alanların gizlenmesini önermiyoruz.

yalnızca geçersiz kılma ile printMe():

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

yapılan atıf meiçinde Dad.printMestatik alana yöntemle örtülü noktalarından Dad.meböylece tek yönlü veya başka ne değiştirirken printMeyapar Son...

Bir sınıftaki değişkenleri geçersiz kılamazsınız. Yalnızca yöntemleri geçersiz kılabilirsiniz. Değişkenleri gizli tutmalısınız, aksi takdirde çok fazla sorun yaşayabilirsiniz.

Alan 'geçersiz kılınmış değil gizli olduğu için gerçekten de' baba 'yazar. 'Oğul' yazdıracak üç yaklaşım vardır:

Yaklaşım 1: PrintMe'yi geçersiz kıl

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

Yaklaşım 2: Alanı gizleme ve yapıcıda başlatma

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

Yaklaşım 3: Yapıcıdaki bir alanı başlatmak için statik değeri kullanın

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

Değişkenler taşma işleminde yer almaz. Sadece yöntemler işe yarar. Bir yöntem çağrısı çalışma zamanında çözülür, yani bir yöntem çağırma kararı çalışma zamanında alınır, ancak değişkenler yalnızca derleme zamanında kararlaştırılır. Bu nedenle, başvurusu çalışma zamanı nesnesinin değil çağrılması için kullanılan bu değişken çağrılır.

Aşağıdaki snippet'e bir göz atın:

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

}

Kodu çalıştırdığınızda konsol şunları gösterir:

Inside Honda
Inside Honda
Inside bike

Max_Speed = 150
Max_Speed = 90
Max_Speed = 90

Tabii ki özel öznitelikler ve alıcılar ve ayarlayıcılar kullanarak yapılması önerilir, ancak aşağıdakileri test ettim ve işe yarıyor ... Koddaki açıklamaya bakın

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 ... miras kurallarını yeniden tanımladım mı yoksa Oracle'ı zor bir duruma mı soktum? Bana kalırsa, korumalı statik String me bu programı çalıştırdığınızda görebileceğiniz gibi açıkça geçersiz kılınır. Ayrıca, özelliklerin neden geçersiz kılınmaması gerektiği bana bir anlam ifade etmiyor.

Değişkenleri alt sınıflarda kolayca yeniden atayabildiğinizde neden geçersiz kılmak istiyorsunuz?

Dil tasarımında çalışmak için bu modeli takip ediyorum. Birden çok türetilmiş uygulamada farklı tatlarda kullanılması gereken çerçevenizde ağır bir hizmet sınıfına sahip olduğunuz bir durum olduğunu varsayalım. Bu durumda, süper sınıf mantığını yapılandırmanın en iyi yolu 'tanımlayıcı' değişkenlerini yeniden atamaktır.

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

}

Hayır. Sınıf değişkenleri çağıran nesne türüne göre çağrıldığından, sınıf değişkenleri (örnek değişkenler için de geçerlidir) Java'da geçersiz kılma özelliği göstermez. Daha açık hale getirmek için hiyerarşiye bir sınıf daha (İnsan) eklendi. Şimdi elimizde

Oğul uzatır Baba İnsan uzatır

Aşağıdaki kodda, bir dizi İnsan, Baba ve Oğul nesnesi üzerinde yineleme yapmaya çalışıyoruz, ancak çağıran nesnenin türü İnsan olarak her durumda İnsan Sınıfının değerlerini yazdırıyor.

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

Yazdırılacak

• insan
• insan
• insan

Sınıf değişkenlerinin geçersiz kılınması gerekmez.

Üst nesnenin referans değişkeninden gerçek nesnenin sınıf değişkenine erişmek istiyorsak, üst referansı (Human object) türüne dökerek bunu derleyiciye açıkça söylememiz gerekir.

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

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

Yazdırılacak

• baba
• oğul

Bu sorunun nasıl bir parçası olarak: - Daha önce de önerildiği gibi Son sınıfında printMe () yöntemini geçersiz kılınız, daha sonra

Son().printMe();

Babamın Sınıf değişkeni "ben" gizlenecektir, çünkü "ben" in (Son sınıfında) en yakın bildirimi (Son sınıf printme () yönteminden) öncelik kazanacaktır.

Sadece alt sınıf yapıcısında super.variable çağırın

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

}

}

Çıktı 10'dur.