๐ JAVA

์์ธ์ฒ๋ฆฌ(Exception Handling) - (1)
์๋ฐ์์๋ ์คํ ์(runtime) ๋ฐ์ํ ์ ์๋ ํ๋ก๊ทธ๋จ ์ค๋ฅ๋ฅผ '์๋ฌ(Error)'์ '์์ธ(Exception)'๋ก ๊ตฌ๋ถํ๋ค. ์๋ฌ๋ ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ(OutOfMemoryError)์ด๋ ์คํ์ค๋ฒํ๋ก์ฐ(StackOverflowError)์ ๊ฐ์ด ์ผ๋จ ๋ฐ์ํ๋ฉด ๋ณต๊ตฌํ ์ ์๋ ์ฌ๊ฐํ ์ค๋ฅ์ด๊ณ , ์์ธ๋ ๋ฐ์ํ๋๋ผ๋ ์์ต๋ ์ ์๋ ๋น๊ต์ ๋ ์ฌ๊ฐํ ๊ฒ์ด๋ค. ์๋ฌ๋ ํ๋ก๊ทธ๋จ ์ฝ๋์ ์ํด์ ์์ต๋ ์ ์๊ณ ์์ธ๋ ์์ต๋ ์ ์์ผ๋ฏ๋ก, ์์ธ ์ฒ๋ฆฌ(Exception Handling)๋ฅผ ํตํด ํด๋น ์ํฉ์ ์ธ์ํ๊ณ ๋์ฒํ๋๋ก ํ๋ค. 1. ์์ธ ํด๋์ค์ ๋ถ๋ฅ ๐น ์์ธ ํด๋์ค์ ๊ณ์ธต ๊ตฌ์กฐ๋ ํฌ๊ฒ 3๊ฐ์ง๋ก ๋๋์ด ๋ณผ ์ ์๋ค. ์ผ์ชฝ์ ์๋ Error, ํ๋์์ผ๋ก ํ์๋ Checked Exception ๊ณ์ด, ์ฃผํฉ์์ผ๋ก ํ์..

equals๋ฅผ ์ฌ์ ์ํ๋ ค๊ฑฐ๋ hashCode๋ ์ฌ์ ์ํ๋ผ(2) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 11)]
์์์ ์ดํด๋ณธ ๊ฒ์ฒ๋ผ ์ข์ ํด์ ํจ์๋ผ๋ฉด ์๋ก ๋ค๋ฅธ ์ธ์คํด์ค์ ๋ค๋ฅธ ํด์ ์ฝ๋๋ฅผ ๋ฐํํ๋ค. ์ด์์ ์ธ ํด์ ํจ์๋ ์ฃผ์ด์ง (์๋ก ๋ค๋ฅธ) ์ธ์คํด์ค๋ค์ 32๋นํธ ์ ์ ๋ฒ์์ ๊ท ์ผํ๊ฒ ๋ถ๋ฐฐํด์ผ ํ๋ค. ์ด์์ ์๋ฒฝํ๊ฒ ์คํํ๊ธฐ๋ ์ด๋ ต์ง๋ง ๋น์ทํ๊ฒ ๋ง๋ค๊ธฐ๋ ๊ทธ๋ค์ง ์ด๋ ต์ง ์๋ค. ํด๋น ๊ธ์ ํตํด ํด์ ์ฝ๋๋ฅผ ๊ตฌํํ๋ 4๊ฐ์ง ๋ฐฉ๋ฒ๊ณผ ์ฃผ์ ์ฌํญ์ ์์๋ณด์. 1. ์ ํ์ ์ธ hashCode ๊ตฌํ ๐ฅ ํต์ฌ ํ๋ ์ค์ ํ๋๋ฅผ ๊ณจ๋ผ์ hashCode๋ฅผ ๊ตฌํ๋ค. ๊ธฐ๋ณธ ํ์ (primitive type) ํ๋๋ผ๋ฉด ํด๋น ํ์ ์ hashCode๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๊ตฌํ๋ฉด ๋๋ค. (Type.hashCode(f)) ์ฐธ์กฐ ํ์ (reference tyep) ํ๋๋ผ๋ฉด ํด๋น ํ์ ์ hashCode๋ฅผ ํธ์ถํด์ ๊ตฌํ๋ค. (Point๋ผ๋ ํ์ ์ ์ฌ์ฉํ..

equals๋ฅผ ์ฌ์ ์ํ๋ ค๊ฑฐ๋ hashCode๋ ์ฌ์ ์ํ๋ผ(1) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 11)]
equals๋ฅผ ์ฌ์ ์ํ ํด๋์ค ๋ชจ๋์์ hashCode๋ ์ฌ์ ์ํด์ผ ํ๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด hashCode ์ผ๋ฐ ๊ท์ฝ์ ์ด๊ธฐ๊ฒ ๋์ด ํด๋น ํด๋์ค์ ์ธ์คํด์ค๋ฅผ HashMap์ด๋ HashSet ๊ฐ์ ์ปฌ๋ ์ ์ ์์๋ก ์ฌ์ฉํ ๋ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ๊ฒ์ด๋ค. ๋ค์์ Object ๋ช ์ธ์์ ๋ฐ์ทํ hashCode์ ๋ํ ๊ท์ฝ์ด๋ค. equals ๋น๊ต์ ์ฌ์ฉ๋๋ ์ ๋ณด๊ฐ ๋ณ๊ฒฝ๋์ง ์์๋ค๋ฉด hashCode๋ ๋งค๋ฒ ๊ฐ์ ๊ฐ์ ๋ฆฌํดํด์ผ ํ๋ค. ์ ๋ณด๊ฐ ๋ณ๊ฒฝ๋๊ฑฐ๋, ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ค์ ์คํํ๋ค๋ฉด ๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค. ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๊ฐ๋ค๋ฉด, hashCode์ ๊ฐ๋ ๊ฐ์์ผ ํ๋ค. ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๋ค๋ฅด๋๋ผ๋, hashCode์ ๊ฐ์ ๊ฐ์ ์ ์๋ค. ํ์ง๋ง, ํด์ ํ ์ด๋ธ ์ฑ๋ฅ์ ๊ณ ๋ คํด ๋ค๋ฅธ ๊ฐ์ ๋ฆฌํดํ๋ ๊ฒ์ด ์ข..

