깨어 있는 세상

< Java Beginning >

1. 자바의 역사
    (1) 1991년 : sun사 Green Project에서
                    James Gosling외 기술자들이
                    Oak라는 언어로 제작(가전기기에서
                    사용할 목적)
    (2) 1997년 : jdk 1.1 발표
    (3) 1998년 : jdk 1.2 발표
    (4) 2000년 : jdk 1.3 발표
    (5) 2002년 : jdk 1.4 발표
    (6) 2004년 : jdk 1.5(5.0) 발표
    (7) 2007년 : jdk 6 발표

2. 자바의 특징
    (1) 플랫폼(OS)에 독립적 : 자바가상머신(Java
        Virtual Machine)이 해당 플랫폼마다 따로
        제공되어서, 동일한 실행결과를 보장한다.
    (2) 객체 지향 언어 : 재사용성, 프로그램의
        생산성이 향상
    (3) 멀티 쓰레드를 지원 : Thread는 Process 보다
        작은 단위, 동시 다발적인 작업을 수행할 수 있다.
    (4) 자동 메모리 관리 :
        가비지 컬렉터(JVM에 포함되어 있는 소프트웨어)
        에 의해서 자동관리된다.

3. 용어정리
    (1) 객체(Object) : 모든것이다. Class 를 통해서
                            만들어지는 구현물 (아반떼)
    (2) 클래스(Class) : 객체(Object)를 만들어 내는 틀
                            (설계도, blueprint)
    (3) 속성(Field) : 객체의 속성, 성질, 클래스에 정의
                        되어 있다.
    (4) 메소드(Method) : 객체가 할 수 있는 기능(행위)
    (5) 생성자(Constructor) : 객체가 만들어질때(초기화)
                        호출되는 것
        - 클래스 이름과 동일한 단어 (대문자로 시작한다)
        - 메소드와 비슷한 형태
        - 반환타입이 없다.
        - 하위클래스의 객체가 생성되기 위해서는 먼저
            내부적으로 상위클래스의 생성자가 호출되어서
            부모 객체가 먼저 생성되어야 한다.
            (부모 없는 자식은 없다)
        - 생성자가 하나도 없는 경우 컴파일러가
            기본 생성자를 만들어준다.

4. OOP(Object Oriented Programming)의 특징
    (1) 상속성(inheritance) - Human, Superman, Xman
    (2) 다형성(polymorphism)
    (3) 은닉성(Information Hiding)
    (4) 캡슐화(Encapsulation)

5. 자바의 구조
    (1) package 선언
    (2) import 구문
    (3) class 선언
    {
        (4) 속성(Field)이자 멤버변수(Member Variable)
            선언 및 초기화
        (5) 생성자(초기화)
        (6) 메소드 선언
        public static void main(String[] args)
        {
            실행시 제일 먼저 JVM이 호출하는 메소드
        }
        public void otherMethod(int a)
        {
            this.a = a;
        }
    }

6. 자바의 주석
    (1) // 한줄짜리 주석
    (2) /*
            라인1
            라인2
        */
    (3) /**
            javadoc (API문서를 제작할때 쓰인다)
        */

7. 자바의 변수
    (1) 변수 type에 따라
        <1> 기본형 (primitive type) 변수(8개)
            - 존재 이유 : 실행의 효율성 때문이다.
            - 형변환 방향(오른쪽으로)
byte(1) -> short(2) -> int(4) -> long(8) -> float(4) -> double(8)
                    |
                char(2)
boolean
        <2> 참조형 (Reference type, 객체형) 변수
            - 형변환 방향(위로)
                Object
                    |
                Human
                    |
                Superman
    (2) 유효범위에 따라
        <1> 멤버변수 (member variable = Field)
            - 굳이 초기화를 하지 않아도 된다.
            ex) int i; (선언만 해도 된다)
        <2> 메소드 지역변수(local variable)
            - 반드시 초기화를 해야한다.
            ex) int i = 0;

