「java中的关联关系」java关系图展示

今天给各位分享java中的关联关系的知识，其中也会对java关系图展示进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java中对象引用与数据库在实现关联关系时的不同
• 2、Java类之间的关联关系有哪些
• 3、java中类与类之间的关系讲解
• 4、类（对象）之间的四种关系
• 5、JAVA作业求助。
• 6、怎么看java代码中接口调用关系

java中对象引用与数据库在实现关联关系时的不同

....

完全不是

一个问题

首先java中的数据

变量

和数据库中的

字段

存储方式就不一样

java是对象存储

数据库是关系存储

如果你想让java

中数据

直接映射到数据库

术语是：ORM

对象关系映射

你所提出的问题

应该是在对象关系映射

基础

上的问题

而数据库中的主键和

外键

在ORM基础上的反映只是一个flag而已

数据库的外键主键关系不影响java中对数据的操作

Java类之间的关联关系有哪些

组合:一个类中使用其它类的对象做变量。

如:class Car{private Wheel wheel;}

class Wheel{}

继承:从父类衍生出一个新类

class Animal{}

class Dog extends Animal{}

java中类与类之间的关系讲解

1.关联

关联即对象与对象之间的连接。java类之间的关联是一个类的作为另一个的属性被定义，即“has-a”的关系。关联又分为组合与聚合两种。示例如下：

//两个类之间的聚合public class Car{}public class Person{

private Car car;

}//两个类之间的组合public class Car{}public class Person{

private Car car=new Car();//创建一个Car对象}123456789101112

关联又分为单向关联与双向关联，以上代码为单向关联(Person类关联Car类)，双向关联(Person类关联Car类，同时Car类关联Person类)代码如下：

public class Car{

private Person per;

}public class Person{

private Car car;

}123456

类之间的关联，可以一对一的关联，也可以一对多的关联。

2.依赖

依赖的具体表现是将一个类的对象当做方法参数传给另一个类的方法，是一种use-a的关系。如：

public class Person{

public void dirve(Car car){

}

}1234

关联与依赖的区别在于:关联是has-a的关系，依赖是use-a的关系;而且关联中Person关联Car，只要Person类对象存在，Car对象就存在;依赖中只有Person类对象调用到dirve()方法时，Car对象才会被创建，方法执行结束后，Car对象就被收回。

3.继承

类与类的另一个关系是继承。继承是一个类的定义基于另一个存在的类，即子类基于父类，如此可实现代码的重用，子类能够继承父类可访问的方法、属性，并能扩展新的能力，而且子类可重写父类方法以满足子类需要。在继承中子类可调用父类的构造方法，子类构造方法总是先调用父类的构造方法，而且默认情况下调用父类的无参构造方法，在子类构造方法的第一行使用super关键字即可调用父类构造方法。示例代码如下：

public class Point {

private double x; private double y; public double getX() { return x;

} public void setX(double x) { this.x = x;

} public double getY() { return y;

} public void setY(double y) { this.y = y;

} //无参构造方法

public Point() {

} //有参构造方法

public Point(double x, double y) { this.x = x; this.y = y;

} //draw（）方法

public void draw(){

}

}public class Circle extends Point {

private double r; public double getR() { return r;

} public void setR(double r) { this.r = r;

} //有参构造方法

public Circle(double x, double y) { super(x, y);

} public void draw() {

System.out.println("半径为：" + this.r + " x坐标为：" + getX() + " y坐标为：" + getY() + "的圆绘制成功！");

}

}public class Test {

public static void main(String[] args) {

Circle circle = new Circle(2, 3);

circle.setR(3);

circle.draw();

}

}

类（对象）之间的四种关系

类（对象）之间的四种关系

1.依赖关系（Dependency）

    所谓依赖就是某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。

    举例：

    一个人自从出生就需要不停的呼吸，而人的呼吸功能之所以能维持生命就在于吸进来的气体发挥了作用，所以说空气只不过是人类的一个工具，而并不是人类对它的引用。

2.关联关系（Association）

    某个对象会长期的持有另一个对象的引用，而二者的关联往往也是相互的。

    关联的两个对象彼此间没有任何强制性的约束，只要二者同意，可以随时解除关系或是进行关联，它们在生命周期问题上没有任何强制性的约束，被关联的对象还可以再被别的对象关联，所以关联是可以共享的。

    举例：

    人从生至死都在不断的交朋友，然而没有理由认为朋友的生死与我的生死有着联系，故他们的生命周期没有关联，我的朋友又可以是别人的朋友，所以说朋友是可以共享的。

