Access to fields and static methods in Java without polymorphic understanding

1. Associating a method call with the method body is called

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

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. In addition to static methods and final methods (Private methods are final methods), all other methods are late binding, and all methods in Java achieve polymorphism through dynamic binding

5. The behavior of accessing a certain domain is not With polymorphism

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 domain access operation will be parsed by the compiler, 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. By calling the method To access

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 Access to fields and static methods in Java without polymorphic understanding. For more information, please follow other related articles on the PHP Chinese website!