8. 제한자
    (1) 정의
        클래스, 인터페이스, 변수, 상수, 메소드, 생성자
        앞에 붙어서 기능을 제한하는 keyword
    (2) 종류
        <1> 접근제한자
            public(제한이 없음) > protected(상속관계)
            > default(같은 패키지 안) > private(클래스)
        <2> 소유제한자
            static
            : static 붙으면 class 의 소유
              안 붙으면 객체의 소유
        <3> 수정제한자
            final
            : 붙으면 수정할 수 없게 만드는 제한자
            1) field : 상수가 된다
            2) method : 재정의(overriding) 안됨
            3) class : 상속 안됨
        <4> 추상제한자
            abstract
            1) class : 추상클래스
            2) method : 추상메소드({}가 없는 것)
            - 추상메소드가 1개라도 있으면 추상클래스가
               되어야 한다.
        <5> 기타
            synchronized, transient, volatile, native...

9. 오버로딩과 오버라이딩
    (1) 오버로딩 (overloading)
        <1> 정의
            메소드의 이름은 같은데, 인수의 개수나 type,
            순서가 다른 형태의 메소드로써 이름만 같지
            별개의 메소드인 것을 말한다.
        <2> 조건
            인수(parameter)의 개수나 type, 순서가
            달라야한다.
        <3> 종류
            - 생성자 오버로딩
            - 메소드 오버로딩
    (2) 오버라이딩(overriding)
        <1> 정의
            상속관계가 있는 클래스에서 부모 클래스의
            메소드 내용을 자식클래스에서 재정의하는 것
        <2> 조건
            - 반환타입이 같아야 한다.
            - 인수(parameter)의 개수나 type, 순서가
                모두 같아야 한다.
            - 부모클래스의 오버라이딩될 메소드의
                접근제한자보다 자식클래스에서 재정의하는
                메소드의 접근제한자의 범위가
                같거나 더 커야한다.

10. this, super
    (1) this -  자기 자신(class)의 객체
    (2) super - 부모클래스의 객체

11. 식별자(identifier)
    (1) 정의
        개발자가 임의로 만드는 패키지, 클래스, 메소드,
        변수명 등을 의미
    (2) 규칙 (어기면 컴파일 에러 발생)
        <1> 식별자의 첫문자는 특수문자, 숫자여서는
            안된다. (_, $는 예외)
        <2> 문자와 숫자, 특수문자(_, $)로
            조합할 수 있다.
        <3> 예약어를 사용하면 안된다.
        <4> 길이의 제한은 없다.
    (3) 관례
        <1> 의미있는 단어를 사용한다.
        <2> 클래스와 인터페이스의 첫문자는 대문자
        <3> 단어의 결합으로 되어있을 경우 다음 단어의
            첫번째 글자를 대문자로 하거나 _로 연결한다
            ex) TestClass, getName, set_name
        <4> $문자는 사용하지 않는다.

12. 연산자
    (1) 산술연산자
        +, -, *, /, %
    (2) 증감연산자
        ++, --
    (3) 대입연산자
        =
    (4) 산술 할당(대입) 연산자
        +=, -=, *=, /=, %= ...
    (5) 비트연산자
        &, |, ^, ~(not은 무조건 반대로 0->1 1->0)
    (6) 쉬프트 연산자
        <<, >>, >>>(부호보장X)
    (7) 논리 연산자
        &&, ||, &, |, !
    (8) 삼항(조건) 연산자
        조건식 ? 참일때 : 거짓일때
    (9) instanceof 연산자
        - 형식 :
            Reference Type 변수 instanceof Class 명
        - 앞의 변수가 뒤의 클래스와 상속관계인지를
            알아보는 연산자
13. 조건문(Condition)
    (1) if(boolean 형) {}문
        (body내용에 명령이 한문장이면 {} 생략가능 )
    (2) if(boolean) {} else {} 문
    (3) if(boolean) {} else if {} else {} 문
    (4) switch(값) { case : ... default : } 문

