在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