Java的继承

继承(Inheritance)

【1】类是对对象的抽象：

举例：

荣耀20 ，小米 红米3，华为 p40 pro   ---> 类：手机类

【2】继承是对类的抽象：

举例：

学生类：Student：

属性：姓名，年龄，身高，学生编号

方法：吃饭，睡觉，喊叫，学习

教师类：Teacher:

属性：姓名，年龄，身高，教师编号

方法：吃饭，睡觉，喊叫，教学

员工类：Emploee:

属性：姓名，年龄，身高，员工编号

方法：吃饭，睡觉，喊叫，工作

共同的东西：

人类：

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

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

以后定义代码：

先定义人类：

人类： ---》父类，基类，超类

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

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

学生类：Student：

属性：学生编号

方法：学习

教师类：Teacher:

属性：教师编号

方法：教学

员工类：Emploee:

属性：员工编号

方法：工作 

子类  继承自  父类 

狗类：

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

我们的继承关系，是在合理的范围中进行的抽取 ，抽取出子类父类的关系：

上面的案例中：

学生类/教师类/员工类  继承 自   人类   ---》合理

学生类/教师类/员工类  继承 自   狗类   ---》不合理

区分：

学生是一个人

教师是一个人

员工是一个人   ---》合理

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

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

【3】代码层面的解释： 

先写父类，再写子类：

父类：人类  Person

子类：学生类   Student

1.package com.msb.test03;
2.
3./**
4. * @Auther: msb-zhaoss
5. */
6.public class Person {
7.    //属性：
8.    private int age;
9.    private String name;
10.    private double height;
11.
12.    //提供setter getter方法：
13.
14.    public int getAge() {
15.        return age;
16.    }
17.
18.    public void setAge(int age) {
19.        this.age = age;
20.    }
21.
22.    public String getName() {
23.        return name;
24.    }
25.
26.    public void setName(String name) {
27.        this.name = name;
28.    }
29.
30.    public double getHeight() {
31.        return height;
32.    }
33.
34.    public void setHeight(double height) {
35.        this.height = height;
36.    }
37.
38.    //方法：
39.    public void eat(){
40.        System.out.println("可以吃饭。。。");
41.    }
42.
43.    public void sleep(){
44.        System.out.println("可以睡觉。。。");
45.    }
46.
47.}

1.package com.msb.test03;
2.
3./**
4. * @Auther: msb-zhaoss
5. */
6.public class Student extends Person {//子类Student 继承  父类Person
7.    //属性：
8.    private int sno;//学号
9.
10.    public int getSno() {
11.        return sno;
12.    }
13.
14.    public void setSno(int sno) {
15.        this.sno = sno;
16.    }
17.
18.    //方法：
19.    public void study(){
20.        System.out.println("学生可以学习");
21.    }
22.
23.}

1.package com.msb.test03;
2.
3./**
4. * @Auther: msb-zhaoss
5. */
6.public class Test {
7.    //这是一个main方法，是程序的入口：
8.    public static void main(String[] args) {
9.        //创建子类Student的对象
10.        Student s = new Student();
11.        s.setSno(1001);
12.        s.setAge(18);
13.        s.setName("菲菲");
14.        s.setHeight(180.4);
15.
16.        System.out.println("学生名字为："+s.getName()+",学生的年纪："+s.getAge());
17.
18.        //访问方法：
19.        s.study();
20.        s.eat();
21.        s.sleep();
22.    }
23.}
24.

【4】继承的好处：提高代码的复用性

父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了

需要注意的点：

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

【5】总结：

（1）继承关系 ：

父类/基类/超类

子类/派生类

子类继承父类一定在合理的范围进行继承的    子类 extends  父类

（2）继承的好处：

1.提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了

2.便于代码的扩展

3.为了以后多态的使用。是多态的前提。

（3）父类private修饰的内容，子类也继承过来了。

（4）一个父类可以有多个子类。

（5）一个子类只能有一个直接父类。

但是可以间接的继承自其它类。

6）继承具有传递性：

Student --》继承自  Person  ---》继承自Object

Object类是所有类的根基父类。

所有的类都直接或者间接的继承自Object。

【1】private：权限：在当前类中可以访问

【2】default:缺省修饰符：权限：到同一个包下的其他类都可以访问

【3】protected：权限：最大到不同包下的子类

【4】public：在整个项目中都可以访问

总结：

属性，方法：修饰符：四种：private，缺省，protected，public

类：修饰符：两种：缺省，public

以后写代码

一般属性：用private修饰 ，方法：用public修饰