'Programing/Java'에 해당되는 글 35건

  1. [Java] abstract
  2. [Java] 인터페이스의 이해
  3. [Java] 형변환
  4. [Java] 실행
  5. [Java] Java SE, JDK, JRE

[Java] abstract

abstract


1.  추상화란

추상[抽象]: 낱낱의 구체적 표상이나 개념에서 공통된 성질을 뽑아 이를 일반적인 개념으로 파악하는 정신 작용

즉. 프로그래밍에서는 추상화는 기존의 클래스의 공통부분을 뽑아내서 조상클래스를 만드는 것이다.

추상화를 구체화와 반대되는 의미로 이해하면 보다 쉽게 이해할 수 있다. 상속계층도를 따라 내려갈수록 클래스는 점점 기능이 추가되어 구체와의 정도가 심해지며, 상속 계층도를 따라 올라갈수록 클래스는 추상화의 정도가 심해진다고 할 수 있다.

즉, 상속계층도를 따라 갈수록 세분화되며, 올라갈수록 공통요소만 남게 된다.

추상화: 클래스간의 공통점을 찾아내서 공통의 조상을 만드는 작업

구체화: 상속을 통해 클래스를 구현, 확장하는 작업


2. 추상클래스

클래스를 설계도에 비유한다면 추상클래스는 미완성 설계도에 비유할 수 있다.

미완성 설계도란, 단어의 뜻 그대로 완성되지 못한 채로 남겨진 설계도를 말한다.

클래스가 미완성이라는 것은 멤버의 개수에 관계된 것이 아니라, 단지 미완성 메서드(추상메서드)를 포함하고 있다는 의미이다.

미완성 설계도로 완성된 제품을 만들 수 없듯이 추상클래스로 인스턴스는 생성할 수 없다.

추상클래스는 상속을 통해서 자손클래스에 의해서만 완성될 수 있다.

추상클래스 자체로는 클래스로서의 역할을 다 못하지만, 새로운 클래스를 작성하는데 있어서 바탕이 되는 조상클래스로서 중요한 의미를 

갖는다. 새로운 클래스르 작성할 때 아무 것도 없는 상태에서 시작하는 것보다는 완전하지는 못하더라도 어느 정도 틀을 갖는 상태에서 

시작하는 것이 나을 것이다.

실생활에서 예를 들자면, 같은 크기의 TV라도 기능의 차이에 따라 여러 종류의 모델이 있지만, 사실 이 들의 설계도는 아마 90%정도는

동일할 것이다. 서로 다른 세 개의 설계도를 따로 그리는 것보다는 이들의 공통부분만을 그린 미완성 설계도를 만들어 놓고, 이 미완성 설계도

를 이용해서 각각의 설계도를 완성하는것이 훨씬 효율적이다.

추상클래스는 키워드 'abstract'를 붙이기만 하면 된다. 이렇게 함으로써 이 클래스를 사용할 때, 클래스 선언부의 abstract를 보고 이 

클래스에는 추상메서드가 있으니 상속을 통해서 구현해주어야 한다는 것을 쉽게 알 수 있을 것이다.

추상클래스는 추상메서드를 포함하고 있다는 것을 제외하고는 일반클래스와 전혀 다르지 않다. 추상클래스에도 생성자가 있으며,

멤버변수와 메서드도 가질 수 있다.

cf.) 추상메서드를 포함하고 있지 않은 클래스에도 키워드 'abstract'를 붙여서 추상클래스로 지정할 수도 있다. 추상 메서드가 없는 

완성된 클래스라 할지라도 추상클래스로 지정되면 클래스의 인스턴스를 생성할 수 없다.


3. 추상 메서드

메서드는 선언부와 구현부(몸통)로 구성되어 있다고 했다. 선언부만 작성하고 구현부는 작성하지 않은 채로 남겨 둔 것이 추상메서드이다.

즉 설계만 해 놓고 수행될 내용은 작성하지 않았기 때문에 미완성 메서드인 것이다.

메서드를 이와 같이 미완성 상태로 남겨 놓는 이유는 메서드의 내용이 상속받는 클래스에 따라 달라질 수 있기 때문에 조상 클래스에서는

