子类与超类，多态，上转型，下转型

1. 写一个父类

package SuperAndThis;

public class SuperClass{

    public static void eat(){
        System.out.println("我是静态的，父类吃！");
    }

    public void say(){
        System.out.println("我是父类说！");
    }

    public void go(){
        System.out.println("我是父类走！");
    }

    public static void think(){
        System.out.println("我是静态的，父类想！");
    }
}

2.写一个子类：

package SuperAndThis;

public class ChildClass extends SuperClass {

    public static void eat(){
        //super.eat();  //静态方法中不能用super
        System.out.println("我是静态的，子类吃！");
    }

    public void say(){
        super.say();
        System.out.println("我是子类说！");
    }

    public void usePareStaticThink(){
        super.think();  //子类方法调用父类静态方法
    }
}

1. 写一个main

package SuperAndThis;

public class Main {

    public static void main(String[] args) {
        SuperClass parent=new SuperClass();
        ChildClass child=new ChildClass();
        ChildClass.think(); //1.子类可直接调用父类的类方法
        child.say();        //2.子类方法重写并调用父类方法
        child.go();         //3.子类对象可以调父类的非静态方法
        child.think();      //4.子类对象可以调父类的静态方法
        child.usePareStaticThink();  //5.子类方法可以调用父类静态方法(用super)
        System.out.println();
        System.out.println("向上转型(多态)：");

        //向上转型，多态
        parent=child;  
        parent.say();  //1. 自身和子类都有say,调用了子类的say(多态)  
        parent.think();  //2. 自身有think，子类没有think，调用自身的think
        //3. 自身没有usePareStaticThink，子类有，需要强制转换(向下转型)为子类才可调用
        ((ChildClass) parent).usePareStaticThink();  
    }

}

1. 输出：

我是静态的，父类想！
我是父类说！
我是子类说！
我是父类走！
我是静态的，父类想！
我是静态的，父类想！

向上转型(多态)：
我是父类说！
我是子类说！
我是静态的，父类想！
我是静态的，父类想！