equals๋ ์ผ๋ฐ ๊ท์ฝ์ ์ง์ผ ์ฌ์ ์ํ๋ผ(3) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 10)]
์ด๋ฒ ๊ธ์์๋ ์ง๊ธ๊น์ง์ ๋ด์ฉ์ ์ข ํฉํด์ ์์ง์ equals ๋ฉ์๋ ๊ตฌํ ๋ฐฉ๋ฒ๊ณผ ์ฃผ์ ์ฌํญ์ ๋ํด์ ์์๋ณด๊ณ ์ ํ๋ค. 1. equals ๊ตฌํ ๋ฐฉ๋ฒ == ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ์ ๋ ฅ์ด ์๊ธฐ ์์ ์ ์ฐธ์กฐ์ธ์ง ํ์ธํ๋ค. instanceof ์ฐ์ฐ์๋ก ์ ๋ ฅ์ด ์ฌ๋ฐ๋ฅธ ํ์ ์ธ์ง ํ์ธํ๋ค. ์ ๋ ฅ์ ์ฌ๋ฐ๋ฅธ ํ์ ์ผ๋ก ํ๋ณํํ๋ค. ์ ๋ ฅ ๊ฐ์ฒด์ ์๊ธฐ ์์ ์ ๋์๋๋ 'ํต์ฌ' ํ๋๋ค์ด ๋ชจ๋ ์ผ์นํ๋์ง ํ๋์ฉ ๊ฒ์ฌํ๋ค. float์ double์ ์ ์ธํ ๊ธฐ๋ณธ ํ์ ํ๋๋ == ์ฐ์ฐ์๋ก ๋น๊ตํ๊ณ , ์ฐธ์กฐ ํ์ ํ๋๋ ๊ฐ๊ฐ์ equals ๋ฉ์๋๋ก, float๊ณผ double ํ๋๋ ๊ฐ๊ฐ ์ ์ ๋ฉ์๋์ธ Float.compare(float, float)์ Double.compare(double, double)๋ก ๋น๊ตํ๋ค. (float์ doubl..

equals๋ ์ผ๋ฐ ๊ท์ฝ์ ์ง์ผ ์ฌ์ ์ํ๋ผ(2) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 10)]
์ด๋ฒ ๊ธ์์๋ equals ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ ๋ ๋ฐ๋์ ์ง์ผ์ผ ํ๋ ์ผ๋ฐ ๊ท์ฝ 5๊ฐ์ง๋ฅผ ์กฐ๊ธ ๋ ์์ธํ ์์๋ณด๊ณ ์ ํ๋ค. 1. ๋ฐ์ฌ์ฑ(reflexivity) A.equals(A) == true ๋ฐ์ฌ์ฑ์ ๋จ์ํ ๋งํ๋ฉด ๊ฐ์ฒด๋ ์๊ธฐ ์์ ๊ณผ ๊ฐ์์ผ ํ๋ค๋ ๋ป์ด๋ค. ์ด ์๊ฑด์ ์ผ๋ถ๋ฌ ์ด๊ธฐ๋ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด ๋ง์กฑ์ํค์ง ๋ชปํ๊ธฐ๊ฐ ๋ ์ด๋ ค์ ๋ณด์ธ๋ค. 2. ๋์นญ์ฑ(symmetry) A.equals(B) = B.equals(A) ๋์นญ์ฑ์ ๋ ๊ฐ์ฒด๋ ์๋ก์ ๋ํ ๋์น ์ฌ๋ถ์ ๋๊ฐ์ด ๋ตํด์ผ ํ๋ค๋ ๋ป์ด๋ค. ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ณํ์ง ์๋ ๋ฌธ์์ด์ ๊ตฌํํ ๋ค์ ํด๋์ค๊ฐ ์๋ค๊ณ ํ์. public final class CaseInsensitiveString { private final String s; public CaseInsens..

equals๋ ์ผ๋ฐ ๊ท์ฝ์ ์ง์ผ ์ฌ์ ์ํ๋ผ(1) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 10)]
๊ผญ ํ์ํ ๊ฒฝ์ฐ๊ฐ ์๋๋ฉด equals๋ฅผ ์ฌ์ ์ํ์ง ๋ง์. equlas ๋ฉ์๋๋ ์ฌ์ ์ํ๊ธฐ ์ฌ์ ๋ณด์ด์ง๋ง ๊ณณ๊ณณ์ ํจ์ ์ด ๋์ฌ๋ฆฌ๊ณ ์์ด์ ์์นซํ๋ฉด ๋์ฐํ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฒ ๊ธ์์๋ 'equals๋ฅผ ์ฌ์ ์ ํ์ง ์์๋ ๋๋ 4๊ฐ์ง ์ํฉ'๊ณผ '๋ง์ฝ equals ์ฌ์ ์๋ฅผ ํด์ผ ํ๋ค๋ฉด, ๋ง์กฑํด์ผ ํ๋ 5๊ฐ์ง ๊ท์ฝ'์ ๋ํด์ ์์๋ณผ ๊ฒ์ด๋ค. 1. ์ฌ์ ์ ํ์ง ์์๋ ๋๋ 4๊ฐ์ง ์ํฉ ๐ฉ 1. ๊ฐ ์ธ์คํด์ค๊ฐ ๋ณธ์ง์ ์ผ๋ก ๊ณ ์ ํ ๊ฒฝ์ฐ ๐ด ์ฑ๊ธํค, ENUM ๋ฑ ๊ฐ ์ธ์คํด์ค๊ฐ ๋ณธ์ง์ ์ผ๋ก ๊ณ ์ ํ ๊ฒฝ์ฐ equals๋ฅผ ์ฌ์ ์ ํ์ง ์์๋ ๋๋ค. 2. ์ธ์คํด์ค์ '๋ ผ๋ฆฌ์ ๋์น์ฑ(logical equality)'์ ๊ฒ์ฌํ ์ผ์ด ์๋ ๊ฒฝ์ฐ ๐ด ์ค๊ณ์๊ฐ ๋ ผ๋ฆฌ์ ๋์น์ฑ ๋ฐฉ์์ ์ํ์ง ์๊ฑฐ๋ ์ ์ด์ ํ์ํ์ง ์๋ค๊ณ ํ๋จํ๋ ๊ฒฝ..