선언부만을 작성하고, 주석을 덧붙여 어떤 기능을 수행할 목적으로 작성되었는지 알려 주고, 실제 내용은 상속받는 클래스에서 구현하도록

비워 두는 것이다. 그래서 추상클래스를 상속받는 자손 클래스는 조상의 추상메서드를 상황에 맞게 적절히 구현해주어야 한다.

추상메서드 역시 키워드 'abstract'를 앞에 붙여 주고, 추상메서드는 구현부가 없으므로 괄호{}대신 문장의 끝을 알리는 ';'을 적어준다.

추상클래스로부터 상속받는 자손클래스는 오버라이딩을 통해 조상인 추상클래스의 추상메서드를 모두 구현해주어야 한다.

만일 조상으로부터 상속받은 추상메서드 중 하나라도 구현하지 않는다면, 자손클래스 역시 추상클래스로 지정해 주어야 한다.

abstract class Player{

abstract void play(int pos);//추상 메서드

abstract void stop();// 추상 메서드

}

class AudioPlayer extends Player{

void play(int pos){.....}// 추상 메서드를 구현

void stop(){.....}//추상 메서드를 구현

abstract class AbstractPlayer extends Player{

void play(int pos){.....}//추상 메서드를 구현

}

실제 작업내용인 구현부가 없는 메서드가 무슨 의미가 있을까 싶기도 하겠지만, 메서드를 작성할 때 실제 작업내용인 구현부보다 더 중요한 부분이 선언부이다.

메서드의 이름과 메서드의 작업에 필요한 매개변수, 그리고 작업의 결과로 어떤 타입의 값을 반환할 것인가를 결정하는 것은 쉽지 않은 일이다.

선언부만 작성해도 메서드의 절반 이상이 완성된 것이라 해도 과언이 아니다.

메서드를 사용하는 쪽에서 메서드가 실제로 어떻게 구현되어있는지 몰라도 메서드의 이름과 매개변수, 리턴타입, 즉 선언부만 알고 있으면 되므로 내용이 없을 지라도

추상메서드를 사용하는 코드를 작성하는 것이 가능하며 실제로는 자손클래스에 구현된 완성된 메서드가 호출되도록 할 수 있다.


4. 추상클래스의 작성

아래에 Player라는 추상클래스를 작성해 보았다. 이 클래스는 VCR이나 Audio와 같은 재생 가능한 기기(Player)를 클래스로 작설할 때, 이 들의 조상클래스로 사용될 수 있을 것이다.

abstract class Player{

boolean pause;// 일시정지 상태를 저장하기 위한 변수

int currentPos;// 현재 play되고 있는 위치를 저장하기 위한 변수

Player(){// 추상클래스도 생성자가 있어야 한다.

pause= false;

currentPos = 0;

}// 저장된 위치(pos)에서 재생을 시작하는 기능이 수행하도록 작성되어야 한다.


abstract void play(int pos);// 추상메서드

  // 재생을 즉시 멈추는 기능을 수행하도록 작성되어야 한다.

abstract void stop();// 추상메서드

play(currentPos); // 추상메서드를 사용할 수 있다.

}


void pause(){

if(pause){// pause가 true일 때(정지상태)에서 pause가 호출되면

pause = false;// pause의 상태를 false로 바꾸고,

play(currentPos);// 현재의 위치에서 play를 한다.

}else{//pause가 false일 때(play 상태)에서 pause가 호출되면,

pause=true;// pause의 상태를 true로 바꾸고

stop();// play를 멈춘다.

}

}

}


class CDPlayer extends Player{

// 조상 클래스의 추상메서드를 구현한다.

void play(int currentPos){

  ....실제 구현 내용

}

void stop(){

.... 실제 구현 내용

}

// CDPlayer 클래스에 추가로 정의된 멤버


int currentTrack;// 현재 재생중인 트랙

void nextTrack(){

currentTrack++;

....

}

void preTrack(){

if(currentTrack >1){

currentTrack--;

}

....

}

}


