Java中类的继承，包含，依赖关系

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

关系	含义	形式
泛化	A is – a B	继承，实现
包含	A has – a B	组合，聚合，关联
依赖	A use – a B	依赖

1.继承

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

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

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

    public void sleep(){ 
        System.out.println("动物的睡觉方法");
    }
}

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

}

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

【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");
    }
}

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
    }
}

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

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

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

}

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

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

Object类中的方法	作用
hashCode()	将对象在内存中的地址经过计算得到一个int整数
equals()	用来比较两个对象的内容 Object默认效果是== ，==可以比较基本类型(比较值) 可以比较引用类型(比较地址)，equals方法时Object类中继承过来的方法，默认效果比较地址，如果想要改变其规则可以进行方法重写
toString()	打印输出时将对象变成String字符串
getClass()	获取对象对应类的类映射(反射)
wait()	线程进入挂起等待状态存在方法重载
notify()	线程唤醒
notifyAll()	线程唤醒
notifyAll()	唤醒所有线程
finalize()	权限修饰符是protected ，在对象被GC回收的时候默认调用执行的方法
clone()	权限修饰符是protected 为了克隆对象

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

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

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

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

    public void eat(){ 
        System.out.println("人类的吃饭方法，讲究色香味俱全");
    }
}

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

【8】关于this和super的使用

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

public class Animal { 
    public String name;

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

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

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("人类的学习方法");
    }
}

public class Test { 
    public static void main(String[] args) { 
        Person p = new Person();
        p.study();
    }
}
/*****运行结果*****/
父类参构造函数
子类的构造方法
父类的吃饭方法
子类的吃饭方法
人类的学习方法

注意：调用一般方法的时候可以来回互相调用，执行可能产生问题(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("轮子可以旋转");
    }
}

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();//方法一定是对象调用的 车轮子的方法肯定是车轮子对象调用 可以放置在任何地方
    }
}

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尺寸酷黑颜色的车轮子
轮子可以旋转

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;
    }
}

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();
    }
}

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
小花被杀啦，好惨呀

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

本文地址：https://blog.csdn.net/qq_45544223/article/details/113944887

黄山市民网：https://www.huangshanshimin.com/

目录

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

1.继承

2.包含

3.依赖

相关文章