๐Today...
โ Today I Leaned
Enum
Enum(์ด๊ฑฐํ)์ ์๋ก ์ฐ๊ด๋ ์์์ ์งํฉ์ด๋ค. ์์ = ๋ณํ์ง ์๋ ๊ฐ์ ์๋ฏธํ๊ณ , ์ด๊ฑฐํ์ ์ด๋ฌํ ์์๋ค์ ๊ฐํธํ๊ฒ ๋ค๋ฃฐ๋ ์ฌ์ฉํ๋ค.
enum Names { JELLY, KEVIN, YOUMIN } //์ด๋ฐ์์ผ๋ก ์ ์ธํ์ฌ ์ฌ์ฉ
public Class Main{...}
enum์ ์ฌ์ฉํ๋ฉด ์์๋ช ์ ์ค๋ณต์ ํผํ๊ณ ํ์ ์ ๋ํ ์์ ์ฑ์ ๋ณด์ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ switch๋ฌธ์์๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํด์ง๋ค.
๋ฆฌํดํ์ | ๋ฉ์๋(๋งค๊ฐ๋ณ์) | ์ค๋ช |
String | name() | ์ด๊ฑฐ ๊ฐ์ฒด๊ฐ ๊ฐ์ง๊ณ ์๋ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ฉฐ, ๋ฆฌํด๋๋ ๋ฌธ์์ด์ ์ด๊ฑฐํ์ ์ ์ ์ํ ๋ ์ฌ์ฉํ ์์ ์ด๋ฆ๊ณผ ๋์ผํฉ๋๋ค. |
int | ordinal() | ์ด๊ฑฐ ๊ฐ์ฒด์ ์๋ฒ(0๋ถํฐ ์์)์ ๋ฆฌํดํฉ๋๋ค. |
int | compareTo(๋น๊ต๊ฐ) | ์ฃผ์ด์ง ๋งค๊ฐ ๊ฐ๊ณผ ๋น๊ตํด์ ์๋ฒ ์ฐจ์ด๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
์ด๊ฑฐ ํ์ | valueOf(String name) | ์ฃผ์ด์ง ๋ฌธ์์ด์ ์ด๊ฑฐ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
์ด๊ฑฐ ๋ฐฐ์ด | values() | ๋ชจ๋ ์ด๊ฑฐ ๊ฐ์ฒด๋ค์ ๋ฐฐ์ด๋ก ๋ฆฌํดํฉ๋๋ค. |
์ ๋ค๋ฆญ(Generic)
#์ ๋ค๋ฆญ ํด๋์ค
generic์ ํ์ ์ ๊ตฌ์ฒด์ ์ผ๋ก ์ง์ ํ๋ ๊ฒ์ด ์๋๋ผ, ์ถํ์ ์ง์ ํ ์์๋๋ก ์ผ๋ฐํํด ๋๋๊ฒ์ ์๋ฏธํ๋ค. ์์ฑํ ํด๋์ค ๋๋ ๋ฉ์๋์ ์ฝ๋๊ฐ ํน์ ๋ฐ์ดํฐ ํ์ ์ ์ฝ๋งค์ด์ง ์๊ฒ ํด ๋ ๊ฒ์ด๋ค.
//์ ๋ค๋ฆญ ํด๋์ค ์ ์
class Basket<T> {
private T item1; // O
static T item2; // X ==> ํด๋์ค ๋ณ์์๋ ํ์
๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ ์์๋ค.
}
//์ ๋ค๋ฆญ ํด๋์ค ์ฌ์ฉ
Basket<String> basket1 = new Basket<String>("Hello");
Basket<String> basket1 = new Basket<>("Hello"); //new ๋ค์๋ ๊ตฌ์ฒด์ ์ธ ํ์
์๋ต๊ฐ๋ฅ
//์ ๋ค๋ฆญ ํด๋์ค ๋คํ์ฑ ์ ์ฉ
class Flower { ... }
class Rose extends Flower { ... }
class RosePasta { ... }
class Basket<T> {
private T item;
public void setItem(T item) {
this.item = item;
}
}
class Main {
public static void main(String[] args) {
Basket<Flower> flowerBasket = new Basket<>();
flowerBasket.setItem(new Rose()); // ๋คํ์ฑ ์ ์ฉ
flowerBasket.setItem(new RosePasta()); // ์๋ฌ
}
}
์ ๋ค๋ฆญ ํด๋์ค ์ฌ์ฉ์์ ๊ธฐ๋ณธํ์ ์ ์ง์ ํ ์์๋ค. ์ฆ int, double๋ฑ์ ์์ํ์ ์ ์ง์ ํ ๊ฒฝ์ฐ, Integer, Double ๊ฐ์ ๋ํผํด๋์ค๋ฅผ ์ฌ์ฉํด์ผํ๋ค.
[wrapperclass] http://www.tcpschool.com/java/java_api_wrapper
# ํน์ ํด๋์ค๋ฅผ ์์ ๋ฐ์ผ๋ฉด์ ๋์์ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค ํ์ ์ผ๋ก ์ ํ
class Basket<T extends Flower & Plant> { // &๋ฅผ ์ฌ์ฉํ๋ค.
private T item;
...
}
์ด๋ฌํ ๊ฒฝ์ฐ์๋ ํด๋์ค๋ฅผ ์ธํฐํ์ด์ค๋ณด๋ค ์์ ์์น์์ผ์ผํ๋ค.
# ์ ๋ค๋ฆญ ๋ฉ์๋
generic method๋ ํด๋์ค ๋ด๋ถ์ ํน์ ๋ฉ์๋๋ง ์ ๋ค๋ฆญ์ผ๋ก ์ ์ธํ ๊ฒ์ด๋ค,
class Basket<T> { // 1 : ์ฌ๊ธฐ์์ ์ ์ธํ ํ์
๋งค๊ฐ ๋ณ์ T์
...
static <T> void add(T element) { // 2 : ์ฌ๊ธฐ์์ ์ ์ธํ ํ์
๋งค๊ฐ ๋ณ์ T๋ ์๋ก ๋ค๋ฅด๋ค.
...
}
}
์ ์์ ์๊ฐ์ด <T>๋ก ํ์ ์ด ์ ์๋ Basket class์ add๋ฉ์๋๋ ์ํ๋ฒณ ๋ฌธ์๋ฅผ ๊ฐ์ด ์ฌ์ฉํ๋ ๊ฒ์ผ๋ฟ ์๋ก ๋ค๋ฅธ ํ์ ์ ๋งค๊ฐ๋ณ์์ด๋ค. ์ด์ ๋ ํ์ ์ด ์ง์ ๋๋ ์์ ์ด ๋ฌ๋ผ์์ธ๋ฐ, ํด๋์ค๋ช ์์ ์ ์ธํ ํ์ ๋งค๊ฐ๋ณ์๋ ํด๋์ค๊ฐ ์ธ์คํด์คํ ๋ ๋ ํ์ ์ด ์ง์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ ๋ค๋ฆญ ๋ฉ์๋์ ํ์ ์ง์ ์ ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ์ด๋ฃจ์ด ์ง๋ค.
๊ทธ๋ฆฌ๊ณ ์์์๋ ๋ณผ์์๋ฏ์ด ํด๋์ค ํ์ ๋งค๊ฐ๋ณ์์ ๋ฌ๋ฆฌ static๋ฉ์๋์์๋ ์ ์ธํ์ฌ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
class Basket {
public <T> void getPrint(T item) {
System.out.println(item.equals("Kim coding")); // ๊ฐ๋ฅ
}
}
๊ทธ๋ฆฌ๊ณ ์์ ๊ฐ์ด Objectํด๋์ค์ ๋ฉ์๋๋ฅผ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค. (๋ค๋ฅธ ํด๋์ค์ ๋ฉ์๋๋ ๋ถ๊ฐ๋ฅ)
์์ผ๋ ์นด๋
<? extends T> //์ํ์ ํ, T์ T๋ฅผ ์์๋ฐ๋ ํ์ํด๋์ค ํ์
๋ง ํ์
ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์์์๋ค.
<? super T> //ํํ์ ํ, T์ T์ ์์ ํด๋์ค๋ง ํ์
ํ๋ผ๋ฏธํฐ๋ก ๋ฐ๋๋กํ๋ค.
<?> // <? extends Object> ์ ๊ฐ๋ค, ์ฆ ๋ชจ๋ ํด๋์คํ์
์ ํ์
ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์์์๋ค.
์์ธ์ฒ๋ฆฌ
# ์์ธ ์ฒ๋ฆฌ์ ๊ณ์ธต๋
์๋ฐ์ ์๋ฌ์ ์์ธ๋ Throwable ํด๋์ค๋ก ๋ถํฐ ํ์ฅ๋๋ฉฐ, ๋ชจ๋ ์์ธ์ ์ต๊ณ ์์ ํด๋์ค๋ Exception ํด๋์ค์ด๋ค.
public class RuntimeExceptionTest {
public static void main(String[] args) {
try {
System.out.println("[์๋ฌธ์ ์ํ๋ฒณ์ ๋๋ฌธ์๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ]");
printMyName(null); // (1) ์์ธ ๋ฐ์
printMyName("abc"); // ์ด ์ฝ๋๋ ์คํ๋์ง ์๊ณ catch ๋ฌธ์ผ๋ก ์ด๋
}
catch (ArithmeticException e) {
System.out.println("ArithmeticException ๋ฐ์!"); // (2) ์ฒซ ๋ฒ์งธ catch๋ฌธ
}
catch (NullPointerException e) { // (3) ๋ ๋ฒ์งธ catch๋ฌธ
System.out.println("NullPointerException ๋ฐ์!");
System.out.println("e.getMessage: " + e.getMessage()); // (4) ์์ธ ์ ๋ณด๋ฅผ ์ป๋ ๋ฐฉ๋ฒ - 1
System.out.println("e.toString: " + e.toString()); // (4) ์์ธ ์ ๋ณด๋ฅผ ์ป๋ ๋ฐฉ๋ฒ - 2
e.printStackTrace(); // (4) ์์ธ ์ ๋ณด๋ฅผ ์ป๋ ๋ฐฉ๋ฒ - 3
}
finally {
System.out.println("[ํ๋ก๊ทธ๋จ ์ข
๋ฃ]"); // (5) finally๋ฌธ
}
}
static void printMyName(String str) {
String upperCaseAlphabet = str.toUpperCase();
System.out.println(upperCaseAlphabet);
}
}
// ์ถ๋ ฅ๊ฐ
[์๋ฌธ์ ์ํ๋ฒณ์ ๋๋ฌธ์๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ]
NullPointerException ๋ฐ์!
e.getMessage: null
e.toString: java.lang.NullPointerException
[ํ๋ก๊ทธ๋จ ์ข
๋ฃ]
java.lang.NullPointerException
at RuntimeExceptionTest.printMyName(RuntimeExceptionTest.java:20)
at RuntimeExceptionTest.main(RuntimeExceptionTest.java:7)
- try : ์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ์ฝ๋๋ฅผ ์ฝ์ . ์ ์์คํ => finally๋ธ๋ก ์์ธ๋ฐ์=>catch๋ธ๋ก
- catch : ์์ธ๊ฐ ๋ฐ์ํ ๋ ์คํ๋๋ ์ฝ๋, ์ฌ๋ฌ์ข ๋ฅ์ ์์ธ๋ฅผ ์ฒ๋ฆฌ๊ฐ๋ฅ, ํ๋ ์ด์ ์ฌ์ฉ๊ฐ๋ฅ
- finally : ์์ธ ์ฌ๋ถ์ ๊ด๊ณ์์ด ํญ์ ์คํ, ํ์ x
# ์์ธ ์ ๊ฐ
์์ธ๋ฅผ ํธ์ถํ ๊ณณ์ผ๋ก ๋ ๋๊ธฐ๋ ๋ฐฉ๋ฒ.
static void throwException() throws ClassNotFoundException, NullPointerException {
...
}