...

์ํํธ์จ์ด์ ๋ชจ๋ ๋ ๋ฆฝ์ฑ
์๊ณ ๋ก ํ๋ก๊ทธ๋๋ฐ์ด๋ ๋ฌธ์ ๋ฅผ ์ ์ํ๊ณ ํ๋์ฉ ํด๊ฒฐํด๋๊ฐ๋ ๊ณผ์ ์ ๋งํ๋ค.
๋ง์ฝ ๋ฌธ์ ๊ฐ ๋ณต์กํ๊ณ ํฐ ๋ฌธ์ ๋ผ๋ฉด, ์ผ๋ฐ์ ์ผ๋ก ๋ฌธ์ ๋ฅผ ์์ ๋ถ๋ถ์ผ๋ก ์ชผ๊ฐ์ด์ ํ๋์ฉ ํ์ด๋๊ฐ๊ฒ ๋ ๊ฒ์ธ๋ฐ, ์ด ๋ ๋ฌธ์ ๋ฅผ ์์ ๋ถ๋ถ์ผ๋ก ์ชผ๊ฐ๋๊ฐ๋ ๊ฒ์ ๋ชจ๋ํ๋ผ๊ณ ํ๋ค.
๋ชจ๋์ ์ํํธ์จ์ด๋ฅผ ๊ฐ ๊ธฐ๋ฅ๋ณ๋ก ๋๋์ด์ง ์์ค ๋จ์๋ฅผ ๋งํ๋ค. ๋ ๋ฆฝ์ ์ผ๋ก ์ปดํ์ผ ๊ฐ๋ฅํ ํ๋ก๊ทธ๋จ ํน์ ํ๋์ ํจ์๋ ํด๋์ค๋ ๋ชจ๋์ด ๋๋ค.
๋ณดํต ์ข์ ์ํํธ์จ์ด ์ผ์๋ก ๋ชจ๋์ ๋ ๋ฆฝ์ฑ์ด ๋๋ค๊ณ ํ๋ค.
์ข์ ๋ชจ๋ํ๋ ๋ชฉ์ ์ ๋ง๋ ๊ธฐ๋ฅ๋ง์ผ๋ก ๋ชจ๋์ ๋๋๊ฒ ๋๋๋ฐ, ๊ฐ๊ฐ์ ๋ชจ๋์ ์ฃผ์ด์ง ๊ธฐ๋ฅ๋ง์ ๋ ๋ฆฝ์ ์ผ๋ก ์ํํ๊ธฐ ๋๋ฌธ์ ์ฌ์ฌ์ฉ์ฑ์ด ๋๊ณ ์ฝ๋์ ์ดํด/์์ ์ด ์ฉ์ดํ๊ธฐ ๋๋ฌธ์ด๋ค.
์๋ฅผ๋ค์ด ํด๋น ๋ชจ๋์ ์์ ํ๋๋ผ๋ ๋ค๋ฅธ ๋ชจ๋์ ๋ผ์น๋ ์ํฅ์ด ์ ๊ฒ ๋๋ฉฐ, ์ค๋ฅ๊ฐ ๋ฐ์ํ๋๋ผ๋ ๊ธฐ๋ฅ ๋จ์๋ก ์ ๋๋์ด ์ ธ ์๊ธฐ ๋๋ฌธ์ ์์ฝ๊ฒ ๋ฌธ์ ๋ฅผ ๋ฐ๊ฒฌํด ํด๊ฒฐํ ์ ์๊ธฐ๋ ํ๋ค.
์ด๋ฌํ ๋ชจ๋์ ๋ ๋ฆฝ์ฑ์ ๋ชจ๋์ ๊ฒฐํฉ๋(Coupling) ์ ์์ง๋(Cohesion)์ ๊ธฐ์ค ๋จ๊ณ ์ธก์ ํ๋ค

๊ฐ๋จํ๊ฒ ์ด๋ค์ ์๊ฐํ์๋ฉด, ๊ฒฐํฉ๋๋ ๋ชจ๋๊ณผ ๋ชจ๋ ๊ฐ์ ์์กด ์ ๋๋ฅผ ์๋ฏธํ๊ณ , ์์ง๋๋ ํ ๋ชจ๋ ๋ด์ ๊ตฌ์ฑ์์๋ค ๊ฐ์ ์ฐ๊ด ์ ๋๋ฅผ ์๋ฏธํ๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฒฐํฉ๋์ ์์ง๋์ ๊ฐ๋ ์ธ๊ธฐ์ ๋ฐ๋ผ ์ฌ๋ฌ ๋จ๊ณ๋ก ๋๋๊ฒ ๋๋๋ฐ ์์ง๋๋ ๊ฐํ ์๋ก, ๊ฒฐํฉ๋๋ ๋์จํ ์๋ก ๋ ๋ฆฝ์ฑ์ด ๋์ ๋ชจ๋๋ก ํ๊ฐ ๋๋ค.

์ด์ ๋ถํฐ ์ด๋ค์ ๋ํด ์์ธํ ์์๋ณด์.
๊ฒฐํฉ๋(Coupling)
๊ฒฐํฉ๋๋ ๋ชจ๋(ํด๋์ค ํ์ผ)๊ฐ์ ์ํธ ์์กด ์ ๋ ๋๋ ์ฐ๊ด๋ ๊ด๊ณ์ ๋๋ํจ ์ ๋๋ฅผ ์๋ฏธํ๋ค๊ณ ๋ณด๋ฉด ๋๋ค. (๊ฒฐํฉ๋๋ฅผ ์์กด๋๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํ๋ค)
์๋ฅผ ๋ค๋ฉด ๊ฒฐํฉ๋๊ฐ ๋์ ํด๋์ค๋ ๋ค๋ฅธ ํด๋์ค์ ์ฐ๊ด ๊ด๊ณ๊ฐ ๋๋ํ์ฌ, ๋ง์ผ ํ๋์ ํด๋์ค์ ๊ตฌ์กฐ๋ฅผ ๋ณ๊ฒฝํ๊ฒ ๋๋ค๋ฉด ๊ทธ์ ์ฐ๊ด๋ ํด๋์ค๋ค๋ ์น ๋ณ๊ฒฝํด์ผ ํ ์๋ ์๊ณ , ๊ฐ์ฒด ์ฌ์ฉ ์ฝ๋๋ ๋ณ๊ฒฝํด์ผ ํ ์๋ ์์ด์, ์ ์ง๋ณด์ ์ธก๋ฉด์์ ๋งค์ฐ ๋ง์ด๋์ค์ ์ธ ์์๋ก ์์ฉ๋๋ค.
์ค์ํ๋ก ๋น์ ํ์๋ฉด ์์ ํ ์๋์ฐจ ํ๋์๋ ์ฌ๋ฌ๊ฐ์ ๋ชจ๋๋ค ํธ๋ค, ๋ฐํด, ์์ง, ๋ฐฐํฐ๋ฆฌ ๋ฑ์ด ๋ค์ด์์ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๋ ๊ฒ ํ๋์ ํ๋ก๊ทธ๋จ(์๋์ฐจ) ์์์ ๊ฐ ๋ชจ๋๋ค์ด ์๋ก ๊ด๋ จ๋์ด ์์กดํ๊ณ ์๋ ์ ๋๊ฐ ๊ฒฐํฉ๋ ์ด๋ค.
ํธ๋ค๊ณผ ๋ฐํด ๋ชจ๋๊ฐ์ ๊ด๊ณ๋ฅผ ์๋ก ๋ค์๋ฉด, ์ด ๋์ ๊ฐ๊ฐ์ ๋์์ด ์ํธ์์ฉ์ ํตํด ์๋์ฐจ๊ฐ ๊ตด๋ฌ๊ฐ๊ธฐ ๋๋ฌธ์ ์ด๋์ ๋์ ๊ฒฐํฉ๋๊ฐ ์๊ธธ ์ ๋ฐ์ ์๋ค. ํ์ง๋ง ๊ทธ๋ ๋ค๊ณ ํด์ ๋ฐํด๋ฅผ ๊ต์ฒดํ๋๋ฐ ํธ๋ค๊น์ง ๊ต์ฒดํด์ผ ๋๋ค๋ฉด ์ด๊ฑด ์์์ ์ผ๋ก ์๋์ฐจ ์ค๊ณ ๋ถํฐ๊ฐ ์๋ชป ๋์๋ค๊ณ ๋งํ ์ ์๋ค.

