Java的继承

【1】类是对对象的抽象：
举例：
荣耀20 ，小米 红米3，华为 p40 pro   ---> 类：手机类

【2】继承是对类的抽象：
举例：
学生类：Student：
属性：姓名，年龄，身高，学生编号
方法：吃饭，睡觉，喊叫，学习

教师类：Teacher:
属性：姓名，年龄，身高，教师编号
方法：吃饭，睡觉，喊叫，教学

员工类：Emploee:
属性：姓名，年龄，身高，员工编号
方法：吃饭，睡觉，喊叫，工作

共同的东西：
人类：
属性：姓名，年龄，身高
方法：吃饭，睡觉，喊叫

学生类/教师类/员工类  继承 自   人类  

以后定义代码：
先定义人类：
人类： ---》父类，基类，超类
属性：姓名，年龄，身高
方法：吃饭，睡觉，喊叫

再定义 ： ---》子类，派生类

学生类：Student：
属性：学生编号
方法：学习

教师类：Teacher:
属性：教师编号
方法：教学

员工类：Emploee:
属性：员工编号
方法：工作 

子类  继承自  父类 

狗类：
属性：姓名，年龄，身高
方法：吃饭，睡觉，喊叫

我们的继承关系，是在合理的范围中进行的抽取 ，抽取出子类父类的关系：
上面的案例中：
学生类/教师类/员工类  继承 自   人类   ---》合理
学生类/教师类/员工类  继承 自   狗类   ---》不合理

区分：
学生是一个人
教师是一个人
员工是一个人   ---》合理

学生是一个狗    ---》不合理

总结：继承 就是  is - a 的关系 

【3】代码层面的解释：
先写父类，再写子类：

父类：人类  Person
子类：学生类   Student

父类的创建：

package com.msb.test03;
/**
 * @Auther: msb-zhaoss
 */
public class Person {
    //属性：
    private int age;
    private String name;
    private double height;
    //提供setter getter方法：
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        this.height = height;
    }
    //方法：
    public void eat(){
        System.out.println("可以吃饭。。。");
    }
    public void sleep(){
        System.out.println("可以睡觉。。。");
    }
}

子类的创建： 

package com.msb.test03;
/**
 * @Auther: msb-zhaoss
 */
public class Student extends Person {//子类Student 继承  父类Person
    //属性：
    private int sno;//学号
    public int getSno() {
        return sno;
    }
    public void setSno(int sno) {
        this.sno = sno;
    }
    //方法：
    public void study(){
        System.out.println("学生可以学习");
    }
}

测试类的创建 

package com.msb.test03;
/**
 * @Auther: msb-zhaoss
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建子类Student的对象
        Student s = new Student();
        s.setSno(1001);
        s.setAge(18);
        s.setName("菲菲");
        s.setHeight(180.4);
        System.out.println("学生名字为："+s.getName()+",学生的年纪："+s.getAge());
        //访问方法：
        s.study();
        s.eat();
        s.sleep();
    }
}

【4】继承的好处：提高代码的复用性
父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了

需要注意的点：
父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式，可以间接调用。

【5】总结：

（1）继承关系 ：
父类/基类/超类
子类/派生类
子类继承父类一定在合理的范围进行继承的    子类 extends  父类
（2）继承的好处：
1.提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了
2.便于代码的扩展
3.为了以后多态的使用。是多态的前提。

（3）父类private修饰的内容，子类也继承过来了。
（4）一个父类可以有多个子类。
（5）一个子类只能有一个直接父类。
但是可以间接的继承自其它类。

 

（6）继承具有传递性：

Student --》继承自  Person  ---》继承自Object
Object类是所有类的根基父类。
所有的类都直接或者间接的继承自Object。