try-finally ๋ณด๋ค๋ try-with-resources๋ฅผ ์ฌ์ฉํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 9)]
์ ํต์ ์ผ๋ก ์์์ด ์ ๋๋ก ๋ซํ์ ๋ณด์ฅํ๋ ์๋จ์ผ๋ก try-finally๊ฐ ์ฐ์๋ค. ํ์ง๋ง ์๋์ 2๊ฐ์ง ๋ฌธ์ ์ ์ผ๋ก ์ธํด try-with-resources์ ์ฌ์ฉ์ด ๊ถ์ฅ๋๋ค. ๋ณต์์ ์์์ ์ฒ๋ฆฌํ๊ฒ ๋๋ฉด ์ฝ๋๊ฐ ์ง์ ๋ถํด์ง๋ค. ์คํ ์ถ์ ๋ด์ญ์ ์ด์ ์ ์์ธ์ ๊ดํ ์ ๋ณด๋ ๋จ์ง ์๊ฒ ๋์ด, ์ค์ ์์คํ ์์์ ๋๋ฒ๊น ์ ๋ชน์ ์ด๋ ต๊ฒ ํ๋ค. try-with-resources์ ์ฅ์ ๋ค์ ํตํด ํด๋น ๊ธฐ๋ฅ์ ์์๋ณด์. ์ฅ์ 1. ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์๋ค. try-finally์ ๊ธฐ๋ณธ๊ตฌ์กฐ๋ ์๋์ ๊ฐ๋ค. static String firstLineOfFile(String path) throws IOException { BufferedReader br = new BufferedReader(new FileReader(p..

finalizer์ cleaner ์ฌ์ฉ์ ํผํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 8)]
์๋ฐ๋ finalizer์ cleaner๋ผ๋ ๋ ๊ฐ์ง ๊ฐ์ฒด ์๋ฉธ์๋ฅผ ์ ๊ณตํ๋ค. ํ์ง๋ง ์ฌ๋ฌ ๊ฐ์ง ๋ฌธ์ ์ ์ผ๋ก ์ธํด ์ฌ์ฉ์ด ์์ ๋๋ค. ํด๋น ๊ธ์์ ๋ฌธ์ ์ ๋ค๊ณผ ์ ์ ํ ์ฐ์์์ ๋ํด์ ์์๋ณด์. ๐ข๋ฌธ์ ์ 1. finalizer์ cleaner๋ ์ฆ์ ์ํ๋๋ค๋ ๋ณด์ฅ์ด ์๋ค. finalizer๋ cleaner๋ฅผ ์ผ๋ง๋ ์ ์ํ ์ํํ ์ง๋ ์ ์ ์ผ๋ก ๊ฐ๋น์ง ์ปฌ๋ ํฐ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌ๋ ธ์ผ๋ฉฐ, ์ด๋ ๊ฐ๋น์ง ์ปฌ๋ ํฐ ๊ตฌํ๋ง๋ค ์ฒ์ฐจ๋ง๋ณ์ด๋ค. finalizer๋ cleaner ์ํ ์์ ์ ์์กดํ๋ ํ๋ก๊ทธ๋จ์ ๋์ ๋ํ ๋ง์ฐฌ๊ฐ์ง๋ค. ๐ข๋ฌธ์ ์ 2. finalizer์ cleaner๋ ์คํ๋์ง ์์ ์๋ ์๋ค. ์ด๋ ์ ๊ทผํ ์ ์๋ ์ผ๋ถ ๊ฐ์ฒด์ ๋ธ๋ฆฐ ์ข ๋ฃ ์์ ์ ์ ํ ์ํํ์ง ๋ชปํ ์ฑ ํ๋ก๊ทธ๋จ์ด ์ค๋จ๋ ์๋ ์๋ค๋ ์๊ธฐ๋ค. ๋ฐ๋ผ์ ํ๋ก๊ทธ๋จ..

๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 7)]
์๋ฐ์์๋ ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ๋์์ค๋ค. ํ์ง๋ง ๊ฐ๋น์ง, ์ปฌ๋ ํฐ๊ฐ ์๋ค๊ณ ํด๋ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ํ์ง ์๋ ๊ฒ์ ์๋๋ค. ์ด๋ฒ ๊ธ์์๋ ๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ์ฌ ๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ๋ฐฉ์งํ ์ ์๋ 3๊ฐ์ง ์ํฉ์ ์์๋ณด๊ณ ์ ํ๋ค. 1. Stack์์์ ๋ฉ๋ชจ๋ฆฌ ๋์ & ํด๊ฒฐ์ฑ public class Stack{ private Object[] elements; private int size = 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; public Stack(){ elements = new Object[DEFAULT_INITIAL_CAPACITY]; } public void push(Object e){ ensureCapacity(); el..

๋ถํ์ํ ๊ฐ์ฒด ์์ฑ์ ํผํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 6)]
ํด๋น ์ฅ์์๋ ๋ถํ์ํ๊ฒ ๊ฐ์ฒด ์์ฑ์ ํ๋ 3๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๋งํด์ฃผ๊ณ ์๋ค. ํ๋์ฉ ์์๋ณด์. 1. ๋ฌธ์์ด public static void main(String[] args){ String hello1 = "hello"; String hello2 = new String("hello"); String hello3 = "hello"; System.out.println(hello1 == hello2); // false // ๋ค๋ฅธ ์ธ์คํด์ค System.out.println(hello1.equals(hello2)); // true // ๊ฐ์ ๋ฌธ์์ด System.out.println(hello1 == hello3); // true // ๊ฐ์ ์ธ์คํด์ค System.out.println(hello1.equals(hell..

์์์ ์ง์ ๋ช ์ํ์ง ๋ง๊ณ ์์กด ๊ฐ์ฒด ์ฃผ์ ์ ์ฌ์ฉํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 5)]
์์ดํ ์ ์ ๋ชฉ์ ํตํด '๋ชจ๋ ๊ฒฝ์ฐ์ ์์กด ๊ฐ์ฒด ์ฃผ์ ์ ์ฌ์ฉํด์ผ๊ฒ ๋ค'๋ผ๊ณ ์ดํดํ์ง ์๊ธฐ๋ฅผ ๋ฐ๋๋ค. ์ฌ์ฉํ๋ ์์์ ๋ฐ๋ผ ๋์์ด ๋ฌ๋ผ์ง๋ ํด๋์ค์ธ ๊ฒฝ์ฐ์ '์์กด ๊ฐ์ฒด ์ฃผ์ '์ ๊ณ ๋ คํด๋ณด๋๋ก ํ์. (์์ผ๋ก ๋์ฌ ์์์์๋ ํ์ธํ ์ ์๋ฏ์ด ์ฌ์ ์ ์ข ๋ฅ(Dictionary)์ ๋ฐ๋ผ SpellChecker๋ผ๋ ํด๋์ค์ ๋์์ด ๋ฌ๋ผ์ง๋ ๊ฒฝ์ฐ์ ์์กด ๊ฐ์ฒด ์ฃผ์ ์ ์ฌ์ฉํ๋ ๊ฒ์ ์ ์ ์๋ค.) public class SpellChecker{ private static final Dictionary dictionary = new Dictionary(); // ์ด๊ฒ์ด ์ ๋ชฉ์์ ๋์จ ์์์ ์ง์ ๋ช ์ํ๋ ์์์ด๋ค. private SpellChecker(){} public static boolean isValid(String..

์ธ์คํด์คํ๋ฅผ ๋ง์ผ๋ ค๊ฑฐ๋ private ์์ฑ์๋ฅผ ์ฌ์ฉํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 4)]
์ ์ ๋ฉ์๋๋ง ๋ด์ ์ ํธ๋ฆฌํฐ ํด๋์ค๋ ์ธ์คํด์ค๋ก ๋ง๋ค์ด ์ฐ๋ ค๊ณ ์ค๊ณํ ํด๋์ค๊ฐ ์๋๋ค. ํ์ง๋ง ์์ฑ์๋ฅผ ๋ช ์ํ์ง ์์ผ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก ๊ธฐ๋ณธ ์์ฑ์๋ฅผ ๋ง๋ค์ด์ค๋ค. ์ฆ, ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐ์ง ์๋ public ์์ฑ์๊ฐ ๋ง๋ค์ด์ง๋ฉฐ, ์ฌ์ฉ์๋ ์ด ์์ฑ์๊ฐ ์๋ ์์ฑ๋ ๊ฒ์ธ์ง ๊ตฌ๋ถํ ์ ์๋ค. ๊ทธ๋์ ์ด๋ฒ ์์ดํ ์ ํตํด ์ธ์คํด์ค ์์ฑ์ ๋ฐฉ์งํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด๊ณ ์ ํ๋ค. public abstract class UtilityClass{ // ์๋๋ ๊ธฐ๋ณธ์์ฑ์๊ฐ ์์ง๋ง, ์ถ๋ ฅ์ ํตํด ๋์ผ๋ก ํ์ธํ๊ธฐ ์ํด ์๋์ ๊ฐ์ด ์์ฑํ์๋ค. public UtilityClass(){ System.out.println("Contructor"): } } public class DefaultUtilityClass extends Utili..