java的继承性

在java继承中，子类也称为派生类，父类也称为基类或者超类，基本语法 ：子类 extends 父类{}

实现一个简单的继承类：

class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name ;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age ;
    }
    public int getAge(){
        return age ;
    }
}
class Student extends Person{
    private String school ;
    public void setSchool(String school){
        this.school = school ;
    }
    public String getSchool(){
        return school ;
    }
}
public class Test{
    public static void main(String args[]){
        Student stu = new Student();
        stu.setName("小学生");//父类方法
        stu.setAge(18);//父类方法
        stu.setSchool("蓝翔挖掘机专修学院"); //自身方法
        System.out.println(stu.getName()+"、"  + stu.getAge() + "、" + stu.getSchool());
    }
}

在对子类进行实例化的时候，先是执行父类构造方法，然后执行子类

class Person{
    public Person(){
        System.out.println("父类无参构造");
    }
}
class Student extends Person{
    public Student(){
        super();//此处不写super();也会默认调用
        System.out.println("子类无参构造");
    }
}
public class Test{
    public static void main(String args[]){
        new Student();//此时默认调用父类无参构造
    }
}
/*执行结果：
父类无参构造
子类无参构造
*/

class Person{
    private String name;
    public Person(String name){
        System.out.println("父类无参构造" + name); 
    }
}
class Student extends Person{
    public Student(){
        super("java");//调用父类的有参构造，一定要放在第一个语句，和this()相似
        System.out.println("子类无参构造");
    }
}
public class Test{
    public static void main(String args[]){
        new Student();//此时默认调用父类无参构造
    }
}
/*执行结果：
父类无参构造
子类无参构造
*/

子类覆写父类的方法中的注意点

　　实例化的是哪一个类，在实例化对象在调用的时候就会默认调用该类的方法，如果子类不存在该方法，则会调用父类中的该方法，

　　子类在覆写父类中的方法时候，方法的访问权限不能比父类要高，如果父类使用了private定义了一个方法，那么子类无法覆写，因为private定义的方法对外不可见只可以在本类中使用，即使子类写了一个相同的方法，也不可以称为覆写

class A{
    public void print(){
        System.out.println("A类中的方法");
    }
    public void fun(){
        System.out.println("B类没有覆写该方法，默认调用父类");
    }
}
class B extends A{
    public void print(){
        System.out.println("B类中的方法");
    }
}
public class Test{
    public static void main(String args[]){
        B b = new B();
        b.print();    //B类中的方法
        b.fun();    //B类没有覆写该方法，默认调用父类
    }
}

this.方法():首先会查找子类是否存在该方法，如果存在则直接调用，如果不存在则查找父类中是否有该方法，如果有则直接调用，如果没有则出现编译错误；

super.方法():直接调用父类中的该方法，如果不存在则出现编译时的错误；

重载和覆写之间的区别：

　　重载（Overloading）:在一个类中进行；方法名相同，参数个数以及类型不同；方法定义的没有权限限制；

　　覆写（overrid）:发生在继承关系中；方法名称相同，参数个数以及类型相同，返回值相同；子类不能比父类更加严格；

一个不需要注意的继承案例

class Array{
    private int data[];
    private int foot;
    public Array(int len){
        if(len != 0){
            this.data = new int[len];
        }else{
            this.data = new int[1];
        }
    }
    public void  add(int num){
        if(this.foot>=this.data.length){
            return;
        }else{
            this.data[foot++] =num;    
        }
    }
    public int[] getData(){
        return this.data;
    }
}
//定义一个排序类
class SortArray extends Array{
    public SortArray(int len){
        super(len);//明确调用父类的有参构造，作用是为数组初始化
    }
    //覆写父类方法
    public int[] getData(){
        java.util.Arrays.sort(super.getData());//
        return super.getData();
    }
}
//反转数组
class ReverseArray extends Array{
    public ReverseArray(int len){
        super(len);
    }
    public int[] getData(){
        int num = super.getData().length/2;//反转次数
        int head = 0;
        int tail = super.getData().length - 1;
        for(int x = 0;x < num;x++){
            int temp = super.getData()[head];
            super.getData()[head] = super.getData()[tail];
            super.getData()[tail] = temp;
            head ++;
            tail --;

        }
        return super.getData();
    }
}
public class Test{
    public static void main(String args[]){
        ReverseArray arr = new ReverseArray(3);
        arr.add(1);
        arr.add(10);
        arr.add(3);
        arr.add(4);
        //arr.add(5);
        int data[] = arr.getData();
        for(int x=0;x<data.length;x++){
            System.out.print(data[x]+"	");
        }
    }
}