Java的类继承

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

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

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

NUM.1 同包验证：

11 package a;
22 public class A {
33     private String a="1";
44     String b="2";
55     protected String c="3";
66     public String d="4";
77 }
8
91 package a;
102 public class B {
113     public static void main(String[]args){
124         A a=new A();
135         System.out.println(a.b);//可以调用除用private修饰的之外所有的变量
146     }
157 }

NUM.2 不同包验证：

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

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

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

1 1 package day20190227;
2 2 public class Pet {
3 3     private String name;
4 4     private int health;
5 5     private int love;
6 6     public Pet(){
7 7         System.out.println("父类的无参构造方法调用");
8 8     }
9 9     public Pet(String name,int health,int love){
1010         System.out.println("父类的有参构造方法调用");
1111         this.name=name;
1212         this.health=health;
1313         this.love=love;
1414     }
1515     public String getName() {
1616         return name;
1717     }
1818     public void setName(String name) {
1919         this.name = name;
2020     }
2121     public int getHealth() {
2222         return health;
2323     }
2424     public void setHealth(int health) {
2525         this.health = health;
2626     }
2727     public int getLove() {
2828         return love;
2929     }
3030     public void setLove(int love) {
3131         this.love = love;
3232     }
3333     //输出宠物信息
3434     public String printInfo(){
3535         return "我的名字叫"+name+",健康值为"+health+",亲密度为"+love;
3636     }
3737 }
38
39 1 package day20190227;
40 2 /**
41 3  * 狗类，继承Pet类
42 4  * @author Administrator
43 5  *
44 6  */
45 7 public class Dog extends Pet {
46 8     private String strain;
47 9     public Dog(){
4810         System.out.println("狗类无参构造方法调用");
4911     }
5012     public Dog(String name,int health,int love,String strain) {
5113         //super.printInfo();调用父类的方法
5214         //super.name;调用父类的属性
5315         super(name,health,love);//调用父类构造方法,必须在第一行
5416         System.out.println("狗类有参构造方法调用");
5517         this.strain = strain;
5618     }
5719     public String getStrain() {
5820         return strain;
5921     }
6022     public void setStrain(String strain) {
6123         this.strain = strain;
6224     }
6325 }

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

1 1 package day20190227;
2 2 /**
3 3  * 有参&无参调用测试
4 4  * @author Administrator
5 5  *
6 6  */
7 7 public class TestDogCon {
8 8     public static void main(String[] args) {
9 9         Dog dog=new Dog("小华",90,90,"拉布拉多犬");
1010     }
1111 }

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

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

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

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

评论区

相关推荐