Detailed explanation of access to fields and static methods without polymorphism in Java

The following editor will bring you an article based on the fact that access to fields and static methods in Java does not have polymorphism (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. Associating a method call with the method body is called

2. Compile-time binding (static) is determined during the program compilation phase. The type of the referenced object

3. Runtime binding (dynamic binding) refers to determining the actual type of the referenced object during execution and calling its corresponding method according to its actual type

4. Except for static methods and final methods (private methods are final methods), all other methods are late binding. All methods in Java achieve polymorphism through dynamic binding

5. The behavior of accessing a certain field is not polymorphic

package polymorphism; 
 
class SuperField { 
 public int field = 1; 
 
 public int getField() { 
  return field; 
 } 
} 
 
class SubField extends SuperField { 
 public int field = 2; 
  
 public int getField() { 
  return field; 
 } 
  
 public int getSuperField() { 
  return super.field; 
 } 
} 
 
public class FieldPolymorphism { 
 
 public static void main(String[] args) { 
  SuperField sup = new SubField(); 
  System.out.println("sup.field = " + sup.field + ", sup.getField() = " + sup.getField()); 
  SubField sub = new SubField(); 
  System.out.println("sub.field = " + sub.field + ", sub.getField() = " + sub.getField() + 
    ", sub.getSuperField() = " + sub.getSuperField()); 
 } 
 
}

Output result:

sup.field = 1, sup.getField( ) = 2
sub.field = 2, sub.getField() = 2, sub.getSuperField() = 1

When the SubField object is converted to a Super reference, any field access operations will be handled by the compiler Parsed, so it is not polymorphic. SubField actually contains two fields called fields: its own and inherited from SuperField.

Usually the field is set to private and cannot be accessed directly or inherited. Access by calling a method

6. Accessing a static method is not polymorphic and is not associated with a single object

package polymorphism; 
 
class Super { 
  
 public static String staticMethod() { 
  return "Super staticMethod()"; 
 } 
} 
 
class Sub extends Super { 
 public static String staticMethod() { 
  return "Sub staticMethod()"; 
 } 
} 
 
public class StaticPolymorphism { 
 
 public static void main(String[] args) { 
  Super sup = new Sub(); 
  System.out.println(sup.staticMethod()); 
  System.out.println(Sub.staticMethod()); 
 } 
 
}

Output Result:

Super staticMethod()
Sub staticMethod()

The above is the detailed content of Detailed explanation of access to fields and static methods without polymorphism in Java. For more information, please follow other related articles on the PHP Chinese website!