Java4Andriod 从零学起 ---learn3

super ; 函数的复写 ; 对象的转型

super:

class Person{
    String name ;
    int age ;

    Person(){
        System.out.println("Person的无参数构造函数");
    }

    Person(String name , int age){
        this.name = name ;
        this.age = age;
        System.out.println("Person的两个参数构造函数,他们是"+this.name+"和"+this.age);
    }

    void eat(){
        System.out.println("我是eat!");
    }
}

class Student extends Person{
    int grade ;

    Student(){
        super();//如果不写这句的话,系统就会自动加上这句话 , 与this一样,必须为函数的第一个语句
        System.out.println("Student的无参数构造函数");
    }

    Student(int grade){
        this() ; //调用本类中的其他构造函数
        this.grade = grade ;
        System.out.println("Student有grade="+this.grade+"为参数的构造函数");
    }

    Student(String name , int age , int grade){
        //this.name = name;
        //this.age = age;
        super(name , age);  //根据参数的不同,调用父类中的构造函数 , 减少了重复代码
        this.grade = grade ;
        System.out.println("Student调用了父类构造函数的构造函数");
    }

}

//在子类中,必须调用父类的构造函数即super() , 因为这样会减少重复代码的出现
//this() 和 super() 不能一起使用,因为他们两个都必须加在构造函数的第一句,会冲突 

---------------------------------------------

函数的复写:

class Person2{
    String name ;
    int age;

    void introduce(){
        System.out.println("我的姓名是"+this.name+"我的年龄是"+age);
    }

}

//复写(override):
//1.在具有父子类关系的两个类中
//2.在子类中函数与父类完全相同(返回值,参数)

class Student2 extends Person2{
    String address;

    void introduce(){  //这个就是函数的复写,它覆盖了原来Peron2中的introduce()
        super.introduce();  //super就相当于对父类的this
        System.out.println("我的地址是"+address);
    }
}

------------------------------------------------

对象的转型:

class Test2{
    public static void main(String args []){

        Student2 s1 = new Student2();
        s1.name = "Owen";
        s1.age = 20;
        s1.address = "Beijing";
        s1.introduce();

        Person2 p1 = new Person2();
        p1.name = "Owen" ;
        p1.age = 20;
        p1.introduce();
//----------------------------------------------------------------------------
        //对象的转型(两个类必须满足继承关系)-->有点像C语言中的强制转换

        //向上转型(上转)
        //1.一个引用能够调用哪些成员(变量和函数),取决于这个引用的类型
        //2.一个引用能够调用哪个方法,取决于这个引用所指的对象
        System.out.println("----下面是对象的转型相关内容-----");

        Student2 s = new Student2();
        Person2 p = s;  //向上转型
        //这样也可以: Person2 p = new Student2();

        p.name = "成爷";
        p.age = 20;
        //p.address = "北京"       -->Person2 会报错,因为person中没有address变量
        p.introduce();   //调用的是Student2中的复写过的introduce (就是Student2真的覆盖了Person2)

        //向下转型(先上转,再下转)
        //为了保证他们是相同的类型
        //

        Person2 pp = new Student2();
        Student2 ss = (Student2)pp;
        //Person2 pp = new Person2(); Student2 ss = (Student2)pp;  这样是不行的,因为无法保证pp可转

    }
}

为什么要进行对象的转型?

向上转型:   转型后,调用的方法,是复写过的方法(子类的方法); 成员变量, 是父类的成员变量(父类的变量);