14. 반복문
    (1) for(초기식; 조건식; 증감식) {}
    (2) while(boolean) {}
    (3) do {} while(boolean);

15. 제어의 이동
    (1) break : 블럭({})을 나간다.
    (2) continue : continue 문 이후의 명령을
                실행하지 않고 건너뛴다.
    (3) return : 메소드를 호출한 곳으로 제어권을
                    넘긴다.
   
16. interface(인터페이스)
    (1) 정의 : 명세서이다(골격이다)
                모든 메소드가 추상메소드, 모든 field가
                상수로 구성된 것.
                클래스에 다중 상속이 가능하다.
    (2) 특징
        <1> 인터페이스끼리 다중 상속이 가능하다.
            ex) Inter1 extends Inter2, Inter3
        <2> 클래스에서 인터페이스를 다중상속 가능하다
            ex) InterClass implements Inter1, Inter2
        <3> 형태
            - field에는 public static final 생략 가능
            - method에는 public abstract 생략 가능
        <4> 인터페이스를 구현(상속)하는 클래스에서는
            반드시 메소드를 재정의(overriding)해야 한다.

17. abstract class (추상 클래스)
    (1) 정의
        추상 메소드를 가질 수 있는 클래스
    (2) 특징
        <1> 추상 클래스는 객체를 생성할 수 없다
            (완벽한 설계도가 아니다)
        <2> 하위 클래스가 추상클래스가 아니면
            반드시 추상메소드를 구현(재정의)해야만 한다.
    (3) 추상메소드 : 메소드의 body({})가 없는,
        선언만 되어있는 메소드

18. 배열 (Array)
    (1) 정의 : 같은 타입(type)의 객체 또는 기본형
                자료를 저장하는 저장소로써, 생성될때
                그 크기가 고정되는 저장소
    (2) 생성
        <1> Type[] 변수명 = new Type[저장소크기];
            ex) int[] i = new int[30]
                 int []i = new int[30]
                 int i[] = new int[30]
        <2> Type[] 변수명 = {value, value, value};
            ex) String[] str = {"1", "2", "3"}
                 int[] i = {1, 2, 3}

19. 예외처리
    (1) 예외(Exception)의 정의
        프로그램이 정상적으로 진행되지 못하게 하는
        돌발 상황
    (2) 계층도
        Object
            |
        Throwable
        |            |
    Error        Exception
                |            |
CheckedException    RuntimeException
    (3) 예외처리의 목적
        프로그램 진행시에 발생할 수 있는 상황들을
        정해놓고, 해당 상황 발생시 적절한 조치를
        취해서 프로그램이 정상적으로 작동하도록
        하는 것이다
    (4) 예외처리의 특징
        <1> Exception 은 메소드, 생성자에서 발생한다.
        <2> 발생시킬때에는(던질때에는) throw 라는
            예약어를 사용한다.
            ex) throw new MKException();
        <3> 메소드를 호출한 곳으로 throws 라는
            예약어를 사용해서 Exception 객체를
            넘긴다(또 던진다)
    ex) void main() throws IOException, Exception
        <4> 잡는 방법
            try {
                예외가 던져지는 구문
            } catch(예외클래스 변수명) {
                예외처리 구문
            }
        <5> catch 절(clause)에서 두개 이상의
            Exception 을 잡을 경우 반드시 하위 Exception
            부터 잡아야한다.
            ex) try {
                 }catch(IOException ie) {
                 }catch(Exception e) {}
        <6> finally 절
            try 절과 함께 쓰이며, catch 절의 실행유무와
            상관없이 무조건 실행된다.
            (return 문이 나와도 실행한다.)
        <7> 자동으로 throws 되고, 잡지 않아도 되는 예외
            RuntimeException, Error
            - throws 안해도 되고, 해도 된다.
            - try catch 안해도 되고, 해도 된다.

