Read Code(Chap.04)

------------------------------------------------------------------------------------------
package chap04;
 
public class AbstractDefine {
    public static void main(String[] args) {
        InterfaceDefine i;
        AbstractClass a;
        NormalClass n;
        // i=new InterfaceDefine();//인터페이스는 객체를 생성할 수가 없음
        // a=new AbstractClass();//추상클래스는 객체를 생성할 수가 없음
        n = new NormalClass();
        a = new NormalClass();
        i = new NormalClass();
        n.print();
        n.print("테스트");
        n.print(300);
        a.print();
        a.print("테스트"); // a.print(300); int를 받는 것이 없어서 사용불가
        i.print();
        i.print("테스트");
        i.print(300);
    }
}
 
class NormalClass extends AbstractClass implements InterfaceDefine {
    // 클래스는 선언부()만 있으면 안되고 구현부{}를 무조건 만들어야 한다.
    // extends 를 통해서 AbstractClass와 NormalClass는 is a 관계가 성립되었다.
    // 추상클래스로부터 상속을 받을때 상속받은 것 중
    // abstract가 있는 메소드는 반드시 재정의 해주어야 한다.
    // implements를 통해서 InterfaceDefine을 상속받았다.
    // Interface를 상속받을 경우 반드시 구현부를 재정의해주어야 한다.
    int a;
 
    // public void print(String str){}
    public void print() {// 재정의를 할경우 반환형 데이터 타입도 똑같아야 한다.
        System.out.println("일반클래스");// print
    }
 
    public void print(int a) {
        System.out.println("일반클래스 print 구현(재정의)" + a);
    }
}
 
abstract class AbstractClass {
    // 추상클래스, class 내에 abstract가 하나라도 있으면
    // class에 abstract라고 표시해야 함.
    int a;
 
    abstract public void print();
 
    public void print(String str) {// 선언부와 구현부가 다있는 메소드
        System.out.println("추상클래스:" + str);
    }
}
 
interface InterfaceDefine {
    // 인터페이스, 구현부가 없어야 한다. 선언부만 존재함, 선언만 하는 것이 인터페이스
    // 그래서 인터페이스는 상속을 해줄 수 있지만 인터페이스에 있는 값은 반드시
    // 초기화해야하고 반대로 class를 상속받을 수는 없다.
    public static final int a = 10;
 
    public int b = 15;
 
    public void print();
 
    // 메소드 구현부가 없어야 함
    // public void print(String str){System.out.println("추상클래스:"+str);}
    public void print(String str);
 
    public void print(int a);
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class AnonymouseClassTest {
    public static void main(String[] args) {
        AnonymouseClassTest at = new AnonymouseClassTest(); // 생성자
        at.println();// 메소드 호출
    }
 
    public void println() {// 메소드
        System.out.println(toString());// 출력
        // 객체 만들기 시작
        new AnonymouseClassTest() {
            // 익명의 클래스를 생성했으므로 주소에 $로 연결되어 표시가 되어 있다.
            AnonymouseClassTest at1 = new AnonymouseClassTest();
            // 자기자신을 두번째 객체생성
            // OuterClass를 사용하여 객체를 생성하면 생성이 안된다.
 
            public void print() {// 메소드
                System.out.println(at1.toString());
                // 그래서 첫번째 자기자신과 다른 주소를 만들어냄
                System.out.println(toString());
                // InnerClass 주소 출력
            }
        }.print();// 메소드 호출
        new AnonymouseInnerClassTset() {
            // 익명의 클래스, 클래스 안에 new 키워드를 작성한 후
            // 생성자를 만들면 익명의 InnerClass가 되는 것이다.
            public void print() {
                System.out.println(toString());
            }
        }.print();
    }
}
 
class AnonymouseInnerClassTset {
 
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class AnonymouseInnerClass {
    int mem = 700;
 
    public static void main(String[] args) {
        AnonymouseClass a = new AnonymouseClass(100, "테스트");
        a.println();
        AnonymouseInnerClassDefine ai = new AnonymouseInnerClassDefine();
    }
 
    AnonymouseInnerClass(String str) {
        System.out.println("AnonymouseInnerClass 클래스 생성자: " + str);
    }
}
 
class AnonymouseInnerClassDefine {// 익명 클래스
    AnonymouseInnerClassDefine(String[] ar) {
        System.out.println(ar.length);
        System.out.println(ar[0]);
        System.out.println(ar[1]);
    }
 