๊ฐ์ฒด์งํฅ์ ๊ด์ ์์ ๊ฒฐํฉ๋๋ ํด๋์ค ๋๋ ๋ฉ์๋๊ฐ ํ๋ ฅ์ ํ์ํ ์ ์ ํ ์์ค์ ๊ด๊ณ๋ง์ ์ ์งํ๊ณ ์๋์ง๋ฅผ ๋ํ๋ธ๋ค.
์ฆ, ์ด๋ค ํด๋์ค๊ฐ ๋ค๋ฅธ ํด๋์ค์ ๋ํด ๋๋ฌด ์์ธํ ์๊ณ ์๋ค๋ฉด ๋ ๋ชจ๋์ ๋์ ๊ฒฐํฉ๋๋ฅผ ๊ฐ์ง๊ฒ ๋๊ณ , ๋ฐ๋๋ก ์ด๋ค ํด๋์ค๊ฐ ๋ค๋ฅธ ํด๋์ค์ ๋ํด ๊ผญ ํ์ํ ์ง์๋ง ๊ฐ์ง๊ณ ๊ณ ์๋ค๋ฉด ๋ ๋ชจ๋์ ๋ฎ์ ๊ฒฐํฉ๋๋ฅผ ๊ฐ์ง๋ค๊ณ ๋งํ ์ ์๋ ๊ฒ์ด๋ค.
๋ง์ฝ ํด๋์ค๋ค ๊ฐ์ ์ฐ๊ด์ด ์์๋ ์ธํฐํ์ด์ค๋ก ์ ๋๋ก ๋ถ๋ฆฌ๋์ด ์์ง ์๊ณ ๋ถํ์ํ๊ฒ ๋ง์ ์ ๋ณด๋ฅผ ์๊ณ ์๋ค๋ฉด ์ด๋ ๊ฒฐํฉ๋๊ฐ ๋๊ฒ ์ธก์ ๋๊ฒ ๋๋ค.
๋ฐ๋ผ์ ์ข์ ์ํํธ์จ์ด๋ ๋ฎ์ ๊ฒฐํฉ๋(low coupling)๋ฅผ ๊ฐ์ง๊ณ ์๋ค๊ณ ๋งํ ์ ์๋ค.
[๊ฒฐํฉ๋๊ฐ ๋ฎ์ ํด๋์ค์ ํน์ง]
- Open Closed Principle์ ์์น์ ์ ์งํจ ํด๋์ค (ํ์ฅ์๋ ์ด๋ ค์๊ณ ๋ณ๊ฒฝ์๋ ๋ซํ ์๋ ํด๋์ค)
- ๋คํ์ฑ์ ์ ์งํจ ํด๋์ค
๊ฒฐํฉ๋ ๋จ๊ณ ์ข ๋ฅ
์์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ๊ฒฐํฉ๋๋ ๊ฐ๋์ ์ธ๊ธฐ์ ๋ฐ๋ผ ์ฌ๋ฌ ๋จ๊ณ๋ก ์ข ๋ฅ๋ณ๋ก ๋๋์ด ์ง๋ค.
๋ค์๊ณผ ๊ฐ์ด ๊ฒฐํฉ๋๋ ์๋ฃ, ์คํฌํ, ์ ์ด, ์ธ๋ถ, ๊ณตํต, ๋ด์ฉ ๊ฒฐํฉ๋์ ์ฒ๋๋ก ๋ํ๋ผ ์ ์๋ค.

์ธ๊ธฐ | ์ข ๋ฅ | ๋ด์ฉ |
์ฝํจ โ ๊ฐํจ |
์๋ฃ ๊ฒฐํฉ๋ (Data Coupling) |
๋ชจ๋๊ฐ์ ์ธํฐํ์ด์ค๋ก ์ ๋ฌ๋๋ ํ๋ผ๋ฏธํฐ(๋ฐ์ดํฐ)๋ฅผ ํตํด์๋ง ์ํธ ์์ฉ์ด ์ผ์ด๋๋ ๊ฒฝ์ฐ ๊ฒฐํฉ๋๊ฐ ์ ์ผ ๋ฎ๊ณ ์ ์ผ ์ข์ ํํ์ด๋ค. |
์คํฌํ ๊ฒฐํฉ๋ (Stamp Coupling) |
๋ชจ๋๊ฐ์ ์ธํฐํ์ด์ค๋ก ๋ฐฐ์ด์ด๋ ๊ฐ์ฒด, ์๋ฃ ๊ตฌ์กฐ ๋ฑ์ด ์ ๋ฌ๋๋ ๊ฒฝ์ฐ | |
์ ์ด ๊ฒฐํฉ๋ (Control Coupling) |
์ด๋ค ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋ ๋ด๋ถ์ ๋ ผ๋ฆฌ์ ์ธ ํ๋ฆ์ ์ ์ดํ๋ ์ ์ด ์์๋ฅผ ์ ๋ฌํ๋ ๊ฒฝ์ฐ | |
์ธ๋ถ ๊ฒฐํฉ๋ (External Coupling) |
์ด๋ค ๋ชจ๋์ด ์ธ๋ถ์ ์๋ ๋ค๋ฅธ ๋ชจ๋์ ๋ฐ์ดํฐ๋ฅผ ์ฐธ์กฐํ๋ ๊ฒฝ์ฐ (๋ฐ์ดํฐ, ํต์ ํ๋กํ ์ฝ ๋ฑ) | |
๊ณตํต ๊ฒฐํฉ๋ (Common Coupling) |
์ฌ๋ฌ ๊ฐ์ ๋ชจ๋์ด ํ๋์ ๊ณตํต ๋ฐ์ดํฐ ์์ญ(์ ์ญ ๋ณ์ ์ฐธ์กฐ ๋ฐ ๊ฐฑ์ )์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ | |
๋ด์ฉ ๊ฒฐํฉ๋ (Content Coupling) |
์ด๋ค ๋ชจ๋ ๋ด๋ถ์ ์๋ ๋ณ์๋ ๊ธฐ๋ฅ์ ๋ค๋ฅธ ๋ชจ๋์์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ฒฐํฉ๋๊ฐ ์ ์ผ ๋๊ณ ์ ์ผ ์ข์ง ์์ ํํ์ด๋ค. |
์๋ฃ ๊ฒฐํฉ๋ (Data Coupling)
- ๊ฐ์ฅ ๊ฒฐํฉ๋๊ฐ ๋ฎ๊ณ , ๊ฐ์ฅ ์ข์ ํํ
- ๋ชจ๋๋ผ๋ฆฌ ๋จ์ํ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๊ฒฝ์ฐ (๊ธฐ๋ฅ ์ํ์ ์์ด์ ๋ก์ง์ ์ ์ดํ๊ฑฐ๋ ํ์ง ์๋ ์์ํ ์๋ฃํ ์์์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๊ฒ)
- ํ ๋ชจ๋์ ๋ณ๊ฒฝํ๋๋ผ๋ ๋ค๋ฅธ ๋ชจ๋์๋ ์ํฅ์ ๋ผ์น์ง ์๋ ๊ฒฐํฉ ํํ

