Java的继承

Java的继承

Object类

所有的类默认继承Object类

Ctrl+H 查看继承关系

类的继承

父类

package Demo03;

public class Person {
    /*修饰符 优先级
    public
    protected
    private
     */
    public void say(){
        System.out.println("说句话");
    }
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

子类

package Demo03;
//              使用extends继承
public class Student extends Person{
    //继承父类的所有公共方法 public修饰的

}

子类在其他类中的调用

package Demo03;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        //调用了student继承父类的Person的say方法
        student.setName("student继承了Person类,因为是private修饰的,所以要使用特殊方法调用");
        System.out.println(student.getName());

    }
}

super–this

属性和方法的调用

测试类

package Demo03;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say("王五");
        student.test();
    }
}

父类

package Demo03;

public class Person {
    protected String name="张三";
    //私有的不能被继承
    private int num = 20;
    public void print(){
        System.out.println("Person");
    }


}

子类

package Demo03;

public class Student extends Person{
        String name="李四";

        public void say(String name){
            System.out.println(name);//王五:传参的name
            System.out.println(this.name);//李四:Student类中的name
            System.out.println(super.name);//张三:父类中的name
        }
        public void print(){
            System.out.println("Student");
        }
        public void test(){
            print();//默认调用本类的方法
            this.print();//本类的方法
            super.print();//调用父类的方法
        }

}

构造器的调用

测试类

package Demo03;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        /*
        Person无参被执行了
        Student无参被执行了
         */
    }
}

父类

package Demo03;

public class Person {
    public Person() {
        System.out.println("Person无参被执行了");
    }
}

子类

package Demo03;

public class Student extends Person{

    public Student() {
        //隐藏代码 super()调用父类的构造器
        super();//必须放在子类的构造器的第一行
        //this("name")必须放在构造器第一行
        //总结要么调用父类构造器，要么调用子类构造器
        System.out.println("Student无参被执行了");

    }
    String name;

    public Student(String name) {
        this.name = name;
    }
}

父类中没有无参构造的情况

父类

package Demo03;

public class Person {


    public Person(String name) {
        this.name = name;
    }
    //有有参构造必须写出无参构造
    String name;
}

子类

package Demo03;

public class Student extends Person{
    //报错，父类中没有无参构造，子类中也不能调用
    public Student() {
        System.out.println();
    }
    //解决方法，调用父类的有参构造
    public Student(String name) {
        super(name);
    }
}

重写

静态方法static不能实现重写

测试

package Demo03;

public class Application {
    public static void main(String[] args) {
        //静态方法不能实现方法的重写,其输出值与左边的调用有关
    Person p = new Student();
    p.test();//输出为Person类的方法
    Student s = new Student();
    s.test();//输出为Student类的方法

    }
}

父类

package Demo03;

public class Person {
 public static void test(){
     System.out.println("Person");
 }

}

子类

package Demo03;

public class Student extends Person{
    public static void test(){
        System.out.println("Student");
    }
}

非静态方法的重写

测试

package Demo03;

public class Application {
    public static void main(String[] args) {
    Person p = new Student();
    p.test();//子类方法
    Student s = new Student();
    s.test();//子类方法
        //重写成功调用子类重写父类的方法

    }
}

父类

package Demo03;

public class Person {
    //要使用public修饰,不能使用private修饰
 public void test(){
     System.out.println("父类方法");
 }


}

子类

package Demo03;

public class Student extends Person{
    //alt+insert重写方法
    @Override
    //要使用public修饰,不能使用private修饰
    public void test() {
        //super.test();//默认调用父类方法
        System.out.println("子类方法");
    }
}

重写总结

/*
重写
 1.子类重写父类的方法
 2.方法名和列表相同
 3.修饰符范围可以扩大但不能缩小,一般使用public修饰
 4.抛出的异常范围可以缩小但不能放大
 重写子类方法与父类方法一致，但是方法体不同
 */