    AnonymouseInnerClassDefine() {
        System.out.println("익명 클래스 생성자");
    }
}
 
class AnonymouseClass {// 클래스
    int a;
    String str;
 
    AnonymouseClass(int a, String str) {// 생성자
        this.a = a;
        this.str = str;
    }
 
    static {// static 블록 (클래스안에 있다.)
        System.out.println("클래스(정적) 블록");
    }
    {// 그냥 객체 블록 (클래스안에 있다.)
        System.out.println("객체 블록");
    }
 
    public void println() {// 메소드는 호출을 해야만 실행이 되고, 클래스는 적재가 된다.
        System.out.println("----------메소드 시작 ----------");
        // AnonymouseInnerClassDefine ai=
        new AnonymouseInnerClassDefine() {
            // 이것은 생성자인데 Anonymous 클래스라고도 불린다.
            // System.out.println("익명의 InnerClass"); 여기서 주석을 풀면 out에
            // 에러가 뜨는데 뜨는 이유는 out은 static으로 선언되었기 때문이다.
            // AnonymouseClass a=new AnonymouseClass();는OuterClass이기 때문에 만들
            // 수가없다.
            AnonymouseInnerClass b = new AnonymouseInnerClass(str);
 
            // 익명의 InnerClass는 밖에 있는 것을 사용할 수가 없다.
            public void print() {
                System.out.println("익명의 InnerClass Print");
                System.out.println("익명의 InnerClass mem: " + b.mem);
            }
        }.print();
        // static{System.out.println("클래스(정적)블록");}
        // static블록은 메소드 안에 작성할 수가 없다.
        {// 그냥 객체 블록 (메소드 안에 있다.)
            System.out.println("메소드 객체 블록");
        } // 블록은 {}; 세미콜론이 생략이 가능하지만 배열은 불가능하다.
        String str[] = { "익명의 InnerCLass1", "익명의 InnerClass2" };
        // 이렇게 작성을 하면 배열로 인식을 한다.
        new AnonymouseInnerClassDefine(str);// 객체생성
        System.out.println("----------메소드 종료 ----------");
        // System.out.println("익명의 InnerClass");
 
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class ArrayDefine {
    int a[], y;
    // 이렇게 작성을 할 경우 int 기본형 변수 배열 a를 선언하고,
    // int 기본형 변수 y를 선언한 것이다. 여기서 y는 배열이 아니다.
    int[] b, c;
    // int 기본형 변수 배열 b,c 선언, int옆에 []를 붙일 경우 뒤에 선언한 모든
    // 변수명은 다 배열 형태를 가진다. 객체든 배열이든 Default 값은 NULL이다.
    String str[];// String 참조형변수 배열 str 선언
    Integer[] d, e;// Integer 참조형변수 배열 d,e 선언
    Integer f;// Integer 참조형변수 f 선언
 
    public static void main(String[] args) {
        ArrayDefine ad = new ArrayDefine();// 객체 생성
        ad.a = new int[5];
    // 배열a 에 int 타입방을 5개 만듬, 배열이기 때문에 a에다가 5개 방의 주소를 넣는것이다.
        ad.y = 3;
        ad.b = new int[10];
    // 배열b 에 int 타입방을 10개 만듬, 배열이기 때문에 b에다가 10개 방의 주소를 넣는것이다.
        ad.c = new int[7];
    // 배열c 에 int 타입방을 7개 만듬, 배열이기 때문에 c에다가 7개 방의 주소를 넣는것이다.
        System.out.printf("%d, %d, %d%n", ad.a.length, ad.b.length, ad.c.length);
        ad.str = new String[3];
    // 객체 배열 str에 참조형변수 String 타입 방을 3개 만들고, 3개의 주소를 str에 넣어준다.
        ad.d = new Integer[3];// Wrapper 클래스에 속하는 메소드를 객체화한 것이다.
        ad.e = new Integer[5];
        ad.f = new Integer(ad.y);
// Integer이라는 객체에 매개변수 5라는 값을 넣어주는 것이다.
        System.out.printf("%d, %d, %d%n", ad.str.length, ad.d.length, ad.e.length);
        System.out.printf("%d, %d, %d%n", ad.f, ad.f.MAX_VALUE, ad.f.MIN_VALUE);
        System.out.printf("%d ~ %d%n", Byte.MAX_VALUE, Byte.MIN_VALUE);
        System.out.print(" " + (Math.pow(2, 31) - 1));
        System.out.println(ad.f.max(5, 10));
        System.out.println(ad.f.min(5, 10));
        System.out.println(ad.f.parseInt("123") + ad.f.parseInt("121"));
        // parseInt는 형변환을 하는 것이다.
        System.out.println(ad.f.valueOf("123").intValue() + 
                           ad.f.valueOf("125").intValue());
        // intValue를 써야 숫자로 만들어준다.
        System.out.println(ad.f.valueOf("123") + ad.f.valueOf("100"));
        System.out.println(ad.f.toString());
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class ArrayInitial {
    int a[], b[][];// int타입 배열 a 와 이차원배열 b를 선언
    int[] c, d[];// 이차원배열은 이렇게 작성할수도 있다.
    String str[], st[][];//
    Byte bt[], byt[][];
 
    public static void main(String[] args) {
        ArrayInitial ai = new ArrayInitial();// 객체생성
        ai.a = new int[3];// 방3개 만들기
        ai.a[0] = 5;
        ai.a[1] = 7;// 방에 값 넣기
        System.out.printf("%d, %d, %d%n", ai.a[0], ai.a[1], ai.a[2]);// 출력
        for (int i = 0; i < ai.a.length; i++) {// 반복문
            ai.a[i] = i + 5;// 배열에 값을 반복문으로 초기화
            System.out.println(ai.a[i]);
        }
        int b[] = { 5, 7, 9 };
        int c[] = new int[3];
        c[0] = 5;
        c[1] = 7;
        c[2] = 9;
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
        /* 기본형 2차원 배열 */
        ai.b = new int[3][];// 2차원 배열작성방법1
        ai.b[0] = new int[2];
        ai.b[0][0] = 1;
        ai.b[0][1] = 2;
        ai.b[1] = new int[2];
        ai.b[1][0] = 3;
        ai.b[1][1] = 4;
        ai.b[2] = new int[2];
        ai.b[2][0] = 5;
        ai.b[2][1] = 6;
 
        int[] d[] = new int[3][2];// 2차원 배열작성방법2
        d[0][0] = 1;
        d[0][1] = 2;
        d[1][0] = 3;
        d[1][1] = 4;
        d[2][0] = 5;
        d[2][1] = 6;
 
        int[] e[] = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
        // 2차원 배열작성방법3 배열의 모든 구성요소를 다 알고있을 때 사용
        int k[][];
        k = ai.b;
        ai.print(k);
        k = d;
        ai.print(k);
        k = e;
        ai.print(k);
 
        ai.str = new String[3];
        ai.str[0] = "홍길동";
        ai.str[1] = "이몽룡";
        ai.str[2] = "성춘향";
        System.out.printf("%s,%s,%s%n", ai.str[0], ai.str[1], ai.str[2]);
 
        ai.st = new String[3][];
        ai.st[0] = new String[2];
        ai.st[0][0] = "홍길동";
        ai.st[0][1] = "이몽룡";
        ai.st[1] = new String[1];
        ai.st[1][0] = "성춘향";
        ai.st[2] = new String[1];
        ai.st[2][0] = "강감찬";
        String[] s[] = { { "홍길동", "이몽룡" }, { "성춘향" }, { "강감찬" } };
        ai.print(ai.st);
        ai.print(s);
 
        ai.bt = new Byte[3];
        ai.bt[0] = 7;
        ai.bt[1] = 8;
        ai.bt[2] = 9;
        Byte[] z;
        z = ai.bt;
        ai.print(z);
        ai.bt[0] = new Byte(ai.bt[0]);
        ai.bt[0] = new Byte((byte) 10);
        ai.bt[1] = new Byte(ai.bt[1]);
        ai.bt[2] = new Byte(ai.bt[2]);
        ai.print(ai.bt);
        java.util.Vector v[] = new java.util.Vector[3];
        v[0] = new java.util.Vector();
        v[1] = new java.util.Vector();
        v[2] = new java.util.Vector();
        v[0].add("홍길동");
        v[0].add("성춘향");
        v[0].add("이몽룡");// Vector 안에는 객체만 들어갈 수 가 있다.
        System.out.println(v[0]);
        // ai.byt={{1,2},{3,4}}이렇게 작성을 하면 오류이다.
        ai.byt = new Byte[2][2];
        ai.byt[0] = new Byte[2];
        ai.byt[0][0] = 1;
        ai.byt[0][1] = 2;
        ai.byt[1] = new Byte[2];
        ai.byt[1][0] = 3;
        Byte[][] byt = { { 1, 2 }, { 3, 4 } };
        ai.print(ai.byt);
        ai.print(byt);
    }
 
    public void print(int[][] k) {
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.printf("%d,\t", k[i][j]);
            }
            System.out.println("\n-------------------");
        }
    }
 
    public void print(Byte[] k) {
        for (int i = 0; i < k.length; i++) {
            System.out.printf("%d,\t", k[i]);
        }
        System.out.println();
    }
 
    public void print(Byte[][] k) {
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.printf("%d,\t", k[i][j]);
            }
            System.out.println("\n-------------------");
        }
    }
 