20. 중첩클래스(Nested class)
    (1) 정의 : 클래스 안에 있는 클래스
    (2) 종류 (static 제한자 유무에 따라)
        <1> static nested class
            ex) Outer.InnerStatic in
                    = new Outer.InnerStatic()
        <2> inner class
            ex)Outer out = new Outer();
                Outer.Inner in
                    = out.new Inner();
        <3> anonymous inner class
            이름이 없는 클래스, 기존의
            클래스(인터페이스)를 클래스 내부에서
            상속받아서 새롭게 정의하는 클래스

21. 주요 클래스
    (1) Object (가장 상위 root class)
        - equals(), hashCode(), toString()
    (2) String (불변 클래스 immutable)
        <1> 한번 생성된 객체의 내용을 연산이나
            메소드의 사용에 의해 변화시킬 수 없다
        <2> 문자열 비교시 반드시 equals 메소드를
            써야한다.
    (3) StringBuffer (가변 클래스 mutable)
        한번 생성된 객체의 내용이 연산이나 메소드를
        통해서 변화한다.
    (4) Math
        상수와 static 메소드만으로 구성

22. Collections Framework
    (1) hierachy (계층 구조도)
        Collection                        Map
        |    |    |                          |
      Set  List  Queue                SortedMap
        |
    SortedSet

    (2) interface
        <1> Collection : 컬렉션 계층구조의 root
        <2> Set : 중복된 요소(element)를 허용하지
                    않는다. ex) 트럼프 카드
        <3> List : 순서가 있는 컬렉션(sequence
                    라고도 한다) 중복허용, 인덱스로
                    각 요소에 접근 가능
        <4> Queue : 우선순위를 가지는 여러개의
                    요소를 가지고 있는 컬렉션
                    FIFO (First In First Out)
        <5> Map : key와 value로 이루어진 것, 중복된
                    key 불가능
       
        // 순서가 있는 계열
        <6> SortedSet : ascending(오름차순)의
                        순서로 요소를 가진다.
        <7> SortedMap : key값을 오름차순으로
                        가진다.
            ex) 사전, 전화번호부
       
        // ETC
        <8> Enumeration : 각각의 요소를 나열된
                        형태로 가지고 있다.
        <9> Iterator : remove가 가능하다.
   
    (3) implementations (구현체들 class)
        <1> Set
            1) HashSet : TreeSet 보다 빠르다
            2) TreeSet : SortedSet 에서 구현, 정렬
        <2> List
            1) ArrayList : LinkedList 보다 빠르다
            2) LinkedList : List 의 부분적으로 요소를
                    추가하거나 삭제하거나 하는 일이
                    많을때 빠르다.
        <3> Map
            1) HashMap : 빠르다.
                            null 키와 null value값을 허용
            2) TreeMap : SortedMap 에서 구현 정렬된다.
            3) LinkedHashMap : 집어넣는 순서로 정렬,
                            거의 HashMap 만큼 빠르다.

        <4> synchronized (동기화) 계열
            1) Vector (List 계열)
            2) Hashtable (Map 계열)
                : null 키, null value 허용 안함.
   
    (4) Collections : 각종 Collection 관련 유틸 클래스

23. Thread
    (1) Process : 컴퓨터 내에서 실행중인 프로그램
    (2) Thread 란?
        한 프로그램내에서 동시에 두가지 일을 수행하는
        것으로 프로세스보다 작은 업무단위이며,
        프로세스의 resource(자원)를 공유하기 때문에
        가볍다는 장점이 있다.
    (3) 생성
        <1> java.lang.Thread 를 상속받는 방법
        <2> java.lang.Runnable 을 구현하는 방법(권장)

        - 실행 : start() 호출하면 JVM이 자동으로
            run() 메소드 실행
    (4) 소멸
        run() 메소드의 실행이 끝나면 terminated된다
    (5) 멀티 쓰레드 (Multi Thread)
        여러개의 쓰레드를 동시에 수행하는 것
    (6) 쓰레드 Life Cycle : ppt 참조
    (7) 동기화 (synchronized)
        synchronized 로 되어있는 곳은 실행중인
        쓰레드가 lock(monitor)를 소유하고 실행이
        끝난 뒤 unlock (monitor를 반환)해 주는 것
        한마디로 한번에 하나의 쓰레드만 실행된다
    (8) 우선순위 (priority) :
        MIN(1), MAX(10), NORM(5)
    (9) wait(), notify(), notifyAll() : wait 폴더 참조

