Java에서의 집약과 구성의 구현 차이
집약과 구성의 개념적인 차이를 알고 있습니다.예를 들어 자바 구현의 차이점을 알려주실 수 있나요?
구성.
final class Car {
private final Engine engine;
Car(EngineSpecs specs) {
engine = new Engine(specs);
}
void move() {
engine.work();
}
}
집약
final class Car {
private Engine engine;
void setEngine(Engine engine) {
this.engine = engine;
}
void move() {
if (engine != null)
engine.work();
}
}
구성의 경우 엔진은 완전히 차량에 의해 캡슐화됩니다.외부에서 엔진을 참조할 수 있는 방법은 없습니다.엔진은 차와 함께 살다가 죽는다.집계를 통해 차량도 엔진을 통해 기능을 수행하지만, 엔진이 항상 차량의 내부 부품인 것은 아닙니다.엔진을 교체하거나 완전히 제거할 수 있습니다.그뿐만 아니라 외부 세계에서도 엔진에 대한 참조를 할 수 있고, 차에 있든 없든 엔진을 만질 수 있습니다.
나는 좋은 UML 예를 사용할 것이다.
1에서 20개의 다른 학과가 있고 각 학과마다 1~5명의 교수가 있는 대학을 예로 들어보자.대학과 그 학과 사이에는 구성 링크가 있다.한 학과와 그 학과 교수들 사이에는 집계 링크가 있다.
작문은 단지 STRING 집합일 뿐이며, 대학이 파괴되면 학과도 파괴되어야 한다.하지만 교수들의 학과는 없어지더라도 죽여서는 안 된다.
자바:
public class University {
private List<Department> departments;
public void destroy(){
//it's composition, when I destroy a university I also destroy the departments. they cant live outside my university instance
if(departments!=null)
for(Department d : departments) d.destroy();
departments.clean();
departments = null;
}
}
public class Department {
private List<Professor> professors;
private University university;
Department(University univ){
this.university = univ;
//check here univ not null throw whatever depending on your needs
}
public void destroy(){
//It's aggregation here, we just tell the professor they are fired but they can still keep living
for(Professor p:professors)
p.fire(this);
professors.clean();
professors = null;
}
}
public class Professor {
private String name;
private List<Department> attachedDepartments;
public void destroy(){
}
public void fire(Department d){
attachedDepartments.remove(d);
}
}
이 주변에 뭔가 있어.
EDIT: 요청에 따른 예
public class Test
{
public static void main(String[] args)
{
University university = new University();
//the department only exists in the university
Department dep = university.createDepartment();
// the professor exists outside the university
Professor prof = new Professor("Raoul");
System.out.println(university.toString());
System.out.println(prof.toString());
dep.assign(prof);
System.out.println(university.toString());
System.out.println(prof.toString());
dep.destroy();
System.out.println(university.toString());
System.out.println(prof.toString());
}
}
대학 수업
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class University {
private List<Department> departments = new ArrayList<>();
public Department createDepartment() {
final Department dep = new Department(this, "Math");
departments.add(dep);
return dep;
}
public void destroy() {
System.out.println("Destroying university");
//it's composition, when I destroy a university I also destroy the departments. they cant live outside my university instance
if (departments != null)
departments.forEach(Department::destroy);
departments = null;
}
@Override
public String toString() {
return "University{\n" +
"departments=\n" + departments.stream().map(Department::toString).collect(Collectors.joining("\n")) +
"\n}";
}
}
부서급
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Department {
private final String name;
private List<Professor> professors = new ArrayList<>();
private final University university;
public Department(University univ, String name) {
this.university = univ;
this.name = name;
//check here univ not null throw whatever depending on your needs
}
public void assign(Professor p) {
//maybe use a Set here
System.out.println("Department hiring " + p.getName());
professors.add(p);
p.join(this);
}
public void fire(Professor p) {
//maybe use a Set here
System.out.println("Department firing " + p.getName());
professors.remove(p);
p.quit(this);
}
public void destroy() {
//It's aggregation here, we just tell the professor they are fired but they can still keep living
System.out.println("Destroying department");
professors.forEach(professor -> professor.quit(this));
professors = null;
}
@Override
public String toString() {
return professors == null
? "Department " + name + " doesn't exists anymore"
: "Department " + name + "{\n" +
"professors=" + professors.stream().map(Professor::toString).collect(Collectors.joining("\n")) +
"\n}";
}
}
교수반
import java.util.ArrayList;
import java.util.List;
public class Professor {
private final String name;
private final List<Department> attachedDepartments = new ArrayList<>();
public Professor(String name) {
this.name = name;
}
public void destroy() {
}
public void join(Department d) {
attachedDepartments.add(d);
}
public void quit(Department d) {
attachedDepartments.remove(d);
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Professor " + name + " working for " + attachedDepartments.size() + " department(s)\n";
}
}
작성, 채용 삭제 등의 처리 방법에 따라 실장은 논란의 여지가 있습니다.OP와 무관함
간단한 작문 프로그램
public class Person {
private double salary;
private String name;
private Birthday bday;
public Person(int y,int m,int d,String name){
bday=new Birthday(y, m, d);
this.name=name;
}
public double getSalary() {
return salary;
}
public String getName() {
return name;
}
public Birthday getBday() {
return bday;
}
///////////////////////////////inner class///////////////////////
private class Birthday{
int year,month,day;
public Birthday(int y,int m,int d){
year=y;
month=m;
day=d;
}
public String toString(){
return String.format("%s-%s-%s", year,month,day);
}
}
//////////////////////////////////////////////////////////////////
}
public class CompositionTst {
public static void main(String[] args) {
// TODO code application logic here
Person person=new Person(2001, 11, 29, "Thilina");
System.out.println("Name : "+person.getName());
System.out.println("Birthday : "+person.getBday());
//The below object cannot be created. A bithday cannot exixts without a Person
//Birthday bday=new Birthday(1988,11,10);
}
}
간단히 말하면:
구성 및 집약은 모두 연관성입니다.구성 -> 강력한 Has-A 관계 집약 -> 취약한 Has-A 관계
아래 URL에 좋은 설명이 있습니다.
http://www.codeproject.com/Articles/330447/Understanding-Association-Aggregation-and-Composit
확인해주세요!!!
먼저, 우리는 실제적인 차이점에 대해 이야기해야 한다.Aggregation그리고.Composition마음이 통해야 한다.
집약은 연관지을 수 있는 엔티티가 연관지을 수 있는 연관지을 수 있습니다.예를 들어, 개인은 조직에 관련될 수 있지만, 그/그녀는 시스템 내에서 독립적으로 존재할 수 있다.
반면에.
구성이란 관련된 실체 중 하나가 다른 실체와 강하게 관련되어 있고 다른 실체가 존재하지 않으면 존재할 수 없는 상황을 말한다.실제로 그 엔티티의 ID는 항상 다른 오브젝트의 ID와 관련지어집니다.예를 들어, 차 안의 바퀴.
이제 통합은 한 기업의 부동산을 다른 기업에 보유함으로써 다음과 같이 간단히 달성할 수 있다.
class Person {
Organisation worksFor;
}
class Organisation {
String name;
}
class Main {
public static void main(String args[]) {
//Create Person object independently
Person p = new Person();
//Create the Organisation independently
Organisation o = new Organisation();
o.name = "XYZ Corporation";
/*
At this point both person and organisation
exist without any association
*/
p.worksFor = o;
}
}
Composition의 경우 종속 객체는 항상 연관된 객체의 ID를 사용하여 생성되어야 합니다.마찬가지로 내부 클래스를 사용할 수 있습니다.
class Car {
class Wheel {
Car associatedWith;
}
}
class Main {
public static void main() {
//Create Car object independently
Car car = new Car();
//Cannot create Wheel instance independently
//need a reference of a Car for the same.
Car.Wheel wheel = car.new Wheel();
}
}
애플리케이션 시나리오에 따라서는, 같은 유스케이스가 집약/구성에 포함되는 경우가 있습니다.예를 들어, 어떤 조직에서 일하는 사람들을 위한 애플리케이션을 개발 중이고 등록 시 조직에 대한 참조가 필수인 경우 Person-Organization 케이스가 구성될 수 있습니다.마찬가지로 자동차 부품에 대한 인벤토리를 유지하는 경우 자동차-휠 관계가 집계될 수 있습니다.
차이점은 어떤 구성도 하나의 집합이며 그 반대도 아니라는 것입니다.
조건을 정합시다.Aggregation은 UML 표준에서 메타템으로, 단순히 공유라는 이름의 구성과 공유 집약을 모두 의미합니다.너무 자주 "집약"이라는 이름이 잘못 지정됩니다.구성도 하나의 집합체이기 때문에 BAD입니다.제가 알기로는 '공유'를 말하는 것 같군요.
UML 표준에서 더 나아가서:
composite - 속성이 복합적으로 집계됨을 나타냅니다. 즉, 복합 객체는 구성된 객체(부품)의 존재와 저장을 책임집니다.
University to Cathedra Association은 하나의 구성입니다. 왜냐하면 University to Cathedra는 University(IMHO) 밖에 존재하지 않기 때문입니다.
공유 집계의 정확한 의미는 응용 프로그램 영역 및 모델러에 따라 다릅니다.
즉, 자신의 원칙이나 다른 사람의 원칙만 따르는 경우 다른 모든 연관성을 공유 집약으로 그릴 수 있습니다.여기도 보세요.
집약과 구성
집계는 자녀가 부모로부터 독립적으로 존재할 수 있는 관계를 의미합니다.예를 들어, 은행과 직원, 은행을 삭제해도 직원은 여전히 존재합니다.
반면 구성은 자녀가 부모로부터 독립적으로 존재할 수 없는 관계를 의미한다.예:인간과 심장, 심장은 인간과 따로 존재하지 않는다.
집계 관계는 "has-a"이고 구성은 "일부" 관계입니다.
구성은 강한 연관성인 반면 집계는 약한 연관성입니다.
두 유형 모두 물론 연관성이 있기 때문에 그와 같은 언어 요소에 엄밀하게 매핑되어 있지는 않습니다.차이점은 시스템의 목적, 컨텍스트 및 모델링 방법에 있습니다.
실제적인 예로서 유사한 엔티티를 가진 두 가지 다른 유형의 시스템을 비교합니다.
주로 자동차, 자동차 소유자 등을 추적하는 자동차 등록 시스템여기서는 엔진을 별개의 개체로 취급하는 것에 관심이 없지만, 출력 및 연료 유형과 같은 엔진 관련 속성이 여전히 있을 수 있습니다.여기서 엔진은 자동차 엔티티의 복합 부품일 수 있습니다.
자동차 부품 관리, 자동차 정비 및 부품 교체, 엔진 전체를 관리하는 자동차 정비소 관리 시스템입니다.여기에는 엔진이 비축되어 있고, 엔진과 다른 부품을 자동차와는 별도로 추적해야 할 수도 있습니다.여기서 엔진은 자동차 엔티티의 집합체일 수 있습니다.
그 수준에서는 가독성과 같은 것이 훨씬 중요하기 때문에 언어에서 어떻게 이것을 구현하느냐는 작은 관심사입니다.
언급URL : https://stackoverflow.com/questions/11881552/implementation-difference-between-aggregation-and-composition-in-java
'source' 카테고리의 다른 글
| Vue CLI 3에서 vue 라우터 플러그인을 설치하려면 어떻게 해야 합니까? (0) | 2022.09.21 |
|---|---|
| 노드 속편화JS 서버에서 "ERR_UNKNOWN_ENCODING" 오류가 발생했습니다. (0) | 2022.09.21 |
| Laravel where 관계 객체 (0) | 2022.09.21 |
| PhpStorm이 탭 닫기를 자동으로 중지하도록 설정 (0) | 2022.09.21 |
| 오류 메시지 엄격한 표준: 비정적 메서드는 php에서 정적으로 호출하면 안 됩니다. (0) | 2022.09.21 |