Java中类的继承，包含，依赖关系_8、 java语言类间的继承关系

---

Java中类和类有以下几种关系

---

---

1.继承

---

【1】 子类继承父类，通过一个关键字： extends

【2】类的对象可以调用父类中的(public protected)属性和方法 ，当做自己的来使用

//父类
public class Animal {
    public String name;
    
    public void eat(){
        System.out.println("动物的吃饭方法");
    }

    public void sleep(){
        System.out.println("动物的睡觉方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

//子类继承父类
public class Person extends Animal {

}
1
2
3
4

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Lisi";
        p.eat();            // 动物的吃饭方法
        p.sleep();          // 动物的睡觉方法
    }
}
1
2
3
4
5
6
7
8

【3】子类可以添加自己独有的属性和方法的

【4】子类从父类中继承过来的方法不能满足子类需要，可以在子类中重写(覆盖)父类的方法，更多指的是内容

public class Person extends Animal {
    public void eat(){           //子类中eat方法的重写
        System.out.println("人类的吃饭方法，讲究色香味俱全");
    }
    
    public void study(){         //子类独有的方法
        System.out.println("good good study,day day up");
    }
}
1
2
3
4
5
6
7
8
9

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Lisi";
        p.eat();        // 人类的吃饭方法，讲究色香味俱全
        p.study();      // good good study,day day up
    }
}
1
2
3
4
5
6
7
8

【5】每一个类都有继承类，如果不写extends关键字，默认继承Object，如果写了extends则继承后面那个父类。可以理解为Object是任何一个引用类型的父类(直接或间接的继承Object) ，但Object类没有父类。

【6】Java中继承是单个存在的(单继承) 每一个类只能有一个继承类 (在extends关键字后面只能写一个类)，但可以通过传递的方式实现多继承的效果 ，后续还会有多实现。

// 去掉继承关系后
public class Person {

}

1
2
3
4
5

注:作者使用的IDE是《IntelliJ IDEA Educational Edition 2020.3 x64》

• Object类中的方法
• 注：按住shift键 + ctrl键 再点击上面的函数名，就可以点进去查看Object函数源码

【7】继承在内存中的存储形式

public class Animal {
    public Animal(){
        System.out.println("动物无参构造函数");
    }

    public void eat(){
        System.out.println("动物的吃饭方法");
    }
}
1
2
3
4
5
6
7
8
9

public class Person extends Animal{
    public Person(){
        System.out.println("人类的构造方法");
    }

    public void eat(){
        System.out.println("人类的吃饭方法，讲究色香味俱全");
    }
}
1
2
3
4
5
6
7
8
9

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.eat();
    }
}
/*****运行结果*****/
动物无参构造函数
人类的构造方法
人类的吃饭方法，讲究色香味俱全
1
2
3
4
5
6
7
8
9
10

【8】关于this和super的使用

• this和super都是指代词 ，代替的是对象，都能调用一般属性 和 一般方法，可以放置在类成员的任意位置(属性， 方法， 构造，块)
• this代替的是当前执行方法时的那个对象 ，不一定是当前类的
• super代替的是当前执行方法时的对象的父类对象 ， 空间内部的那个

public class Animal {
    public String name;

    public Animal(){
        System.out.println("父类参构造函数");
    }