//////////////////// 5.0 변경사항 /////////////////
24. Generics
    (1) 특성
        <1> Type 안정성을 갖춘 컬렉션을
            만들 수 있다.
        <2> 컴파일 시점에 Type에 대한 검증을 한다
    (2) 선언방법
        <1> E : 컬렉션에 저장하고 컬렉션에서
                    리턴할 원소의 타입
            E : element, K : key, V : value, O : Object
            T : Type
        <2> class 나 interface 선언
            ex) public class ArrayList<E> extends
                                    AbstractList<E> {
                    public boolean add(E element)
                    public E get(int index)
                 }
        <3> 메소드 선언(호출)시
            1) 선언 : void list(ArrayList<E> list)
            2) 호출 : x.list(list);
        <4> 인스턴스 생성시
            ex) ArrayList<E> list = new ArrayList<E>();
    (3) Generics의 유형매개변수(Type parameter)
        <1> 사용방법
            1) 일반적인 선언
        public void setHuman(ArrayList<Human> list)
        public <T extends Human> void
                                setHuman(ArrayList<T> list)
            2) wildcard를 사용
                public void setHuman(ArrayList<?> list)
                public void setHuman
                    (ArrayList<? extends Human> list)
        <2> 특징
            1) interface 도 extends로 표현한다.
            2) 일반적으로 wildcard를 쓰는 방법을
                선호하지 않습니다.
                (인자값이 늘어날수록 쓰기 힘들어진다)
        public <T extends Human> void
                        setHuman(ArrayList<T> list,
                        ArrayList<T> list2)
        public void setHuman(
                    ArrayList <? extends Human> list,
                    ArrayList <? extends Human> list2)

25. 확장 for 문 (Enhanced for loop)
    (1) 형식
        for(데이터형 변수명 : 배열이나 컬렉션 객체)
    (2) 특징
        Generics 와 같이 쓰여서 효율적인 Collection
        계열의 루핑이 가능하다.
        ex) ArrayList<Integer> list =
                                new ArrayList<Integer>();
            for(Integer i : list)

26. Autoboxing / Unboxing
    (1) 정의
        <1> Autoboxing : primitive type 변수를
                            Wrapper class 로 자동 변환
        <2> Unboxing : 반대의 경우
    (2) 특징
        오토박싱은 -128~127의 범위에 있는 정수값의
        경우에만 같은 오브젝트로의 리턴을 보장한다.

27. Typesafe enums (타입에 안전한 enum)
    (1) 기존의 열거형 타입은 상수 값만 같으면, 사실상
        열거형 타입의 구분이 없어진다.
        ex)
        interface Num {
            public static final int ZERO = 0;
        }

        interface Language {
            public static final int JAVA = 0;
        }
    (2) if나 switch 를 사용해서 분기작업을 할 수 있다.
    (3) == 나 equals() 모두 쓸 수 있다.
    (4) 열거 타입 그 자체가 타입이다.

28. Varargs (가변인수)
    (1) 여러개의 인수(parameter)를 배열이 아닌
        "..." 으로 처리할 수 있다.
        ex) void getString(String ... names)
    (2) 메소드(생성자) 오버로딩시는 사용하지
        않는 것이 좋다.
        ex) Human(Integer ... i)
            Human(int i, int j)
        new Human(3, 4)
            = new Human(new Integer(3),
                                new Integer(4))

