Hidden details about member variables in Java

The following editor will bring you an article on hiding Java member variables (explanation with examples). The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor and take a look.

1. If there is a member variable with the same name in the subclass and the parent class, will the member variable of the subclass overwrite the member variable of the parent class? Let’s look at the following example:

public class A {
  public int x=10;
}
public class B extends A {
  public int x=20;
}
public class C {
  public static void main(String[] args) {
    A a=new B();
    System.out.println(a.x);  //1
    B b=new B();
    System.out.println(b.x);  //2
    System.out.println(((A)b).x);  //3
  }
}

The result of running the main method of class C is:

10
20
10

Through the results, we can see that the subclass will not overwrite the member variables of the parent class. Our eclipse debugging tool can also clearly see that they exist in object a at the same time. Two member variables of Direct access to members is statically bonded. The official explanation is as follows:

In a class, if the member variables in the subclass have the same name as the member variables in the parent class, even if their types are different, as long as Same name. Member variables in the parent class will be hidden.

In a subclass, the member variables of the parent class cannot be accessed simply by reference. Instead, the hidden member variables of the parent class must be obtained from the reference of the parent class. Generally speaking, we do not recommend hiding member variables,

because this will make the code difficult to read.

The static method is similar to the member variable, as follows:

public class A {
  public static void print() {
    System.out.println("A Static ");  
  }
}
public class B extends A {
  public static void print() {
    System.out.println("B Static ");  
  }
}
public class C {
  public static void main(String[] args) {
    A a=new B();
    a.print();
    
    B b=new B();
    b.print();
    ((A)b).print();
  }
}

The result is as follows:

A Static 
B Static 
A Static

The above is the detailed content of Hidden details about member variables in Java. For more information, please follow other related articles on the PHP Chinese website!