class Bill {
// ์ฃผ์ฐจ ์๊ธ ์ฒญ๊ตฌ์ ๋ชจ๋ (์ฌ์ฉ์๊ฐ๊ณผ ํ ์ธ๋ฅ ์ ์ธ์๋ก ๋ฐ๊ณ ๊ณ์ฐํ์ฌ ์ฃผ์ฐจ์๊ธ ๋ฉ์๋๋ฅผ ํธ์ถ)
public static int getBillFee(int time, int discount) {
double discountPercentage = discount / 100;
// ๋ฉ์๋์์์ ๋ ๋ค๋ฅธ ๋ฉ์๋๋ฅผ ํธ์ถํด ์์กด๋๊ฐ ์๊ธด ํ์ง๋ง, ๋ฉ์๋์ ๋จ์ ํ๋ผ๋ฏธํฐ ๋ฐ์ดํฐ๋ฅผ ๋ณด๋ด๋ ํํ
return Fee.calculateFee(time) * discountPercentage;
}
}
class Fee {
// ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐ ๋ชจ๋
public static int calculateFee(int time) {
int defaultMoney = 1000;
return defaultMoney * time;
}
}
public class Main {
public static void main(String[] args) {
Bill.getBillFee(2, 80); // 2์๊ฐ ์ด์ฉ, 80% ํ ์ธ
}
}
์คํฌํ ๊ฒฐํฉ๋ (Stamp Coupling)
- ๋ ๋ชจ๋์ด ์ธํฐํ์ด์ค๋ก ๋ฐฐ์ด์ด๋ ์ค๋ธ์ ํธ์ ๊ฐ์ ๋์ผํ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฐธ์กฐํ๋ ํํ์ ๊ฒฐํฉ๋
- ๋ง์ผ ๋ชจ๋์ ์ฐ์ผ ์๋ฃ๊ตฌ์กฐ ํํ๊ฐ ๋ณ๊ฒฝ๋๋ฉด ๊ทธ๊ฒ์ ์ฐธ์กฐํ๋ ๋ชจ๋ ๋ชจ๋์ ์ํฅ์ ์ฃผ๊ฒ ๋จ

// ์ด์ฉ๊ธฐ๋ก ์๋ฃ๊ตฌ์กฐ ํํ
class Record {
public int carNum;
public int useTime
private int fee
Record(int carNum, int useTime) {
this.carNum = carNum;
this.useTime = useTime;
}
public void setFee(int fee) {
this.fee += fee;
}
public int getFee(int fee) {
return this.fee;
}
}
class BillFee {
// ์ฃผ์ฐจ์ฅ ์ด์ฉ ์ฒญ๊ตฌ์ ์์ฑ ๋ชจ๋
public static int getBillFee(String name, int hour) {
Record record = new Record(name, hour); // ์๋ฃ๊ตฌ์กฐ ์์ฑ
Bill.calculateFee(record); // ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ฉ์๋์ ๋๊น
Fee.calculateFeeAnother(record); // ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ฉ์๋์ ๋๊น
return record.getFee();
}
}
class Bill {
// ์ฃผ์ฐจ๋น์ฉ ๊ณ์ฐ ๋ชจ๋
public static void calculateFee(Record record) {
int defaultMoney = 1000;
record.setFee(defaultMoney * record.useTime);
}
}
class Fee {
// ๊ธฐํ๋น์ฉ ๊ณ์ฐ ๋ชจ๋
public static int calculateFeeAnother(Record record) {
int defaultMoney = 5000;
record.setFee(defaultMoney * record.useTime);
}
}
์์ ์คํฌํ ๊ฒฐํฉ๋์ ์ฝ๋ ์์ ๋ฅผ ์ดํด๋ณด๋ฉด, ์์ ์ดํด๋ณธ ์๋ฃ ๊ฒฐํฉ๋(Data Coupling)๋ ๋จ์ ๋ฐ์ดํฐ ํ์ ์ ๋๊ฒผ์ง๋ง ์คํฌํ ๊ฒฐํฉ๋๋ ์ค๋ธ์ ํธ ํํ์ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ ๋ฌํ๋ค๋ ์ ์ด ๋ค๋ฅด๋ค.
์ด๋ฐ์์ผ๋ก ์๋ฃ ๊ตฌ์กฐ๋ฅผ ๋๊ฒจ ์์กด์ํค๊ฒ ๋๋ฉด, ๋ง์ผ ํด๋์ค์ ํ๋๋ช
์ด๋ ๊ตฌ์ฑ์ด ๋ณ๊ฒฝ๋๋ ๊ฒฝ์ฐ ์ด๋ฅผ ์ฐธ์กฐํ๋ ๋ชจ๋์๋ ๋ณ๊ฒฝ์ด ํ์ํ ์ ์๋ค. (ํด๋์ค ํ๋๋ช
์ useTime์ useHour ์ด๋ผ๊ณ ๋ฐ๊ฟ ๊ฒฝ์ฐ ๋ฉ์๋ 2๊ฐ๋ฅผ ํต์ง๋ก ์ง์ ์์ ํด์ผ ํ๋ค)
์ ์ด ๊ฒฐํฉ๋ (Control Coupling)
- ์ด๋ค ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋ ๋ด๋ถ์ ๋ ผ๋ฆฌ์ ์ธ ํ๋ฆ์ ์ ์ดํ๋ ์ ์ด ์์๋ฅผ ์ ๋ฌํ๋ ๊ฒฝ์ฐ
- ์์ ๋ชจ๋์ด ํ์ ๋ชจ๋์ ์์ธํ ์ฒ๋ฆฌ ์ ์ฐจ๋ฅผ ์๊ณ ์์ด ์ด๋ฅผ ํต์ ํ๋ ๊ฒฝ์ฐ
- ์ ์ด ๊ฒฐํฉ์ ์ ๋ณด์๋์ ์๋ฐฐํ๋ ๊ฒฐํฉ์ผ๋ก, ํ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋ ๋ด๋ถ์ ๊ด์ฌํ์ฌ ๊ด๊ณ๊ฐ ๋ณต์กํด์ง