    public void print(String[][] k) {
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.printf("%s,\t", k[i][j]);
            }
            System.out.println("\n-------------------");
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class EraseGarbage {
    public static void main(String[] args) {
        new GarbageObject();
        Runtime rt = Runtime.getRuntime();
        long current = rt.freeMemory();
        long before = current;
        do {
            current = rt.freeMemory();
            System.out.println("1: befor =" + before);
            System.out.println("1: current=" + current);
        } while (current <= before);
        new GarbageObject();
        current = rt.freeMemory();
        before = current;
        do {
            rt.gc();
            current = rt.freeMemory();
            System.out.println("2:before =" + before);
            System.out.println("2:current=" + current);
        } while (current <= before);
    }
}
 
class GarbageObject {
    protected void finalize() throws Throwable {
        super.finalize();
        String name = Thread.currentThread().getName();
        System.out.println("finalize() name =" + name);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;//패키지 lecture
 
public class InnerClass {// 클래스 InnerClass
    public static void main(String[] args) {// 메인 메소드
        NormalClassDefine ncd = new NormalClassDefine(50);
        OuterClassDefine ocd = new OuterClassDefine(100);
        // 숫자 100을 지우면 에러가 발생한다
        // 그 이유는 OuterClassDefine에 ()생성자가 없기 때문이다.
        // InnerClassDefine icd=new InnerClassDefine(200);
        // InnerClass는 이렇게 작성할수가 없다.
        // InnerClassDefine icd;
        // 이렇게 선언하면 오류가 난다 그 이유는 InnerClass이기 때문이다.
        OuterClassDefine.InnerClassDefine icd = ocd.new InnerClassDefine(200);
        // 위에 ocd를 선언했기 때문에 이렇게 작성할 수가 있다.
        OuterClassDefine.InnerClassDefine icd1 
        = new OuterClassDefine(100).new InnerClassDefine(200);
        // 위 두개의 작성방식은 같다.
        System.out.printf("ncd:%d, ocd:%d, icd:%d, icd1:%d%n",
                         ncd.a, ocd.a, icd.a, icd1.a);
        ncd.a = ocd.a = icd.a = 300;// 모든 값을 100으로 초기화
        System.out.printf("ncd:%d, ocd:%d, icd:%d, icd1:%d%n",
                         ncd.a, ocd.a, icd.a, icd1.a);
    }
}
 
class NormalClassDefine {// 클래스 NormalClassDefine
    int a;// 객체 맴버변수
 
    NormalClassDefine(int a) {
        this.a = a;
    }// 생성자 매=멤
}
 
class OuterClassDefine {// OuterClass 생성
    int a;// 객체 맴버변수
 
    class InnerClassDefine {// InnerClass 생성
        int a;// 객체 맴버변수
 
        InnerClassDefine(int a) {
            this.a = a;
        }// 생성자, 멤버변수 초기화
    }
 
    OuterClassDefine(int a) {
        this.a = a;
    }// 생성자, 멤버변수 초기화
}// OuterClass와 InnerClass는 상속관계가 아니다.
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class InstanceBlock {
    public static void main(String[] args) {
        InstanceBlockClass ib;
        ib = new InstanceBlockClass();
        System.out.printf("%d,%d%n", ib.a, ib.b);
        ib = new InstanceBlockClass(10, 15);
        System.out.printf("%d,%d%n", ib.a, ib.b);
        ib = new InstanceBlockClass(100);
        System.out.printf("%d,%d%n", ib.a, ib.b);
    }
}
 
class InstanceBlockClass {
    {
        a = 2;
        b = 1;
    }
    int a = -1, b = -3;
    {
        a = 5;
        b = 3;
    }
 
    public InstanceBlockClass() {
    }
 
    public InstanceBlockClass(int a) {
        this.a = a;
    }
 
    public InstanceBlockClass(int a, int b) {
        this.a = a;
        ;
        this.b = b;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class InterfaceObject {
    public static void main(String[] args) {
        InterfaceImplementClass iis;
        TestInterface ti;
        SuperInterface si;
        iis = new InterfaceImplementClass();
        iis.print();
        System.out.println(iis.print(true));
        iis.print(100);
        iis.print("테스트");
        ti = new InterfaceImplementClass();
        ti.print();
        System.out.println(iis.print(true));
        ti.print(100);
        ti.print("테스트");
        si = new InterfaceImplementClass();
        /* si.print(); */ System.out.println(iis.print(true));
        /* si.print(100); */ si.print("테스트");
    }
}
 
class InterfaceImplementClass implements TestInterface {
    public String print(boolean b) {
        if (b)
            return "참";
        else
            return "거짓";
    }
 
    public void print(String str) {
        System.out.println(str);
    }
 
    public void print(int a) {
        System.out.println(a);
    }
 
    public void print() {
        System.out.println("print 구현");
    }
}
 
interface TestInterface extends SuperInterface, SubInterface {
    public void print(int a);
}
 
interface SubInterface {
    public void print();
}
 
interface SuperInterface {
    public String print(boolean b);
 
    public abstract void print(String str);
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class Outer1 {
    private int out = 10;// 접근범위 private int 타입 변수명 out 값은 10
 
    public static void main(String[] args) {
        Outer1.Inner inner = new Outer1().new Inner();
        System.out.println("in = " + inner.in);
        Outer1 outer = new Outer1();
        outer.om();
    }
 
    public void om() {
        Inner inner = new Inner();
        inner.im();
    }
 
    public class Inner {
        Outer1 outer = Outer1.this;
        Inner inner = this;
        private int in = 5;
 
        void im() {
            System.out.println("out = " + out);
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
import javax.swing.*;
import java.awt.event.*;
 
public class OuterN extends JFrame {
    public static void main(String[] args) {
        JFrame frame = new OuterN();
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
                System.exit(0);
            }
        });
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class OverridingAccessModifier {
    public static void main(String[] args) {
        OverridingAccessModifierSubClass oams 
        = new OverridingAccessModifierSubClass();
        OverridingAccessModifierSuperClass oamsc 
        = new OverridingAccessModifierSuperClass();
        oams.print();
        oamsc.print();
        System.out.println(oams.equals(5));
        System.out.println(oams.equals("테스트"));
        System.out.println(oams.equals(new OverridingAccessModifierSubClass()));
 
    }
}
 
class OverridingAccessModifierSubClass extends OverridingAccessModifierSuperClass {
    // , OverridingAccessModifierSuperClass1
    // 상위 클래스는 오직 1개, 하위클래서에서 범위지정자는 상위클래스보다 크거나 같아야 한다.
    public void print() {
        System.out.println("하위클래스 print 메소드");
 
    }
}
 
//class Access Modifier(접근제한자)는 default(기본값), public만 사용가능
class OverridingAccessModifierSuperClass {
    // extends Object //명시적으로 사용시 기입하면 되나 생략 가능
    public void print() {
        System.out.println("상위클래스 print 메소드");
    }
 
    public int equals(String str) {
        System.out.println(super.toString());
        return 0;
    }
 
    public boolean equals(int a) {
        return false;
    }
 
    public boolean equals(Object obj) {
        // 최상위클래스인 Object를 재정의 한것이다.
        // overloading 규칙 범위지정자와 반환명 매개변수 데이터 타입이 같아야 한다.
        return super.equals(obj);
    }
}
 
class OverridingAccessModifierSuperClass1 {
 
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
import java.util.Date;
 
public class PackageImportTarget {
    String str; // 맴버변수1
    Date dat; // 맴버변수2
 
    public PackageImportTarget(String str) { // 생성자1
        this.str = str;
    }
 
    public PackageImportTarget(String str, Date dat) {// 생성자2
        this.str = str;
        this.dat = dat;
    }
 
    public String print() {
        if (str != null && dat != null)
            return str + dat.toString();
        else if (dat != null)
            return "" + dat.getYear();
        else if (str != null)
            return str;
        else
            return "null";
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
import java.sql.Date;
 
public class PackageScope {
    public static void main(String[] args) {
        Date dat = new Date(117, 5, 28);// 1900월 0월~11월
        System.out.println(dat);
        // System.out.println(dat.valueOf("yyyy-m-d"));
        PackageImportTarget pit;
        pit = new PackageImportTarget("테스트");
        System.out.println(pit.print());
        pit = new PackageImportTarget("테스트1", dat);
        System.out.println(pit.print());
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class PrivateConstructor {
    public static void main(String[] args) {
        PrivateConstructorClass pcc = PrivateConstructorClass.getInstance();
        PrivateConstructorClass pcc1 = PrivateConstructorClass.getInstance();
        System.out.println(pcc);
        System.out.println(pcc1);
        // 두개가 같은 주소를 참조한다.
 
    }
}
 
class PrivateConstructorClass {// PrivateContructorClass클래스
    private PrivateConstructorClass() {
        // 접근범위 private PrivateContructorClass생성자
        System.out.println("PrivateContructorClass 객체생성");
    }
 
    private static PrivateConstructorClass pcc;
 
    public static PrivateConstructorClass getInstance() {
        if (pcc == null)
            pcc = new PrivateConstructorClass();
        // 여러 내용을 같은 주소에 사용하기 위해 만든것
        return pcc;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class StaticinnerClass {
    public static void main(String[] args) {
        OuterClassStaticInner.StaticInnerClass os, os1;
        os = OuterClassStaticInner.StaticInnerClass.getInstance();
        os.print(new int[3]);// 배열 매개변수 a=3으로 입력하여 출력
        int a[] = new int[5];// int 타입 변수명 배열a에 방 5개 생성
        for (int i = 0; i < a.length; i++) {
            if (i == 0)
                a[i] = 1;
            else
                a[i] = ++a[i - 1];
            System.out.println(a[i]);
        }
        os1 = os.getInstance1(a);
        os1.print();
    }
}
 
class OuterClassStaticInner {
    static int a = 10;// 클래스멤버변수
 
    static void print() {// 클래스멤버메소드
        System.out.println(a);// 출력
    }
 
    static class StaticInnerClass {// Inner클래스
        int a[];// a[] 멤버변수 배열 선언
 
        public static StaticInnerClass getInstance() {// Inner클래스의 매소드
            return new StaticInnerClass();
        }
 
        public StaticInnerClass getInstance1(int a[]) {
            // 메소드 int타입 a[]을 매개변수로 사용함.
            this.a = a;// 멤버변수는 매개변수이다.
            return this;// StaticInnerClass를 반환한다.
        }
 
        public void print(int[] a) {
            for (int i = 0; i < a.length; i++)
                // 반복문 시작 a[]가 배열이기 때문에 배열을 생성한다.
                System.out.println(a[i]);
        }
 
        public void print() {// 메소드
            for (int i = 0; i < a.length; i++)
                System.out.println(a[i]);
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class SuperSub {
    public static void main(String[] args) {
        Super sup = new Sub();
        Sub sub = new Sub();
        sup.method();
        System.out.println("sup.var : " + sup.var);
        sub.method();
        System.out.println("sup.var : " + sub.var);
        System.out.println("getVar var :" + sub.getVar());
        System.out.println("getVar super.var :" + sub.getVarSuper());
        System.out.println(sup);
        System.out.println(sub);
    }
}
 
class Super {
    int var = 10;
 
    public void method() {
        System.out.println("Super : " + var);
    }
}
 
class Sub extends Super {
    int var = 20;
 
    public void method() {
        System.out.println("sub : " + var);
    }
 
    public int getVar() {
        return var;
    }
 
    public int getVarSuper() {
        return super.var;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class ThisSuper {
    public static void main(String[] args) {
        S_uper s_up1 = new S_ub(100);
        S_uper s_up2 = new S_ub();
        if (s_up2 == s_up2.getThis()) {
            System.out.println("'sup2 == getThis()' is equal");
        }
    }
}
 
abstract class S_uper {
    int var;
 
    S_uper() {
        System.out.println("S_uper()");
    }
 
    S_uper(int i) {
        this();
        System.out.println("S_uper(" + i + ")");
        var = i;
    }
 
    public void method() {
        System.out.println("S_uper.this : " + var);
    }
 
    public abstract S_ub getThis();
}
 
class S_ub extends S_uper {
    int var;
 
    S_ub() {
        System.out.println("S_ub()");
    }
 
    S_ub(int i) {
        super(i + 10);
        System.out.println("S_ub(" + i + ")");
        var = i;
        this.method();
    }
 
    public void method() {
        super.method();
        System.out.println("S_ub.this :" + this.var);
        System.out.println("S_ub.super :" + super.var);
    }
 
    public S_ub getThis() {
        System.out.println("S_ub.getThis()");
        return (this);
    }
}
 
------------------------------------------------------------------------------------------