3.聚合关系（Aggregation）

    聚合是强版的关联

    它暗含着一种所属关系以及生命周期关系

    被聚合的对象还可以再被别的对象关联，所以被聚合对象是可以共享的。虽然是共享的，聚合代表的是一种更亲密的关系。

    举例：

    我的家和我之间具有着一种强烈的所属关系。我的家可以分享的，但是这里的分享又可以分为两种：

    其一：聚合间的分享      正如你和你老婆都对这个家有着同样强烈的关联。

    其二：聚合与关联的分享     你朋友来家里吃个便饭，估计你不会给你朋友配一把你家的钥匙。

4.组合关系（Compostion）

    组合是关系中的最强版，它直接要求包含对象对被包含对象的拥有以及包含对象与被包含对象生命周期的关系。    

    被包含的对象还可以再被别的对象关联

    所以被包含对象是可以共享的

    然而绝不存在两个包含对象对同一个被包含对象的共享

    举例：

    组合关系就是整体与部分的关系，部分属于整体

    整体不存在，部分一定不存在，然而部分不存在整体是可以存在的。

    说的更明确一些就是部分必须创生与整体创生之后，而销毁整体销毁之前。

/**

* 所谓依赖关系，就是指其中一个对象依赖于另一个对象的某种功能或者属性，就是说，依赖者把被依赖者当作工具来使用，

*被依赖者并不属于依赖者。

public class Dependency {

       public static void main(String[] args) {

            Human person = new Human();

            while(true){

                person,breath();

            }

        }

  }

/**

* 属于依赖者

* @author Administrator

*

*/

class Human{

public void breath(){

Air freshAir = new Air();

freshAir.provideOxygen();

System.out.println("吸了一口");

System.out.println("呼了一口");

}

}

/**

* 属于被依赖者

* @author Administrator

*

*/

class Air{

public void provideOxygen(){

System.out.println("释放了一波氧气");

}

}

import java.util.ArrayList;

二·关联关系

/**

*     所谓关联，某个对象长期持有另一个对象的引用，

而且这两者之前的关联是相互的，

关联的两个对象彼此之间没有任何的强制性约束，

只要两者同意，可以随时解除关联关系，

而且它们在生命周期上没有任何约定，

被关联的对象是共享，它还可以被其他对象关联。

* @author Administrator

*

*/

public class Association {

public static void main(String[] args) {

Human$ person = new Human$();

School zhengZhouHighSchool = new School();

while(true){

person.makeFriend(zhengZhouHighSchool.getStudent());

}

}

}

class Human${

ArrayList friends = new ArrayList();

public void makeFriend(Human$ hunman$){

friends.add(hunman$);

}

}

class School{

public Human$ getStudent(){

return new Human$();

}

}

三   聚合关系

* @author Administrator

*家庭和我之间属于一种比较亲密的关系，而且我的家庭是可以分享，我回家以及我家人回家，这种分享具有跟强的亲密度

*朋友去我家，亲密度要小于我和我家人。

*/

public class Aggregation {

public static void main(String[] args) {

Human

person=newHuman

();

while(true){

//吃饭

//上学

//放学

person.goHome();

}

}

}

class Human$${

Home myHome = new Home();

public void goHome(){

myHome.openDoor();

}

}

class Home{

public void openDoor(){

}

}

import java.util.ArrayList;

四  组合关系

* @author Administrator

* 组合关系就是整体与部分的关系，部分属于整体，整体不存在，则部分一定不存在

* 然后部分不存在整体依然可以生存

* 部分存在于整体创建之后，部分销毁于整体销毁之前。

*/

public class Compostion {

public static void main(String[] args) {

Human

$person=newHuman

$();

while(true){

person.heart.beat();

}

}

}

class Human$$${

Heart heart = new Heart();

}

class Heart{

public void beat(){

}

}

JAVA作业求助。

在Java中，依赖关系通常表示为一个类依赖于另一个类，因为它需要调用另一个类的方法或构造函数来完成它的工作。例如，假设我们有一个名为Car的类，它拥有一个名为startEngine的方法，用于启动汽车的发动机。我们还有一个名为Driver的类，它有一个名为drive的方法，用于驾驶汽车。那么Driver类就依赖于Car类，因为Driver类需要调用Car类的startEngine方法来启动汽车。

下面是一个示例代码，实现了一个依赖关系的场景：

=================

public class Car {

public void startEngine() {

System.out.println("Engine started.");

}

}

public class Driver {

private Car car;

public Driver(Car car) {

this.car = car;

}

public void drive() {

car.startEngine();

System.out.println("Car is being driven.");

}

}

public class Main {

public static void main(String[] args) {

Car car = new Car();

Driver driver = new Driver(car);

driver.drive();

}

}

=================

在这段代码中，Driver类的构造函数接收一个Car类的实例作为参数，并将它保存在私有字段car中。在Driver类的drive方法中，我们首先调用了car实例的startEngine方法，然后打印一条消息，表示汽车正在被驾驶。