// ํ์ ์ ๋ณด ํด๋์ค
class User { ... }
class Bill {
// ์ฃผ์ฐจ ์๊ธ ์ฒญ๊ตฌ์ ๋ชจ๋
public static int getBillFee(int time) {
double discountPercentage = discount / 100;
User user1 = new User();
// ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌ๋๋ ๊ฐ์ ๋ฐ๋ผ์ ๋ชจ๋ ๋ด๋ถ ๋ก์ง์ ์ฒ๋ฆฌ๊ฐ ๋ฌ๋ผ์ง๋ ๊ฒฐํฉ ํํ
return Fee.calculateFee(time, user.isJoin) * discountPercentage;
}
}
class Fee {
// ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐ ๋ชจ๋
public static int calculateFee(int time, boolean isJoin) {
int defaultMoney = 1000;
// ํ์ ์ฌ๋ถ์ ๋ฐ๋ผ ์ฃผ์ฐจ์๊ธ์ ๊ณ์ฐํ๋ ๋ก์ง์ด ๋ฌ๋ผ์ง๊ฒ ๋๋ค
if(isJoin) {
return defaultMoney * time - 400; // ํ์ ์ด๋ฉด 400์ ํ ์ธ
} else {
// ...
}
}
}
์ธ๋ถ ๊ฒฐํฉ๋ (External Coupling)
- ๋ชจ๋์ด ์ธ๋ถ์ ์๋ ๋ค๋ฅธ ๋ชจ๋์ ๋ฐ์ดํฐ๋ฅผ ์ฐธ์กฐํ ๋์ ๊ฒฐํฉ๋
- ์ธ๋ถ์ ๋ฐ์ดํฐ, ํต์ ํ๋กํ ์ฝ ๋ฑ์ ๊ณต์ ํ ๋ ๋ฐ์ (์ฐธ์กฐํ ๋ฐ์ดํฐ๊ฐ ์ธ๋ถ ๋ชจ๋์ ์์นํ ๋)
- ์ด๋ค ์ธ๋ถ ๋ชจ๋์์ ๋ฐํํ ๊ฐ์ ๋ค๋ฅธ ๋ชจ๋์์ ์ฐธ์กฐํ๋ ๊ฒฝ์ฐ
- ์ฐธ์กฐ๋๋ ๋ฐ์ดํฐ์ ๋ฒ์๋ฅผ ๊ฐ ๋ชจ๋์์ ์ ํํ ์ ์๋ค

class AddFee {
private int plusFee;
private int plusTime;
AddFee(int p1, int p2) {
// ...
}
// Getter / Setter ...
}
// ์ธ๋ถ ๋ชจ๋์ ๊ฐ์ ธ์ค๊ธฐ
import AddFee;
class Bill {
// ์ฃผ์ฐจ ์๊ธ ์ฒญ๊ตฌ์ ๋ชจ๋
public int getBillFee(int time, int discount, Addfee f) {
double discountPercentage = discount / 100;
return calculateFee(time, f) * discountPercentage + f.getPlusFee(); // ์ธ๋ถ ๋ชจ๋ f์ ์๋ ๋ฐ์ดํฐ ์ฐธ์กฐ
}
}
class Fee {
// ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐ ๋ชจ๋
public int calculateFee(int time, Addfee f) {
int defaultMoney = 1000;
return defaultMoney * (time + f.getPlusTime); // ์ธ๋ถ ๋ชจ๋ f์ ์๋ ๋ฐ์ดํฐ ์ฐธ์กฐ
}
}
public class Main {
public static void main(String[] args) {
int a = 1000;
int b = 10;
// ์ธ๋ถ ๋ชจ๋์ ๋ฐ์ดํฐ๋ฅผ ๊ฒฐ์ ํ๋ ํ๋ผ๋ฏธํฐ a์ b๋ฅผ ๋ฃ์ด์ฃผ๊ณ ์ธ๋ถ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ
Addfee addfee = new Addfee(a, b);
getBillFee(2, 80, addfee);
}
}
// main ๋ฉ์๋
๊ณตํต ๊ฒฐํฉ๋ (Common Coupling)
- ์ฌ๋ฌ ๊ฐ์ ๋ชจ๋์ด ํ๋์ ๊ณตํต ๋ฐ์ดํฐ ์์ญ์ ์ฌ์ฉํ๋ ๊ฒฐํฉ๋
- ๋ํ์ ์ผ๋ก ์ ์ญ ๋ณ์(global variable)๋ฅผ ์๋ก ๋ค ์ ์์ (์ ์ญ ๋ณ์์ ๋ณ๊ฒฝ์ด ์ฌ๋ฌ ๋ชจ๋์ ์ํฅ์ ์ค)
- ๊ณตํต ๋ฐ์ดํฐ ์์ญ์ ๋ด์ฉ์ ์กฐ๊ธ๋ง ๋ณ๊ฒฝํ๋๋ผ๋ ์ด๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ ๋ชจ๋์ ์ํฅ์ ๋ฏธ์นจ
- ์์ ์ธ๋ถ ๊ฒฐํฉ๋์ ์ ์ฌํ๊ฒ ๋ณผ์ ์์ผ๋ ๊ณตํต ๋ฐ์ดํฐ๊ฐ ์ธ๋ถ๋ ๋ด๋ถ๋์ ๋ฐ๋ผ ์ฐจ์ด๊ฐ ์๋ค.
- ๊ณตํต ๊ฒฐํฉ๋๊ฐ ์ธ๋ถ ๊ฒฐํฉ๋ ๋ณด๋ค ๊ฒฐํฉ๋๊ฐ ๋์ ์ด์ ๋, ์ ์ญ ๋ณ์์ ๊ฐ์ ๋ฐ๋ผ ๊ฒฐ๊ตญ์ ์ธ๋ถ์ ๋ชจ๋ ๋ฐํ๊ฐ ๊น์ง ๊ฒฐ์ ๋ ์ ์๋ ๊ฐ๋ฅ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ ์ธ๋ถ ๊ฒฐํฉ๋ ๋ณด๋ค ๋ ๊ฒฐํฉ๋๊ฐ ๋๋๋ก ํ๊ฐ๋๋ค๊ณ ๋ณด๋ฉด ๋๋ค.