29. static import
    (1) static class, static variable, enum 등의
        값을 사용할때 타이핑을 더 적게 해보자는 의도
        ex) import static java.lang.Math.*;
            import static java.lang.System.out;

30. Annotation (metadata)
    (1) @("at") 표시와 어노테이션 이름으로 표현한다
    (2) BuiltIn(내장) annotation
        <1> Override Annotation
            오버라이드가 되지 않으면 컴파일러에서
            문제를 표시한다.
        <2> Deprecated Annotation
        <3> SuppressWarning Annotation
            컴파일러가 warning(예를 들어서 generics
            를 안쓰면 발생)을 나지 않게 해준다.

31. StringBuilder
    (1) StringBuffer의 unsynchronized version이다
    (2) 멀티쓰레드 환경에서 안전하지 않지만 StringBuffer
        에 비해서 속도면에서 월등하다
    (3) StringBuffer 와 동일한 메소드를 제공한다.

간단하게 코드를 소개합니다.



흔히 쓰이는 HttpURLConnection ...
나만 자주 쓰낭;

무튼 이렇게해서 결과값을 읽어들이고 값에 따른 메시지를 출력하거나, 로그를 남기도록 처리했다.
흠 회사내에서 만든 코드를 퍼온거라 일부 내용들은 죄 삭제했다.

원래 쓰던거에선 좀더 안쪽에 복잡한 파서들이 즐비했는데..
태그를 써서 xml 로 데이터가 오지 않는한 그런건 필요없을듯 하다.

변수
더보기
자바에서 OOP 라는 개념을 정확히 하고 나면 자바에 과연 변수 type이  필요가 있을까?
라는 의문을 한번 가져봐야겠다.

Integer, Double, Float ...  등등
C 언어에서 사용하는 int , double, float 등과 같은 데이터 타입은 자바에서 위와 같이 클래스로 구현이 되어져 있다.
그렇다면 자바에 int, double, float 등과 같은 변수 타입이 존재할까?
물론 존재한다. 당연한거 같지만 그 쓰임의 의미가 틀리다.

1. 기본형 변수
자바에서도 기본 타입으로 기본형 변수 8개를 제공 하고 있다. (primitive type)
그 이유는 바로 실행의 효율성 때문이다.

하도 오래전에 설명을 들은 이야기라 자세한건 기억이 나질 않지만.. Integer 클래스를 사용해서 값을 가지고 있다면
그 클래스에 부가적으로 들어가 있는 여러 메소드들을 활용 할수 있어 좋지만,
반면 그냥 변수 안에 나는 1 이라는 값을 하나 가지고 싶을 뿐인데, 쓸데없는 메소드를 주렁주렁 달고있는 클래스 객체에
덜렁 1값 하나를 넣어놓는다는건 아무리 봐도 비효율적이라고 밖에 생각이 들지 않는다.

따라서 자바에서도 기본적인 변수 타입을 제공하고 있는것이다.
위에서 설명한 8가지 변수를 소개해 본다.

* 형변환 방향(오른쪽으로)

숫자형 : byte(1) -> short(2) -> int(4) -> long(8) -> float(4) -> double(8)
                                |
문자형 :                 char(2)
논리형 : boolean

위의 변수 타입에서 숫자형, 문자형, 논리형 간에는 형변환이라는것이 이루어지지 않는다.
형변환이라는것은 오빠가 형으로 변하는게 아니라...  (몹쓸개그 작렬!!)
작은 타입의 변수가 큰변수 타입으로 자동으로 변환될수 있다는것이다.
즉, byte형 타입의 변수에 입력된 값은 short 형 변수에 대입하더라도 아무런 문제가 없다는 말씀이다.

반대로 int 형 변수의 값을 short 형 변수에 넣으려고 한다면 자동으로 들어가지 않게 된다.
쉽게 생각하자면 큰 그릇에 물을 꽉 차게 부어넣었다.
그리고나서 작은 그릇으로 그 물을 옮긴다면.. 전부 옮길수 있을까?

