Static methods

[lahiru nanayakkara]

class A{
	static void myMethod(){
		System.out.println("myMethod class A");
	}
}
class B extends A{
	static void myMethod(){
		System.out.println("myMethod class B");
	}
}
class Demo{
	public static void main(String[] args){
		A a1=new B();
		a1.myMethod();
	}
}

Above programe prints "myMethod class A" I created object from class B but it execute method in class(template) A.please explain

[Campbell Ritchie]

Please don't use coloured text, which many people find difficult to read. Also use code tags which I shall add to your two posts, and you can see how much better it looks

Start by reading our FAQ which will probably answer your question.

[Robert D. Smith]

Campbell Ritchie wrote: [...] Start by reading our FAQ which will probably answer your question.

public class test2 {
	public static void main(String[] args){
	
	Foo f = new Bar();
    f.instanceMethod();
    Foo.classMethod();
	}
}

class Foo {
    public static void classMethod() {
        System.out.println("classMethod() in Foo");
    }

    public void instanceMethod() {
        System.out.println("instanceMethod() in Foo");
    }
}

class Bar extends Foo {
    public static void classMethod() {
        System.out.println("classMethod() in Bar");
    }

    public void instanceMethod() {
        System.out.println("instanceMethod() in Bar");
    }
}

This is (pretty much) the code from the FAQ. I understand (reasonably well) why it does what it does. But, what caught my attention was the discussion on better coding style (see line 6). I'm not entirely certain on how or why this works. If I understand correctly, as long as I declare an instance of class Foo f = new Foo;, I can make calls directly to Foo without using the declared variable name?

[Campbell Ritchie]

Not sure I understand the question. If you declare a variable, any static members are bound at compile‑time and calling them is done on the Foo type. If you create it as a Bar, static members are still bound at compile‑time. Instance members are dynamically bound (dynamic ≠ static, which might be why they chose the keyword static) at run‑time, so you get polymorphism. Because of the potential for confusion, you ought always to use the class name: Foo.myStaticMethod(...); and you can do that whether or not there are any variables of type Foo.