class CDPlayer extends Player{

// 조상 클래스의 추상메서드를 CDPlayer클래스의 기능에 맞게 완성해주고, CDPlayer만의 새로운 기능들을 추가하였다.

사실 Player클래스의 play(int pos)와 stop()을 추상메서드로 하는 대신, 아무 내용도 없는 메서드로 작성할 수도 있다. 아무런 내용도 없이 단지 괄호{}만 있어도,

추상메서드가 아닌 일반메서드로 간주되기 때문이다.


class Player{

...

void play(int pos){ }

void stop(){ }

...

}

어차피 자손 클래스에서 오버라이딩하여 자신의 클래스에 맞게 구현할 테니 추상메서드로 선언하는 것과 내용없는 빈 몸통만 만들어 놓는 것이나 별 차이가 없어 보인다.

그래도 굳이 abstract를 붙여서 추상메서드로 선언하는 이유는 자손클래스에서 추상메서드를 반드시 구현하도록 강요하기 위해서이다.

만일 추상메서드로 정의되어 있지 않고 위와 같이 빈 몸통만 가지도록 정의되어 있다면, 상속받는 자손 클래스에서는 이 메서드들이 온전히 구현된 것으로 인식하고 오버라이딩을 통해 자신의 클래스에 맞도록 구현하지 않을 수도 있기 때문이다.

하지만, abstract를 이용해서 추상메서드로 정의해 놓으면, 자손 클래스를 작성할 때 이들이 추상메서드이므로 내용을 구현해주어야 한다는 사실을 인식하고 자신의 클래스에 알맞게 구현할 것이다.


이번엔 기존의 클래스로부터 공통된 부분을 뽑아내어 추상클래스를 만들어 보도록 하자.

class Marine{ //보병

int x, y;// 현재 위치

void move(int x, int y){   }//지정된 위치로 이동

void stop(){   }//현재 위치에 정지

void stimPack(){   }// 스팀팩을 사용한다.

}


class Tank{

int x, y;// 현재 위치

void move(int x, int y){   }//지정된 위치로 이동

void stop(){   }//현재 위치에 정지

void changMode(){   }//공격 모드로 전환한다.

}


class Dropship{

int x, y;// 현재 위치

void move(int x, int y){   }//지정된 위치로 이동

void stop(){   }//현재 위치에 정지

void load(){   }// 선택된 대상을 태운다.

void unloas{   }//선택된 대상을 내린다.

}


이 유닛들은 각자 나름대로 기능을 가지고 있지만 공통부분만 뽑아내어 하나의 클래스로 만들고, 이 클래스로부터 상속받도록 변경해보자.

abstract class Unit{

int x,y;

abstract void move(int x, int y);

void stop(){//현재 위치에 정지

}


class Marine extends Unit{

void move(int x, int y){   }//지정된 위치로 이동

void stimPack(){   }// 스팀팩을 사용한다.

}


class Tank extends Unit{

void move(int x, int y){   }//지정된 위치로 이동

void changMode(){   }//공격 모드로 전환한다.

}


class Dropship extends Unit{

void move(int x, int y){   }//지정된 위치로 이동

void load(){   }// 선택된 대상을 태운다.

void unloas{   }//선택된 대상을 내린다.

}

이들 클래스에 대해서 stop메서드는 선언부와 구현부 모두 공통적이지만, Marine, Tank는 지상유닛이고 Dropship은 공중유닛이기 때문에 이동하는 방법이 서로 달라서 move메서드의 실제 구현 내용이 다를 것이다.

그래도 move메서드의 선언부는 같기 때문에 추상메서드로 정의할 수 있다. 최대한의 공통부분을 뽑아내기 위한 것이기도 하지만. 모든 유닛은 이동할 수 있어야 하므로 Unit클래스에는 move메서드가 반드시 필요한 것이기 때문이다.

move 메서드가 추상메서드로 선언된 것에는,  앞으로 Unit 클래스를 상속받아서 작성되는 클래스는 move 메서드를 자신의 클래스에 알맞게 반드시 구현해야 한다는 의미가 담겨 있는 것이기도 하다.


Unit[ ] group = new group[4];

group[0] = new Marine();

group[1] = new Tank();

group[2] = new Marine();

group[3] = new Dropship();


for(int i = 0; i <group.length; i++){

group[i].move(100,200);

}

위의 코드는 공통적인 Unit클래스 타입의 참조변수 배열을 통해서 서로 다른 종류의 인스턴스를 하나의 묶음으로 다룰 수 있다는 것을 보여 주기 위한 것이다. 다형성에서 배웠듯이 조상 클래스타입의 참조변수로 자손 클래스의 인스턴스를 참조하는 것이 가능하기 때문에 이처럼 조상 클래스타입의 배열에 자손 클래스의 인스턴스를 담을 수 있는 것이다.

만일 이들 클래스간의 공통 조상이 없다면 이처럼 하나의 배열로 다룰 수 없을 것이다. Unit클래스에 move메서드를 호출하는 것이 가능하다. 메서드는 참조변수의 타입에 관계없이 실제 인스턴스에 구현된 것이 호출되기 때문이다.

group[i].move(100,200)과 같이 호출하는 것이 Unit 클래스의 추상메서드인 move를 호출하는 것 같이 보이지만 실제로는 이 추상메서드가 구현된 Marine, Tank, Dropship인스턴스의 메서드가 호출되는 것이다.

모든 클래스의 조상인 Object클래스 타입의 배열로도 서로 다른 종류의 인스턴스를 하나의 묶음으로 다룰 수 있지만, Object클래스에는 move메서드가 정의되어 있지 않기 때문에 move메서드를 호출하는 부분에서 에러가 발생한다.


5. 인터페이스와 비교

인터페이스는 일종의 추상클래스이다. 인터페이스는 추상클래스처럼 추상메서드를 갖지만 추상클래스보다 추상화 정도가 높아서 추상클래스와 달리 몸통만 갖춘 일반메서드 또는 멤버변수를 구성원으로 가질 수 없다. 오직 추상메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다름 어떠한 요소도 허용하지 않는다.

추상클래스를 부분적으로만 완성된 '미완성 설계도'라고 한다면, 인터페이스는 구현된 것은 아무것도 없고 밑그림만 그려져 있는 '기본 설계도'라고 할 수 있다.

- 모든 멤버변수는 public static final 이어야 하며, 이를 생략할 수 있다.

- 모든 메서드는 public abstract 이어야 하며, 이를 생략할 수 있다.