형변환에 대해서는 나중에 좀더 자세히 알아보도록 하자.

2. 참조형 (Reference type, 객체형) 변수
참조형, 객체형 변수는 우리가 만들어 내었거나, 혹은 자바 SDK에서 제공하고 있는 클래스 타입의 변수들을 말한다.
흔히 자주 쓰는 System.out.println() 를 보면은 System 객체가 사용 되는것을 볼 수 있다.
적절한 예시는 아니었다. System 객체를 사용하는데에는 변수 선언을 하지 않기 때문에 그렇다.
이 내용은 static 메소드를 설명하면서 좀 더 알아보도록 하고,

다른 예를 들자면
String str = "";
과 같이 String 객체 타입의 변수 str을 선언하는걸 보면 알수 있다.
이런식으로 쓰이는것들이 객체형 변수이다.

객체형 변수들도 형변환이 이루어질수 있다.

* 형변환 방향(위로)

                Object
                    |
                Human
                    |
                Superman

원리는 같다고 보면 된다.
큰그릇에 작은 그릇의 물을 담을수 있고, 반대로 작은그릇에 큰그릇의 물을 담을수 없는것이다.
이전 포스트에서 설명했듯이.. 모든 객체형 변수, 클래스 타입은 Object 를 상속 하고 있다.
따라서 어떠한 객체 타입이든 Object 로 형변환이 이루어 질수 있다.

OOP(Object Oriented Programming)의 특징
    (1) 상속성(inheritance) - Human, Superman, Xman
    (2) 다형성(polymorphism)
    (3) 은닉성(Information Hiding)
    (4) 캡슐화(Encapsulation)


정리 하면 위와 같다.

일단 상속성은 하나의 큰 개체에서 여러개의 개체들이 파생되는것과 같다
좀 어렵게 들린다면 이렇게 생각해보자

인간 클래스가 있다. 그리고 익히 알다시피 미국 헐리우드의 영웅들인
슈퍼맨 클래스 와 액스맨 클래스가 있다.
슈퍼맨과 액스맨은 (물론 슈퍼맨은 클립톤행성에서 온 외계인, 액스맨은 돌연변이 이지만)
인간 클래스부터 상속을 받아서 만들어졌다.
왜? 대부분의 평범한 (여기서 평범한 이란 머리는 하나요 코도 하나요 콧구멍도 하나요.. 등등.. 외형을 말한다)
인간들과 슈퍼맨과 액스맨은 겉으로는 비슷해 보인다.
여기서 많은 공통점을 찾을수 있을것이다.

이렇듯 세가지의 공통적인 부분은 인간클래스에 있고.. 슈퍼맨과 액스맨은
인간 클래스와 동일한부분에(공통점)  대해서 변수를 만든다거나 행위를 만들어 내는것이 아니라
단지 인간클래스를 상속 받음으로서 인간클래스에서 쓰이는 것들을 다 쓸수 있게되는것이다.

두번째로 일단 생각해보면 슈퍼맨과 엑스맨은 기본적으로 사람의 외형을 가지고 있지만
그들은 사람이 할 수 없는 일들을 해낼수가 있다. 그렇게 하기 위해서 일부 행위들이 변경되고
수치들도 변화하게 되고 추가가 될 수도 있다.
이것이 바로 다형성이다.
상속을 받은 슈퍼맨은 날아다닐수 있게되고, 눈은 보는것 뿐만 아니라 레이져를 쏠수도 있을것이다.
인간이 1초에 1걸음을 걷는다면 슈퍼맨은 100걸음을 걸을수도 있을것이다.
이렇듯 인간과 슈퍼맨은 다른 능력을 가지는데 같은 행위에서 다른 모습을 보일수도 있는것..
말그대로 다형성이 되겠다.

다음으로는 은닉성, 캡슐화 가 되겠다.
이건 더더욱 설명이 쉽겠다.
슈퍼맨은 알다시피 자기자신을 숨겨왔다.. 왜???   자기자신이 인간과 다르다는걸 숨겨야 했다.

