1. ๊ธฐ๋ณธํ์ ํ๊ณ
- ๊ธฐ๋ณธํ์ ๊ฐ์ฒด๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๋จ์ ์ ์ด๋ฆด ์ ์๋ค(๋ฉ์๋ ์ ๊ณต ๋ถ๊ฐ๋ฅ ๋ฑ...)
- null๊ฐ์ ๊ฐ์ง ์ ์๋ค.
1) ๊ธฐ๋ณธํ๊ณผ null
- ๊ธฐ๋ณธํ์ ํญ์ ๊ฐ์ ๊ฐ์ ธ์ผํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ๊ฐ ์์(null)์ ์ํ๋ฅผ ํ์ํ ์ ์๋ค.
- ๋ํผ ํด๋์ค๋ฅผ ์ฌ์ฉํด ํด๊ฒฐ๊ฐ๋ฅ(int๋์ ์๋์์ ๋ง๋ MyInteger ์ฌ์ฉ)
- null๊ฐ์ ์๋ชป ๋ฐํํ๋ฉด NullPointerException์ด ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ ์ฃผ์ํด์ ์ฌ์ฉํด์ผํ๋ค.
2. ๋ํผ ํด๋์ค
- ํน์ ๊ธฐ๋ณธํ์ ๊ฐ์ธ์ ๊ฐ์ฒด๋ก ๋ง๋๋ ํด๋์ค๋ฅผ ๋ํผ ํด๋์ค๋ผ๊ณ ํ๋ค.
//..์๋ต
private final int value;
//๋ํผ ํด๋์ค
public MyInteger(int value) {
this.value = value;
}
public int compareTo(int target) {
if (value < target) {
return -1;
}else {
return 0
}
}
- MyInteger๋ int value๋ผ๋ ๋จ์๊ฐ ๊ธฐ๋ณธํ ๋ณ์๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ ์ด ๊ธฐ๋ณธํ ๋ณ์๋ฅผ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ๋๋ก ๋ค์ํ ๋ฉ์๋๋ฅผ ์ ๊ณตํจ
- compareTo()๋งค์๋๋ ํด๋์ค ๋ด๋ถ๋ก ์บก์ํ
- MyInteger๋ฅผ ํตํด int๋ฅผ ๊ฐ์ฒด๋ก ๋ค๋ฃฐ ์ ์๊ฒ ๋จ
1) ์๋ฐ ๋ํผ ํด๋์ค
* ์๋ฐ๋ ๊ธฐ๋ณธํ์ ๋์ํ๋ ๋ํผ ํด๋์ค๋ฅผ ๊ธฐ๋ณธ์ผ๋ก ์ ๊ณตํ๋ค.
- byte → Byte
- short → Short
- int → Integer
- long → Long
- float →Float
- double → Double
- char → Character
- boolean → Boolean
- ๋ถ๋ณ์ด๋ฉฐ equals๋ก ๋น๊ตํด์ผํ๋ค.
2) ๋ํผ ํด๋์ค ์์ฑ - ๋ฐ์ฑ(Boxing)
- ๊ธฐ๋ณธํ์ ๋ํผ ํด๋์ค๋ก ๋ณ๊ฒฝํ๋ ๊ฒ
//Boxing
Integer integerObj = Integer.valueOf();
3) ์ธ๋ฐ์ฑ(Unboxing)
- ๋ํผ ํด๋์ค์ ๋ค์ด์๋ ๊ธฐ๋ณธํ ๊ฐ์ ๋ค์ ๊บผ๋ด๋ ๋ฉ์๋
//Unboxing
int value = integerObj.intValue();
4) ์คํ ๋ฐ์ฑ, ์คํ ์ธ๋ฐ
- ๊ฐ๋ฐ์ ํ๋ค๋ณด๋ฉด ๊ธฐ๋ณธํ์ ๋ํผ ํด๋์ค๋ก, ๋ํผํด๋์ค๋ฅผ ๊ธฐ๋ณธํ์ผ๋ก ๋ฐ๊ฟ์ผํ ์ผ์ด ์์ฃผ ๋ฐ์
- ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๊ธฐ๋ฅ์ด ์คํ ๋ฐ์ฑ, ์คํ ์ธ๋ฐ์ฑ
- ์๋๊ฐ ๋ช ํํ๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅ
Integer boxedValue = value; //์คํ ๋ฐ์ฑ
// ์ปดํ์ผ ๋จ๊ณ์์ Integer.getValueOf(value); ์ถ๊ฐ
int unboxedValue = boxedValue; //์คํ ์ธ๋ฐ์ฑ
// ์ปดํ์ผ ๋จ๊ณ์์ boxedValue.intValue(); ์ถ๊ฐ
3. ์ฃผ์ ๋ฉ์๋
Integer.valueOf(10); //์ซ์, ๋ํผ ๊ฐ์ฒด ๋ณํ
Integer.valueOf("10"); //๋ฌธ์์ด, ๋ํผ ๊ฐ์ฒด ๋ณํ
Integer.parseInt("10"); //๋ฌธ์์ด ์ ์ฉ, ๊ธฐ๋ณธํ ๋ณํ
value.compareTo(10); //value๊ฐ๊ณ ๋์ด์จ ๊ฐ ๋น๊ต
Integer.sum(10, 20); //๋ํ๊ธฐ , 30
Integer.max(10, 20); //์ต๋๊ฐ , 20
Integer.min(10, 20); //์ต์๊ฐ , 10
1) ๋ํผ ํด๋์ค์ ์ฑ๋ฅ
๋ํผ ํด๋์ค๋ง ์ฌ์ฉํ๋ฉด ๋์ง ๊ธฐ๋ณธํ์ ์์ง๋ ์ฌ์ฉํ๋ ์ด์ ? ์ฑ๋ฅ ์ฐจ์ด ๋๋ฌธ
- ๊ธฐ๋ณธํ์ ๋ฉ๋ชจ๋ฆฌ์์ ๊ทธ ํฌ๊ธฐ๋งํผ ๊ณต๊ฐ์ ์ฐจ์งํ์ง๋ง, ๋ํผ ํด๋์ค๋ ๊ธฐ๋ณธํ ๊ฐ + ๊ฐ์ฒด ๋ฐ์ดํฐ๋งํผ ๊ณต๊ฐ์ ์ฐจ์งํ๊ธฐ ๋๋ฌธ์ ์ฑ๋ฅ์ด ๋ ๋จ์ด์ง๋ค.
- ๊ทธ๋ฌ๋ ์ฐจ์ด๊ฐ ๊ฑฐ์ ์ฌํ์ง ์๊ธฐ ๋๋ฌธ์ ์ ์ง๋ณด์ํ๊ธฐ ๋ ๋์ ๊ฒ์ ์ ํํ๋ฉด ๋๋ค.
4. Class ํด๋์ค
- ํด๋์ค์ ์ ๋ณด๋ฅผ ๋ค๋ฃจ๋๋ฐ ์ฌ์ฉ๋๋ค.
- Class ํด๋์ค๋ฅผ ํตํด ๊ฐ๋ฐ์๋ ์ํ ์ค์ธ ์๋ฐ ๋ด์ ํ์ํ ํด๋์ค์ ์์ฑ๊ณผ ์ ๋ณด๋ฅผ ์กฐํ ๋ฐ ์กฐ์ํ ์ ์๋ค.
1) ์ฃผ์ ๊ธฐ๋ฅ
- ํ์ ์ ๋ณด ์ป๊ธฐ : ํด๋์ค์ ์ด๋ฆ, ์ํผํด๋์ค, ์ธํฐ ํ์ด์ค, ์ ๊ทผ ์ ํ์ ๋ฑ๊ณผ ๊ฐ์ ์ ๋ณด ์กฐํ ๊ฐ๋ฅ
- ๋ฆฌํ๋ ์ : ํด๋์ค์ ์ ์๋ ๋ฉ์๋, ํ๋, ์์ฑ์ ๋ฑ์ ์กฐํํ๊ณ , ์ธ์คํด์ค๋ฅผ ์์ฑ ๋ฐ ๋ฉ์๋ ํธ์ถ ๋ฑ์ ์์ ๊ฐ๋ฅ
- ๋์ ๋ก๋ฉ ์์ฑ : Class.forName() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ๋ฑ์ ์์ ๊ฐ๋ฅ
- ์ ๋ ธํ ์ด์ ์ฒ๋ฆฌ : ํด๋์ค์ ์ ์ฉ๋ ์ ๋ ธํ ์ด์ ์ ์กฐํํ๊ณ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ฅ์ ์ ๊ณต
5. System Class ํด๋์ค
- ํ์ค ์ ๋ ฅ, ์ถ๋ ฅ, ์ค๋ฅ ์คํธ๋ฆผ : System.in, System.out, System.err
- ์๊ฐ ์ธก์ : System.currentTimeMilis() ๋ฑ...
- ํ๊ฒฝ ๋ณ์ : System.getenv() ๋ฉ์๋๋ฅผ ํตํด OS์์ ์ค์ ํ ํ๊ฒฝ ๋ณ์์ ๊ฐ์ ์ป์ ์ ์๋ค.
- ์์คํ ์์ฑ : System.getProperties๋ฅผ ํตํด ์๋ฐ์์ ์ฌ์ฉํ๋ ์ค์ ๊ฐ์ ๋ณผ ์ ์๋ค.
- ์์คํ ์ข ๋ฃ : System.exit(int status) ๋ฉ์๋๋ฅผ ํตํด ํ๋ก๊ทธ๋จ์ ์ข ๋ฃํ๊ณ OS์ ํ๋ก๊ทธ๋จ ์ข ๋ฃ ์ํ ์ฝ๋๋ฅผ ์ ๋ฌ(์ฌ์ฉ ๊ถ์ฅ X)
- ๋ฐฐ์ด ๊ณ ์ ๋ณต์ฌ : System.arraycopy๋ ์์คํ ๋ ๋ฒจ์์ ์ต์ ํ๋ ๋ฉ๋ชจ๋ฆฌ ๋ณต์ฌ ์ฐ์ฐ์ ์ฌ์ฉํ๋ค.
6. Math, Random ํด๋์ค
1) Math ํด๋์ค
- Math๋ ์ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ฃผ๋ Class. ์๋ ๋ง์ผ๋ ์ค์ ์ฌ์ฉํ ๋ API ๋ฌธ์๋ฅผ ์ฐพ์๋ณด๊ธธ ๊ถ์ฅ
Math (Java Platform SE 8 )
Returns the value of the first argument raised to the power of the second argument. Special cases: If the second argument is positive or negative zero, then the result is 1.0. If the second argument is 1.0, then the result is the same as the first argument
docs.oracle.com
2) Random ํด๋์ค
random.nextInt(); // int ๋ฒ์ ๋ด์์ ์กฐํ
random.nextDouble(); //0.0d ~ 1.0d
random.nextBoolean(); //true or false ์กฐํ
random.nextInt(10); //0~9๊น์ง ์กฐํ
1) Seed
- ๋๋ค์ ๋ง๋ค ๋ ์๋๊ฐ ๊ฐ์ผ๋ฉด ์คํ๊ฒฐ๊ณผ๊ฐ ๋๊ฐ๋ค.
Random random = new Random(1); //seed๊ฐ 1
- ์ฐธ๊ณ : ๊น์ํ์ ์ค์ ์๋ฐ - ์ค๊ธ 1ํธ
๋๊ธ