 추상클래스

인터페이스 

 추상메서드+일반메서드, 멤버변수+상수

 추상메서드, 상수




'Programing > Java' 카테고리의 다른 글

[Java] 클래스멤버와 인스턴스멤버간의 참조와 호출  (0) 2014.12.14
[Java] 변수의 종류  (0) 2014.12.14
[Java] 인터페이스의 이해  (0) 2014.12.06
[Java] 형변환  (0) 2014.12.02
[Java] 실행  (0) 2014.12.02

[Java] 인터페이스의 이해


인터페이스의 이해


1. 인터페이스의 이해 서두

먼저 인터페이스를 이해하기 위해서는 다음의 두 가지 사항을 반드시 염두에 두고 있어야 한다.

1) 클래스를 사용하는 쪽(User)과 클래스를 제공하는 쪽(Provider)이 있다.

2) 메서드를 사용(호출)하는 쪽(User)에서는 사용하려는 메서드(Provider)의 선언부만 알면 된다. (내용은 몰라도 된다.)


class A{

public void method( B b){

b.method();

}

}


class B {

public void methodB(){

System.out.println("methodB()");

}

}


class InterfaceTest{

public static void main(String args[]){

A a = new A();

a.methodA(new B());

}

}

-------------------------------------

실행결과

methodB()


클래스 A(User)는 클래스 B(Provider)의 인스턴스를 생성하고 메서드를 호출한다. 이 두 클래스는 서로 직접적인 관계에 있다. 이것을 간단히 'A(User)-->B(Provider)'라고 표현하다.

이 경우 클래스 A를 작성하기 위해서는 클래스 B가 이미 작성되어 있어야 한다. 그리고 클래스의 B의 methodB()의 선언부가 변경되면, 이를 사용하는 클래스 A도 변경되어야 한다.

이와 같이 직접적인 관계의 두 클래스는 한쪽(Provider)이 변경되면 다른 한 쪽(User)도 변경되어야 한다는 단점이 있다.

