Coding Style - Sizuha/devdog GitHub Wiki
๋ชฉ์
๋๊ตฌ๋ ์ฝ๊ฒ ์ฝ๋๋ฅผ ์ดํดํ๊ณ ๊ณ ์น ์ ์๋๋ก ํ๋, ์ผ๊ด๋ ์ฝ๋ ์์ฑ ๋ฐฉ๋ฒ์ ๋ํ ๊ฐ์ด๋.
๊ธฐ๋ณธ ์์น
- ๋ณด๊ธฐ ์ข๊ณ , ์ฝ๊ธฐ ํธํด์ผ ํ๋ค.
- ํ๋ฉด์์์ ๋ฟ๋ง ์๋๋ผ ์ธ์๋ ๋๋ ์๊ฐํ๋ค.
- ํผ๋์ด ์์ด์ผ ํ๋ค.
- ๋์ค์ ์ฝ๊ฒ ๊ณ ์น ์ ์์ด์ผ ํ๋ค.
- ์ค๋ณต๋ ์ ๋ณด๋ฅผ ๋ด์ง ์๋๋ค.
- ๊ฐ๋ฅํ ๋ค์์ ์ฌ๋๋ค์ด ์ฐ๋ ๋ฐฉ์์ ๋ฐ๋ฅธ๋ค.
๊ณตํต
self ํน์ this ๋ฅผ ๋ถ์ด๋ ๊ฒฝ์ฐ
์๊ธฐ ์์ ์ ์ธ์คํด์ค์ ๋ํ ๋ ํผ๋ฐ์ค ๋ณ์์ธ self ํน์ this ๊ฐ ์๋ต ๊ฐ๋ฅํ ์ํฉ์ด์ฌ๋, ํด๋น ์ธ์คํด์ค ๋ณ์๊ฐ ์ ์๋ ํด๋์ค ๋ด๋ถ์์ ์ฌ์ฉ ๋์ด์ง๋ ๊ฒฝ์ฐ์๋ ๋ช ์์ ์ผ๋ก ํ๊ธฐํ๋ค.
๋ค๋ฅธ ํด๋์ค ์์ญ(์๋ฅผ๋ค์ด, ์์์ ํตํด ์ ์๋ ํ์ ํด๋์ค)์์๋ ๋ถ์ด์ง ์๋๋ค.
๋ค์ฌ์ฐ๊ธฐ
- ๋ค์ฌ์ฐ๊ธฐ(Intent)๋ ํญ์ผ๋ก๋ง ํ๋ค. ์คํ์ด์ค ์ฌ์ฉ๊ธ์ง.
- ๋ง์ฝ ๊ตณ์ด ์คํ์ด์ค๋ฅผ ์จ์ผ ํ๋ค๋ฉด, ๋ค์ฌ์ฐ๊ธฐ๋ ์ ๋ถ ์คํ์ด์ค๋ก๋ง ํ๋ค. ์ฆ, ํญ๊ณผ ์์ด์ ์ฌ์ฉํ์ง ๋ง๊ฒ!
- ํญ ๋ฌธ์์ ๋ํ ์ฒ๋ฆฌ๊ฐ ์๋ํฐ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์๊ธฐ์ ์์ด์ฐ๋ฉด ๋ค๋ฅธ ํ๊ฒฝ์์ ๋ณผ๋ ์ ๋ ฌ์ด ํํธ๋ฌ์ง.
- ์ ์ด๋ธ๋ญ์ด ๋ฐ์ํ ๋, ์ฆ ์ ์ด ๋ฒ์๊ฐ ํ ๋จ๊ณ ๊น์ด ๋ค์ด๊ฐ๋ ๊ฒฝ์ฐ์ ๋ค์ฌ์ด๋ค.
if (...) {
// ์กฐ๊ฑด ์ฒ๋ฆฌ์ ์ํด ์ ์ด ๊น์ด๊ฐ ๋ฐ์.
}
void Func(...) {
// ํจ์์ ๋ํ ์ ์ด ๋ฒ์ ๋ฐ์.
}
struct XXX {
// ๊ตฌ์กฐ์ฒด ์ ์ธ์ ์ํ ์ ์ด ๋ฒ์ ๋ฐ์.
}
- ๋ช ๋ น๋ฌธ์ด ํ ๋ผ์ธ์์ ๋๋์ง ์๊ณ ๋ค์ ๋ผ์ธ๊น์ง ์ด์ด์ง ๋, ๊ทธ ๋ค์์ ๋ผ์ธ๋ถํฐ ๋ค์ฌ์ด๋ค.
someFunc(arg1,
arg2, // ๋ค์ฌ์ฐ๊ธฐ
arg3, // ๋ค์ฌ์ฐ๊ธฐ
argN); // ๋ค์ฌ์ฐ๊ธฐ
- ์ ์ฒ๋ฆฌ ๋ฌธ์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ค์ฌ์ฐ์ง ์๋๋ค.
- C๊ณ์ด ์ธ์ด์ ๊ฒฝ์ฐ #define ์ด๋ #if ๋ฑ์ ๊ฒฝ์ฐ.
๋ณ์ ์ ์ธ, ์ด๋ฆ ์ง๊ธฐ
- ํ๊ฐ๋ฆฌ์ ํ๊ธฐ ๊ธ์ง.
- int, float ๊ฐ์ ๋ปํ ํ์
(type)์ ์ ๋์ด๋ก ๋ถ์ด์ง ์๋๋ค.
- ์ด๋ฐ๊ฑด ์ ์ธ๋ฌธ๋ง ๋ด๋ ์๋ค. ๊ทธ๋ฆฌ๊ณ ์ปดํ์ผ ๋จ๊ณ์์๋ ํ์ ์ฒดํฌ๊ฐ ์ด๋ค์ง๊ณ , ์๋ํฐ์์๋ ์ฝ๊ฒ ํ์ธ์ด ๋๋ค.
- ํ์ ์ด ๋ณ๊ฒฝ๋ ๊ฒฝ์ฐ, ๋ณ์ ์ด๋ฆ๊น์ง ๊ณ ์ณ์ผ ๋๋ ์๊ณ ๋ ํ์ง ๋ง์.
- ์๋ํฐ์์ ์ํฌํธ ๋์ง ์์ ํ์ ์ ๋ณด๊ฐ ํ์ํ๊ฑฐ๋, ๊ฐ์ฒด๋ค๊ฐ์ ๊ณตํต๋ ํน์ฑ ๋ฑ์ ๊ฐ์กฐํ๊ณ ์ ํ ๋ ์ ๋นํ ์ ๋์ด๋ฅผ ๋ถ์ธ๋ค.
- int, float ๊ฐ์ ๋ปํ ํ์
(type)์ ์ ๋์ด๋ก ๋ถ์ด์ง ์๋๋ค.
- ์์(const)๋ ์ ๋ถ ๋๋ฌธ์๋ก ํ๋ค.
- ํจ์์ ์ธ์์ ์ง์ญ ๋ณ์๋ ์๋ฌธ์๋ก ์์ํ๋ค.
- ํ์ ์ด๋ฆ์ ๋๋ฌธ์๋ก ์์ํ๋ค.
์ฐ์ฐ์
- ๊ธฐ๋ณธ์ ์ผ๋ก ์ดํญ ์ฐ์ฐ์์ ์์ชฝ์๋ ๊ณต๋ฐฑ์ ํ์นธ ์ฉ ๋๋ค.
- ๋จ, ์ฐ์ ์์๋ฅผ ๊ฐ์กฐํ๊ณ ์ ํ ๋ ๋ถ์ฌ์ ์ธ ์๋ ์๋ค. ๋ค๋ง ๊ดํธ๋ฅผ ํ์คํ๊ฒ ํด์ฃผ๋๊ฒ ๋ ๋์์ง๋.
int a = (1 + 2*3) / 4;
C ๊ณ์ด ์ธ์ด
์ง์ญ ๋ณ์
- ์์ ๋ณ์(์ง์ญ ๋ณ์)๋ ์๋ฌธ์์ ๋ฐ์ค(_)๋ก๋ง ๋ช ๋ช ํ๋ค. (optional)
- index, iterator๋ก ํ์ฉ๋๋ ์ง์ญ ๋ณ์๋ i_ ๋ก ์์ํ๋ค.
- ๋ณ์ ์ ์ธ์ ์ต๋ํ ํด๋น ๋ณ์๊ฐ ์ฌ์ฉ๋๋ ์ง์ ๊น์ง ๋ฏธ๋ฃฌ๋ค. ์ฆ, ๋ณ์ ์ ์ธ์ ๊ณง ์ด ๋ณ์๊ฐ ์ฌ์ฉ๋ ๊ฑฐ๋ผ๋ ๊ฑธ ์์ํ๋ค.
์ ์ด๋ฌธ ๋ธ๋ญ
- ์ ์ด๋ฌธ ๋ธ๋ญ์ ์ ์ด๋ฌธ์ด ์ ์ธ๋ ํ์์ { ๋ฅผ ์ฐ๋ค.
- } ๋ ์ ์ด๋ฌธ ํค์๋๊ฐ ์์๋ ์ด์ ๋ง์ถฐ์ ๋ซ๋๋ค.
- ๋ธ๋ญ์ ์ฌ๋ { ๋ฌธ์๊ฐ ์๋ ํ์ ์ฒซ ๋ฌธ์๊ฐ ์์๋๋ ์ด๊ณผ, ๋ธ๋ญ์ ๋ซ์ ๋ ๋์ค๋ } ๋ฌธ์๊ฐ ์๋ ์ด์ ์ผ์น ์ํค๋๋ก ํ๋ค.
- ์ ์ด๋ฌธ์ ( ) ๋ ํจ์ ํธ์ถ๊ณผ ๊ตฌ๋ณํ๊ธฐ ์ํด ์ ์ด๋ฌธ ํค์๋์ ํ์นธ ๊ณต๋ฐฑ์ ๋๊ณ ์ด๋ค.
if/else
- if์ else๋ฌธ์ฅ์ด ํจ๊ป ๋์ฌ ๋๋, if์ ๋ค์์๋ ๊ธ์ ์กฐ๊ฑด์ else์๋ ๋ถ์ ์กฐ๊ฑด ๋์ ์ฒ๋ฆฌ๋ฅผ ๊ธฐ์ ํจ์ ์์น์ผ๋ก ํ๋ค.
- ์ด๋ if ~ else ํ์์ ๋ฌธ์ฅ์ ๋ดค์ ๋, ๊ฐ๋ฅํ ์ผ๊ด๋๊ฒ ํด์์ด ๋๋๋ก ํ๊ธฐ ์ํจ์ด๋ค.
if (condition) {
// when condition == true.
}
else {
// when condition == false.
}
// ๋ค์๊ณผ ๊ฐ์ด ํ์ง ์๋๋ค.
if (!condition) {
// when condition == false.
}
else {
// when condition == true.
}
- if ~ else if ~ else ํํ:
if (...) {
// . . .
}
else if (...) {
// . . .
}
else if (...) {
// . . .
}
else {
// . . .
}
- ๋ค์์ or , and ๋ก ์ฐ๊ฒฐ๋ ๊ธด ์กฐ๊ฑด์์ด ์๋ ๊ฒฝ์ฐ:
if (CONDITION1 ||
CONDITION2 ||
CONDITION3 ||
CONDITIONn)
{
// . . .
}
// ์์๋ก ํน์ ์กฐ๊ฑด์ ๋ง์๋๊ฑฐ๋ ํ ๋๋ ๋ค์๊ณผ ๊ฐ์ด ํธํ๊ฒ ์ฃผ์์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
if (CONDITION1 ||
CONDITION2 ||
// CONDITION3 ||
CONDITIONn)
{
// . . .
}
- C์ธ์ด์ ๊ฒฝ์ฐ: if๋ while๋ฑ์ ์กฐ๊ฑด์์์, ๋์
์ฐ์ฐ(=)๊ณผ ๋น๊ต ์ฐ์ฐ(==)์ ์คํ๋ก ์ธํ ์ค๋ฅ ๋ฐฉ์ง๋ฅผ ์ํด ๋ค์๊ณผ ๊ฐ์ด ํ๋ค.
- ์กฐ๊ฑด์์์ ๋์ ์ฐ์ฐ์๋ ์ฐ์ง ์๋๋ค. ==์ ์คํ๋ก ์ค์ธํ ์ ์์ผ๋ฏ๋ก.
- ๋ณ์์ ์์๋ฅผ ๋น๊ตํ ๊ฒฝ์ฐ, ์์๋ฅผ ๋จผ์ ์ด๋ค. ์คํ์ผ ๊ฒฝ์ฐ, ์ปดํ์ผ ๋จ๊ณ์์ ์ค๋ฅ๊ฐ ๋๋๋ก.
if (10 == a) { ... }
- C++์ ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ๊ฐ์ด bool ํ์
์ด ๋์ด์ผ ํ๋ฏ๋ก, C์์์ ๊ฐ์ ์คํ๋ก ์ธํ ์ค๋ฅ๋ ๋ฐฉ์ง๊ฐ ๋์ง๋ง, ํผ๋์ ๋ฐฉ์งํ๊ธฐ ์ํด ์กฐ๊ฑด์ ์์์ ๋์
์ฐ์ฐ์ ๊ฐ๋ฅํ ํ์ง ๋ง์.
- ์กฐ๊ฑด์์ ํ์ ์ bool ํ์ ์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ๋ค์๊ณผ ๊ฐ์ด true/false๋ฅผ ๋ช ์์ ์ผ๋ก ์จ์ค ํ์๋ ์๋ค.
// ๋ค์์ ์๋ฏธ์์ ์ค๋ณต
if (a == true) { ... }
// ์คํ๋ก ์ธํ ๋ฒ๊ทธ๋ ์ฐ๋ ค๋๋ค
if (a = true) { ... }
switch
switch (condition) {
case CASE_1:
break;
case CASE_2:
case CASE_3:
break;
case CASE_n:
break;
default:
break;
}
/* case ์์์ ๋ณ์ ์ ์ธ์ด ์๋ ๊ฒฝ์ฐ */
switch (condition) {
case CASE_x: {
int x = xxx;
// . . .
break;
}
}
wile, do ~ while
while {
// . . .
}
do {
// . . .
} while (...);
do ~ while์์ while์ } ๋ค์์ ์ด๋ค. ๋ค์ ํ์ผ๋ก ๋ด๋ ค์ ์ฐ๋ฉด ์ผ๋ฐ while๋ฌธ๊ณผ ํผ๋๋ ์ ์๊ธฐ ๋๋ฌธ์.
for
for (int i = 0; i < MAX, i++) {
// . . .
}
3ํญ ์ฐ์ฐ์
์กฐ๊ฑด์ ๋๋ผ ๋ณ์ ์ด๊ธฐํ ๋ด์ฉ์ด ๋ฌ๋ผ์ง ๋,
/* Java */
int some;
if (cond)
some = 1;
else
some = 0;
3ํญ ์ฐ์์๋ฅผ ์ด์ฉํด์ ๊ฐ๋จํ ํํํ๊ธฐ.
/* Java */
final int some = cond ? 1 : 0;
// ๋๋
final int some = cond
? 1
: 0;
๋๋ฒ์งธ ํํ ๋ฐฉ์์, ๋จ์ํ ์์๋ฅผ ํ ๋นํ๋๊ฒ ์๋๋ผ ๋ด์ฉ์ด ์ข ๋ ๋ณต์กํ ๊ฒฝ์ฐ์ ์ ์ฉํ๋ค.
ํนํ ์ค์ฒฉ๋ ์กฐ๊ฑด์ด ํ์ํ ๊ฒฝ์ฐ์,
/* Java */
final int some = cond > 0
? cond == 1
? getCase1()
: getCase2()
: cond < 0
? getCase3()
: getCase4();
ํจ์
ํจ์ ์ ์ธ
void Func(int argName, ...) {
// TODO ...
}
void Func(int arg_1,
int arg_2,
int arg_n)
{
// TODO ...
}
// ๊ฒฐ๊ณผ๊ฐ์ return๋ฌธ ์๋ ์ธ์์๋ค ์ ๋ฌ ํ ๊ฒฝ์ฐ, ๊ฒฐ๊ณผ๋ฅผ ์ ๋ฌ ๋ฐ๋ ์ธ์์ ์ ๋์ด 'out_' ์ ๋ถ์ธ๋ค.
// out_์ด ๋ถ์ ์ธ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ํจ์๋ด์์ ์ด๊ธฐํ๋ฅผ ๋ด๋นํ๋ค.
void FuncA(int* out_result) { ... }
void FuncB(int& out_result) { ... }
ํจ์ ํธ์ถ
- ์ ์ด๋ฌธ๊ณผ ๊ตฌ๋ถํ๊ธฐ ์ํด, ํจ์๋ช ์ ( )๋ฅผ ๊ณต๋ฐฑ์์ด ๋ถ์ฌ์ ์ด๋ค.
- ํจ์ ์ธ์๊ฐ ๊ธธ์ด์ง๋ ๊ฒฝ์ฐ:
Func(arg_1,
arg_2,
arg_n);
result = Func(arg_1,
arg_2,
arg_n);
- ๋ถ๋ฑํธ๊ฐ ํฌํจ๋ ์ฐ์ฐ(>, <, >=, <=)์ ํจ์ ์ธ์๋ฅผ ๋๊ธฐ๋ ๊ณณ์์๋ ๊ฐ๊ธ์ ์ฐ์ง ์๋๋ก ํ๋ค. C++์ ๊ฒฝ์ฐ ํ ํ๋ฆฟ ๋ฌธ๋ฒ(< >)๊ณผ ํผ๋์ด ์ฌ ์ ์๋ค.
C#
- ๋งค์๋์ ํ๋กํผํฐ๋ ๋๋ฌธ์๋ก ์์ํ๊ณ ๋ํ๋ฒ์ผ๋ก ๋ช ๋ช ํ๋ค.
- ๋งด๋ฒ๋ณ์๋ m_ ์ผ๋ก ์์ํ๊ณ ๋ํ๋ฒ์ผ๋ก ๋ช
๋ช
ํ๋ค.
- ๋จ public ๋งด๋ฒ๋ณ์๋ ํ๋กํผํฐ ์๋ช ๊ณผ ๋์ผํ ๊ท์น์ ์ ์ฉํ๋ค.
class Sample {
public string Name;
private int m_memberVar;
public int ExcuteSome(int someParam) {
int local_var = 1;
return local_var * memberVar + someParam;
}
public int Count {
get { return 0; }
}
}
Java
- ๋งด๋ฒ ๋ณ์๋ ์๋ฌธ์๋ก ์์ํ๊ณ ๋ํ๋ฒ์ผ๋ก ๋ช ๋ช ํ๋ค.
- ๋งค์๋๋ ์๋ฌธ์๋ก ์์ํ๊ณ ๋ํ๋ฒ์ผ๋ก ๋ช ๋ช ํ๋ค.
class Sample {
public string name;
private int memberVar;
public int excuteSome(int someParam) {
int local_var = 1;
return local_var * m_memberVar + someParam;
}
}
Kotlin
๋ช ๋ช ๊ท์น
- Type์ ๋๋ฌธ์๋ก ์์
- enum ๋ด๋ถ์ ํญ๋ชฉ๋ค์ ๋๋ฌธ์๋ก ์์. (์์ ์ทจ๊ธ)
- ์ปดํ์ผ ํ์ ์์(const)๋ ๋ชจ๋ ๋๋ฌธ์
- ์ด ์ธ๋ ๋ชจ๋ ์๋ฌธ์๋ก ์์
Android
Resource ID ๋ช ๋ช ๊ท์น
๊ธฐ๋ณธ์ ์ผ๋ก ์๋ฌธ์์ ๋ฐ์ค(_)๋ง์ผ๋ก ๋ช ๋ช ํ๋ ๊ฒ์ ์์น์ผ๋ก ํ๋ค.
View ID
prefix | ่ชฌๆ |
---|---|
action_ | Button ๋ฑ์ ํตํด ์ฌ์ฉ์์ ์ก์ ์ ๋ฐ์ํ๋ UI |
edit_ | ์ฌ์ฉ์๊ฐ ์ ๋ ฅ/ํธ์ง ํ ์ ์๋ UI |
select_ | ์ด๊ฑฐ๋ ํญ๋ชฉ ์ค์์ ์ ํ๋ง ๊ฐ๋ฅํ UI |
text_ | ๋ฌธ์์ด์ ํ์ํ๊ธฐ ์ํ UI |
img_ | ์ด๋ฏธ์ง๋ฅผ ํ์ํ๊ธฐ ์ํ UI |
view_ | ๊ธฐํ, ์ ๋ณด ํ์๋ฅผ ๋ชฉ์ ์ผ๋ก ํ๋ UI |
touch_ | ํฐ์น ์ด๋ฒคํธ๋ฅผ ๋ฐ๊ธฐ ์ํ UI. ์ค์ ํ๋ฉด์ ๋ณด์ด๋ ๋ด์ฉ๋ณด๋ค ๋ ๋์ ํฐ์น ์์ญ์ ์ง์ ํ๊ณ ์ ํ๋ ๊ฒฝ์ฐ ๋ฑ. |
list_ | ListView, RecyclerView ๊ฐ์ด Adapter๋ฅผ ์ด์ฉํด์ ๋ด๋ถ์ ๋ค์์ Item View๋ฅผ ํ์ํ๋ UI |
group_ | ๋ณต์์ View๋ฅผ ๊ทธ๋ฃนํํด์ ๊ด๋ฆฌํ๊ธฐ ์ํ ๋ชฉ์ ์ UI |
๋ด์ฉ์ ์ค๋ณต๋๋ UI๊ฐ ์๋ ๊ฒฝ์ฐ, ๋ช ๋ช ๊ท์น์ ์์์ ๋ถํฐ ์ฐ์ ์ ์ผ๋ก ์ ์ฉํ๋ค. ์๋ฅผ ๋ค๋ฉด, ํ ์คํธ๋ฅผ ํ์ํ๋ UI์ด์ง๋ง ๋ฒํผ์ฒ๋ผ ์ฐ์ด๋ ๊ฒฝ์ฐ๋ action_ ์ ๋ถ์ธ๋ค.
strings
prefix | ่ชฌๆ |
---|---|
err_ | ์๋ฌ ๋ฉ์ธ์ง |
fmt_ | Formatting์ ์ํ ๋ฌธ์์ด |
msg_ | ๋ฉ์ธ์ง ํ์๋ฅผ ์ํ ๋ฌธ์์ด |
๋ฆฌ์์ค ํ์ผ ๋ช ๋ช ๊ท์น
Layout
prefix | ่ชฌๆ |
---|---|
activity_ | Activity Layout |
fragment_ | Fragment Layout |
dailog_ | Dialog Layout |
adapter_ | Adapter์์ Item View๋ฅผ ๊ตฌ์ฑํ๋ Layout |
sub_ | ๋ค๋ฅธ Layout์์ include ํ๊ทธ ๋ฑ์ผ๋ก ๋ถ๋ ค์ง๋ Layout |
Swift
๋ช ๋ช ๋ฒ
UI Controls
- ์ ๋ ฅ ์ปจํธ๋กค: inputXxxx
- ํ์์ฉ ์ปจํธ๋กค(์ ๋ ฅ/๋ถ๋ฌ์จ ๋ด์ฉ์ ํ์ํ๋ ์ฉ๋): dispXxxx
- ๋ฒํผ: btnXxxx
- ๋ผ๋ฒจ: lblXxxx
- ์ด๋ฏธ์ง ํ์: imgXxxx
- UIBarButtonItem: bbiXxxx
Class
class HomeViewController: UIViewController {
// ...
}
// ํด๋์ค ์ ์ธ๋ถ๊ฐ ๊ธด ๊ฒฝ์ฐ
class HomeViewController
: UIViewController
, AVAudioRecorderDelegate
, CLLocationManagerDelegate {
@IBOutlet weak var txtDisplay: UILabel!
@IBOutlet weak var btnStart: UIButton!
@IBOutlet weak var btnStop: UIButton!
// . . .
}
function / method
์ธ์๊ฐ ๊ธด ๊ฒฝ์ฐ
func getTodayData(
date: SizYearMonthDay,
onResponse: @escaping (
_ resultCode: SimpleApiResultCode,
_ today: CheckInOut?,
_ today_vocation: Vocation?,
_ yesterday: CheckInOut?
) ->Void
) -> Bool {
//...
}
์ ์ด๋ฌธ
if ~ else
if cond {
// ...
}
else {
// ...
}
Switch
switch์ case/default๋ ๊ฐ์ ์ด์
switch xxx {
case A:
// ...
case B:
// ...
case C:
// ...
default: break // default๋ ๋ฐ๋์ ํฌํจ ์ํฌ ๊ฒ!
}
do ~ catch
do {
try some()
}
catch someException {
// ...
}