关联关系通常表示为两个类之间的关系，它们之间的关系可能是一对一，一对多或多对多。例如，假设我们有一个名为Student的类，它有一个名为enroll的方法，用于选课。我们还有一个名为Course的类，它有一个名为addStudent的方法，用于添加学生。那么Student类和Course类之间就存在一对多的关联关系，因为一个学生可以选择多个课程，而一个课程也可以被多个学生选择。

下面是一个示例代码，实现了一个关联关系的场景：

=================

public class Student {

private ListCourse courses = new ArrayList();

public void enroll(Course course) {

courses.add(course);

course.addStudent(this);

}

}

public class Course {

private ListStudent students = new ArrayList();

public void addStudent(Student student) {

students.add(student);

}

}

public class Main {

public static void main(String[] args) {

Student student = new Student();

Course course1 = new Course();

Course course2 = new Course();

student.enroll(course1);

student.enroll(course2);

}

}

=================

在这段代码中，Student类拥有一个私有字段courses，表示学生选择的课程。Student类的enroll方法用于选课，它接收一个Course类的实例作为参数，并将它添加到courses列表中。同时，enroll方法还会调用课程实例的addStudent方法，将学生添加到课程的学生列表中。

在Main类的main方法中，我们创建了一个学生实例和两个课程实例。我们调用学生实例的enroll方法，将两个课程实例添加到学生的选课列表中，同时将学生添加到两个课程的学生列表中。这就实现了一对多的关联关系。

总之，依赖关系和关联关系都是表示两个类之间的关系，但是它们之间的关系不同。依赖关系表示一个类依赖于另一个类，因为它需要调用另一个类的方法或构造函数来完成它的工作；关联关系表示两个类之间的关系，它们之间可能是一对一，一对多或多对多。

怎么看java代码中接口调用关系

类与类的关系

1、依赖关系

依赖关系表示一个类依赖于另一个类的定义。通俗来讲即是类A中使用了另外的一个类B，且类B并非类A中作为属性存在，即表示类A依赖于类B。对象之间最弱的一种关联方式，是临时性的关联。代码中一般指由局部变量、函数参数、返回值建立的对于其他对象的调用关系。

class A{

public B method(C c){

B b = new B();

return b;

}

}

登录后复制

2、关联关系

关联关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。通俗来讲即类A中有一个属性b，该属性的数据类型为类B，类A可以通过属性b调用类B的属性与方法。也即一般来说的has-a的关系。

class A{

public B b;

}

登录后复制

3、聚合关系

聚合关系是特殊的关联关系，其与关联关系在代码上并无实际上的区别，二者的区别主要体现在语义上，关联关系即代表可有可无，而聚合关系则代表必须拥有（注：被聚合或关联的事务也代表一个单独的事务，其也有独立的意义。）举例说明就像笔记本电脑，其与外接鼠标就是关联关系，外接鼠标只是附件，而想cpu，内存条等是组成一个笔记本电脑所必须的，而他们的关系就是聚合关系。

class computer{

public Cpu cpu1;

}

登录后复制

4、组合关系

组合关系也是特殊的关联关系，其类似于聚合关系，但比聚合关系更加的强，即对象 A 包含对象 B，对象 B 离开对象 A 没有实际意义。举例来讲就是作为一个人，你可以没有钱，但你不能没有脑子（物理），你与钱就是关联关系，钱乃身外之物，而你与大脑则是组合关系，大脑每人就一个，没了它，你便无法存在，而单独一个脑子离开了人也就失去了它应有的作用。

class person{

public Head head;

}

登录后复制

5、继承关系

类与类的继承关系，类与接口的实现关系。继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。

class A extends B{

public A(){

super();

}

}

登录后复制

类与类之间的继承只能是单继承，但可以多层继承。

单继承即表示一个类只可以继承一个父类。

多层继承即是类A继承类B，而类B又继承了类C，所以类A间接继承了类C

类与接口之间的关系

注：Java8新增了默认方法和静态方法；

public interface A{

//抽象方法

public void a1();

//默认方法

default void a2() {

System.out.println("a2");

}

//静态方法

static void a4() {

System.out.println("a4");

}

}

登录后复制



其中，静态方法只供接口直接使用

类可以继承一个类且实现多个接口

注意：

1.如果多个接口中有同名的抽象方法,那么实现类只需要实现一次即可

2.如果多个接口中有同名的默认方法,那么实现类必须重写一次,并且要去掉default关键字

接口可以继承多个接口

注意：

1.如果多个父接口中有同名的抽象方法,那么子接口只需要实现一次即可

2.如果多个父接口中有同名的默认方法,那么子接口必须重写默认方法,必须要加default关键字

关于java中的关联关系和java关系图展示的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。