class Discount {
public static int discount = 50; // ๊ณตํต ์ ์ญ ๋ฐ์ดํฐ
public static int discountDefault = 500; // ๊ณตํต ์ ์ญ ๋ฐ์ดํฐ
}
class Bill {
// ์ฃผ์ฐจ ์๊ธ ์ฒญ๊ตฌ์ ๋ชจ๋
public int getBillFee(int time) {
double discountPercentage = Discount.discount / 100; // ๊ณตํต ๋ฐ์ดํฐ ์ฌ์ฉ
return calculateFee(time) * discountPercentage;
}
}
class Fee {
// ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐ ๋ชจ๋
public int calculateFee(int time) {
int defaultMoney = 1000 - Discount.discountDefault; // ๊ณตํต ๋ฐ์ดํฐ ์ฌ์ฉ
return defaultMoney * time;
}
}
๋ด์ฉ ๊ฒฐํฉ๋ (Content Coupling)
- ๊ฐ์ฅ ๋์ ๊ฒฐํฉ๋๋ฅผ ๊ฐ์ผ๋ฉฐ, ๊ฐ์ฅ ์ข์ง ์์ ๊ฒฐํฉ ํํ
- ์ด๋ค ๋ชจ๋์ด ์ฌ์ฉํ๋ ค๋ฉด ๋ค๋ฅธ ๋ชจ๋์ ๋ด๋ถ ๊ธฐ๋ฅ๊ณผ ๋ฐ์ดํฐ๋ฅผ ์ง์ ์ฐธ์กฐํด ๊ทธ๋๋ก ๊ฐ์ ธ์ ์ฌ์ฉํ๊ฑฐ๋ ์์ ํ๋ ๊ฒฝ์ฐ
- ์ด๋ ๊ฒ ๋๋ฉด A๋ชจ๋, B๋ชจ๋ ๋ชจ๋ ์ฝ๋๋ฅผ ์๊ณ ์์ด์ผ ํ๋ฉฐ A๋ชจ๋์ด ๋ณ๊ฒฝ๋๋ฉด B๋ชจ๋๋ ์ํฅ์ ๋ฏธ์ณ ๋ณ๊ฒฝํด์ผ ํจ
์์ง๋(Cohesion)
์์ง๋๋ ํ๋์ ํด๋์ค๊ฐ ๊ธฐ๋ฅ์ ์ง์คํ๊ธฐ ์ํ ๋ชจ๋ ์ ๋ณด์ ์ญํ ์ ๊ฐ๊ณ ์์ด์ผ ํ๋ค๋ ์๋ฏธ์ด๋ค.
์ ํํ ์์ง๋๋ ํ ๋ชจ๋ ๋ด์ ๊ตฌ์ฑ ์์ ๊ฐ์ ๋ฐ์ ํ ์ ๋๋ฅผ ์๋ฏธํ๋๋ฐ, ํ ๋ชจ๋์ด ํ๋์ ๊ธฐ๋ฅ(์ฑ ์)์ ๊ฐ๊ณ ์๋ ๊ฒ์ ์์ง๋๊ฐ ๋์ ๊ฒ์ด๊ณ , ํ ๋ชจ๋์ด ์ฌ๋ฌ ๊ธฐ๋ฅ์ ๊ฐ๊ณ ์๋ ๊ฒ์ ์์ง๋๊ฐ ๋ฎ์ ๊ฒ์ด๋ค.
์์ง๋๊ฐ ๋์ ๋ชจ๋์ ํ๋์ ๋ชจ๋ ์์ ํจ์๋ ๋ฐ์ดํฐ์ ๊ฐ์ ๊ตฌ์ฑ ์์๋ค์ด ํ๋์ ๊ธฐ๋ฅ์ ๊ตฌํํ๊ธฐ ์ํด ํ์ํ ๊ฒ๋ค๋ง ๋ฐฐ์น๋์ด ์๊ณ ๊ธด๋ฐํ๊ฒ ํ๋ ฅํ๋ค. ๋ฐ๋๋ก ์์ง๋๊ฐ ๋ฎ์ ๋ชจ๋์ ๋ชจ๋ ๋ด๋ถ์ ์๋ก ๊ด๋ จ ์๋ ํจ์๋ ๋ฐ์ดํฐ๋ค์ด ์กด์ฌํ๊ฑฐ๋ ๊ด๋ จ์ฑ์ด ์ ์ ์ฌ๋ฌ ๊ธฐ๋ฅ๋ค์ด ์๋ก ๋ค๋ฅธ ๋ชฉ์ ์ ์ถ๊ตฌํ๋ฉฐ ์ฐ์ฌํด ์๋ค.
์๋ฅผ๋ค์ด ์ผํ๋ชฐ ํ๋ก์ ํธ์์ ์ฃผ๋ฌธ ์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๋ ํด๋์ค์์ ํ์์ ์ ๋ณด๋ฅผ ์ ๋ฐ์ดํธํ๋ ๋ฉ์๋๊ฐ ์๋ค๋ฉด, ์ด๊ฒ์ ์์ง๋๊ฐ ๋ฎ์ ๊ฒ์ด๋ค. ํ์ ์ ๋ณด ์ ๋ฐ์ดํธ๋ ํ์๋ง ๋ด๋นํ๋ ํด๋์ค์์ ๋ฐ๋ก ๋ถ๋ฆฌํ์ฌ ์ฒ๋ฆฌํ๋๊ฒ์ด ์ณ๊ธฐ ๋๋ฌธ์ด๋ค.


์ด์ฒ๋ผ ์์ง๋๊ฐ ๋์ ๋ชจ๋์ ๊ธฐ๋ฅ์ ์์ ํ ๋ ๊ด๋ จ ๋ด์ฉ์ด ํ๋์ ๋ชจ๋์ ๋ชจ์ฌ์์ผ๋ฏ๋ก ์ฝ๋๋ฅผ ์ดํดํ๊ธฐ๋ ์ฝ๊ณ , ์์ ํ ํ ๊ด๋ จ ์๋ ๋ค๋ฅธ ๋ชจ๋์๊ฒ ์ํฅ์ ์ฃผ์ง ์์ ์ฝ๋์ ์ ์ง๋ณด์์ ์ ๋ฆฌํ๋ค.
๊ฐ์ฒด์งํฅ์ ๊ด์ ์์ ์์ง๋๋ ๊ฐ์ฒด ๋๋ ํด๋์ค์ ์ผ๋ง๋ ๊ด๋ จ ์๋ ์ฑ ์๋ค์ ํ ๋นํ๋์ง๋ฅผ ๋ํ๋ธ๋ค.
๋์ ์ฝ๋๊ฐ ์์ง๋๊ฐ ๋์์ง ๊ฒ์ฌํด๋ณด๋ ๋ฐฉ๋ฒ์ ๋ฉ์๋๋ค์ ๋ํ์ฌ ์ธ์คํด์ค ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๋น์จ์ด ๋์์ง ๋ณด๋ ๊ฒ์ด๋ค. ์ด๋ค ํด๋์ค์ ์์ง๋๊ฐ ๋๋ค๋ฉด ๋ฉ์๋์ ๋ณ์๊ฐ ์๋ก ์์กดํ๊ณ ์์ ๊ฒ์ด๊ณ , ์์ง๋๊ฐ ๋ฎ๋ค๋ฉด ์ํ์ ๊ธฐ๋ฅ์ ๋ ผ๋ฆฌ์ ์ฐ๊ฒฐ์ด ์ฝํ ๊ฒ์ด๊ณ ์ด๋ ํด๋์ค๋ฅผ ๋์ฑ ๋ถ๋ฆฌํ ์ ์์์ ์์ํ๊ธฐ๋ ํ๋ค.
์ฆ, ์์ง๋๊ฐ ๋์ ์๋ก ๋ ๋ฆฝ์ฑ์ด ๋์ ๋ชจ๋์ด๋ฉฐ ์ข์ ์ํํธ์จ์ด๋ ๋์ ์์ง๋(high cohesion)์ ์ ์งํด์ผ ํ๋ค.
[์์ง๋๊ฐ ๋์ ํด๋์ค์ ํน์ง]
- ๋จ์ผ ์ฑ ์์ ๊ฐ์ง ํด๋์ค (Single Responsibility Principle)
- ๋ค๋ฅธ ํด๋์ค์ ์ ํ๋ ฅํ๋ ํด๋์ค
์์ง๋ ๋จ๊ณ ์ข ๋ฅ
์์ง๋์ ๊ฐ๋ ๋จ๊ณ๋ ๊ธฐ๋ฅ์ , ์์ฐจ์ , ๊ตํ์ , ์ ์ฐจ์ , ์๊ฐ์ , ๋ ผ๋ฆฌ์ , ์ฐ์ฐ์ ์์ง๋์ ์ฒ๋๋ก ๋ถ๋ฆฌ ๋๋ฉฐ, ์ด์ ๋ฐ๋ผ ๋ชจ๋์ ํ์ง์ ์ธก์ ํ ์ ์๋ค. ๊ธฐ๋ฅ์ ์์ง๋ ์ชฝ์ผ๋ก ๊ฐ ์๋ก ์ข์ ํ์ง์ด๋ผ๊ณ ํ ์ ์์ผ๋ฉฐ ์ฐ์ฐ์ ์์ง๋๋ก ๊ฐ์๋ก ๋์ ํ์ง์ด ๋๋ค.