그러나 클래스 A가 클래스 B를 직접 호출하지 않고 인터페이스를 매개체로 해서 클래스 A가 인터페이스를 통해서 클래스 B의 메서드에 접근하도록 하면, 클래스 B에 변경사항이 생기거나 클래스 B와 같은 기능의 다른 클래스로 대체 되어도 클래스 A는 전혀 영향을 받지 않도록 하는 것이 가능하다.


2. 두 클래스간의 관계를 간접적으로 변경하기

두 클래스간의 관계를 간접적으로 변경하기 위해서는 먼저 인터페이스를 이용해서 클래스B(Provider)의 선언과 구현을 분리해야 한다.


먼저 다음과 같이 클래스 B에 정의된 메서드를 추상메서드로 정의하는 인터페이스 I를 정의한다.

interface I {

public abstract void methodB();

}


그 다음에는 클래스 B가 인터페이스 I를 구현하도록 한다.

class B implements I {

public void methodB(){

System.out.println("methodB in class");

}

}


이제 클래스 A는 클래스 B 대신 인터페이스 I를 사용해서 작성할 수 있다.

class A {

public void methodA(I i){

i.methodB();

}

}

cf.) methodA가 호출될 때 인터페이스 I를 구현한 클래스의 인스턴스(클래스 B의 인스턴스)를 제공받아야 한다.


--> 클래스 A를 작성하는데 있어서 클래스 B가 사용되지 않았다는 점에 주목하자. 이제 클래스 A와 클래스 B는 'A-B'의 직접적인 관계에서 'A-I-B'의 간접적인 관계로 바뀐 것이다.

결국 클래스 A는 여전히 클래스 B의 메서드를 호출하지만, 클래스 A는 인터페이스 I하고만 직접적인 관계에 있기 때문에 클래스 B의 변경에 영향을 받지 않는다.

클래스 A는 인터페이스를 통해 실제로 사용하는 클래스의 이름을 몰라도 되고 심지어는 실제로 구현된 클래스가 존재하지 않아도 문제되지 않는다. 클래스 A는 오직 직접적인 관계에 있는 인터페이스의 I의 영향만 받는다.

인터페이스 I는 실제 구현 내용(클래스 B)을 감싸고 있는 껍데기이며, 클래스 A는 껍데기안에 어떤 알맹이(클래스)가 들어 있는지 몰라도 된다.


 class A {

    void autoPlay(I i) {

          i.play();

     }

 }


 interface I {

      public abstract void play();

 }


 class B implements I {

     public void play() {

          System.out.println("play in B class");

     }

 }


 class C implements I {

     public void play() {

          System.out.println("play in C class");

     }

 }


class InterfaceTest2 {

public static void main(String[] args) {

A a = new A();

a.autoPlay(new B());

a.autoPlay(new C());

}

}

---------------------------------------

실행결과

play in B class

play in C class


클래스 A가 인터페이스 I를 사용해서 작성되긴 하였지만, 이처럼 매개변수를 통해서 인터페이스 I를 구현한 클래스의 인스턴스를 동적으로 제공받아야 한다.



'Programing > Java' 카테고리의 다른 글

[Java] 변수의 종류  (0) 2014.12.14
[Java] abstract  (0) 2014.12.11
[Java] 형변환  (0) 2014.12.02
[Java] 실행  (0) 2014.12.02
[Java] Java SE, JDK, JRE  (0) 2014.12.02

[Java] 형변환


형변환


형 변환(Type Conversion)이란 데이터의 타입을 변경하는 것이다. 예를 들어 int 타입의 정수 200의 bit 값은 아래와 같다.

00000000 00000000 00000000 11001000

프로그래밍을 처음 시작하는 사람도 컴퓨터는 모든 정보가 0과 1로 만들어진다는 이야기를 들어봤을 것이다. 여러분이 200이라는 숫자를 입력하면 컴퓨터에는 위와 같이 0과 1로 이루어진 조합으로 저장된다. 바로 이 0과 1을 bit라고 부른다. 위의 데이터는 8X4개의 자릿수로 이루어져 있다. 이것을 32bit라고 부른다. 위의 데이터는 int 형으로 숫자 200을 저장했을 때 메모리상에 만들어지는 내용이다. 그럼 실수형인 float 타입으로 정수 200.0을 저장하면 어떻게 될까? 사람에게는 똑같은 수인 정수 200과 실수 200.0을 컴퓨터는 전혀 다른 방식으로 저장한다. float 타입의 정수 200.0의 bit 값은 아래와 같다.


