Java的类继承

知识点
1、继承
作用：提高代码的重用性，继承之后子类可以继承父类中的属性和方法
减少重复代码
条件：子类和父类要满足is a的逻辑关系，才能使用继承。
如：苹果 is a水果
语法：使用extends 连接子类和父类。子类 extends 父类
Java是单继承，一个类只能继承一个父类。
子类不能继承父类私有的属性，但是可以继承父类属性的GET/SET方法
super关键字：代表父类对象，可以调用父类的属性，父类的方法，
子类对象在创建的时候，默认调用父类的无参构造方法。

二、abstract关键字 抽象
abstract可以修饰类和方法
1.抽象类
不能被实例化
2.abstract也可用于方法——抽象方法
抽象方法没有方法体
抽象方法必须在抽象类里
抽象方法必须在子类中被实现，除非子类是抽象类

 

对应验证访问修饰符总结的代码：

NUM.1 同包验证：

package a;
public class A {
    private String a="1";
    String b="2";
    protected String c="3";
    public String d="4";
}

package a;
public class B {
    public static void main(String[]args){
        A a=new A();
        System.out.println(a.b);//可以调用除用private修饰的之外所有的变量
    }
}

 NUM.2 不同包验证：

package b;
/**
 * 在这里要先进行导包，如果不这样，
 * 下面要想new A()就不行，new c()的意义在于建立一个子类方法，
 * 从而观察经private修饰过后的变量是否能在其子类中调用
 */
import a.A;
public class C extends A{
    public static void main(String[]args){
        A a=new A();
        C c=new C();
        //c作为子类是可以调用以private访问修饰符修饰的c
        //以及用public修饰的d
        System.out.println(c.c);
        System.out.println(c.d);
        //而a作为new的父类，则因在不同包的原因而只能调用public修饰的d
        System.out.println(a.d);
    }
}

 

写到这里，我突然想到java默认的调用方法是用无参的方法，如果有在调用时设定了参数就会使用有参构造方法，

此时不由想到父类和子类的代码块调用，于是我设计了以下代码去进行测试

package day20190227;
public class Pet {
    private String name;
    private int health;
    private int love;
    public Pet(){
        System.out.println("父类的无参构造方法调用");
    }
    public Pet(String name,int health,int love){
        System.out.println("父类的有参构造方法调用");
        this.name=name;
        this.health=health;
        this.love=love;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    //输出宠物信息
    public String printInfo(){
        return "我的名字叫"+name+",健康值为"+health+",亲密度为"+love;
    }
}

package day20190227;
/**
 * 狗类，继承Pet类
 * @author Administrator
 *
 */
public class Dog extends Pet {
    private String strain;
    public Dog(){
        System.out.println("狗类无参构造方法调用");
    }
    public Dog(String name,int health,int love,String strain) {
        //super.printInfo();调用父类的方法
        //super.name;调用父类的属性
        super(name,health,love);//调用父类构造方法,必须在第一行
        System.out.println("狗类有参构造方法调用");
        this.strain = strain;
    }
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
}

在设定好父类和子类的无参构造方法和有参构造方法后，我在其中分别加入了一段说明语句，而后再重新编辑了一个TestDogCon类用于测试；

package day20190227;
/**
 * 有参&无参调用测试
 * @author Administrator
 *
 */
public class TestDogCon {
    public static void main(String[] args) {
        Dog dog=new Dog("小华",90,90,"拉布拉多犬");
    }
}

经测试发现当dog设定了数据时，显示的都是

而当将new Dog（）中的数据删去后，显示的则是

 

总结：在创建子类的对象时，Java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法。

在多级继承的情况下，将从继承树的最上层的父类开始，依次执行各个类的构造方法，这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确的初始化。