์ธ๊ธฐ | ์ข ๋ฅ | ๋ด์ฉ |
๊ฐํจ โ ์ฝํจ |
๊ธฐ๋ฅ์ ์์ง๋ (Functional Cohesion) |
๋ชจ๋ ๋ด๋ถ์ ๋ชจ๋ ๊ธฐ๋ฅ์ด ๋จ์ผ ๋ชฉ์ ์ ์ํด ์ํ๋๋ ๊ฒฝ์ฐ ์์ง๋๊ฐ ์ ์ผ ๋๊ณ ์ ์ผ ์ข์ ํํ์ด๋ค. |
์์ฐจ์ ์์ง๋ (Sequential Cohesion) |
๋ชจ๋ ๋ด์์ ํ ํ๋์ผ๋ก๋ถํฐ ๋์จ ์ถ๋ ฅ ๊ฐ์ ๋ค๋ฅธ ํ๋์ด ์ฌ์ฉํ ๊ฒฝ์ฐ | |
๊ตํ์ ์์ง๋ (Communication Cohesion) |
๋์ผํ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฌ์ฉํด ๋ค๋ฅธ ๊ธฐ๋ฅ์ ์ํํ๋ ํ๋๋ค์ด ๋ชจ์ฌ์์ ๊ฒฝ์ฐ | |
์ ์ฐจ์ ์์ง๋ (Procedural Cohesion) |
๋ชจ๋์ด ๋ค์ ๊ด๋ จ ๊ธฐ๋ฅ์ ๊ฐ์ง ๋ ๋ชจ๋ ์์ ๊ตฌ์ฑ์์๋ค์ด ๊ทธ ๊ธฐ๋ฅ์ ์์ฐจ์ ์ผ๋ก ์ํํ ๊ฒฝ์ฐ | |
์๊ฐ์ ์์ง๋ (Temporal Cohesion) |
์ฐ๊ด๋ ๊ธฐ๋ฅ์ด๋ผ๊ธฐ ๋ณด๋จ ํน์ ์๊ฐ์ ์ฒ๋ฆฌ๋์ด์ผ ํ๋ ํ๋๋ค์ ํ ๋ชจ๋์์ ์ฒ๋ฆฌํ ๊ฒฝ์ฐ | |
๋
ผ๋ฆฌ์ ์์ง๋ (Logical Cohesion) |
์ ์ฌํ ์ฑ๊ฒฉ์ ๊ฐ๊ฑฐ๋ ํน์ ํํ๋ก ๋ถ๋ฅ๋๋ ์ฒ๋ฆฌ ์์๋ค์ด ํ ๋ชจ๋์์ ์ฒ๋ฆฌ๋๋ ๊ฒฝ์ฐ | |
์ฐ์ฐ์ ์์ง๋ (Coincidental Cohesion) |
๋ชจ๋ ๋ด๋ถ์ ๊ฐ ๊ตฌ์ฑ์์๋ค์ด ์ฐ๊ด์ด ์์ ๊ฒฝ์ฐ ์์ง๋๊ฐ ์ ์ผ ๋ฎ๊ณ ์ ์ผ ์ข์ง ์์ ํํ์ด๋ค. |
๊ธฐ๋ฅ์ ์์ง๋ (Functional Cohesion)
- ๊ฐ์ฅ ์์ง๋๊ฐ ๋์ ํํ๋ก ๊ฐ์ฅ ์ข์ ํํ์ด๋ค.
- ๋ชจ๋ ๋ด๋ถ์ ๋ชจ๋ ๊ธฐ๋ฅ์ด ๋จ์ผ ๋ชฉ์ ์ ์ํด ์ํ๋๋ ๊ฒฝ์ฐ
- ๋์ ๋๋ ๋ณ์๊ฐ ๊ณตํต์ ์ผ๋ก ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ
- ๋ํ์ ์ธ ์๋ก ์ํ ์ฐ์ฐ์ ๊ด๋ จ๋ ๋ชจ๋๋ค์ ๋ชจ์ Math ํด๋์ค๋ฅผ ๋ค ์ ์๋ค.
public class Stack {
private int topOfStack = 0;
private List<Integer> elements = new LinkedList<Integer>();
public int size() {
return topOfStack;
}
public void push(int element) {
topOfStack++;
elements.add(element);
}
public int pop() throws PoppedWhenEmpty {
if (topOfStack == 0) {
throw new PoppedWhenEmpty();
}
int element = elements.get(--topOfStack);
elements.remove(topOfStack);
return element;
}
}
์์ ์ฝ๋๋ Stack ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํํ ํด๋์ค์ด๋ค.
๋ณดํต ๋ฉ์๋๊ฐ ์ธ์คํด์ค ๋ณ์๋ฅผ ๋ง์ด ์ฌ์ฉํ๋ฉด ํ ์๋ก ๋ฉ์๋์ ํด๋์ค๋ ์์ง๋๊ฐ ๋์์ง๋๋ฐ, ์์ ์ฝ๋์์๋ ๊ฐ ๋ฉ์๋ ๋ง๋ค ์ธ์คํด์ค ๋ณ์๋ฅผ ์ด์ฉํด ์๋ฃ๋ฅผ ์ ๋ฐ์ดํธ ํด์ค์ผ๋ก์จ ์์ง๋๋ฅผ ๋์๋ค.
์์ฐจ์ ์์ง๋ (Sequential Cohesion)
- ๋ชจ๋ ๋ด์์ ํ ํ๋์ผ๋ก ๋ถํฐ ๋์จ ์ถ๋ ฅ๊ฐ์ด ๋ค์ ํ๋์ ์ ๋ ฅ ๋ฐ์ดํฐ๋ก ์ฌ์ฉํ ๊ฒฝ์ฐ
- ์ด๋ค ๋ชจ๋์ด ํน์ ํ์ผ์ ์ฝ๊ณ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ฅ์ ํ๋ ๋ฑ๊ณผ ๊ฐ๋ค
class Sequential {
void processGrade(Grade grade) {
String numberGrade = grade.getGrade(); // ์ด๋ ๋ชจ๋์ ์ถ๋ ฅ๊ฐ์ด
String letterGrade = grade.computeLetter(numberGrade); // ๋ฐ๋ก ๋ค์ ์
๋ ฅ๊ฐ์ผ๋ก ์ด์ฉ
grade.displayLetter(letterGrade); // ๋ค์ ์ ์ ๋ฐํ๊ฐ์ด ๋ฐ๋ก ๋ค์ ์
๋ ฅ๊ฐ์ผ๋ก ์ด์ฉ
// ์์ ๊ฐ์ด ์์ด์ผ ๋ค์ ๋ชจ๋์ ์คํํ ์ ์๊ธฐ ๋๋ฌธ์ ์ฒ๋ฆฌ ์์๊ฐ ์์
// ๋ฉ์๋์ ๋ฆฌํด ๋ ๊ฒฐ๊ณผ๊ฐ ๋ค์ ๋ฉ์๋์ ์
๋ ฅ ํ๋ผ๋ฏธํฐ๋ก ์ฐ์ด๋ ๊ฒฝ์ฐ
}
}
๊ตํ์ ์์ง๋ (Communication Cohesion)
- ํต์ ์ ์์ง๋ ๋ผ๊ณ ๋ ๋ถ๋ฆผ
- ๋์ผํ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ๊ธฐ๋ฅ์ ์ํํ๋ ํ๋๋ค์ด ๋ชจ์ฌ์๋ ๊ฒฝ์ฐ
- ๋ฉ์๋ ํธ์ถ์ ๊ณตํต๋ ํ๋ผ๋ฏธํฐ๊ฐ ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ
- ์์ฐจ์ ์์ง๋์ ์ฐจ์ด์ ์ ๋์ ์ ์ฒ๋ฆฌ ์์๊ฐ ์ค์์น ์๋ค๋ ๊ฒ์ด๋ค.
class Communicational {
void Compute_MatrixMatrix(Matrix marix) {
int[][] aMatrix = marix.setGraph({ // ์ด๋ ๋ชจ๋์ ์ถ๋ ฅ๊ฐ์ด
{0, 0, 0},
{0, 0, 0}
});
transform_matrix = marix.trans(aMatrix); // ๋ฐ๋ก ๋ค์ ์
๋ ฅ๊ฐ์ผ๋ก ์ด์ฉ
inverse_matrix = marix.inverse(aMatrix); // ๋ฐ๋ก ๋ค์ ์
๋ ฅ๊ฐ์ผ๋ก ์ด์ฉ
// ๋ค๋ง ์์ ๊ฐ์ผ๋ก ์๋ก ๋ค๋ฅธ ๊ธฐ๋ฅ์ ๋ชจ๋์ ์ํํ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ์ฒ๋ฆฌ ์์๋ ์๊ด ์์
// ๋ฉ์๋ ํธ์ถ์ ๊ณตํต๋ ํ๋ผ๋ฏธํฐ๊ฐ ์
๋ ฅ
}
}
์ ์ฐจ์ ์์ง๋ (Procedural Cohesion)
- ๋ชจ๋์ด ๋ค์ ๊ด๋ จ ๊ธฐ๋ฅ์ ๊ฐ์ง ๋ ๋ชจ๋ ์์ ๊ตฌ์ฑ์์๊ฐ ๊ทธ ๊ธฐ๋ฅ์ ์์ฐจ์ ์ผ๋ก ์ํํ ๊ฒฝ์ฐ
- ํ๋์ ํด๋์ค์ ์๋ ๋ฉ์๋๋ค์ ์ฌ๋ฌ ๊ฐ ํธ์ถํ๋ ๊ฒฝ์ฐ
class Procedural extends Letter {
void sendLetter() {
// ํ๋์ ํด๋์ค์ ์๋ ๋ฉ์๋๋ค์ ์ฌ๋ฌ ๊ฐ ํธ์ถํ๋ ๊ฒฝ์ฐ
this.writerBody();
this.writerSalutation();
this.send();
}
}
์๊ฐ์ ์์ง๋ (Temporal Cohesion)
- ์ผ์์ ์์ง๊ณ ๋ผ๊ณ ๋ ๋ถ๋ฆผ
- ๊ฐ ๊ธฐ๋ฅ ์์๋ค์ด ์์์ ์๊ด์์ด ํน์ ์์ ์ ๋ฐ๋์ ์ํ๋๋ ๊ฒฝ์ฐ
- ์ฐ๊ด๋ ๊ธฐ๋ฅ์ด๋ผ๊ธฐ ๋ณด๋จ ํน์ ์๊ฐ์ ์ฒ๋ฆฌ๋์ด์ผ ํ๋ ํ๋๋ค์ ํ ๋ชจ๋์์ ์ฒ๋ฆฌํ ๊ฒฝ์ฐ
- ๋ฉ์๋ ํธ์ถ์ด ์ผ์ด๋์ง ์๊ณ ๋ณ์์ ์ด๊ธฐํ๋ง ์คํ๋๊ฑฐ๋, Exception ์๋ฌ ๋ก๊ทธ๋ฅผ ๋ณด๋ด๊ฑฐ๋ ๋ฑ
class Temporal {
int no_student;
int no_department;
String university_name;
void Init_Variables() {
// ํน์ ์๊ฐ์ ์ฒ๋ฆฌ๋์ด์ผ ํ๋ ํ๋๋ค์ ํ ๋ชจ๋์์ ์ฒ๋ฆฌ (๋ณ์ ์ด๊ธฐํ)
no_student = 0;
no_department = 0;
university_name = "Hongik University";
}
}
๋ ผ๋ฆฌ์ ์์ง๋ (Logical Cohesion)
- ์ ์ฌํ ์ฑ๊ฒฉ์ ๊ฐ๊ฑฐ๋ ํน์ ํํ๋ก ๋ถ๋ฅ๋๋ ์ฒ๋ฆฌ ์์๋ค์ด ํ ๋ชจ๋์์ ์ฒ๋ฆฌ๋๋ ๊ฒฝ์ฐ
- ๋ ผ๋ฆฌ์ ์ผ๋ก ๋น์ทํ ๊ธฐ๋ฅ์ ์ํํ์ง๋ง ์๋ก์ ๊ด๊ณ๋ ๋ฐ์ ํ์ง ์์ ํํ
- switch๋ฌธ์ด ์ฐ์ฌ case์ ๋ฐ๋ผ ๋น์ทํ์ง๋ง ๋ค๋ฅธ ์์ ์ ์ํํ๋ ๊ฒฝ์ฐ
class Logical {
public void solve_equation(int no_equ, long x) {
// switch๋ฌธ์ผ๋ก ๋
ผ๋ฆฌ์ ์ผ๋ก ๋ถ๋ฆฌ๋ ๊ธฐ๋ฅ์ ์ํํ๋ ๊ฒ์ฒ๋ผ ๋ณด์ด์ง๋ง, ์๋ก ๋ค๋ฅธ ๋ชจ๋์ ์คํํ๋ ๊ด๊ณ๊ฐ ์๋ ์ํ
switch (no_equ) {
case 1:
// ๋ชจ๋ ์คํ
break;
case 2:
// ๋๋ค๋ฅธ ๋ชจ๋ ์คํ
break;
case 3:
// ๋๋ค๋ฅธ ๋๋ค๋ฅธ ๋ชจ๋ ์คํ
break;
}
}
}
class SetProp {
// height์ width ์ธ์คํด์ค ๊ฐ์ ๋์์ ์ค์ ํ๋ Setter ๋ชจ๋
public void setValue(String name, int value) {
// ๊ธฐ๋ฅ ๋์ ์์ฒด๋ก๋ ๋ฌธ์ ๋ ์์ง๋ง, ํ๋์ ๋ฉ์๋์์ ์ ๋ถ ์ฒ๋ฆฌํ๋๊ฒ๋ณด๋ค, ๊ฐ๊ฐ์ ๋ฉ์๋์ ํ๋์ ์ธ์คํด์ค๋ฅผ ์ฒ๋ฆฌํ๋๋ก ์ง๋๊ฒ ์ข๋ค.
if ("height".equals(name)) {
this.height = value;
}
if ("width".equals(name)) {
this.width = value;
}
}
}
์ฐ์ฐ์ ์์ง๋ (Coincidental Cohesion)
- ๊ฐ์ฅ ์ข์ง ์์ ์์ง๋
- ๋ชจ๋ ๋ด๋ถ์ ๊ฐ ๊ตฌ์ฑ ์์๋ค์ด ์๋ก ๊ด๋ จ์๋ ์์๋ก๋ง ๊ตฌ์ฑ๋ ๊ฒฝ์ฐ
class Coincidental extends RecordProcess {
int average, totalScore;
boolean done;
Letter l;
void doStuff() {
// ๋ฌด์ง์ฑ์ผ๋ก ์๋ก ๊ด๋ จ ์๋ ์ฝ๋๋ฅผ ํ ๋ชจ๋์์ ๋ชจ์ ์คํ
readRecords();
average = totalScore / 10;
l.printNames();
done = true;
return;
}
}
๋์ ์์ง๋ & ๋ฎ์ ๊ฒฐํฉ๋
๊ฒฐํฉ๋๊ฐ ๋์ ํด๋์ค์ ๋ฌธ์ ์ ์ ํด๋์ค์ ๊ท๋ชจ๊ฐ ์ปค์ง๊ธฐ ๋๋ฌธ์ ์ดํด ํ๊ธฐ ์ฝ์ง ์์ผ๋ฉฐ, ๋ณํ์ ๋ฐ๋ฅธ ๋ค๋ฅธ ์์๋ค์ ๋ณ๊ฒฝ์ ์์ธกํ๊ธฐ ์ฝ์ง ์๋ค.
์์ง๋ ๋ฎ์ ํด๋์ค์ ๋ฌธ์ ์ ์ ์ฝ๋๋ฅผ ์ดํดํ๊ธฐ๊ฐ ํ๋ค๊ณ , ์ฌ์ฌ์ฉ์ด ํ๋ค๋ค. ๋ํ ์ ์ง๋ณด์๊ฐ ๋งค์ฐ ์ฝ์ง์์ผ๋ฉฐ ํด๋์ค ๋ณํ์ ๋ฏผ๊ฐํ๋ค
๋ฐ๋ผ์ ๋์ ์์ง๋์ ๋ฎ์ ๊ฒฐํฉ๋๊ฐ ์ด์์ ์ธ ์ํํธ์จ์ด ๋ชจ๋์ด๊ฒ ๋๋ค.

