例4.11
JConstructionPeople.java

public class JConstructionPeople  
{
    private String name;
    private int age;

    public JConstructionPeople(String n, int age)
    {
        name = n;
        this.age = age;
    }

    public JConstructionPeople(String n)
    {
        this(n, 10);
    }

    public JConstructionPeople()
    {
        this("who am i");
    }

    public static void main(String args[])
    {
        JConstructionPeople a1 = new JConstructionPeople();
        JConstructionPeople a2 = new JConstructionPeople("张三");
        System.out.println("对象a1的name是  " + a1.name + "  ;对象a1的age是" + a1.age
                + "岁");
        System.out.println("对象a2的name是  " + a2.name + "  ;对象a2的age是" + a2.age
                + "岁");
    }
}

例4.12
JOverridingTest.java

class JOverriding  
{
    public void test1()
    {
        System.out.println("Hi JOverriding");
    }
}

class JSubOverriding  extends  JOverriding  
{
    //方法覆盖
    public void test1()
    {
        System.out.println("Hi JSubOverriding");
    }

    //方法重载
    public void test1(int i)
    {
        System.out.println("Hi JSubOverriding,Now i = " + i);
    }

    /**
     * 既不是方法重载也不是覆盖，不被允许
     * public String test1() { return "ok"; }
     */
}

public class JOverridingTest  
{
    public static void main(String args[])
    {
        JSubOverriding jSubOverriding=new JSubOverriding();
        JOverriding jOverriding=new JOverriding();
        jSubOverriding.test1();
        jSubOverriding.test1(100);
        jOverriding.test1();
    }
}

例4.13
JStaticMethodTest.java

class JStaticMethod  
{
    public void One(int i){}
    public void Two(int i){}
    public static void Three(int i){}
    public static void Four(int i){}

}

class JSubStaticMethod extends JStaticMethod  
{
    public void One(int i){}
    //public static void Two(int i){}  //编译出错，无法将父类的非静态方法覆盖为静态方法
    public static void Three(int i){}
    //public void Four(int i){}  ////编译出错，无法将父类的静态方法覆盖为非静态方法
}

例4.14
JDynamicMethodTest.java

class A  
{
    public void Hello()
    {
        System.out.println("Hello,here is A");
    }
}

class B extends A  
{
    public void Hello()
    {
        System.out.println("Hello,here is B");
    }
}

class C extends B  
{
    public void Hello()
    {
        System.out.println("Hello,here is C");
    }
}

public class JDynamicMethodTest  
{
    public static void main(String args[])
    {
        A a = new A(); // 实例化类A，得到A类型的对象a
        B b = new B(); // 实例化类B，得到B类型的对象b
        C c = new C(); // 实例化类C，得到C类型的对象c
        A x; // 声明一个A类型的对象x，即x的引用对象类型为A
        x = a; // 初始化x，被引用的对象类型也是A
        x.Hello(); // x实际执行的是类A的Hello()方法
        x = b; // 初始化x，通过向上转型，此时被引用的对象类型是B
        x.Hello(); // x实际执行的是类B的Hello()方法
        x = c; // 初始化x，通过向上转型，此时被引用的对象类型是C
        x.Hello(); // x实际执行的是类C的Hello()方法

        b = new C(); // 重新初始化b，通过向上转型，此时被引用的对象类型是其子类C
        b.Hello(); // b实际执行的是类C的Hello()方法
    }
}