01000011 01001000 00000000 00000000

정수 200과 실수 200.0의 bit 값이 완전히 다른 것을 알 수 있다. 이렇게 형식이 다른 데이터들을 더하려면 한쪽의 데이터 타입을 다른 쪽의 데이터 타입으로 전환(Conversion)해야 한다. 자바는 이러한 형 변환을 자동으로 처리해주는데 이러한 전환작업을 자동(암시적) 형 변환(implicit Conversion)이라고 부른다.


1. 자동 형 변환

아래 예제를 보자. 

double a = 3.0F;

위의 코드는 double 타입의 변수 a에 float 타입의 값을 대입하고 있다. 이 때 3.0F의 값은 자동으로 double 타입으로 형 변환이 일어난다. 이것이 가능한 이유는 double 타입이 float 타입보다 더 많은 수를 표현 할 수 있기 때문이다. 타입을 변경해도 정보의 손실이 일어나지 않는 경우 자동 형 변환이 일어난다.


반대로 아래의 예제는 오류가 발생한다. 상수 3.0은 상수인데, 이 상수는 double 형이다. 이 값을 표현 범위가 좁은 float에 넣으려고 하기 때문에 오류가 발생한다. 

float a = 3.0;

자동 형 변환의 원칙은 표현범위가 좁은 데이터 타입에서 넓은 데이터 타입으로의 변환만 허용된다는 것이다.

아래는 자동 형 변환이 일어나는 규칙을 보여준다.


byte 타입은 short가 될 수 있지만 short는 byte 타입이 될 수 없다. long은 float가 될 수 있지만, float는 long이 될 수 없다.

상수와 상수를 연산한다면 어떻게 될까? 다음 예제를 보자. 

int a = 3;

float b = 1.0F;

double c = a + b;

위의 연산은 두 번의 형 변환이 일어난다. 우선 a와 b를 더하기 위해서 정수 a와 실수 b 중 하나가 형 변환을 해야 한다. 위의 그림에 따르면 int와 float가 붙으면 int가 float가 되기 때문에 변수 a에 담겨있는 값 3은 float 타입이 된다. 연산 결과는 float 타입이다. 하지만 이 값이 담겨질 변수 C의 타입은 double이다. float가 double 타입의 변수에 담기기 위해서는 float가 double로 형 변환을 해야 한다. 이렇게 해서 최종적으로 형 변환된 값이 변수 c에 담겼다.


2. 명시적 형 변환

자동 형 변환이 적용되지 경우에는 수동으로 형 변환을 해야 한다. 이를 명시적(Explicit Conversion)이라고 한다. 아래 예제는 모든 행의 코드에서 오류가 발생한다. 자동 형 변환이 이루어지지 않기 때문이다. (실행)

float a = 100.0;

int b = 100.0F;


위의 예제를 조금 수정해보자. 아래 코드는 오류가 발생하지 않는다. 

float a = (float)100.0;

int b = (int)100.0F;

아래와 같이 괄호 안에 데이터 타입을 지정해서 값 앞에 위치시키는 것을 명시적인 형 변환이라고 부른다.


형 변환은 한 번에 설명할 수 있는 주제는 아니다. 여러분이 객체지향까지 진입하면 다양한 방법으로 형 변환이라는 주제가 다시 언급될 것이다. 일단은 이정도로 언급하고 후속 수업을 통해서 형 변환에 대해서 좀 더 심화된 내용을 알아가자.




'Programing > Java' 카테고리의 다른 글

[Java] 변수의 종류  (0) 2014.12.14
[Java] abstract  (0) 2014.12.11
[Java] 인터페이스의 이해  (0) 2014.12.06
[Java] 실행  (0) 2014.12.02
[Java] Java SE, JDK, JRE  (0) 2014.12.02

[Java] 실행


실행


1. 코드