ํ์ง๋ง ๊ทธ๋ ๋ค๊ณ ์์ง๋๋ ๋์์๋ก ์ข๊ณ ๊ฒฐํฉ๋๋ ๋ฎ์ ์๋ก ์ข๋ค๋ "high cohesion loose coupling" ์์น์ด ํญ์ ์ ํจํ ๊ฒ์ ์๋๋ค.
๊ฒฐ๊ตญ ํ๋ก๊ทธ๋จ์ ํน์ฑ์ด๋ ์ํฉ์ ๋ฐ๋ผ ์ ์ฐํ๊ฒ ์ ์ฉํด์ผ ํ๋ค.
ํ์ง๋ง ์์คํ ์ ์ง๋ณด์ ์ธก๋ฉด์ ์์ด์ ๋ชจ๋์ ์์ง๋๋ ๋์์๋ก, ๊ฒฐํฉ๋๋ ๋ฎ์ ์๋ก ์ ๋ฆฌํ ๊ฒ์ ๋ถ๋ช ํ๋ค.
ํนํ๋ ๋จ์ด ๊ฐ๋ฐํด๋์ ์๋ง์ง์ฐฝ์ธ ์ฝ๋๋ฅผ ์ ์ง๋ณด์ ํด์ผํ ๋ ๋น๋ก์ ์ฒด๊ฐํ๊ฒ ๋๋ ๊ฒ์ด ์์ง๋์ ๊ฒฐํฉ๋ ์ด๋ค.
ํ๋ฒ์ฏค์ ๋ค์ด๋ณธ ๊ฐ์ฒด์งํฅ์ ์ฌ๋ฌ๊ฐ์ง ์ ๋ช ํ ๋์์ธ ํจํด๋ค์ด ๋ฐ๋ก ์ด ์์ง๋๋ฅผ ๋ํ๊ณ ๊ฒฐํฉ๋๋ฅผ ๋ฎ์ถ๊ธฐ ์ํ ์์น์ผ๋ก ์ค์ ๋๊ณ ๊ตฌ์ฑ๋ ์์์ด๋ค. ๊ทธ๋์ ๋์์ธ ํจํด์ ์์น์ ์ ์งํค๋ฉด ํ๋ํ๋ ๋จ๊ณ๋ฅผ ๋ฐ์ง ํ์์์ด ์์ฐ์ค๋ฝ๊ฒ "high cohesion loose coupling" ๋ฐ๋ฅด๊ฒ ๋๋ ๋ค๋ค ์ ์ ๋ชจ์ ์ค์ํ๋ค๊ณ ํ๋ ๊ฒ์ด๋ค.
# ์ฐธ๊ณ ์๋ฃ
https://madplay.github.io/post/coupling-and-cohesion-in-software-engineering
https://rutgo-letsgo.tistory.com/227
https://feature-sliced.design/docs/concepts/low-coupling
https://medium.com/@jang.wangsu/%EC%84%A4%EA%B3%84-%EC%9A%A9%EC%96%B4-%EC%9D%91%EC%A7%91%EB%8F%84%EC%99%80-%EA%B2%B0%ED%95%A9%EB%8F%84-b5e2b7b210ff
์ด ๊ธ์ด ์ข์ผ์ จ๋ค๋ฉด ๊ตฌ๋ & ์ข์์
์ฌ๋ฌ๋ถ์ ๊ตฌ๋
๊ณผ ์ข์์๋
์ ์์๊ฒ ํฐ ํ์ด ๋ฉ๋๋ค.