Intro
ํ๋ก๊ทธ๋๋ฐ ์ด์ฐฝ๊ธฐ์๋ System = Routine + Subroutine
์ด์๋ค. Fortran, PL/1์์ ์๋ System = Program + SubProgram + Function
์ด์๋ค.์ง๊ธ์ Function๋ง ๋จ์๋ค. ์ฆ, **์ด๋ ํ ํ๋ก๊ทธ๋จ์ด๋ ๊ธฐ๋ณธ ๋จ์๋ ํจ์๋ค. **์ฝ๋๋ฅผ ์ฝ๋ค๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ ํน์ง๋ค์ ๊ฐ์ง๋ ์ฝ๋๋ฅผ ์ฝ๊ฒ ๋๋ค.
- ๊ธธ์ด๊ฐ ๊ธธ๋ค.
- ์ฝ๋๊ฐ ์ค๋ณต๋์ด ์๋ค.
- ๋ฌธ์์ด์ด ๊ดด์ํ๋ค.
- ๋ฏ์ค๊ณ ๋ชจํธํ ์๋ฃ ์ ํ์ด ์๋ค.
์ด๋ฐ ํน์ง์ ๊ฐ์ง๋ ํจ์๋ ์ดํดํ๊ธฐ ๋งค์ฐ ์ด๋ ต๋ค. ์ด๋ฏ๊ฒ ํ๋ฉด ์ฝ๊ธฐ ์ฝ๊ณ ์ดํดํ๊ธฐ ์ฌ์ด ํจ์๋ฅผ ์์ฑํ ์ ์์๊น?
์๊ฒ ๋ง๋ค์ด๋ผ
์์๊ฒ ์ต๊ณ ๋ค.
public static String renderPageWithSetupsAndTeardowns( PageData pageData, boolean isSuite) throws Exception {
boolean isTestPage = pageData.hasAttribute("Test");
if (isTestPage) {
WikiPage testPage = pageData.getWikiPage();
StringBuffer newPageContent = new StringBuffer();
includeSetupPages(testPage, newPageContent, isSuite);
newPageContent.append(pageData.getContent());
includeTeardownPages(testPage, newPageContent, isSuite);
pageData.setContent(newPageContent.toString());
}
return pageData.getHtml();
}
public static String renderPageWithSetupsAndTeardowns( PageData pageData, boolean isSuite) throws Exception {
if (isTestPage(pageData))
includeSetupAndTeardownPages(pageData, isSuite);
return pageData.getHtml();
}
์ ์๋ ์ ์ฝ๋๋ ์๋ค๊ณ ํ๋ค. ๋๋๋ก ํ ํจ์๋น 3~5์ค ๋ด๋ก ์ค์ด๋ ๊ฒ์ ๊ถ์ฅํ๋ค.
๋ธ๋ก๊ณผ ๋ค์ฌ์ฐ๊ธฐ
if/else/while์ ๋ค์ด๊ฐ๋ ๋ธ๋ก์ ํ ์ค์ด์ด์ผ ํ๋ค. ๋ค์ฌ์ฐ๊ธฐ ์์ค์ 2๋จ์ ๋์ด์๋ฉด ์๋๋ค.
์ด๋ ๊ฒ ๋๋ฉด enclosing function(๋ฐ๊นฅ์ ๊ฐ์ธ๋ ํจ์)์ด ์์์ง๊ณ , ๋ธ๋ก ํธ์ถ ์ ํจ์ ์ด๋ฆ์ ์ ์ง๋๋ค๋ฉด ์ฝ๋ ์ดํด๊ฐ ์์ํด์ง๋ค.
ํ๊ฐ์ง๋ง ํด๋ผ!
ํจ์๋ ํ ๊ฐ์ง๋ฅผ ํด์ผ ํ๋ค. ๊ทธ ํ ๊ฐ์ง๋ฅผ ์ ํด์ผ ํ๋ค. ๊ทธ ํ๊ฐ์ง๋ง์ ํด์ผ ํ๋ค.
์ง๊ฒน๊ฒ ๋ค์์ง๋ง ์ด๋ ค์ด ๋ง์ด๋ค. โํ ๊ฐ์งโ์ ์ ์๊ฐ ์๋นํ ๋ชจํธํ๋ค.
public static String renderPageWithSetupsAndTeardowns( PageData pageData, boolean isSuite) throws Exception {
if (isTestPage(pageData))
includeSetupAndTeardownPages(pageData, isSuite);
return pageData.getHtml();
}
์ ์ฝ๋๋ โํ ๊ฐ์งโ๋ง ํ๋ค๊ณ ๋งํ ์ ์์๊น? ํน์๋ 3๊ฐ์ง๋ฅผ ํ๋ค๊ณ ๋งํ ์๋ ์๋ค.
- ํ์ด์ง๊ฐ ํ ์คํธ ํ์ด์ง์ธ์ง ํ๋จํ๋ค.
- ๋ง๋ค๋ฉด ์ค์ ํ์ด์ง์ ํด์ ํ์ด์ง๋ฅผ ๋ฃ๋๋ค.
- ํ์ด์ง๋ฅผ HTML๋ก ๋ ๋๋งํ๋ค.
์ด๋ฐ ํ๋จ์ ๊ธฐ์ค์ โ์ถ์ํ ์์คโ์ด๋ค. ๋ค์ ๋งํด ์ผ๋ง๋ Detail์ ๊ฐ์ถ์ด์ ์์ฑํ๋๋๋ฅผ ๋งํ๋ค. ์ฆ, ์ต๋ํ ์ถ์ํ๋ฅผ ํด์ ๋์จ ๊ฒฐ๊ณผ๊ฐ ๋์ด์ ์ถ์ํ๊ฐ ๋ถ๊ฐํ๋ค๋ฉด, ์ด๋ ํ ๊ฐ์ง๋ง ํ๋ ํจ์๋ผ ํ ์ ์์ ๊ฒ์ด๋ค. ์ด๋ ์ด๋ป๊ฒ ๋ณด๋ฉด โํจ์ ๊น์ดโ์๋ ๊น์ ์ฐ๊ด์ฑ์ด ์๋ค๊ณ ํ ์ ์๊ฒ ๋ค. ์ฐ๋ฆฌ๊ฐ ํจ์๋ฅผ ๋ง๋๋ ์ด์ ๋ ํฐ ๊ฐ๋ ์ ์์ ๊ฐ๋ ์ผ๋ก ๋๋์ด ์ฒ๋ฆฌํ๊ธฐ ์ํจ์ด๋ผ๋ ๊ฒ์ ์์ง ๋ง์.
ํจ์๋ด ์น์
ํจ์๋ฅผ ์ฌ๋ฌ Section(์๋ฏธ๋ก ์ ๋จ์)์ผ๋ก ๋๋ ์ ์๋ค๋ฉด, ๊ทธ ํจ์๋ ์ฌ๋ฌ์์ ์ ํ๋ ์ ์ด๋ค.
์ ์ธ, ์ด๊ธฐํ, ๋์์ ์ธ ๋ถ๋ถ์ด ํ๋์ ํจ์ ์์์ ์ด๋ฃจ์ด์ง๊ณ ์๋ค๋ฉด, ์ฌ๋ฌ ์์ ์ ํ๊ณ ์๋ค๋ ๋ฐ์ฆ์ด๋ค.
ํจ์๋น ์ถ์ํ ์์ค์ ํ๋๋ก!
ํจ์๊ฐ ํ์คํ โํ ๊ฐ์งโ๋ง ํ๋ ค๋ฉด, ํจ์๋ด ๋ชจ๋ ๋ฌธ์ฅ์ ์ถ์ํ ์์ค์ด ๊ฐ์์ผ ํ๋ค.
์๊น ๋งํ๋ function depth์ ์ฐ๊ด์ด ์๋ค๋ ๋ง์ด ์ด ๋ง์ด๋ค. ์ฌ๋์ ์ถ์์ ์ธ ๋ด์ฉ์ผ๋ก ์์ํด์ ๊ตฌ์ฒด์ ์ธ ๋ด์ฉ์ ์ฝ๋ ๊ฒ์ ์ํ๋ค. ์ฝ๋ ์ญ์ ์ด๋ฐ์์ผ๋ก ์์ฑํด์ผ ํ๋ค.
๋ด๋ ค๊ฐ๊ธฐ ๊ท์น
์ด๋ฌํ ์ ์์ ์ฝ๋๋ฅผ ์์ฑํ ๋๋ ์์์๋ ๋์ ์์ค์ ์ถ์ํ ์์ค, ํ์์๋ ๋ฎ์ ์์ค์ ์ถ์ํ ์์ค์ด ๋ด๊ธด ํจ์๋ฅผ ์์ฑํ๋ ๊ฒ์ด ์ฝ๊ธฐ ์์ํ๋ค.
Switch ๋ฌธ
public Money calculatePay(Employee e) throws InvalidEmployeeType {
switch (e.type) {
case COMMISSIONED:
return calculateCommissionedPay(e);
case HOURLY:
return calculateHourlyPay(e);
case SALARIED:
return calculateSalariedPay(e);
default:
throw new InvalidEmployeeType(e.type);
}
}
๋ฌธ์ ๋ ์ด๋ ์์ด๋ค. ์ด๋ ์์ ๋ง์ฃผํ ๋๋ง๋ค ์๊ฒ ๋ง๋ค๊ธฐ๊ฐ ํ๋ค์ด์ ๊ณ ์ํ์๋ค. ๋ณธ์ง์ ์ผ๋ก Switch๋ฌธ์ด ๊ฐ์ง๋ ๊ณ ์ง์ ์ด๋ผ ํ ์ ์๊ฒ ๋ค.(if/else๋ ๋ง์ฐฌ๊ฐ์ง) ์ด๋ฌํ ์ ์์ ์ฌ์ค ๋คํ์ฑ์ ์ฌ์ฉํ๋ ๊ฒ์ด ๊ฐ์ฅ ๊น๋ํ๊ฒ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
public abstract class Employee {
public abstract boolean isPayday();
public abstract Money calculatePay();
public abstract void deliverPay(Money pay);
}
-----------------
public interface EmployeeFactory {
public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType;
}
-----------------
public class EmployeeFactoryImpl implements EmployeeFactory {
public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType {
switch (r.type) {
case COMMISSIONED:
return new CommissionedEmployee(r) ;
case HOURLY:
return new HourlyEmployee(r);
case SALARIED:
return new SalariedEmploye(r);
default:
throw new InvalidEmployeeType(r.type);
}
}
}
Factory๋ฅผ ์ฌ์ฉํ์ฌ, ์ค์ instance๋ฅผ ๋ง๋ค์ด ๋ด๋ณด๋ธ๋ค. Switch๋ฌธ์ factory๋ด์์๋ง ์ฌ์ฉํ๋๋ก ๊ฝ๊ฝ ์จ๊น์ผ๋ก์ ๋ณด๋ค ๊น๋ํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค. ๋ฌผ๋ก .. ๋ถ๊ฐํผํ ์ํฉ๋ ์๋ค. ใ ใ
์์ ์ ์ธ ์ด๋ฆ์ ์ฌ์ฉํ๋ผ!
โ์ฝ๋๋ฅผ ์ฝ์ผ๋ฉด์ ์ง์ํ๋ ๊ธฐ๋ฅ์ ๊ฐ ๋ฃจํด์ด ๊ทธ๋๋ก ์ํํ๋ค๋ฉด ๊นจ๋ํ ์ฝ๋๋ผ ๋ถ๋ฌ๋ ๋๊ฒ ๋คโ - ์๋
์ด์ ์ฅ์์ ๋๊ฐ๋ค์ Clean code์ ๋ํ ์ด์ผ๊ธฐ๋ฅผ ๋ค์์๋๋ฐ, ์ด ๋ ๋งํ โ์ง์ํ๋ ๊ธฐ๋ฅโ์ ์ํํ๊ธฐ ์ํด ๊ฐ์ฅ ์ค์ํ ๊ฒ์ ์ด๋ฆ์ด๋ค. ์ด ๋, ์๊น๋งํ โ์๊ฒ ๋ง๋ค์ด๋ผโ ๊ท์น์ ์ ์ฉํ ์์ ํจ์๋ผ๋ฉด ๊ทธ ๊ธฐ๋ฅ์ด ๋ช ํํ๊ธฐ ๋๋ฌธ์ ์ด๋ฆ์ ๋ถ์ด๊ธฐ๊ฐ ๋ ์ฝ๋ค. ์ผ๊ด์ ์ธ ์์ ํ ์ด๋ฆ(๋์ฌ)๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ์์ฐจ์ ์ผ๋ก ์ดํดํ๊ธฐ๋ ์ฝ๋ค.
ํจ์ ์ธ์
์ด์์ ์ธ ํจ์ ์ธ์๋ 0๊ฐ์ด๋ค. ์ฐจ์ ์ 1๊ฐ.
Class ๋ด๋ถ์ instance ๋ณ์๋ก ๋ค๊ณ ์์ง ์๊ณ ์ผ์ผํ ์ธ์๋ก ๋๊ฒจ์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ๋ ์์ ๊ฒ์ด๋ค. ํ์ง๋ง ์ด๋ ๊ฒ ํ ๊ฒฝ์ฐ ๊ฐ๋ ์ฑ์๋ ์คํ๋ ค ์ข์ง ์์๋ฐ, ๋ค์๊ณผ ๊ฐ์ ์ด์ ๊ฐ ์๋ค.
- ์ธ์๋ก ๋์ด์ฌ ๋๋ง๋ค, ํด๋น ์ธ์๊ฐ ๋ฌด์์ธ์ง ์๊ฐํด์ผ ํ๋ค.
- ํจ์์ ์ธ์์ ์ถ์ํ ์์ค์ด ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์ดํด๊ฐ ์ด๋ ต๋ค.
- ํ ์คํธ์์๋ ์ธ์๊ฐ ์๋ค๋ฉด ์ฌ๋ฌ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ชจ๋ ๋ฐ์ ธ์ ๊ฒ์ฆํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ถ๋ด์ค๋ฝ๋ค.
- ์ถ๋ ฅ ์ธ์(๊ฒฐ๊ณผ๊ฐ์ ๋ฐ๊ธฐ ์ํด ๋ฃ์ด์ฃผ๋ ์ธ์)๋ ๋ ์์ข๋ค. ๋ฆฌํดํ๋ ๊ฒ์ ์ต์ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ถ๊ธ์ฆ: ๊ทธ๋ฐ๋ฐ ๊ทธ๋ผ ํด๋์ค ๋ด๋ถ์์ ๊ณตํต์ ์ํ๊ฐ์ ์ฌ๊ธฐ์ ๋ณ๊ฒฝ, ์ ๊ธฐ์ ๋ณ๊ฒฝํด๋ ๊ด์ฐฎ์๊น? ์์ํจ์๊ฐ ๋ณด๋ค ๋ซ๋ค๋ ๋ง์ ๋ฌด์จ ๋ง์ผ๊น?
๋ง์ด ์ฐ๋ ๋จํญ(์ธ์ 1๊ฐ) ๋ฐฉ์
- ์ธ์์ ์ง๋ฌธ์ ๋์ง๋ ๊ฒฝ์ฐ:
boolean fileExists(โMyFileโ);
- ์ธ์๋ฅผ ๋ณํํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ:
InputStream fileOpen(โMyFileโ);
- ์ด๋ฒคํธ ํจ์์ธ ๊ฒฝ์ฐ:
passwordAttemptFailedNTimes(int attempts)
- ์ด๋ฒคํธ ํจ์๋ผ๋ ์ฌ์ค์ด ์ฝ๋์ ๋ช ํํ ๋๋ฌ๋์ผ ํ๋ค.
์์ ์ค๋ช ํ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด ๋จํญ ํจ์๋ ๊ฐ๊ธ์ ํผํ๋๋ก ํ๋ค.
ํ๋๊ทธ ์ธ์
์ถํ๋ค ์ถํด
๋๋๊ณ ์ธ์๋ก Bool ๊ฐ์ ๋ฐ์ผ๋ฉด์, โ์ ๋ ๋๊ฐ์ง ์ผ์ ํ๊ณ ์์ต๋๋คโ๋ฅผ ๊ด๊ณ ํ๋ ๊ผด์ด๋ค. So Sad.. ๋ฐ์ฑ.. ์ฐจ๋ผ๋ฆฌ ํจ์๋ฅผ ๋๋ ๋๊ณ ํธ์ถํ๋ ๊ฒ์ด ์ข์ ๋ฐฉ์์ด๋ผ ํ๋ค.
์ดํญ ํจ์
๋จํญ ๋ณด๋ค ์ดํดํ๊ธฐ ์ด๋ ต๋ค.
Point
ํด๋์ค์ ๊ฒฝ์ฐ์๋ ์ดํญ ํจ์๊ฐ ์ ์ ํ๋ค. 2๊ฐ์ ์ธ์๊ฐ์ ์์ฐ์ ์ธ ์์๊ฐ ์์ด์ผํจ Point p = new Point(x,y);
๋ฌด์กฐ๊ฑด ๋์ ๊ฒ์ ์๋์ง๋ง, ์ธ์๊ฐ 2๊ฐ์ด๋ ๋งํผ ์ดํด๊ฐ ์ด๋ ต๊ณ ์ํ์ด ๋ฐ๋ฅด๋ฏ๋ก ๊ฐ๋ฅํ๋ฉด ๋จํญ์ผ๋ก ๋ฐ๊พธ๋๋ก ํ์. ๊ตณ์ด ์ธ์ 2๊ฐ๋ฅผ ๋ฐ๊ธฐ๋ณด๋ค, ํน์ Class ๋ด๋ถ์ instance method๋ฅผ ๋ง๋ค์ด ๋จํญ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ๋ ์๋ค.
์ผํญ ํจ์
์ ์คํ, ๋ ์ ์คํ ๋ง๋ค์ด๋ผ.
์ดํญ ํจ์๋ณด๋ค ์ดํดํ๊ธฐ๊ฐ ํจ์ฌ ์ด๋ ต๋ค. ์ํ๋ 2๋ฐฐ์ด์ ๋์ด๋๋ค. assertEquals(message, expected, actual)
์ ์๊ฐํด๋ณด๋ฉด ๋ฉ์นซํ๋ค. ์ฒ์์ด ๋ณดํต expected
๋ผ ์๊ฐํ๋๋ฐ, ์๊ณ ๋ณด๋ message
๋ค.
์ธ์ ๊ฐ์ฒด
์ธ์๊ฐ 2~3๊ฐ ํ์ํ๋ค๋ฉด ๋ ์์ ์ธ ํด๋์ค ๋ณ์๋ก ์ ์ธํ ๊ฐ๋ฅ์ฑ์ ์๊ฐํด๋ณด์.
์ด ํ์ด ์ ์ผ ๋์์ด ๋ง์ด ๋๋ ๊ฒ ๊ฐ๋ค.
Circle makeCircle(doudle x, double y, double radius);
Circle makeCircle(Point center, double radius);
ํธ๋ฆญ์ด๋ผ ์๊ฐํ ์ ์์ง๋ง ๊ทธ๋ ์ง ์๋ค. ๋ฌถ์์ผ๋ก์ ์ด๋ ํ ๊ฐ๋ ์ ํํํ๊ณ ์๋ค.
์ธ์ ๋ชฉ๋ก
String.format
๊ฐ์ ํจ์๋ค์ ์ธ์ ๊ฐ์๊ฐ ๊ฐ๋ณ์ ์ด๋ค. (String์ %s
๋ฃ๋ ์น๊ตฌ) ์ด๋ฐ ๊ฒฝ์ฐ ์ธ์๋ฅผ List ํ ์ธ์ํ๋๋ก ์ทจ๊ธํ๊ฒ ๋๋ฉด ๊ฒฐ๊ตญ ์ดํญ ํจ์๋ก ์ทจ๊ธํ ์ ์๋ค. ์ค์ ์ ์ธ๋ถ๋ฅผ ๋ณด๋ฉด ์ดํญ ํจ์๋ค.
public String formay(String format, Object...args)
๋์ฌ์ ํค์๋
๋จํญ ํจ์๋ ํจ์์ ์ธ์๊ฐ ๋์ฌ/๋ช ์ฌ ์์ ์ด๋ฃจ์ด์ผ ํ๋ค.
writeField(name);
ํจ์ ์ด๋ฆ์ ํค์๋(์ธ์ ์ด๋ฆ)์ ์ถ๊ฐํ๋ฉด ์ธ์ ์์๋ฅผ ๊ธฐ์ตํ ํ์๊ฐ ์์ด์ง๋ค.
assertExpectedEquialsActual(expected, actual);
๋ถ์ ํจ๊ณผ๋ฅผ ์ผ์ผํค์ง ๋ง๋ผ!
๋ถ์ ํจ๊ณผ(Side Effect)๋ ๋ชป๋ ๋. ํ ๊ฐ์ง๋ฅผ ์ํ๊ณ ๋ค์์ ๋ด ์งํ๋ค๋ ๋ง์ด๋ค.
public class UserValidator {
private Cryptographer cryptographer;
public boolean checkPassword(String userName, String password) {
User user = UserGateway.findByName(userName);
if (user != User.NULL) {
String codedPhrase = user.getPhraseEncodedByPassword();
String phrase = cryptographer.decrypt(codedPhrase, password);
if ("Valid Password".equals(phrase)) {
Session.initialize();
return true;
}
}
return false;
}
}
๊ฒ์ผ๋ก ๋ณด๊ธฐ์๋ ๋ฌด์จ ๋ฌธ์ ๊ฐ ์๋์ง ์ ํ ๋ชจ๋ฅด๊ฒ ๋ค. username๊ณผ password๋ฅผ ํ์ธํ๊ณ ๋ ์ธ์๊ฐ ์ฌ๋ฐ๋ฅด๋ฉด true๋ฅผ ๋ฐํํ๋ค. ์๋๋ฉด false๋ฅผ ๋ฐํํ๊ณ . ๊ทธ๋ฐ๋ฐ ํจ์ ์ด๋ฆ์ ๋ณด๋๊น ์ด์ํ๋ค. checkPassword
ํจ์ ๋ด์์ session์ ์ด๊ธฐํํ๊ณ ์๋ค.
checkPassword
๋ผ๋ ํ๋์ ํ๋์ ํ๊ณ ์์ง ์๊ณ , session์ ์ด๊ธฐํํ๋ ๋์๊น์ง ํ๊ณ ์๋ค. ์ด๋ ๊ฒ ์ฝ๋๋ฅผ ์์ฑํ๊ฒ ๋๋ฉด, checkPassword
๋ผ๋ ํ์๋ session์ ์ด๊ธฐํํด๋ ๊ด์ฐฎ์ ๊ฒฝ์ฐ์๋ง ํธ์ถ๊ฐ๋ฅํด์ง๋ค.
์ถ๋ ฅ ์ธ์
ํผํด๋ผ. ์ด๊ฒ ๋ญ์ผ
์ธ์๋ ๋ณดํต input์ผ๋ก ์๊ฐํ๋ค. ๊ทธ๋ฐ๋ฐ ์ฌ๊ธฐ์ ์ถ๋ ฅ์ ๋ด๊ธฐ ์ํ ์ธ์๋ฅผ ๋ฃ์ด์ค๋ค๋ ๊ฒ์ ์ฐ๋ฆฌ์ ๋ณดํธ์ ์์๊ณผ ๋ง์ง ์๋๋ค.
๋ช ๋ น๊ณผ ์กฐํ๋ฅผ ๋ถ๋ฆฌํ๋ผ!
ํจ์๋ โ์ํโํ๊ฑฐ๋ โ๋ตโํ๊ฑฐ๋ ๋ ์ค ํ๋๋ค.
์ฆ, ๊ฐ์ฒด ์ํ๋ฅผ ๋ณ๊ฒฝํ๊ฑฐ๋ ์๋๋ฉด ๊ฐ์ฒด์ ๋ณด๋ฅผ ๋ฐํํ๊ฑฐ๋ ๋ ์ค ํ๋์ด๋ค.
public boolean set(String attribute, String value); // attribute๋ฅผ ์ฐพ์์ value๋ก settingํด์ค, setting๋๋ฉด true๋ก ๋ฐํํด์ค
if(set(โusernameโ, โunclebobโ))... // ..? ์ด๊ฒ ๋ฌด์จ ๋ง์ด์ผ
๋๋์ฒด ๋ฌด์จ ๋ง์ผ๊น. ์ด๊ฑด username์ unclebob์ธ์ง ํ์ธํ๋ ๊ฑธ๊น, ์ธํ
ํ๋ ๊ฑธ๊น? setAndCheckIfExist
๋ผ๊ณ ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ๋ ์์ง๋ง, ๊ทธ๊ฒ๋ณด๋ค๋ ์ ์ด์ ๋ณ๊ฒฝ๊ณผ ์กฐํ๋ฅผ ๋ถ๋ฆฌํ๋ ๊ฒ์ด ํ์คํ๋ค.
if (attrivuteEdists("username")) {
setAttribute("username", "unclebob");
}
์ค๋ฅ ์ฝ๋๋ณด๋ค ์์ธ๋ฅผ ์ฌ์ฉํ๋ผ!
์ค๋ฅ ์ฒ๋ฆฌ๋ ๋ณดํต โ๋ช ๋ นโ์ ๋์์ ์ํํ ๋ ๋ฐ์ํ๋ค. ์ญ์ , ์ ๋ฐ์ดํธ, ์์ฑ ๋ฑ์ ์์ ์์ ์ค๋ฅ๋ฅผ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ๊น? ๋ง์ฝ ๋ฌธ์์ด๋ก ์ฒ๋ฆฌํ๋ค๊ณ ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
if (deletePage(page) == E_OK) {
if (registry.deleteReference(page.name) == E_OK) {
if (configKeys.deleteKey(page.name.makeKey()) == E_OK) {
logger.log("page deleted");
} else {
logger.log("configKey not deleted");
}
} else {
logger.log("deleteReference from registry failed");
}
} else {
logger.log("delete failed"); return E_ERROR;
}
์ด ๋ฐฉ์์ ์ผ๋จ ๋ฌธ์ ๊ฐ ์๋๋ฐ, ๋ช ๋ น๋ฌธ์ ์ฌ์ฉํ์์๋ ๋ฐํ๊ฐ์ด ์๋ค๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ฐํ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ์ค๋ฅ์ฝ๋๋ฅผ ์ฒ๋ฆฌํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ก์ง์ ์์ฑํ๋๋ฐ ์๋นํ ๋ถํธํ๋ค.
public void delete(Page page) {
try {
deletePageAndAllReferences(page);
} catch (Exception e) {
logError(e);
}
}
private void deletePageAndAllReferences(Page page) throws Exception {
deletePage(page);
registry.deleteReference(page.name);
configKeys.deleteKey(page.name.makeKey());
}
private void logError(Exception e) {
logger.log(e.getMessage());
}
์ฌ๊ธฐ์ ์ค๋ฅ ์ฒ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด, ์ค๋ฅ ์ฒ๋ฆฌ ๋ก์ง์ ์์ฑํ๊ธฐ ์ด์ ์ ๋ฌธ๋งฅ์ ๋ฐฉํด๋ฐ์ ์ผ๋ ์๊ณ ์ฝ๋๋ ์๋นํ ๊น๋ํด์ง๋ค. ์ค๋ฅ์ฒ๋ฆฌ๋ ํ ๊ฐ์ง ์์ ์ด๋ผ๋ ๊ฒ๋ ๋ช ์ฌํ์.
Error.java ์์กด์ฑ ์์
public enum Error {
OK,
INVALID,
NO_SUCH,
LOCKED,
OUT_OF_RESOURCES,
WAITING_FOR_EVENT;
}
์ค๋ฅ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ณณ๊ณณ์์ ์ค๋ฅ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ค๋ฉด enum class๋ฅผ ์ฐ๊ฒ ๋๋๋ฐ ์ด๋ฐ ํด๋์ค๋ ์์กด์ฑ ์์์ด๋ฏ๋ก, ์ ์ค๋ฅ์ฝ๋๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ๋ณ๊ฒฝํ ๋ ์ฝ์คํธ๊ฐ ๋ง์ด ํ์ํ๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์์ธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์์ ํ๋ค. ์ฆ Exception class๋ฅผ ํ์ํด์ ๋ง๋ค์ด์ ์ฌ์ฉํ๋ ๋ฐฉ์์ผ๋ก ์ฌ์ฉํด๋ผ.
๋ฐ๋ณตํ์ง ๋ง๋ผ!
์ค๋ณต์ ์ํํธ์จ์ด์์ ๋ชจ๋ ์ ์ ๊ทผ์์ด๋ค.
๊ตฌ์กฐ์ ํ๋ก๊ทธ๋๋ฐ
- ๋ชจ๋ ํจ์์ ํจ์ ๋ด ๋ชจ๋ ๋ธ๋ก์ ์ ๊ตฌ์ ์ถ๊ตฌ๋ ํ๋์ฉ๋ง ์กด์ฌํด์ผ ํ๋ค.
- ํจ์๋ return ๋ฌธ์ด ํ๋์ฌ์ผ ํ๋ค.
- break, continue ์๋๋ค.
- goto๋ ์ฃฝ์ด๋ ์๋๋ค.
์์ ๊ฐ์ ๋ฐฉ์์ ๊ตฌ์กฐ์ ํ๋ก๊ทธ๋๋ฐ์ด๋ผ ํ๋ค. Dijkstra๊ฐ ์ ์ฐฝํ ์์น์ด๋ค. ํ์ง๋ง ํจ์๊ฐ ์์ ๊ฒฝ์ฐ, ์์ ๊ท์น์ ๋ณ๋ค๋ฅธ ํจ์ฉ์ด ์๋ค. ์์ ๊ฒฝ์ฐ์๋ return, break, continue ์ฌ์ฉ์ ๋ฌธ์ ์๋ค. ์คํ๋ ค ๋จ์ผ ์ /์ถ๊ตฌ ๊ท์น๋ณด๋ค ์๋ ํํ์ด ์ฌ์์ง ๋๊ฐ ๋ง๋ค.
ํจ์๋ฅผ ์ด๋ป๊ฒ ์ง์ฃ ?
์ฒ์๋ถํฐ ํ ์ ์๋ค.
๊ธ์ง๊ธฐ์ ๋น์ทํ๋ค. ์๊ฐ๋ค์ ๊ธฐ๋กํ๊ณ , ์ฝ๊ธฐ ์ข๊ฒ ๋ค๋ฌ๋๋ค. ์ด์์ ์ํฌ๋ฅด์ง๋ง ์ ๋ฆฌํ ์๋ก ์ข์ ๋ฌธ์ฅ์ด ๋์จ๋ค. ์ฝ๋๋ ๊ทธ๋ ๋ค.
๊ฒฐ๋ก
ํจ์๋ฅผ ์ ์์ฑํ๋ ๊ฒ๋ณด๋ค, ์์คํ ์ด๋ผ๋ ์ด์ผ๊ธฐ๋ฅผ ํ์ด๊ฐ๋ ๊ฒ์ด ์ง์ ํ ๋ชฉํ์์ ์์ง๋ง๋ผ.
๊ทธ ๊ณผ์ ์์ ํจ์๋ฅผ ์ ์์ฑํ๋ ๊ฒ์ ์ด์ผ๊ธฐ๋ฅผ ํ๊ธฐ ์ํ ์ข์ ๋ฐฉ๋ฒ์ด๋ค. ๊ทธ ํ๋ฆ์์ ์ข์ ์๋จ์ผ๋ก ์๊ฐํ๋ ๊ฒ์ด ๋ชฉ์ ์ ์์ง ์๋๋ฐ ๋์์ด ๋ ๊ฒ์ด๋ค.