우선 코드에 대해서 알아보자. 코드(code) 혹은 소스(source)는 프로그램이 어떤 모습이고, 어떻게 동작해야 하는가를 표현한 일종의 설계도라고 할 수 있다. 그런데 컴퓨터 프로그래밍에서의 설계도는 설계도 이상의 의미가 있다. 설계도를 컴퓨터에게 제출하는 순간 컴퓨터는 그 설계도에서 요구하는 프로그램을 마법처럼 만들어주기 때문이다. 그래서 프로그래밍에서의 설계도는 그 프로그램 자체라고도 할 수 있다. 코드는 자바의 문법에 맞게 만들어진 텍스트 파일이고, 이 파일의 확장자는 .java를 사용한다.


아래와 같이 파일을 만들어보자. 코드를 만드는 데는 복잡한 프로그램이 필요 없다. 가장 간단한 에디터인 메모장(win)이나 텍스트에디터(mac)로도 코드를 만들 수 있다. 적당한 디렉터리를 만들고 아래와 같은 내용을 가지고 있는 파일을 만들어보자. 파일의 이름은 Helloworld.java다.

class Helloworld {

    public static void main(String[] args){

        System.out.println("Hello world");

    }

}


2. 컴파일

그런데 코드 자체를 바로 실행할 수는 없다. 자바의 문법은 사람만이 이해할 수 있는 형식으로 되어 있기 때문이다. 이 코드를 컴퓨터가 이해할 수 있는 상태로 변환해주는 과정이 필요한데 이것을 컴파일(compile)이라고 하고, 이 작업을 하는 소프트웨어를 컴파일러(compiler)라고 부른다. 자바의 컴파일러는 javac 라는 이름을 가지고 있다. 만약 helloworld.java라는 코드를 컴파일한다면 아래와 같은 식으로 javac를 실행하면 된다. 

javac Helloworld.java


3. 실행

위 의 명령을 실행하면 같은 디렉터리에 helloworld.class라는 이름의 파일이 생성된다. 바로 이 파일이 컴파일된 파일이고, 쉽게 말해서 실행파일이라고 할 수 있다. 그런데 이 파일은 파일 이름만으로 실행 할 수 있는 것은 아니고, 컴파일된 파일을 실행시켜주는 프로그램을 이용해야 한다. 이 작업을 하는 프로그램을 런처(launcher)라고 하고 아래와 같이 실행한다.

java Helloworld


여러분이 해야 할 일은 런처를 이용해서 확장자가 class인 파일을 실행하는 것이다. 런처는 내부적으로 자바 가상 머신에서 우리가 만든 코드가 동작하도록 한다. 우리가 만든 프로그램은 최종적으로 자바 가상머신이라는 것을 통해서 동작하게 된다.

위와 같은 흐름을 통해서 자바 프로그램이 만들어지고 실행된다. 이를 통해서 알 수 있는 것은 코드만 있다고 프로그램이 만들어지는 것은 아니라는 것이다. 실제로 동작하는 프로그램은 자바이고, 여러분은 자바가 어떻게 동작할 것인가를 코드로 작성해서 자바에게 전달하면 자바는 그 코드에 적혀있는 데로 실행하게 되는 것이다. 아래 그림을 보자.

                                                                                 




'Programing > Java' 카테고리의 다른 글

[Java] 변수의 종류  (0) 2014.12.14
[Java] abstract  (0) 2014.12.11
[Java] 인터페이스의 이해  (0) 2014.12.06
[Java] 형변환  (0) 2014.12.02
[Java] Java SE, JDK, JRE  (0) 2014.12.02

[Java] Java SE, JDK, JRE

Java SE, JDK, JRE