그냥 보여주면 안돼????  라고 묻는다면 이렇게 물어보고 싶다..
슈퍼맨과 신문기자인 클락캔트가 같다 라는것을 사람들이 전부 안다면?
1. 일단 영화가 재미가 없다.
2. 그럼 대체 왜 슈퍼맨이 필요해? 그냥 클락캔트로 하지..

여기서 은닉성은 슈퍼맨이 인간인 척 할수 있다는것이다. 반대로 인간은 슈퍼맨인척 할수 없을것이고..
캡슐화는 슈퍼맨에서 비유하자면 슈퍼맨의 능력에 관해서는
슈퍼맨 스스로가 조절이 가능하다는것이다. 캡슐화하지 않는다는것은 슈퍼맨의 능력치를
다른 사람들이 마구 조절이 가능할수도 있다는것이다(상상이 되는가??)

쩝.. 쓰다보니 좀 논란이 될 비유들이 넣어졌지만.. 이해를 쉽게 하고자 쓴것이니..
오해하지말고 비난하지 말아 주시길...  아니.. 욕만 안하고 비평해주시면 감사하겠습니다~ ^^

자 이제 자바에 첫걸음을 들이미는단계입니다.
기초가 되는 자바의 설치과정은 
JDK 설치 및 환경변수 설정 5.0기준  을 참조하도록 하세요.

그리고 지금은 간단한 클래스만들기의 기초이기에 넘어가지만
객체지향프로그래밍? 객체란? 란 글을 한번 읽어보시구 의문을 가지고 항상 프로그래밍하길 바랍니다.


그럼 본격적으로 한번 클래스를 만들어봅니다.
클래스에 대한 설명은 다음에 알아보도록하구요. 클래스와 객체라는 글을 한번 쓸까합니다. ^^

일단 만들어보구 실행해보자구요! C언어를 배우면서 항상 처음 짜보는 프로그램
Hello World 프로그램을 Hello JAVA 라는 프로그램으로 업그레이드(?) 해서 만들어 봅니다.

class Hello {
    int num = 3;
   
    public Hello() {
       num = 1;
    }

    public static void main(String[] args) {
       System.out.println("Hello JAVA");
       Hello h = new Hello();
       System.out.println(h.num);
    }
}

위의 소스를 메모장, 혹은 텍스트 편집기를 통해서 작성하고나서
Hello.java 라고 저장합니다.  (class 명과 파일명의 이름이 같아야 한다, 대소문자 구별한다.)

이렇게 저장하고 나면 소스코드가 완성이 되었습니다.
이제는 컴파일하여 실행해보면 됩니다.


command 창을 실행하여 자바파일이 위치한 곳으로 이동합니다.
그 다음 소스 코드를 컴파일해줍니다.

javac Hello.java

라고 명령어를 입력하고 Enter를 누르면
컴파일이된다. (띄어쓰기 및 명령어를 주의하여 쓰셔야 합니다.)

- 만약 javac가 실행이 안된다면 JDK 설치 및 환경변수 설정 5.0기준  보고 환경변수 설정을 다시 해봅니다.

그리고 컴파일이 완료되었다면 dir 명령어로 Hello.class 파일이 만들어져 있는지 살펴봅니다.
만들어져 있다면 정상적으로 컴파일이 완료된 것입니다.

그러면 실행을 해보도록 합시다~

java Hello

- 뒤에 .class 를 붙이지 않습니다. ^^


위의 내용을 실행해본 결과 화면입니다.

어떤가요.. (엇 Hello World 닷;;    옛날에 찍어둔 스샷이라;;;)
다들 알고 계신다구요???
그래도 이클립스같은 툴만쓰다가 갑자기 보셨다면 헷갈리실수도 있자나요! 그래서 한번 써봤어요~ ^^

그럼 다음에는 이렇게 만들어본 클래스 파일과 객체란 무엇인지 살펴보겠습니다.