以下代码执行的结果是多少（）？

public class A { 
    public static String staticStr = "A's static field";  
    public String nonStaticStr = "A's nonstatic field";  
    public static void staticMethod(){  
        System.out.println("A's static method");  
    }  
    public void nonStaticMethod(){  
        System.out.println("A's nonstatic method");  
    }  
}  
public class B extends A{
    public static String staticStr = "B's static field";  
    public String nonStaticStr = "B's nonstatic field";  
    public static void staticMethod(){  
        System.out.println("B's static method");  
    }  
}
public class C extends A{
  
} 
public class Test {  
  
    public static void main(String[] args) {  
        C c = new C();  
        System.out.println(c.nonStaticStr);  //A's nonstatic field
        System.out.println(c.staticStr);  //A's static field
        c.staticMethod(); //A's static method
       
        System.out.println("-------------------------------");  
          
        A c1 = new C();  
        System.out.println(c1.nonStaticStr);  //A's nonstatic field
        System.out.println(c1.staticStr);  //A's static field
        c1.staticMethod(); //A's static method
         
		// 以上这说明java中静态属性和静态方法可以被继承
        
		System.out.println("-------------------------------");  
        B b = new B();  
        System.out.println(b.nonStaticStr); // B's nonstatic field
        System.out.println(b.staticStr);   //B's static field
        b.staticMethod();  //B's static method
		
        System.out.println("-------------------------------");  
        A b1 = new B();  
        System.out.println(b1.nonStaticStr);  //A's nonstatic field
        System.out.println(b1.staticStr);  //A's static field
        b1.staticMethod(); //A's static method
		//b1.nonStaticStr  输出的是父类的非静态属性，说明非静态属性不可以被重写，不能实现多态
		//b1.staticStr     输出的是父类的静态属性，说明静态属性不可以被重写，不能实现多态
		//b1.staticMethod()输出的是父类A的静态方法，不是子类B改写后的，所以没有实现多态
		
		
	    //结论是：静态属性和静态方法只是可以继承没有表现出多态性。
		//因为静态方法和静态属性没有采用动态绑定。具体表现就是，
		//将子类实例向上转型则会调用到基类中的静态方法和属性，
		//不转型就调用子类自身的静态方法和属性。
		//编译器不推荐通过实例去调用静态方法和属性，因为这种调用方式容易造成混淆。
		
		//实际上，在Java的规范中，Java对于类的方法和属性采用了两种完全不同的处理机制：
		//对于方法，使用重载机制实现了多态性；对于属性，使用的是同名属性隐藏机制。
		//所谓的同名属性隐藏机制是指：在具有父子关系的两个类中，
		//子类中相同名字的属性会使得从父类中继承过来的同名属性变得不可见，
		//不管类型是否一致，名称一致的两个属性就是同名属性。
		//在子类中，无法简单地通过属性名称来获取父类中的属性，
		//而是必须通过父类名称加属性名称(super.变量名)的方法才可以访问父类中的该属性。
		//一般而言，为了代码容易阅读，极其不建议在父类和子类中使用同名属性。
    }  
  
}

1、简单而言就是，静态方法不能被重写！
Father father = new Son(),
father调用静态方法时会是father中的方法。
类似java中的同名属性，但属性是会覆盖掉父类的。
2、我本来想选D的，不知道怎么点到C了~

答案是C，因为一开始定义数组的时候就是使用了Collection<?>[] collections，里面的数组元素会变成Collection类型！所以输出都是Super:collection，而不是Super:hashSet（一开始需要显式getType(new HashSet)）！

public class Father {
    static int hello = 1;
    public static void  show(){
        System.out.println("这是父类的show");
    }
    public void method() {
        System.out.println("这是父类的method");
    }
}
public class Sub extends Father{
    static int hello = 2;
    public static void show() {
        System.out.println("这是子类的show");
    }
    public void  method() {
        System.out.println("这是子类的method");
    }
    public static void main(String[] args) {
        Father father = new Sub();
        Sub sub = new Sub();
        father.show(); 
        father.method();
        System.out.println("Sub.main()" + hello);
    }
}
/*
这是父类的show
这是子类的method
Sub.main()2
*/

• 方法名相同
• 方法的参数类型，参数个不一样
• 方法的返回类型可以不相同
• 方法的修饰符可以不相同
• main 方法也可以被重载

• 静态方法（static修饰）是静态绑定，编译期间根据创建对象时，等号左边的数据类型确定调用父类还是子类的方法。因此不会调用子类Sub的`getType`方法，只会调用父类Super的。
• 重载是静态绑定，编译时多态，编译期间根据实参的等号左边的数据类型去严格匹配形参的数据类型和个数。

public class StaticInherit {
    public static void main(String[] args) {
        Collection<?>[] collections =
                {new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
        System.out.println("静态绑定，看编译类型(左边)");

        System.out.println("----------> 通过对象调用方法 <--------------");
        System.out.println("左边为父类，调用父类");
        Super subToSuper = new Sub();
        for(Collection<?> collection: collections) {
            System.out.println(subToSuper.getType(collection));
        }

        System.out.println("-------------------------");
        System.out.println("左边为子类，调用子类");
        Sub sub = new Sub();
        for(Collection<?> collection: collections){
            System.out.println(sub.getType(collection));
        }

        System.out.println("----------> 通过类调用方法 <--------------");
        System.out.println("Super调用方法");
        for(Collection<?> collection: collections){
            System.out.println(Super.getType(collection));
        }
        System.out.println("---------------------");
        System.out.println("Sub调用方法");
        for(Collection<?> collection: collections){
            System.out.println(Sub.getType(collection));
        }

        System.out.println("------------> 通过对象调用属性 <-------------");
        System.out.println(subToSuper.name);
        System.out.println(sub.name);
        System.out.println("------------> 通过类调用属性 <-------------");
        System.out.println(Super.name);
        System.out.println(Sub.name);
    }

    abstract static class Super {
        static String name = "Super";

        public static String getType(Collection<?> collection) {
            return "Super:collection";
        }
        public static String getType(List<?> list) {
            return "Super:list";
        }
        public String getType(ArrayList<?> list) {
            return "Super:arrayList";
        }
        public static String getType(Set<?> set) {
            return "Super:set";
        }
        public String getType(HashSet<?> set) {
            return "Super:hashSet";
        }
    }

    static class Sub extends Super {
        static String name = "Sub";

        public static String getType(Collection<?> collection) {
            return "Sub"; }
    }
}

• 输出结果

静态绑定，看编译类型(左边)
----------> 通过对象调用方法 <--------------
左边为父类，调用父类
Super:collection
Super:collection
Super:collection
-------------------------
左边为子类，调用子类
Sub
Sub
Sub
----------> 通过类调用方法 <--------------
Super调用方法
Super:collection
Super:collection
Super:collection
---------------------
Sub调用方法
Sub
Sub
Sub
------------> 通过对象调用属性 <-------------
Super
Sub
------------> 通过类调用属性 <-------------
Super
Sub

1、简单而言就是，静态方法不能被重写！