- Java SE(Java Platform, Standard Edition)는 자바의 표준안이다. 자바라는 언어가 어떠한 문법적인 구성을 가졌는지와 같은 것들을 정의하고 있다. 이것은 구체적인 소프트웨어가 아니고 그 소프트웨어의 설계도라고 할 수 있다. 소프트웨어에서는 설계도라는 표현 대신에 명세서(spec, specification)이라는 말을 사용한다. 이 명세서에 따라서 Java가 만들어지게 된다. Java SE 7은 버전 7에 대한 명세서이다. 자바는 계속 진화하고 있는 기술이다. 이 명세서는 JCP(Java Community Process, http://jcp.org)라는 조직을 통해서 만들어진다.


- JDK(Java Development Kit)는 Java SE의 표준안에 따라서 만들어진 구체적인 소프트웨어다. Java 개발자라면 JDK를 다운받아서 설치해야 한다. 여기에는 Java 프로그램을 실행하면 Java 코드를 컴파일하는 컴파일러와 개발에 필요한 각종 도구 그리고 JRE가 포함되어 있다. 즉 개발자를 위한 자바 버전이다.


- JRE(Java Runtime Environment)는 자바가 실제로 동작하는 데 필요한 JVM, 라이브러리, 각종 파일들이 포함되어 있다. 자바로 만들어진 프로그램을 구동하려고 한다면 이것을 설치한다. 일반인을 위한 자바 버전이라고 할 수 있다.


- JVM(Java Virtual Machine) JVM은 자바가 실제도 구동하는 환경이다. 자바로 만들어진 소프트웨어는 JVM이라는 가상화된 환경에서 구동되고, 하드웨어나 운영체제에 따라서 달라질 수 있는 호환성의 문제는 운영체제 버전에 따라서 만들어진 JVM이 알아서 해결한다. 즉 하나의 자바 프로그램을 만들면 어떤 환경에서도 실행할 수 있는 것이 바로 JVM의 역할이라고 할 수 있다.


JVM은 자바를 실행하기 위한 가상 기계라고 할 수 있다. 컴퓨터(머신)를 사용해서 자바를 실행하기 위한 가상 컴퓨터라고 이해하면 좋을 것이다.

가상 기계는 소프트웨어로 구현된 하드웨어를 뜻하는 넓은 의미의 용어이며, 컴퓨터의 성능이 향상됨에 따라 점점 더 많은 하드웨어들이 소프트웨어화되어 컴퓨터 속으로 들어오고 있다.

그 예로는 TV와 비디로를 스프트웨어한 윈도우 미디어 플레이어던가, 오디오 시스템을 소프트웨어화한 윈엠프 등이 있다.

이와 마찬가지로 '가상 컴퓨터'는 실제 컴퓨터(하드웨어)가 아닌 스프트웨어로 구현된 컴퓨터라는 뜻으로 컴퓨터 속의 컴퓨터라고 생각하면 된다.


자바로 작성된 어플리케이션은 모두 이 가상 컴퓨터에서만 실행되기 때문에, 자바 어플리케이션이 실행되기 위해서는 반드시 JVM이 필요하다.

이 관계를 그림으로 나타내면 아래와 같다.


cp.)

자바로 프로그래밍을 하기 위해서는 먼저 JDK를 설치해야 한다. JDK를 설치하면, 자바가상머신과 자바클래스 라이브러리외에 자바를 개발하는데 필요한 프로그램들이 설치된다.


(1) JDK의 bin 디렉터리의 주요 파일

1) javac.exe: 자바 컴파일러, 자바소스코드를 바이트코드로 컴파일한다.

c:\jdk1.6\work\javac Hello.java


2) java.exe: 자바 인터프리터, 컴파일러가 생성한 바이트코드를 해석하고 실행한다.

c:\jdk1.6\work\java Hello


3) javap.exe: 역어셈플러, 컴파일된 클래스파일을 원래의 소스로 변환한다.

c:\jdk1.6\javap Hello > Hello.java


vo.) 바이트코드

JVM이 이해할 수 있는 기계어, JVM은 바이트코드를 다시 해당 OS의 기계어로 변환되어 OS로 전달한다.


cf.) jar.exe: 압축프로그램, 클래스파일과 프로그램과 프로그램의 실행에 관련된 파일을 하나의 jar파일(.jar)로 압축하거나 압축해제한다.


cf.) JDK와 JRE

JDK: 자바개발도구

JRE: 자바실행환경


JDK: JRE + 개발에 필요한 실행파일(javac.exe등)

JRE: JVM+클래스라이브러리


프롬프트 창에서 자바 파일 실행

Hello.java 작성 ---> javac.exe --->Hello.class 생성 ---> java.exe ---> 실행



'Programing > Java' 카테고리의 다른 글

[Java] 변수의 종류  (0) 2014.12.14
[Java] abstract  (0) 2014.12.11
[Java] 인터페이스의 이해  (0) 2014.12.06
[Java] 형변환  (0) 2014.12.02
[Java] 실행  (0) 2014.12.02