    public void eat(){
        System.out.println("父类的吃饭方法");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

public class Person extends Animal{
    public Person(){
        System.out.println("子类的构造方法");
    }

    public void eat(){
        System.out.println("子类的吃饭方法");
    }

    public void study(){
       super.eat();     //调用study方法的对象是Person p,super指代Person的父类
       this.eat();      //this指代调用study方法的对象，即Person

        System.out.println("人类的学习方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.study();
    }
}
/*****运行结果*****/
父类参构造函数
子类的构造方法
父类的吃饭方法
子类的吃饭方法
人类的学习方法
1
2
3
4
5
6
7
8
9
10
11
12

• 注意：调用一般方法的时候可以来回互相调用， 执行可能产生问题(StackOverflowError)。
• 可以调用构造方法(放在构造方法的第一行)，this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行。
• 构造方法之间不能来回互相调用(编译就不好用)。

---

2.包含

---

【1】包含关系(组合 聚合 关联) 从亲密程度来讲不太一样

【2】从Java程序来描述这样的关系 通过一个类的对象当做另一个类的属性来存储
【3】类的个数变多啦—>需要管理类—>包package(可以理解为是一个文件夹)

• 在我们类的第一行会出现package关键字
• 如果package和import同时出现，先写package后写import，package只能有一个 ，import可以有多个

【4】以汽车和轮子为例子来解释包含（这里是聚合）的关系

• 建立工程 —> 右键src —> new —> package —> 输入包名

package contain;

public class Wheel {
    // 属性
    public String brand;  //品牌
    public String color;  //颜色
    public int size;      //尺寸

    // 构造方法
    public Wheel(){}
    public Wheel(String brand,String color,int size){
        this.brand = brand;
        this.color = color;
        this.size = size;
    }

    // 方法
    public void turn(){
        System.out.println("轮子可以旋转");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package contain;

public class Car {
    // 属性
    public String brand;    //汽车品牌
    public String color;    //汽车颜色
    public String type;     //汽车型号
    public Wheel wheel;     // 汽车里有轮子 -----> 包含关系

    // 构造方法
    public Car(){}
    public Car(String brand,String color,String type,Wheel wheel){
        this.brand = brand;
        this.color = color;
        this.type = type;
        this.wheel = wheel;

    }
    // 方法
    public void showCar(){
        System.out.println("这是一辆"+brand+"牌"+type+"型号"+color+"的小汽车");
        System.out.println("车上搭载着"+wheel.brand+"牌的"+wheel.size+"尺寸"+wheel.color+"颜色的车轮子");
        wheel.turn();//方法一定是对象调用的  车轮子的方法肯定是车轮子对象调用   可以放置在任何地方
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import contain.Car;
import contain.Wheel;
public class Test {
    public static void main(String[] args) {
        Car car = new Car("宝马","Z4","宝石蓝色",new Wheel("米其林","酷黑",400));
        car.showCar();//展示汽车
    }
}
/******运行结果*****/
这是一辆宝马牌宝石蓝色型号Z4的小汽车
车上搭载着米其林牌的400尺寸酷黑颜色的车轮子
轮子可以旋转
1
2
3
4
5
6
7
8
9
10
11
12

---

3.依赖

---

【1】依赖关系：不是整体和部分的关系 ，某一件事情产生了关系 ，临时组合在一起 ，这件事情一旦做完关系即解散。
【2】 Java程序体现的形式为:一个类的方法中使用到了另一个类的对象

• 可以在方法中传递参数
• 可以在方法中自己创建

【3】下面以农夫养猪，屠夫杀猪来演示类的依赖关系

package rely;

public class Pig {//描述猪

    //属性
    private String name;//名字
    private int weight = 20;//体重

    //构造方法
    public Pig(){}
    public Pig(String name){
        this.name=name;
    }

    //方法
    //描述一个方法  表示小猪被杀啦
    public void beKilled(){
        System.out.println(this.name+"被杀啦，好惨呀");
    }

    //描述一个方法  让猪长肉
    //    每一个月涨到前一个月的两倍
    public void growUp(int month){
        for(int i=1;i<=month;i++){
            this.weight*=2;
        }
    }

    //描述一个方法  猪告知他的体重
    public int getWeight(){
        return this.weight;
    }
    public String getName(){
        return this.name;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package rely;

public class Butcher {//描述屠夫

    //属性  名字 有刀

    //方法
    //描述一个屠夫杀猪的方法   需要提供条件 一头猪
     //依赖--->在屠夫的方法中使用到了猪的对象
    public void killPig(Pig pig){
        System.out.println("屠夫执行了杀猪方法");
        String pigName = pig.getName();
        int pigWeight = pig.getWeight();
        System.out.println(pigName+"的体重为:"+pigWeight);
        pig.beKilled();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import relay.Butcher;
import relay.Pig;
import relay.Farmer;

public class Test {
    public static void main(String[] args) {
        //创建农夫对象
        Farmer farmer = new Farmer();
        //农夫做一件事情--->养猪
        Pig pig = farmer.feedPig(5,"小花");
        //创建屠夫对象
        Butcher butcher = new Butcher();
        //屠夫做事--->杀猪
        butcher.killPig(pig);
    }
}
/*******运行结果********/
屠夫执行了杀猪方法
小花的体重为640
小花被杀啦，好惨呀
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

设计类的关系遵循的原则:高内聚低耦合
耦合度:     继承(实现) > 包含 > 依赖
1
2