public class Test { // No throws clause here public static void main(String[] args) { doThrow(new SQLException()); } static void doThrow(Exception e) { Test.
doThrow0(e); } @SuppressWarnings("unchecked") static
void doThrow0(Exception e) throws E { throw (E) e; } }
class Test { Object x() { return "abc"; } String x() { return "123"; } }
์ค๋ฅธ์ชฝ. Java ์ธ์ด์์๋ throw ๋๋ ๋ฐํ ์ ํ์ ์ฐจ์ด์ ๊ด๊ณ์์ด ๋์ผํ ํด๋์ค ๋ด์์ ๋์์ ๋ ๋ฉ์๋๋ฅผ ๋๋ฑํ๊ฒ ์ฌ์ ์ํ๋ ๊ฒ์ ํ์ฉํ์ง ์์ต๋๋ค. ํ์ง๋ง ์ ๊น๋ง์. Class.getMethod(String, Classโฆ)์ ๋ํ ์ค๋ช
์๋ฅผ ๋ค์ ํ์ธํ์ธ์. ๋ค์๊ณผ ๊ฐ์ด ๋งํฉ๋๋ค.
ํด๋์ค์ ํด๋น ๋ฉ์๋๊ฐ ๋ ๊ฐ ์ด์ ์์ ์ ์์ต๋๋ค. Java ์ธ์ด๋ ์๋ช
์ ๋์ผํ์ง๋ง ๋ฐํ ์ ํ์ด ๋ค๋ฅธ ์ฌ๋ฌ ๋ฉ์๋๋ฅผ ๊ธ์งํ๋ ๋ฐ๋ฉด Java Virtual Machine์ ๊ทธ๋ ์ง ์๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ฐ์ ๋จธ์ ์ ์ด๋ฌํ ์ ์ฐ์ฑ์ ์ฌ์ฉํ์ฌ ๋ค์ํ ์ธ์ด ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๊ณต๋ณ ๋ฐํ์ ๋ธ๋ฆฌ์ง ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ํํ ์ ์์ต๋๋ค. ๋ธ๋ฆฌ์ง ๋ฉ์๋์ ์ฌ์ ์๋ ๋ฉ์๋๋ ๋์ผํ ์๊ทธ๋์ฒ๋ฅผ ๊ฐ์ง์ง๋ง ๋ฐํ ์ ํ์ ๋ค๋ฆ
๋๋ค. ์, ๋ง์ด ๋๋ค์. ๋ค์์ ์์ฑํ ๋ ์ค์ ๋ก ๋ง์ ์ผ์ด ์ผ์ด๋๊ณ ์์ต๋๋ค. ์์ฑ๋ ๋ฐ์ดํธ์ฝ๋๋ฅผ ๋ณด์ญ์์ค. ๋ฐ๋ผ์ t๋ ์ค์ ๋ก ๋ฐ์ดํธ์ฝ๋์ ๊ฐ์ฒด์
๋๋ค. ์ด๊ฒ์ ์ ์ดํด๋ฉ๋๋ค. ํธ์ถ์ ํน์ ๋ถ๋ถ์์ Parent.x()์ ๋ฐํ ์ ํ์ ์์ํ ์ ์๊ธฐ ๋๋ฌธ์ ํฉ์ฑ ๋ธ๋ฆฌ์ง ๋ฉ์๋๋ ์ค์ ๋ก ์ปดํ์ผ๋ฌ์ ์ํด ์์ฑ๋ฉ๋๋ค. ์ด๋ฌํ ๋ธ๋ฆฌ์ง ๋ฉ์๋ ์์ด ์ ๋ค๋ฆญ์ ์ถ๊ฐํ๋ ๊ฒ์ ๋ ์ด์ ์ด์ง ํํ์์ ๋ถ๊ฐ๋ฅํฉ๋๋ค. ๋ฐ๋ผ์ ์ด๋ฌํ ๊ธฐ๋ฅ์ ํ์ฉํ๋๋ก JVM์ ๋ณ๊ฒฝํ๋ฉด ๊ณ ํต์ด ์ค์ด๋ญ๋๋ค(๋ถ์์ฉ์ผ๋ก ๊ณต๋ณ ๋ฐฉ๋ฒ ์ฌ์ ์๋ ํ์ฉ๋ฉ๋๋ค...). ํ๋ช
ํฉ๋๊น?
3. ๋ค์์ ๋ชจ๋ 2์ฐจ์ ๋ฐฐ์ด์ด๋ค. ์ด๊ฒ์ ์ค์ ๋ก ์ฌ์ค์
๋๋ค. ๋ฉํ ๋ถ์๊ธฐ๊ฐ ์์์ ์ค๋ช
ํ ๋ฉ์๋์ ๋ฐํ ์ ํ์ ์ฆ์ ์ดํดํ์ง ๋ชปํ๋๋ผ๋ ๋ชจ๋ ๋์ผํฉ๋๋ค! ๋ค์ ์ฝ๋์ ๊ฐ์ต๋๋ค. ์ด๊ฒ ๋ฏธ์น ์ง์ด๋ผ๊ณ ์๊ฐํ์ธ์? ๊ธ์ ์ธ ์ ์๋ ๊ธฐํ์ ์๋ ๊ทธ์ผ๋ง๋ก ์์๋ ฅ์ ํญ๋ฐ์ํต๋๋ค!
์ฃผ์์ ์
๋ ฅํฉ๋๋ค.
๊ทธ ํ์ ์ด์ด ์ ๋น๋ก์์ด ๋ ๋ฒ์งธ์ธ ์ฅ์น์
๋๋ค. ์ฆ, 4์ฃผ๊ฐ์ ํด๊ฐ ์ง์ ์ ๋ง์ง๋ง ์ปค๋ฐ์ ํ ๋์
๋๋ค. ์ํ๋ ๋ฐฉ์์ผ๋ก ์ฌ์ฉํ๋๋ก ํ๊ฐํฉ๋๋ค.
4. ์กฐ๊ฑด๋ฌธ์ ์ป์ ์ ์์ต๋๋ค . ์กฐ๊ฑด๋ฌธ์ ์ฌ์ฉํ๊ธฐ ์์ํ์ ๋ ์ด๋ฏธ ์กฐ๊ฑด๋ฌธ์ ๋ํ ๋ชจ๋ ๊ฒ์ ์๊ณ ์๋ค๊ณ ์๊ฐํ์
จ๋์? ๋น์ ์ ์ค๋ง์ํค๊ฒ ์ต๋๋ค. ๋น์ ์ ํ๋ ธ์ต๋๋ค. ์ฌ๋ฌ๋ถ ๋๋ถ๋ถ์ ๋ค์ ๋ ๊ฐ์ง ์๊ฐ ๋์ผํ๋ค๊ณ ์๊ฐํ ๊ฒ์
๋๋ค. ์ด๊ฒ๊ณผ ๋์ผํฉ๋๊น? ์๋์. ๊ฐ๋จํ ํ
์คํธ๋ฅผ ์ฌ์ฉํด ๋ณด๊ฒ ์ต๋๋ค. ํ๋ก๊ทธ๋จ์ ๋ค์์ ์ถ๋ ฅํฉ๋๋ค. ์! ์กฐ๊ฑด ์ฐ์ฐ์๋ ํ์ํ ๊ฒฝ์ฐ ์ ํ ์บ์คํธ๋ฅผ ์ํํฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ํ๋ก๊ทธ๋จ์ด NullPointerException์ ๋์ง ๊ฒ์ด๋ผ๊ณ ์์ํ ์ ์๊ธฐ ๋๋ฌธ์
๋๊น?
5. ๋ณตํฉ ํ ๋น ์ฐ์ฐ์๋ ์ป์ ์ ์์ต๋๋ค. ์์์ด ์ถฉ๋ถํฉ๋๊น? ๋ค์ ๋ ๊ฐ์ง ์ฝ๋ ์กฐ๊ฐ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
abstract class Parent
{ abstract T x(); } class Child extends Parent
{ @Override String x() { return "abc"; } }
// Method descriptor #15 ()Ljava/lang/String; // Stack: 1, Locals: 1 java.lang.String x(); 0 ldc
[16] 2 areturn Line numbers: [pc: 0, line: 7] Local variable table: [pc: 0, pc: 3] local: this index: 0 type: Child // Method descriptor #18 ()Ljava/lang/Object; // Stack: 1, Locals: 1 bridge synthetic java.lang.Object x(); 0 aload_0 [this] 1 invokevirtual Child.x() : java.lang.String [19] 4 areturn Line numbers: [pc: 0, line: 1]
class Test { int[][] a() { return new int[0][]; } int[] b() [] { return new int[0][]; } int c() [][] { return new int[0][]; } }
class Test { int[][] a = {{}}; int[] b[] = {{}}; int c[][] = {{}}; }
@Target(ElementType.TYPE_USE) @interface Crazy {} class Test { @Crazy int[][] a1 = {{}}; int @Crazy [][] a2 = {{}}; int[] @Crazy [] a3 = {{}}; @Crazy int[] b1[] = {{}}; int @Crazy [] b2[] = {{}}; int[] b3 @Crazy [] = {{}}; @Crazy int c1[][] = {{}}; int c2 @Crazy [][] = {{}}; int c3[] @Crazy [] = {{}}; }
Object o1 = true ? new Integer(1) : new Double(2.0);
Object o2; if (true) o2 = new Integer(1); else o2 = new Double(2.0);
System.out.println(o1); System.out.println(o2);
1.0 1
Integer i = new Integer(1); if (i.equals(1)) i = null; Double d = new Double(2.0); Object o = true ? i : d; // NullPointerException! System.out.println(o);
i += j; i = i + j;
์ง๊ด์ ์ผ๋ก ๊ทธ๋ค์ ๋์ผํด์ผ ํฉ๋๊น? ๊ทธ๋ฌ๋ ๋น์ ์ ์๊ณ ์์ต๋๋ค - ๊ทธ๋ค์ ๋ค๋ฆ
๋๋ค. JLS ์ฌ์์ ๋ฐ๋ฅด๋ฉด
E1 op = E2 ์ ํ์ ๋ณตํฉ ํํ์์ E1 = (T) ((E1) op (E2))์ ๋์ผํฉ๋๋ค. ์ฌ๊ธฐ์ T๋ E1์ด ํ ๋ฒ๋ง ํ๊ฐ๋๋ค๋ ์ ์ ์ ์ธํ๋ฉด E1์ ์ ํ์
๋๋ค. ์ข์ ์๋ *= ๋๋ /= :
byte b = 10; b *= 5.7; System.out.println(b); // prints 57
๋๋:
byte b = 100; b /= 2.5; System.out.println(b); // prints 40
๋๋:
char ch = '0'; ch *= 1.1; System.out.println(ch); // prints '4'
๋๋: ์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค
char ch = 'A'; ch *= 1.5; System.out.println(ch); // prints 'a'
. ๊ทธ๋ ๋ค๋ฉด ์ด๊ฒ์ด ์ฌ์ ํ ์ ์ฉํ ๋๊ตฌ์
๋๊น?
6. ๋์ ์ ์ ์ด์ ๋ ์ด๋ ค์ด ์์
์ ์ํํฉ๋๋ค. ํด๊ฒฐ์ฑ
์ ์ฝ์ง ๋ง์ญ์์ค. ์ค์ค๋ก ๋ต์ ์ฐพ์ ์ ์๋์ง ํ์ธํด ๋ณด์ธ์. ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํํ๋ฉด
for (int i = 0; i < 10; i++) { System.out.println((Integer) i); }
๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ๋๊ฐ ์์ต๋๋ค.
92 221 45 48 236 183 39 193 33 84
๊ทธ๋ฐ๋ฐ ์ด๊ฒ์ด ์ด๋ป๊ฒ ๊ฐ๋ฅํ ๊น์? ์ข์ต๋๋ค. ๋๋ต์ ๋ฆฌํ๋ ์
์ ํตํด JDK์ ์ ์ ์บ์๋ฅผ ์ฌ์ ์ํ ๋ค์ ์๋ ๋ฐ์ฑ ๋ฐ ์๋ ์ธ๋ฐ์ฑ์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. ์ด๋ฅธ๋ค์ ํ๋ฝ ์์ด๋ ์ด๋ฐ ์ง์ ํ์ง ๋ง์ธ์! ์ฆ,
7. GOTO ์ ๊ฐ ๊ฐ์ฅ ์ข์ํ๋ ๊ฒ ์ค ํ๋์
๋๋ค. ์๋ฐ์๋ GOTO๊ฐ ์์ต๋๋ค! ์ด๋ ๊ฒ ์ฐ์ธ์:
int goto = 1;
๊ทธ๋ฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ต๋๋ค: ๋ง์ฝ์ ๋๋นํด goto๋ ์ฌ์ฉ๋์ง ์๋ ์์ฝ์ด์ด๊ธฐ ๋๋ฌธ์
๋๋ค... ํ์ง๋ง ๊ทธ๊ฒ์ ํฅ๋ฏธ๋ก์ด ๋ถ๋ถ์ด ์๋๋๋ค. ๋ฉ์ง ์ ์ break, continue ๋ฐ ํ์๋ ๋ธ๋ก๊ณผ ํจ๊ป goto๋ฅผ ํฌํจํ ์ ์๋ค๋ ๊ฒ์
๋๋ค. ์์ผ๋ก ์ ํ ๋ฐ์ดํธ ์ฝ๋์์ : ๋ค๋ก ์ ํ ๋ฐ์ดํธ ์ฝ๋์์:
8. Java์๋ ์ ํ ๋ณ์นญ์ด ์์ต๋๋ค . ๋ค๋ฅธ ์ธ์ด(์: Ceylon)์์๋ ์ ํ์ ์ ์ํ ์ ์์ต๋๋ค. ๋ณ์นญ์ ๋งค์ฐ ์ฝ์ต๋๋ค. ์ฌ๊ธฐ์ People ํด๋์ค๋ Set๊ณผ ์ํธ ๊ตํ๋ ์ ์๋ ๋ฐฉ์์ผ๋ก ๊ตฌ์ถ๋์์ต๋๋ค.
Test.java:44: error:
expected int goto = 1; ^
label: { // do stuff if (check) break label; // do more stuff }
2 iload_1 [check] 3 ifeq 6 // Jumping forward 6 ..
label: do { // do stuff if (check) continue label; // do more stuff break label; } while(true);
2 iload_1 [check] 3 ifeq 9 6 goto 2 // Jumping backward 9 ..
interface People => Set
;
People? p1 = null; Set
? p2 = p1; People? p3 = p2;
class Test {
void x(I i, L l) { System.out.println( i.intValue() + ", " + l.longValue() ); } }
new Test().x(1, 2L);
// A helper type. You could also just use List interface Type
{} class C implements Type
> {} class D
implements Type
๊ทธ๋ ๋ค๋ฉด C์ D๋ ๋ฌด์์ ์๋ฏธํ ๊น์? ์ด๋ค ์๋ฏธ์์๋ java.lang.Enum์ ์ฌ๊ท์ ์ ์ฌํ๊ฒ ์ฌ๊ท์ ์
๋๋ค. ๊ณ ๋ ค ์ฌํญ: ์์ ์ฌ์์ ๊ณ ๋ คํ๋ฉด enum์ ์ค์ ๊ตฌํ์ ๋จ์ง ๊ตฌ๋ฌธ์ ์คํ์ผ ๋ฟ์
๋๋ค. ์ด๋ฅผ ์ผ๋์ ๋๊ณ ๋ ๊ฐ์ง ์ ํ์ผ๋ก ๋์๊ฐ๊ฒ ์ต๋๋ค. ๋ค์ ์ฝ๋๊ฐ ์ปดํ์ผ๋ฉ๋๊น? ์ด๋ ค์ด ์ง๋ฌธ์ธ๋ฐ... ์ค์ ๋ก ํด๊ฒฐ๋์ง ์๊ณ ์๋์? C๋ Type์ ํ์ ์ ํ์ธ๊ฐ์ ? Eclipse๋ Idea์์ ์ด๊ฒ์ ์ปดํ์ผํด ๋ณด๋ฉด ๊ทธ๋ค์ด ์ด๋ป๊ฒ ์๊ฐํ๋์ง ๋งํด ์ค ๊ฒ์
๋๋ค. ํ์๊ตฌ๋ก ์ป์ด๋ด์ธ์... Java์ ์ผ๋ถ ์ ํ ๊ด๊ณ๋ ๊ฒฐ์ ํ ์ ์์ต๋๋ค! 10. ์ ํ ๊ต์ฐจ Java์๋ ์ ํ ๊ต์ฐจ๋ผ๋ ๋งค์ฐ ํฅ๋ฏธ๋ก์ด ๊ธฐ๋ฅ์ด ์์ต๋๋ค. ์ค์ ๋ก ๋ ์ ํ์ ๊ต์ฐจ์ ์ธ (์ผ๋ฐ) ์ ํ์ ์ ์ธํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค. Test ํด๋์ค์ ์ธ์คํด์ค์ ์ฐ๊ฒฐํ๋ ์ฌ์ฉ์ ์ ์ ์ ํ ๋งค๊ฐ ๋ณ์ T์๋ Serialized ๋ฐ Cloneable ์ธํฐํ์ด์ค๊ฐ ๋ชจ๋ ํฌํจ๋์ด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ฌธ์์ด์ ์ ํํ ์ ์์ง๋ง ๋ ์ง๋ ์ ํํ ์ ์์ต๋๋ค. ์ด ๊ธฐ๋ฅ์ ์ ํ์ ์บ์คํ
ํ ์ ์๋ Java8์์ ์ฌ๋ฌ ์ฉ๋๋ก ์ฌ์ฉ๋ฉ๋๋ค. ์ด๊ฒ์ด ์ด๋ป๊ฒ ๋์์ด ๋๋์? ๊ฑฐ์ ์๋ฌด๊ฒ๋ ์๋์ง๋ง ๋๋ค ์์ ํ์ํ ์ ํ์ผ๋ก ๋ณํํ๋ ค๋ฉด ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ๋ฉ์๋์ ์์ฒญ๋ ์ ํ์ด ์๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค. ๋ค๋ฅธ ๊ณณ์์ ์คํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋คํธ์ํฌ๋ฅผ ํตํด ์ ์กํ๋ ค๋ ๊ฒฝ์ฐ์๋ง ์ง๋ ฌํ ๊ฐ๋ฅํ Runnable์ ์ํฉ๋๋ค. ๋๋ค์ ์ง๋ ฌํ๋ ์ฝ๊ฐ์ ์์ด๋ฌ๋๋ฅผ ๋ํฉ๋๋ค. ๋์ ์ ํ๊ณผ ์ธ์๊ฐ ์ง๋ ฌํ ๊ฐ๋ฅํ ๊ฒฝ์ฐ ๋๋ค ์์ ์ง๋ ฌํํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ด๊ฒ์ด ์ฌ์ค์ด๋๋ผ๋ ์ง๋ ฌํ ๊ฐ๋ฅ ์ธํฐํ์ด์ค๋ฅผ ์๋์ผ๋ก ํ์ฑํํ์ง๋ ์์ต๋๋ค. ์ด ์ ํ์ ์ง์ ๊ฐ์ ธ์์ผ ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ง๋ ฌํ ๊ฐ๋ฅ์๋ง ์บ์คํ
ํ๋ฉด ๋๋ค๋ ๋ ์ด์ ์คํ ๊ฐ๋ฅํ์ง ์์ผ๋ฏ๋ก ๋ ์ ํ ๋ชจ๋์ ์บ์คํ
ํฉ๋๋ค. ๊ฒฐ๋ก ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ต๋๋ค. public abstract class Enum
// This enum MyEnum {} // Is really just sugar for this class MyEnum extends Enum
class Test { Type c = new C(); Type> d = new D
Step 0) C Step 1) Type
>> > Step 4) D
class Test
// Doesn't compile Test
execute((Serializable) (() -> {}));
execute((Runnable & Serializable) (() -> {}));
GO TO FULL VERSION