Java基础-构造函数,覆写父类方法，多态及动态绑定，抽象类和Object类的运用

1.运行结果：

2.代码：

public class ConstructorStudy {

    public static void main(String[] args) {
        System.out.println("----------无参构造函数---------");
        //无参构造函数：若父类也有构造函数，则先进行父类的无参构造函数扫描，然后才进行自身的扫描
        LiLei ll=new LiLei();
        ll.name="李磊";
        System.out.println("姓名:"+ll.name);
        System.out.println("----------有参构造函数---------");
        //有参构造函数：先通过super来访问父类的有参构造函数信息传递，然后才进行自身的扫描
        ll=new LiLei(10);
        ll.hobby("足球");
        System.out.println("----------子类覆写父类方法---------");
        //子类覆写(overload)了父类的方法Breath();若要访问服务的Breath()方法，则用super.Breath();
        //super的用途：
        //1.子类构造函数中调用父类的构造函数
        //2.子类中调用父类的方法
        ll.Breath();
        System.out.println("----------多态及动态绑定---------");
        People[] p=new People[2];
        p[0]=new People();
        p[1]=new LiLei();
        p[0].Breath();
        p[1].Breath();
        //不能直接访问LiLei里面的方法hobby(P[1].hobby("足球"))，只能访问父类里面有的方法
        //如果要访问LiLei里面的方法，需进行类型转换
        ConstructorStudy cs=new ConstructorStudy();
        cs.TypeTransform(p[0]);
        cs.TypeTransform(p[1]);
        System.out.println("----------抽象类的使用---------");
        WaterObject aboard=new Aboard();
        aboard.function();
        //如果要使用aboard对象的其他方法OtherFunction(),需进行类型转换
        ((Aboard)aboard).OtherFunction();
        System.out.println("----------Object类的使用---------");
        //所有的类都是Object类的子类，创建一个Object数组
        Object[] obj=new Object[3];
        People p1=new People();
        People p2=new LiLei();
        ((LiLei)p2).Do();
        //用Object数组来存放对象，可以存放任何类型
        obj[0]=p1;
        obj[1]=p2;
        obj[2]=new String("字符串");
        ((LiLei)obj[1]).hobby("羽毛球");
    }
    
    void TypeTransform(People pp)
    {
        //instanceof运算符对对象的判断
        if(pp instanceof LiLei)
        {
            ((LiLei)pp).hobby("乒乓球");
        }
        else
        {
            System.out.println("其他");
        }
    }

}

class People
{
    String name;
    int age;
    double weight;
    double height;
    People()
    {
        System.out.println("调用People的无参构造函数");
    }
    People(int i)
    {
        System.out.println("调用LiLei的有参构造函数");
        System.out.println("age:"+i);
    }
    void Breath()
    {
        System.out.println("人需要呼吸");
    }
}

class LiLei extends People
{
    LiLei()
    {
        System.out.println("调用LiLei的无参构造函数");
    }
    LiLei(int i)
    {
        super(i);//super直接调用父类的有参构造函数
        System.out.println("调用LiLei的有参构造函数");
    }
    void hobby(String h)
    {
        System.out.println("爱好是："+h);
    }
    void Breath()//覆写父类的方法
    {
        super.Breath();//调用父类的方法
        System.out.println("人是用嘴呼吸的");
    }
    
    final String Do()
    {
        return "Study English";
    }
}

//final定义类为最终类，即不可继承的类，若类定义为final，则其方法自动也是final类型,但是实例变量不是final类型，必须声明
final class Lucy
{
    //若变量声明为final，则其变量的值是不会改变的
    final int age=7;
    void Do(){};
}

//抽象类定义
//定义为抽象类，则其方法不一定为抽象方法，反若为有抽象方法的类，则一定为抽象类；
//抽象方法在父类中不实现，但是在其继承的非抽象子类中必须实现
abstract class WaterObject
{
    WaterObject(){}
    abstract void function();
}

class Aboard extends WaterObject
{
    //实现其父类的抽象方法
    void function()
    {
        System.out.println("可以渡河");
    }
    void OtherFunction()
    {
        System.out.println("可以其他功能");
    }
}