크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Java 에서는 두가지 방식으로 Thread를 생성할수 있다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

1> 패널 컨테이너란?

우선 Panel 클래스는 Applet 클래스의 상위 클래스이다.
Applet과 Frame은 가장 바깥쪽의 컨테이너 역활을 하는데 반해 Panel 컨테이너는 컴포넌트를 그룹별로 모을 때, 주로 사용한다. 보통 컴포넌트를 Panel 에 먼저 부착을 하고 Panel을 Applet 혹은 Frame 에 부착을 한다. 왜 이렇게 복잡하게 하느냐 싶겠지만, 실제로 Panel 은 불가피한 배치문제로 인해 많이 사용되고 있다. Panel 은 다른 컨테이너에 쉽게 부착을 할 수 있는데, 컴포넌트를 추가할 때와 마찬가지로 add() 메서드를 사용한다.

 

우선 예제를 보자. 나중에 살펴볼 배치를 배우게 되면 이해가 될 것이다.

2> 패널 컨테이너 사용 예

앞서 프레임 컨테이너에서 예를 든 LabelFrame.java에 패널을 사용했다.

1. LabelFramePanel.java

 

import java.awt.*; public class LabelFramePanel extends Frame{ //일반적으로 프레임에서는 생성자에서 GUI를 구성한다. public LabelFramePanel(){ // 라벨을 생성한다. Label label1 = new Label("첫번째"); Label label2 = new Label("두번째"); Label label3 = new Label("세번째"); // 라벨에 배경색을 설정한다. label1.setBackground(Color.red); label2.setBackground(Color.yellow); label3.setBackground(Color.green); //패널 객체 생성 Panel p =new Panel(); //패널에 라벨을 차례대로 붙인다. p.add(label1); p.add(label2); p.add(label3); //패널을 프레임에 붙인다. add(p); } public static void main(String[] args){ LabelFramePanel lf=new LabelFramePanel(); lf.setSize(300,100); lf.show();    } }

<< 실행 결과 >>

출처 : getJAVA™

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

1> Frame 컨테이너

Frame 컨테이너는 어플리케이션의 대표적인 컨테이너이다. 이때까지 우리가 예제를 다룬것에서 그다지 벗어나지 않는다. Frame 컨테이너에서도 애플릿과 마찬가지로 add()를 이용해서 컴포넌트를 부착하면 된다. 다만 Frame 컨테이너는 부착을 할때 위치를 지정해 줘야한다. 또한 Frame 컨테이너의 크기를 결정해주는 setSize() 라든지 setBounds()를 반드시 코딩해 줘야하며 화면에 보이도록 setVisible(true)나 show() 메서드를 코딩해 줘야한다.

2> Frame 컨테이너 사용하기

1. Frame 클래스 import 하기(import java.awt.Frame;)
2. Frame 클래스 상속 받기
3. setSize() 혹은 setBounds()로 크기 결정하기 --> 중요
4. setVisible(true)나 show() 로 화면에 출력하기 --> 하지 않으면 화면에 보이지 않음.

3> Frame 컨테이너 사용 예

1. LabelFrame.java

 

// Frame 클래스를 import 한다. // Frame 클래스는 awt 패키지에 속하므로 다음과 같이 해도 된다. import java.awt.*; public class LabelFrame extends Frame{ public static void main(String[] args){ //애플릿과는 달리 프레임은 객체를 생성해 줘야한다. LabelFrame lf=new LabelFrame(); // 라벨을 생성한다. Label label1 = new Label("첫번째"); Label label2 = new Label("두번째"); Label label3 = new Label("세번째"); // 라벨에 배경색을 설정한다. label1.setBackground(Color.red); label2.setBackground(Color.yellow); label3.setBackground(Color.green); // 라벨을 붙인다. lf.add(label1); lf.add(label2); lf.add(label3); // 반드시 크기결정과 화면출력을 해줘야한다. // 에러는 나지 않지만 실행시 화면이 보이지 않는다. lf.setSize(300,300); lf.show();     } }

<< 실행 결과 >> 실행결과를 보면 좀 황당하다는 생각이 들것이다. 왜냐면 맨 마지막에 부착을 했던 라벨만이 보이기 때문이다. 이것은 애플릿과 프레임의 배치 관리자가 달라서 그렇다. 다시 말하면 애플릿은 붙이는 순서대로 붙는 배치가 디폴트이고 (이것을 FlowLayout 이라한다.) 프레임은 5가지로 영역이 나누어서 붙는 배치가 디폴트이기 때문이다.(이것을 BorderLayout 이라한다.)   아직 배치에 관해 배우지 않았으므로 결과에는 신경을 쓰지 말고 넘어가자. 어쨌든 여기서 중요한 것은 애플릿으로 코딩한 것을 프레임으로 혹은 프레임을 애플릿으로 바꾸는 연습을 많이하고 그 원리를 이해해야한다.

출처 : getJAVA™

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

인터페이스는 일종의 추상클래스이다. 인터페이스는 추상클래스처럼 추상메서드를 갖지만 추상클래스보다 추상화 정도가 높아서 추상클래스와 달리 몸통을 갖춘 일반 메서드 또는 멤버변수를 구성원으로 가질 수 없다.
오직 추상메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않는다.
추상클래스를 부분적으로만 완성된 '미완성 설계도'라고 한다면, 인터페이스는 구현된 것은 아무 것도 없고 밑그림만 그려져 있는 '기본 설계도'라 할 수 있다.

추상클래스처럼 인터페이스도 완성되지 않은 불완전한 것이기 때문에 그 자체만으로 사용되기 보다는 다른 클래스를 작성하는데 도움 줄 목적으로 작성된다.

인터페이스를 작성하는 것은 클래스를 작성하는 것과 같다. 다만 키워드로 class 대신 interface를 사용한다는 것만 다르다. 그리고 interface에도 클래스와 같이 접근제어자로 public 또는 default를 사용할 수 있다.

interface 인터페이스이름 {       public static final 타입 상수이름 = 값;       public abstract 메서드이름(매개변수목록); }

일반적인 클래스의 멤버들과 달리 인터페이스의 멤버들은 다음과 같은 제약사항을 가지고 있다.

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

interface PlayingCard {       public static final int SPADE = 4;       final int DIAMOND = 3;             // public static final int DIAMOND=3;       static int HEART = 2;             // public static final int HEART=2;       int CLOVER = 1;                  // public static final int CLOVER=1;       public abstract String getCardNumber();       String getCardKind();       // public abstract String getCardKind();로 간주된다. }

interface는 클래스가 아닌 인터페이스로부터만 상속받을 수 있으며, 클래스와는 달리 다중상속, 즉 여러 개의 인터페이스로부터 상속을 받는 것이 가능하다.

interface Movable {       /** 지정된 위치(x, y)로 이동하는 기능의 메서드 */       void move(int x, int y);       } interface Attackable {       /** 지정된 대상(u)을 공격하는 기능의 메서드 */       void attack(Unit u); } interface Fightable extends Movable, Attackable { }

클래스에서의 상속과 마찬가지로 자손인터페이스(Fightable)은 조상인터페이스(Movable, Attackable)에 정의된 멤버를 모두 상속받는다.
그래서 Fightable자체에는 정의된 멤버가 하나도 없지만 조상인터페이스로 부터 상속받은 두 개의 추상메서드, move(int x, int y)와 attack(Unit u)를 멤버로 갖게 된다.

추상클래스에서와 같이 인터페이스의 추상메서드를 몸통을 구현하는 자손클래스를 작성해야한다. 이때는 인터페이스를 '구현(implement)한다'고 하며 키워드 implements를 사용한다.

class 클래스이름 implements 인터페이스이름 {       // 인터페이스에 정의된 추상메서드를 구현해야한다. } class Fighter implements Fightable {       public void move() { /* 내용 생략*/ }       public void attack() { /* 내용 생략*/ } }

만일 구현하는 인터페이스의 메서드 중 일부만 구현한다면, 추상클래스로 선언되어야 한다.

abstract class Fighter implements Fightable {      public void move() { /* 내용 생략*/ } }

그리고 다음과 같이 상속과 구현을 동시에 할 수도 있다.

class Fighter extends Unit implements Fightable {       public void move(int x, int y) { /* 내용 생략 */}       public void attack(Unit u) { /* 내용 생략 */} }

[예제7-23] FighterTest.java

class FighterTest {       public static void main(String[] args)       {             Fighter f = new Fighter();             if (f instanceof Unit)       {                               System.out.println("f는 Unit클래스의 자손입니다.");             }             if (f instanceof Fightable) {                         System.out.println("f는 Fightable인터페이스를 구현했습니다.");             }             if (f instanceof Movable) {                               System.out.println("f는 Movable인터페이스를 구현했습니다.");             }             if (f instanceof Attackable) {                         System.out.println("f는 Attackable인터페이스를 구현했습니다.");             }             if (f instanceof Object) {                               System.out.println("f는 Object클래스의 자손입니다.");             }       } } class Fighter extends Unit implements Fightable {       public void move(int x, int y) { /* 내용 생략 */}       public void attack(Unit u) { /* 내용 생략 */} } class Unit { int currentHP;             // 유닛의 체력 int x;                   // 유닛의 위치(x좌표) int y;                   // 유닛의 위치(y좌표) } interface Fightable extends Movable, Attackable { } interface Movable {       void move(int x, int y);       } interface Attackable {       void attack(Unit u); }

[실행결과]

f는 Unit클래스의 자손입니다. f는 Fightable인터페이스를 구현했습니다. f는 Movable인터페이스를 구현했습니다. f는 Attackable인터페이스를 구현했습니다. f는 Object클래스의 자손입니다.

예제에 사용된 클래스와 인터페이스간의 관계를 그려보면 다음과 같다.



실제로 Fighter클래스는 Unit클래스로부터 상속받고 Fightable인터페이스만을 구현했지만, Unit클래스는 Object클래스의 자손이고, Fightable인터페이스는 Movable과 Attackable인터페이스의 자손이므로 Fighter클래스는 이 모든 클래스와 인터페이스의 자손이 되는 셈이다.
인터페이스는 상속 대신 구현이라는 용어를 사용하지만, 인터페이스로부터 상속받은 추상메서드를 구현하는 것이기 때문에 인터페이스도 조금은 다른 의미의 조상이라고 할 수 있다.

여기서 주의 깊게 봐두어야 할 것은 Movable인터페이스에 정의된 void move(int x, int y)를 Fighter클래스에서 구현할 때 접근제어자를 public으로 했다는 것이다.

interface Movable {       void move(int x, int y);       } class Fighter extends Unit implements Fightable {       public void move(int x, int y) { /* 실제구현내용 생략 */}       public void attack(Unit u) { /* 실제구현내용 생략 */} }

오버라이딩을 할 때는 조상의 메서드보다 넓은 범위의 접근제어자를 지정해야한다는 것을 기억할 것이다. Movable인터페이스에 void move(int x, int y)와 같이 정의되어 있지만 사실 public abstract가 생략된 것이기 때문에 실제로 public abstract void move(int x, int y)이다.
따라서 이를 구현하는 Fighter클래스에서는 void move(int x, int y)의 접근제어자를 반드시 public으로 해야 하는 것이다.

두 조상으로부터 상속받는 멤버 중에서 멤버변수의 이름이 같거나 메서드의 선언부가 일치하고 구현 내용이 다르다면 이 두 조상으로부터 상속받는 자손클래스는 어느 조상의 것을 상속받게 되는 것인지 알 수 없다. 어느 한 쪽으로부터의 상속을 포기하던가, 이름이 충돌하지 않도록 조상클래스를 변경하는 수 밖에는 없다.

자바에서는 이러한 충돌문제를 해결하기 위해서 단일 상속만을 허용하고, 인터페이스를 이용해서 단일 상속의 단점을 보완하도록 하였다.

인터페이스는 상수만을 정의할 수 있으므로 조상클래스의 멤버변수와 충돌하는 경우는 극히 드물고 추상메서드는 구현내용이 전혀 없으므로 조상클래스의 메서드와 선언부가 일치하는 경우에는 당연히 조상클래스 쪽의 메서드를 상속받으면 되므로 문제되지 않는다.
이렇게 해서 상속받는 멤버의 충돌은 피할 수 있지만, 다중상속의 장점을 잃게 된다는 것이 아쉽다.

만일 두 개의 클래스로부터 상속을 받아야 할 상황이라면, 두 조상클래스 중에서 비중이 높은 쪽을 선택하고 다른 한쪽은 클래스 내부에 멤버로 포함시키는 방식으로 처리하거나 어느 한쪽을 필요한 부분을 뽑아서 인터페이스로 만든 다음 구현하도록 한다.

다음과 같이 Tv클래스와 VCR클래스가 있을 때, TVCR클래스를 작성하기 위해 두 클래스로부터 상속을 받을 수만 있으면 좋겠지만 다중상속을 허용하지 않으므로, 한 쪽만 선택하여 상속받고 나머지 한 쪽은 클래스 내에 포함시켜서 내부적으로 인스턴스를 생성해서 사용하도록 한다.

public class Tv {       protected boolean power;       protected int channel;       protected int volume;       public void power() { power = ! power;}       public void channelUp() { channel++;}       public void channelDown() { channel--;}       public void volumeUp() { volume++;}       public void volumeDown() { volume--;} } public class VCR {       protected int counter;             // VCR의 카운터       public void play() {             // Tape을 재생한다.       }       public void stop() {             // 재생을 멈춘다.       }      public void reset() {                        counter =0;      }      public int getCounter() {            return counter;      }      public void      setCounter(int c) {            counter = c;      } }

VCR클래스에 정의된 메서드와 일치하는 추상메서드를 갖는 인터페이스를 작성한다.

public interface IVCR {       public void play();       public void stop();       public void reset();      public int getCounter();      public void setCounter(int c); }

이제 IVCR 인터페이스를 구현하고 Tv클래스로부터 상속받는 TVCR클래스를 작성한다. 이때 VCR클래스 타입의 참조변수를 멤버변수로 선언하여 IVCR인터페이스의 추상메서드를 구현하는데 사용한다.

public class TVCR extends Tv implements IVCR {       VCR vcr = new VCR();             public void play() {             vcr.play();   // 코드를 작성하는 대신 VCR인스턴스의 메서드를 호출하면 된다.       }       public void stop() {             vcr.stop();       }       public void reset() {            vcr.reset();      }      public int getCounter() {           return vcr.getCounter();      }      public void setCounter(int c) {           vcr.setCounter(c);      } }

IVCR인터페이스를 구현하기 위해서는 새로 메서드를 작성해야하는 부담이 있지만 이처럼 VCR클래스의 인스턴스를 사용하면 손쉽게 다중상속을 구현할 수 있다.
또한 VCR클래스의 내용이 변경되어도 변경된 내용이 TVCR클래스에도 자동적으로 반영되는 효과도 얻을 수 있다.

사실 인터페이스를 새로 작성하지 않고도 VCR클래스를 TVCR클래스에 포함시키는 것만으로도 충분하지만, 인터페이스를 이용하면 다형적 특성을 이용할 수 있다는 장점이 있다.

다형성에 대해 학습할 때 자손클래스의 인스턴스를 조상타입의 참조변수로 참조하는 것이 가능하다는 것을 배웠다.
인터페이스 역시 이를 구현한 클래스의 조상이라 할 수 있으므로 해당 인터페이스 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조할 수 있으며, 인터페이스 타입으로의 형변환도 가능하다.
인터페이스 Fightable을 클래스 Fighter가 구현했을 때, 다음과 같이 Fighter인스턴스를 Fightable타입의 참조변수로 참조하는 것이 가능하다.

Fightable f = (Fightable)new Fighter(); 또는 Fightable f = new Fighter();

따라서 인터페이스는 다음과 같이 메서드의 매개변수의 타입으로 사용될 수 있다.

void attack(Fightable f) {      //... }

인터페이스 타입의 매개변수가 갖는 의미는 메서드 호출 시 해당 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공해야한다는 것이다.
그래서 attack메서드를 호출할 때는 매개변수로 Fightable인터페이스를 구현한 클래스의 인스턴스를 넘겨주어야 한다.

class Fighter extends Unit implements Fightable {       public void move(int x, int y) { /* 내용 생략 */}       public void attack(Fightable f) { /* 내용 생략 */} }

위와 같이 Fightable인터페이스를 구현한 Fighter클래스가 있을 때, attack메서드의 매개변수로 Fighter인스턴스를 넘겨 줄 수 있다. 즉, attack(new Fighter())와 같이 할 수 있다는 것이다.

그리고 다음과 같이 메서드의 리턴타입으로 인터페이스의 타입을 지정하는 것 역시 가능하다.

Fightable method() {      // ...      return new Fighter(); }

리턴타입이 인터페이스라는 것은 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 것을 의미한다.
위의 코드에서는 method()의 리턴타입이 Fightable인터페이스기 때문에 메서드의 return문에서Fightable인터페이스를 구현한 Fighter클래스의 인스턴스를 반환한다.

[예제7-24] ParserTest.java

class ParserTest {       public static void main(String args[]) {             Parseable parser = ParserManager.getParser("XML");             parser.parse("document.xml");             parser = ParserManager.getParser("HTML");             parser.parse("document2.html");       } } interface Parseable {       public abstract void parse(String fileName);       // 구문 분석작업을 수행한다. } class ParserManager {      // 리턴타입이 Parseable인터페이스이다.       public static Parseable getParser(String type) {                   if(type.equals("XML")) {                return new XMLParser();             } else {                Parseable p = new HTMLParser();                return p;                // return new HTMLParser();       위의 두 줄을 간단히 할 수 있다.             }       } } class XMLParser implements Parseable {       public void parse(String fileName) {           /* 구문 분석작업을 수행하는 코드를 적는다. */             System.out.println(fileName + " - XML parsing completed.");       } } class HTMLParser implements Parseable {       public void parse(String fileName) {           /* 구문 분석작업을 수행하는 코드를 적는다. */             System.out.println(fileName + " - HTML parsing completed.");       } }

[실행결과]

document.xml - XML parsing completed. document2.html - HTML parsing completed.

Parseable인터페이스는 구문분석(parsing)을 수행하는 기능을 구현할 목적으로 추상메서드 parse(String fileName)를 정의했다. 그리고 XMLParser클래스와 HTMLParser클래스는 Parseable인터페이스를 구현하였다.
ParserManager클래스의 getParser메서드는 매개변수로 넘겨받는 type의 값에 따라 XMLParser인스턴스 또는 HTMLParser인스턴스를 반환한다.



getParser메서드의 수행결과로 참조변수 parser는 XMLParser인스턴스의 주소값을 갖게 된다. 마치 Parseable parser = new XMLParser();이 수행된 것과 같다.

parser.parse("document.xml");

참조변수 parser를 통해 parse()를 호출하면, parser가 참조하고 있는 XMLParser인스턴스의 parse메서드가 호출된다.

만일 나중에 새로운 종류의 XML구문분석기 NewXMLPaser클래스가 나와도 ParserTest클래스는 변경할 필요없이 ParserManager클래스의 getParser메서드에서 return new XMLParser(); 대신 return new NewXMLParser();로 변경하기만 하면 된다.

이러한 장점은 특히 분산환경 프로그래밍에서 그 위력을 발휘한다. 사용자 컴퓨터에 설치된 프로그램을 변경하지 않고, 서버측의 변경만으로도 사용자가 새로 개정된 프로그램을 사용하는 것이 가능하다.

인터페이스를 사용하는 이유와 그 장점을 정리해 보면 다음과 같다.

- 개발시간을 단축시킬 수 있다. - 표준화가 가능하다. - 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다. - 독립적인 프로그래밍이 가능하다.

일단 인터페이스가 작성되면, 이를 사용해서 프로그램을 작성하는 것이 가능하다. 메서드를 호출하는 쪽에서는 메서드의 내용에 관계없이 선언부만 알면 되기 때문이다.
그리고 동시에 다른 한 쪽에서는 인터페이스를 구현하는 클래스를 작성하도록 하여, 인터페이스를 구현하는 클래스가 작성될 때까지 기다리지 않고도 양쪽에서 동시에 개발을 진행할 수 있다.

프로젝트에 사용되는 기본 틀을 인터페이스로 작성한 다음 개발자들에게 인터페이스를 구현하여 프로그램을 작성하도록 함으로써 보다 일관되고 정형화된 프로그램의 개발이 가능하다.

서로 상속관계에 있지도 않고, 같은 조상클래스를 가지고 있지 않은 서로 아무런 관계도 없는 클래스들에게 하나의 인터페이스를 공통적으로 구현하도록 함으로써 관계를 맺어 줄 수 있다.

인터페이스를 이용하면 클래스의 선언과 구현을 분리 시킬 수 있기 때문에 실제구현에 독립적인 프로그램을 작성하는 것이 가능하다. 클래스와 클래스간의 직접적인 관계를 인터페이스를 이용해서 간접적인 관계로 변경하면, 한 클래스의 변경이 관련된 다른 클래스에 영향을 미치지 않는 독립적인 프로그래밍이 가능하다.
예를 들어 한 데이터베이스 회사가 제공하는 특정 데이터베이스를 사용하는데 필요한 클래스를 사용해서 프로그램을 작성했다면 이 프로그램은 다른 종류의 데이터베이스를 사용하기 위해서는 전체 프로그램 중에서 데이터베이스 관련된 부분은 모두 변경해야할 것이다.

그러나 데이터베이스 관련 인터페이스를 정의하고 이를 이용해서 프로그램을 작성하면, 데이터베이스의 종류가 변경되더라도 프로그램을 변경하지 않도록 할 수 있다.

단, 데이터베이스 회사에서 제공하는 클래스도 인터페이스를 구현하도록 요구해야한다. 데이터베이스를 이용한 응용프로그램을 작성하는 쪽에서는 인터페이스를 이용해서 프로그램을 작성하고, 데이터베이스 회사에서는 인터페이스를 구현한 클래스를 작성해서 제공해야한다.

실제로 자바에는 다수의 데이터베이스 관련 인터페이스를 제공하고 있으며, 프로그래머는 이 인터페이스를 이용해서 프로그래밍을 하면 특정 데이터베이스에 종속되지 않는 프로그램을 작성할 수 있다.

게임 스타크래프드에 나오는 유닛을 클래스로 표현하고 이들간의 관계를 상속계층도로 표현해 보았다.



게임에 나오는 모든 유닛들의 최고 조상은 Unit클래스이고 유닛의 종류는 지상유닛(GoundUnit)과 공중유닛(AirUnit)으로 나뉘어진다.
그리고 지상유닛에는 Marine, SCV, Tank가 있고, 공중유닛으로는 DropShip이 있다. SCV에게 Tank와 DropShip과 같은 기계화 유닛을 수리할 수 있는 기능을 제공하기 위해 repair메서드를 정의한다면 다음과 같을 것이다.

void repair(Tank t) {       // Tank를 수리한다. } void repair(DropShip d) {       // DropShip을 수리한다. }

이런 식으로 수리가 가능한 유닛의 개수 만큼 다른 버젼의 오버로딩된 메서드를 정의해야할 것이다.

이것을 피하기 위해 매개변수의 타입을 이 들의 공통 조상으로 하면 좋겠지만 DropShip은 공통조상이 다르기 때문에 공통조상의 타입으로 메서드를 정의한다고 해도 최소한 2개의 메서드가 필요할 것이다.

void repair(GroundUnit gu) {       // 매개변수로 넘겨진 지상유닛(GroundUnit)을 수리한다. } void repair(AirUnit au) {       // 매개변수로 넘겨진 공중유닛(AirUnit)을 수리한다. }

그리고 GroundUnit의 자손 중에는 Marine과 같이 기계화 유닛이 아닌 클래스도 포함될 수 있기 때문에 repair메서드의 매개변수 타입으로 GroundUnit은 부적합하다.
현재의 상속관계에서는 이들의 공통점은 없다. 이 때 인터페이스를 이용하면 기존의 상속체계를 유지하면서 이들 기계화 유닛에 공통점을 부여할 수 있다.
다음과 같이 Repairable이라는 인터페이스를 정의하고 수리가 가능한 기계화 유닛에게 이 인터페이스를 구현하도록 하면 된다.

interface Repairable {} class SCV extends GroundUnit implements Repairable {       //... } class Tank extends GroundUnit implements Repairable {       //... } class DropShip extends AitUnit implements Repairable {       //... }

이제 이 세 개의 클래스에는 같은 인터페이스를 구현했다는 공통저이 생겼다. 인터페이스 Repairable에 정의된 것은 아무것도 없고, 단지 인스턴스의 타입체크에 사용된다.
Repairable인터페이스를 중심으로 상속계층도를 그려보면 다음과 같다.



그리고, repair메서드의 매개변수의 타입을 Repairable로 선언하면, 이 메서드의 매개변수로 Repairable인터페이스를 구현한 클래스의 인스턴스만 받아들여질 것이다.

void repair(Repairable r) {       // 매개변수로 넘겨받은 유닛을 수리한다. }

앞으로 새로운 클래스가 추가될 때, SCV의 repair메서드에 의해서 수리가 가능하도록 하려면 Repairable인터페이스를 구현하도록 하면 될 것이다.

[예제7-25] RepairableTest.java

class RepairableTest {       public static void main(String[] args)       {             Tank t = new Tank();             DropShip d = new DropShip();             Marine m = new Marine();             SCV       s = new SCV();             s.repair(t);       // SCV가 Tank를 수리하도록 한다.             s.repair(d); //             s.repair(m);       에러발생 : repair(Repairable) in SCV cannot be applied to (Marine)       } } interface Repairable {} class GroundUnit extends Unit {       GroundUnit(int hp) {             super(hp);       } } class AirUnit extends Unit {       AirUnit(int hp) {             super(hp);       } } class Unit {       int hitPoint;       final int MAX_HP;       Unit(int hp) {             MAX_HP = hp;       }       //... } class Tank extends GroundUnit implements Repairable {       Tank() {             super(150);             // Tank의 HP는 150이다.             hitPoint = MAX_HP;       }       public String toString() {             return "Tank";       }       //... } class DropShip extends AirUnit implements Repairable {       DropShip() {             super(125);             // Goliath의 HP는 125이다.             hitPoint = MAX_HP;       }       public String toString() {             return "DropShip";       }       //... } class Marine extends GroundUnit {       Marine() {             super(40);             hitPoint = MAX_HP;       }       //... } class SCV extends GroundUnit implements Repairable{       SCV() {             super(60);             hitPoint = MAX_HP;       }       void repair(Repairable r) {             if (r instanceof Unit) {                   Unit u = (Unit)r;                   while(u.hitPoint==u.MAX_HP) {                         /* Unit의 HP를 증가시킨다. */                         u.hitPoint++;                   }                   System.out.println( u.toString() + "의 수리가 끝났습니다.");             }       }             //... }

[실행결과]

Tank의 수리가 끝났습니다. DropShip의 수리가 끝났습니다.

repair메서드의 매개변수 r은 Repairable타입이기 때문에 인터페이스 Repairable에 정의된 멤버만 사용할 수 있다.
그러나 Repairable에는 정의된 멤버가 없으므로 이 타입의 참조변수로는 할 수 있는 일은 아무 것도 없다.
그래서 instanceof연산자로 타입을 체크한 뒤 캐스팅하여 Unit클래스에 정의된 hitPoint와 MAX_HP를 사용할 수 있도록 하였다.
그 다음엔 유닛의 현재체력(hitPoint)이 유닛이 가질 수 있는 최고체력(MAX_HP)이 될 때 Marine은 Repairable인터페이스를 구현하지 않았으므로 SCV클래스의 repair메서드의 매개변수로 Marine을 사용하면 컴파일 시에 에러가 발생한다.

이와 유사한 예를 한가지 더 들어보자. 게임 스타크래프트에 나오는 건물들을 클래스로 표현하고 이들의 관계를 상속계층도로 표현하였다.



건물을 표현하는 클래스 Academy, Bunker, Barrack, Factory가 있고 이들의 조상인 Building클래스가 있다고 하자. 이 때 Barrack클래스와 Factory클래스에 다음과 같은 내용의, 건물을 이동시킬수 있는, 새로운 메서드를 추가하고자 한다면 어떻게 해야할까?

void liftOff() { /* 내용생략 */} void move(int x, int y) { /* 내용생략 */} void stop() { /* 내용생략 */} void land() { /* 내용생략 */}

Barrack클래스와 Factory클래스 모두 위의 코드를 적어주면 되긴 하지만, 코드가 중복된다는 단점이 있다. 그렇다고 해서 조상클래스인 Building클래스에 코드를 추가해주면, Building클래스의 다른 자손인 Academy와 Bunker클래스도 추가된 코드를 상속받으므로 안된다.
이런 경우에도 인터페이스를 이용해서 해결할 수가 있다. 우선 새로 추가하고자하는 메서드를 정의하는 인터페이스를 정의하고 이를 구현하는 클래스를 작성한다.

interface Liftable {      /** 건물을 들어 올린다. */      void liftOff();      /** 건물을 이동한다. */      void move(int x, int y);      /** 건물을 정지시킨다. */      void stop();      /** 건물을 착륙시킨다. */      void land(); } class LiftableImpl implements Liftable {      void liftOff() { /* 내용 생략 */}      void move(int x, int y) { /* 내용 생략 */ }      void stop() { /* 내용 생략 */ }      void land() { /* 내용 생략 */ } }

마지막으로 새로 작성된 인터페이스와 이를 구현한 클래스를 Barrack과 Factory클래스에 적용하면 된다.

class Barrack extends Buildings implments Liftable {      LiftableImpl l = new LiftableImpl();      void liftOff() { l.liftOff();}      void move(int x, int y) { l.move(x, y);}      void stop() { l.stop();}      void land() { l.land();}      void trainMarine() { /* 내용 생략 */ }      void trainMedic() { /* 내용 생략 */ }           // ... } class Factory extends Buildings implments Liftable {      LiftableImpl l = new LiftableImpl();      void liftOff() { l.liftOff();}      void move(int x, int y) { l.move(x, y);}      void land() { l.land();}      void trainMarine() { /* 내용 생략 */ }      void trainMedic() { /* 내용 생략 */ }      // ... }

Barrack클래스가 Liftable인터페이스를 구현하도록 하고, 인터페이스를 구현한 LiftableImpl클래스를 Barrack클래스에 포함시켜서 내부적으로 호출해서 사용하도록 한다.
이렇게 함으로써 같은 내용의 코드를 Barrack클래스와 Factory클래스에서 각각 작성하지 않고 LiftableImpl클래스 한 곳에서 관리할 수 있다. 그리고 작성된 Liftable인터페이스와 이를 구현한 LiftableImpl클래스는 후에 다시 재사용될 수 있을 것이다.

지금까지 인터페이스의 특징과 구현하는 방법, 장점 등 인터페이스에 대한 일반적인 사항들에 대해서 모두 살펴보았다. 하지만 '인터페이스란 도대체 무엇인가?'라는 의문은 여전히 남아있을 것이다. 이번 절에서는 인터페이스의 규칙이나 활용이 아닌, 본질적인 측면에 대해 살펴보자.

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

- 클래스를 사용하는 쪽(User)과 클래스를 제공하는 쪽(Provider)이 있다. - 메서드를 사용(호출)하는 쪽(User)에서는 사용하려는 메서드(Provider)의 선언부만 알면 된다.(내용은 몰라도 된다.)

다음과 같이 클래스 A와 클래스 B가 있다고 하자.

class A {       public static void main(String args[]) {             B b = new B();             b.methodB();       } } class B {       public void methodB() {             System.out.println("methodB()");       } }

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

이 경우 클래스 A를 작성하기 위해서는 클래스 B가 이미 작성되어 있어야 한다. 그리고 클래스 B의 methodB()의 선언부가 변경되면, 이를 사용하는 클래스 A도 변경되어야 한다.
이와 같이 직접적인 관계의 두 클래스는 한 쪽(Provider)가 변경되면 다른 한 쪽(User)도 변경되어야 한다는 단점이 있다.

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

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

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

interface I {      public abstract void methodB(); }

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

class B implements I {      public void methodB() {            System.out.println("methodB in B class");       } }

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

class A {       public void methodA(I i) {             i.methodB();       } }

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



결국 클래스 A는 여전히 클래스 B의 메서드를 호출하지만, 클래스 A는 인터페이스 I하고만 직접적인 관계에 있기 때문에 클래스 B의 변경에 영향을 받지 않도록 하는 것이 가능하다.
클래스 A는 인터페이스를 통해 실제로 사용하는 클래스의 이름을 몰라도 되고 심지어는 실제로 구현된 클래스가 존재하지 않아도 문제되지 않는다.
클래스 A는 직접적인 관계에 있는 인터페이스 I의 영향만을 받는다.



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

[예제7-26] InterfaceTest.java

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 InterfaceTest {       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를 구현한 클래스의 인스턴스를 동적으로 제공받아야 한다.
클래스 Thread의 생성자인 Thread(Runnable target)와 AWT컴포넌트의 addActionListener(ActionListener l)가 이런 방식으로 되어 있다.

이처럼 매개변수를 통해 동적으로 제공받을 수 도 있지만 다음과 같이 다른 제 3의 클래스를 통해서 제공받을 수도 있다. JDBC의 DriverManager클래스가 이런 방식으로 되어 있다.

[예제7-27] InterfaceTest2.java

class InterfaceTest2 {       public static void main(String[] args) {             A a = new A();             a.methodA();       } } class A {       void methodA() {            I i = InstanceManager.getInstance();             i.methodB();       } } interface I {       public abstract void methodB(); } class B implements I {       public void methodB() {            System.out.println("methodB in B class");       } } class InstanceManager {       public static I getInstance() {             return new B();       } }

[실행결과]

methodB in B class

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

문자열 다루기 - 분리 split함수 Split함수는 문자열을 기준문자로 분리할 수 있는 함수로 분리결과는 배열로 리턴된다 관리자모드를 간단하게 꾸밀 때 사용할 수 있다. 에제는 FSO(파일시스템객체)를 다룰 때 살펴본다 관리자로그인폼 -> 아이디와 패스 전송 -> 텍스트파일을 읽어 분리. 아이디와 패스 비교 -> 관리자전용화면.수정.수정값 전송 -> 전송결과를 기준문자를 넣어 다시 텍스트파일에 저장 split.asp 아이디 : guest 패 스 : 1234 소스 <% str1="2-300-#ff6666-guest-1234" spl=split(str1,"-") '대상문자열,분리기준 ->배열이 된다 %> <table border="<%=spl(0)%>" width="<%=spl(1)%>" bgcolor="<%=spl(2)%>"> <tr> <td> 아이디 : <%=spl(3)%> </td> <td> 패 스: <%=spl(4)%> </td> </tr> </table>

public class Test {
    public static void main(String[] args) {
        String temp = "123.456"; //temp에 쪼갤 문자 넣기
        String[] temp2 = new String[2]; //배열 선언
        temp2 = temp.split("[.]"); //쪼개 넣기
        System.out.println(temp2[0]); //쪼개 넣은거 출력
    }
}


출력결과 = 123

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

◎ File 객체가 참조하는 파일, 디렉토리를 테스트하기 위한 메서드


▶ canRead() - File 객체가 참조하는 파일 또는 디렉토리를 읽을 권

한이 있다면 true를, 없다면 false를 리턴한다. 만약 권한이 없는데

읽으려고 시도하면 SecurityException이 발생한다.

▶ canWriter() - File 객체가 참조하는 파일 또는 디렉토리에 쓰

기 권한이 있다면 true를, 없다면 false를 리턴한다. 만약 권한

이 없는데 읽으려고 시도하면 SecurityException이 발생한다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

텍스트 파일 저장시 개행문자 넣고 그 파일을 다운로드하여 메모장으로 오픈했을때,

로우가 아래로 내려가지 않고 ■ 으로 표시되고 한줄로만 보이게 된다.

(엑셀이나 다른 워드프로그램으로 보면 제대로 보인다.)

메모장에서도 한줄 한줄 정돈된 모습으로 보고자 한다면

\r\n으로 라인을 구분하여 넣어주면 모습이 제대로 잡히게 된다.

아니면 문장에 \r을 넣고 newLine(); 메소를 사용해도 된다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

１. 파일과 디렉토리 관리

가. 추상 경로명(abstract pathname)

UNIX 플랫폼 또는 Win32 플랫폼 등과 같은 각 운영체제는 파일과 디렉토리 이름에 시스템 의존적인 경로명(system-dependent pathname)의 문자열을 사용합니다. 이는 프로그램 개발자로 하여금 시스템에 일일이 신경쓰도록 해야 하고, 프로그램의 이식성 또는 상호호환성을 어렵게 하는 원인 중의 하나가 됩니다. 이러한 문제를 해결하기 위해, 다시 말해서 플랫폼 독립적인 파일 또는 디렉토리 관리 기능을 제공하기 위해, 자바에서는 File 클래스를 제공해 주고 있으며, 이 클래스는 추상적이고 시스템(플랫폼) 독립적인 관점의 계층적인 경로명을 제공하고 있습니다. 이러한 추상 경로명은 다음과 같은 두 가지 요소로 구성되어 있습니다.

            - 플랫폼 의존적인 prefix 문자열: UNIX 플랫폼 상에서의 루트 디렉토리를 나타내는 "/", 그리고 Win32 플랫폼 상에서는 디스크 드라이브명(disk-drive specifier) 또는 UNC 경로명을 사용할 경우에 사용하는 "\\" 등이 있습니다.

            - 파일 또는 디렉토리를 나타내는 경로명: 이름을 나타내는 0개 이상의 문자열입니다.

prefix 개념은 UNIX 플랫폼상에서의 루트 디렉토리와 Win32 플랫폼 상에서의 드라이브명(drive specifiers), 루트 디렉토리, 그리고 UNC 경로명을 다루기 위해 사용됩니다. 예를 들면, 다음과 같습니다.

            - UNIX 플랫폼: 절대 경로명의 prefix는 항상 "/"이고, 상대 경로명은 prefix를 갖지 않습니다. 이 때, 루트 디렉토리에 대한 자바의 추상 경로명은 prefix "/"와 빈 이름열(name sequence)을 갖습니다.

"/"

"/home/ywpark/"

            - Win32 플랫폼: 경로명의 prefix는 드라이브 문자와 ":"로 구성된 드라이브명(drive specifier)과 절대 경로명일 경우 "\" 등을 포함합니다. UNC 경로명의 prefix는 "\\"이고, 호스트이름과 공유 이름은 이름열의 처음에 나타나는 두 개의 이름입니다. 드라이브를 갖지 않는 상대 경로명은 prefix가 없습니다.

"\\D:\ "

"\\Park\mp3z"

추상 경로명 내의 마지막 이름을 제외한 각 이름은 디렉토리를 의미하고, 마지막 이름은 디렉토리 이름일 수도 있고 파일 이름일 수도 있습니다. 경로명 문자열을 추상 경로명으로 변환하거나 또는 추상 경로명으로부터 경로명 문자열로 변환하는 것은 시스템에 의존적입니다.

추상 경로명 또는 문자열 형태의 경로명은 절대 경로일 수도 있고 상대 경로일 수도 있습니다. 절대 경로명은 파일의 완전한 위치를 나타내므로 더 이상의 정보가 필요 업습니다. 반면, 반면, 상대 경로명이 가리키고 있는 파일은 다른 경로명에서 얻은 정보를 이용하여 그 위치를 얻을 수 있습니다. 일반적으로, java.io 패키지 내에 있는 클래스들은 항상 시스템 속성인 user.dir이 가지고 있는 현재 사용자 디렉토리(current user directory)로부터 상대 경로명을 얻습니다. 일반적으로, 현재 사용자 디렉토리는 자바 가상 머신이 시작된(invoked) 디렉토리입니다.

추상 경로명이 경로명 문자열로 변환될 때, 각 이름은 디폴트 구분자 문자를 이용하여  서로 구분됩니다. 디폴트 이름 구분자 문자(name-separator character)는 시스템 속성으로 file.separator에 정의되어 있습니다. 반면, 경로명 문자열이 추상 경로명으로 변환될 때, 경로명 내의 이름들은 디폴트 이름 구분자 문자 또는 시스템에 의해 지원되는 다른 이름 구분자 문자 등에 의해 구분되어 있습니다.

나. File 클래스

File 클래스는 파일 및 디렉토리를 관리할 수 있도록 기능을 제공해 주는 클래스입니다. File 클래스는 파일의 복사 또는 이름 변경 등의 조작을 할 경우에 사용될 뿐, 파일의 내용을 입출력 하기 위한 메소드를 제공해 주지는 않습니다. 자바에서는 모든 데이터의 입출력을 스트림에 기반하여 수행하므로, File 클래스 내부적으로 이러한 메소드를 구현할 필요가 없기 때문입니다. 입출력 스트림과 관련된 내용은 뒤에서 자세히 살펴보도록 하겠습니다. 그런데, 이러한 File 클래스의 인스턴스는 변경 불가능합니다. 다시 말해서, 한 번 생성되면, File 객체에 의해 표현되는 추상 경로명은 절대로 변하지 않습니다. File 클래스에는 다음과 같은 종류의 경로 구분자와 이름 구분자를 제공해 주고 있습니다.

            - static char separatorChar: 시스템에 해당하는 디폴트 이름 구분 문자로서, 시스템 속성인 file.separator의 값을 갖습니다.

UNIX 시스템: '/'

Win32 시스템: '\'

            - public static final String separator: 시스템에 해당하는 디폴트 이름 구분 문자(name-separator character)로서, 편의상 문자열로 표현되어 있습니다.

UNIX 시스템: "/"

Win32 시스템: "\"

            - public static final char pathSeparatorChar: 시스템에 해당하는 경로 구분 문자로서, 시스템 속성인 path.separator의 값을 갖습니다.

UNIX 시스템: ':'

Win32 시스템: ';'

            - public static final String pathSeparator: 시스템에 해당하는 경로 구분 문자(path-separator character)로서, 편의상 문자열로 표현되어 있습니다.

UNIX 시스템: ":"

Win32 시스템: ";"

File 클래스에는 다음과 같은 세 종류의 생성자가 있습니다. 각각에 대하여 간단히 살펴보도록 하겠습니다.

            - public File(String pathname): 주어진 경로명을 추상 경로명으로 변환하여 새로운 File 객체를 생성합니다. 만약, 주어진 문자열이 빈 문자열이라면, 빈 추상 경로명이 됩니다.

            - public File(String parent, String child): 두 개의 문자열에 주어진 경로명을 이용하여 새로운 File 객체를 생성합니다. parent 문자열이 null이면, child 문자열을 경로명으로 하는 객체를 생성하고, 그렇지 않을 경우 parent 문자열은 디렉토리를 나타내고, child 문자열은 디렉토리 또는 파일일 수 있습니다.

            - public File(File parent, String child): 주어진 File 객체와 문자열을 이용하여 새로운 File 객체를 생성합니다. parent 객체가 null이면, child 문자열을 경로명으로 하는 객체를 생성하고, 그렇지 않을 경우 parent 객체는 디렉토리를 나타내고, child 문자열은 디렉토리 또는 파일일 수 있습니다.

File 클래스에서 제공해주는 주요 메소드를 살펴보면, 다음과 같습니다.

            - public String getName(): 추상 경로명이 나타내는 파일 또는 디렉토리의 이름을 얻습니다. 이 이름은 경로명 이름에 있는 마지막 이름입니다.

            - public String getParent(): 추상 경로명의 부모 경로에 대한 경로명을 문자열로 얻습니다. 이 때, 부모 경로명은 추상 경로명이 갖는 prefix와 경로명에 있는 마지막 이름을 제외한 나머지 이름들을 포함하고 있습니다.

            - public File getParentFile(): 추상 경로명의 부모 경로에 대한 추상 경로명(File 객체)을 얻습니다. 이 때, 부모 경로명은 추상 경로명이 갖는 prefix와 경로명에 있는 마지막 이름을 제외한 나머지 이름들을 포함하고 있습니다.

            - public String getPath(): 추상 경로명을 경로명 문자열로 변환하여 얻습니다. 이 때, 디폴트 이름 구분 문자가 적용됩니다.

            - public boolean isAbsolute(): 절대 경로명인지를 얻습니다. UNIX 시스템 상에서는 prefix가 "/"를 포함하고 있을 경우, Win32 시스템 상에서는 prefix가 "\\"와 드라이브 문자 또는 "\\"를 포함하고 있을 경우 절대 경로명입니다.

            - public String getAbsolutePath(): 추상 경로명에 대한 절대 경로명을 문자열로 얻습니다. UNIX 시스템 상에서 상대 경로명일 경우, 현재 사용자 디렉토리와 결합하여 절대 경로명을 얻습니다. Win32 시스템 상에서의 상대 경로명은 드라이브 문자를 포함하여, UNIX 시스템과 마찬가지로 현재 사용자 디렉토리와 결합하여 얻습니다.

            - public File getAbsoluteFile(): "new File(this.getAbsolutePath()())"와 같습니다.

            - public String getCanonicalPath() throws IOException: 추상 경로명에 대한 유일한 정규 표현 경로명을 얻습니다.

            - public File getCanonicalFile() throws IOException: "new File(this.getCanonicalPath()())"와 같은 효과를 얻습니다.

            - public URL toURL() throws MalformedURLException: 추상 경로명을 URL로 변환하여 얻습니다.

            - public boolean canRead(): 파일이 읽기 가능한지를 얻습니다.

            - public boolean canWrite(): 파일이 쓰기 가능한지를 얻습니다.

            - public boolean exists(): 파일이 존재하는지를 얻습니다.

            - public boolean isDirectory(): 디렉토리인지를 얻습니다.

            - public boolean isFile(): 파일인지를 얻습니다.

            - public boolean isHidden(): 숨겨진(hidden) 파일인지를 얻습니다.

            - public long lastModified(): 파일이 마지막으로 갱신된 시간을 얻습니다.  시간은 epoch (00:00:00 GMT, January 1, 1970)로부터 경과된 밀리초를 나타내며, 값이 0L이면 파일이 존재하지 않거나 I/O 에러가 발생했음을 나타냅니다.

            - public long length(): 파일의 크기를 얻습니다.

            - public boolean createNewFile() throws IOException: 추상 경로명에 해당하는 파일이 존재하지 않는 경우 비어있는 새로운 파일을 생성합니다.

            - public boolean delete(): 추상 경로명이 가리키는 파일이나 디렉토리를 삭제합니다. 이 때, 비어있지 않은 디렉토리는 삭제할 수 없습니다.

            - public void deleteOnExit(): 가상 머신이 종료될 때, 이 추상 경로명이 나타내는 파일을 삭제되도록 요청합니다. 이 메소드에 의해 파일이 지워지도록 요청되면, 이 요청은 취소될 수 없을므로, 주의를 기울여서 사용해야 합니다.

            - public String[] list(): 추상 경로명이 나타내는 디렉토리 내의 파일과 디렉토리의 이름에 대한 문자열 배열을 얻습니다.

            - public File[] listFiles(): 추상 경로명이 나타내는 디렉토리 내의 파일과 디렉토리의 이름에 대한 File 객체 배열을 얻습니다.

            - public boolean mkdir(): 이 추상 경로명에 해당하는 디렉토리를 생성합니다.

            - public boolean mkdirs(): 이 추상 경로명에 해당하는 디렉토리를 생성가능한지를 얻습니다. 만약, 경로명의 부모 경로명이 존재하지 않을 경우도 고려됩니다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

1. Stream

  대부분의 언어에서 입출력을 수행하는 것은 결코 간단한 얘기는 아니다. 그러나 스트림을 지원하는 언어라면 조금은 얘기가 틀려진다. 스트림은 입출력을 위임받아 처리하는 하나의 단위를 의미하는데, 스트림의 정의는 바이트의 순차적 입출력 방식이다.

  이것은 입출력을 수행할 데이터를 바이트의 배열 형태로 바꾸어 입출력을 수행하는 방식으로 데이터가 순서대로 입력과 출력이 이루어진다는 말이다. 이 스트림 방식을 사용하게되면 하드웨어가 어떻게 바뀌더라도 일관된 방식으로 입출력을 수행할 수 있다.

  자바에서 입출력을 수행하기 위해 java.io 패키지로 제공되며 이 패키지를 이용하면 스트림 방식의 입출력이 가능하다.

2. InputStreamReader / OutputStreamWriter 클래스

  Reader와 Writer 클래스는 Object 클래스의 바로 하위 클래스이다. 이것들로부터 바이트 입출력 스트림 상속시켰는데, Buffered Reader/Writer와 InputStreamReader/Writer가 대표적이다.

  InputSreamReader와 Writer를 이용하여 바이트의 입출력을 수행해보자.

import java.io.*; public class ReWriter {         public static void main(String[] args) {                 InputStreamReader ir = new InputStreamReader(System.in);                 OutputStreamWriter or = new OutputStreamWriter(System.out);                                 int temp;                 try{                         while((temp=ir.read())!=-1)                                 System.out.println((char)temp);                 }catch(IOException e){}         } }

  위의 예에서 ir.read() 메서드의 리턴형은 byte형이다. 즉, 형 그대로 출력하게 되면 숫자가 나타나게 된다. 이것을 우리가 원하는 문자로 보여주기 위해서는 char형으로 캐스트 연산되어야 한다.

 

3. BufferedReader / BuffersWriter

  위의 방식에서 더욱 개선된 버퍼를 이용한 입출력 방식이다. 버퍼는 임시기억장치를 의미하는데 입출력 장치과 CPU 사이에서 위치해, 조금 더 효과적인 입출력을 지원하는 방식이다. 예를 들어 입출력 장치에서 입출력이 일어나면 CPU는 입출력이 완료될때까지 대기해야 하는데 버퍼를 사용함으로서 이러한 단점을 줄이면서, 버퍼에 줄을 저장할 수 있기 때문에 줄 단위 입출력이 가능하다.

import java.io.*; public class StringInput {         public static void main(String[] args){                 String inputString;                 String text="String Test..";                 try{                         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));                         BufferedWriter bw = new BufferedWriter(                         new OutputStreamWriter(new FileOutputStream(text)));                         while((inputString = br.readLine()) != null)                                 bw.write(inputString + "\n");                         bw.close();                         br.close();                 }catch(IOExcetion e){}         } }

4. FileReader / FileWriter

  기본 문자 인코딩을 이용해서 파일의 입출력을 담당하는 클래스이다. 이 클래스를 사용하면 파일에 읽고 쓰는 것이 가능하다. 다음은 파일 복사의 예이다.

import java.io.*; public class FileCopy {   public static void main(String[] args) {     try {       FileReader input = new FileReader("FileCopy.java");       FileWriter output = new FileWriter("Test.txt");       int charsRead;       while((charsRead = input.read()) != -1) {         output.write(charsRead);       }       input.close();       output.close();     }     catch(IOException e) {       e.printStackTrace();     }   } }

5. 직렬화(Serializable)

  직렬화란 객체를 입출력하기 위한 방식이다. 실제로 위까지의 예제는 모두 기본 데이터형므로 바이트의 배열형식으로 내보는 것이 그리 어려운 얘기는 아니었다. 그러나 객체를 바이트 형의 배열로 변환하는 것은 그리 간단한 얘기가 아니다.

  다행스럽게도 자바에서는 직렬화라는 방식의 객체를 바이트 배열로 변환해주는 클래스가 지원된다.

public class User {         private int number;         private String name;         private String subject;                 public User(int number, String name, String subject){                 this.number = number;                 this.name = name;                 this.subject = subject;                  }                 public void print(){                 System.out.println("번호 : "+number);                 System.out.println("이름 : "+name);                 System.out.println("학과 : "+subject);         } }

import java.io.*; public class SerialTest {         public static void main(String[] args) {                 FileOutputStream fs;                 ObjectOutputStream os;                 try{                         fs = new FileOutputStream("Serial.ser");                         os = new ObjectOutputStream(fs);                                 User ob1=new User(1, "홍길동", "컴퓨터");                     User ob2=new User(2, "이순신", "수학과");                     User ob3=new User(3, "김좌진", "전자과");                                             os.writeObject(ob1);                     os.writeObject(ob2);                     os.writeObject(ob3);                                         os.close();                 }catch(FileNotFoundException e){             }catch(IOException e){}         } }

import java.io.*; public class SerialTest {         public static void main(String[] args) {                 FileInputStream fs;                 ObjectInputStream os;                 try{                         fs = new FileInputStream("Serial.ser");                         os = new ObjectInputStream(fs);                                 User ob;                     while((ob=(User)os.readObject())!=null)                         ob.print();                                         os.close();                 }catch(FileNotFoundException e){                 }catch(ClassNotFoundException e){             }catch(IOException e){}         } }

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

1. super 키워드

  어떠한 클래스가 어떠한 부모로부터 상속받은 클래스라고 할 때, 부모 클래스를 지칭하는 키워드이다. this 키워드와 보통 비교해 설명하는데, this는 자신이 소속된 메서드를 호출하는 객체를 지칭하게 되지만, super는 자신이 소속되어 있는 클래스의 부모 클래스를 지칭하게 되는 것이다.

2. final 키워드

  final은 클래스명, 메서드명, 변수명 앞에 각각 올 수 있다. 이것은 어느 곳에 위치하느냐에 따라 의미가 달라진다.

1. 클래스명 앞에 붙는 경우     final class A{ ... }

2. 메서드명 앞에 붙는 경우     class A{         final void add(){...}         ...     }

3. 변수명 앞에 붙는 경우     class A{         final float PI=3.14;         ...     }

  1번처럼 클래스명 앞에 final이 오게되면 A라는 클래스는 더 이상 상속될 수 없음을 의미한다. 2번 같은 경우 메서드명 앞에 오게되었는데 이럴경우는 add()메서드는 더 이상 오버라이딩 될 수 없음을 의미한다. 추상 메서드는 반드시 오버라이딩이 되어야 하기 때문에 추상 메서드 앞에는 final이 올 수 없다.

  3번의 경우를 보자. 3번은 변수명 앞에 왔는데 이럴 경우에는 앞에서 얘기했던 상수화가 이루어진다. 다시 얘기하자면, 상수는 변수와 다르게 값이 변경되지 않는 수를 의미한다. 상수명은 관례상 대문자로 기술하며, 선언 후에 변경될 수 없기 때문에 선언과 동시에 반드시 초기화가 이루어져야 한다.

3. 접근제한자

  우선 이 얘기를 하기 전에 먼저 클래스와 패키지에 대한 개념부터 정립하자. 자바에서 클래스는 하나의 파일로 가정한다. 예를 들어 지금까지 클래스명과 파일명을 같게 했고, 소스 파일을 컴파일한 후에 보면 파일명과 같은 이름으로 class파일이 생성되었음을 알고 있을 것이다. 즉, 하나의 클래스는 하나의 파일로 간주하게 되는 것이고, 이 클래스들의 집합을 패키지라고 하며, 윈도우로 따지자면 파일의 집합. 즉, 폴더(디렉토리)가 되는 것이다. 이 클래스와 패키지에 대해서는 뒤에 더 따질테니 현재는 이 정도만 잡고 넘어가자.

  접근제한자의 접근 허용 범위는 public->protected->생략->private 순이다.

  public - 모든 접근에 대해 허용하며, 멤버 메서드는 대부분 public으로 선언한다.

  protected - 같은 패키지/클래스에 대해 허용.

              외부패키지라도 상속받은 자식에 대해 허용

  생략 - 같은 패키지/클래스에서만 접근 가능

  private - 같은 클래스에서만 접근 가능.

            멤버 변수를 대부분 private으로 선언한다.

            또한 뒤에서 배울 내부 클래스도 접근가능하다.

4. static 키워드

class A{     int garo;     int sero;     public static void main(String args[]){         A ob1 = new A();         A ob2 = new A();     } }

  위에서 ob1과 ob2는 각각 리턴 받는 주소가 다르다. 이것은 A의 공간이 서로 다른 주소에 생성되었기 때문이다. ob1.garo=20 했을 경우 ob2.garo의 값이 동시에 20으로 바뀌지 않는 것도 위와 같은 이유 때문이다.

  그러나 static으로 선언된 정적 멤버 변수/메서드는 그렇지가 않다. 이것들은 각각의 객체들이 값을 공유해서 사용하게 되며, 객체명으로 접근하기보다는 대부분 클래스명으로 접근하게 된다.

public class StaticEx {     private static int number=0;     private int number1=0;     public StaticEx() {         ++number;     }     public static void main(String args[]){         StaticEx ob1 = new StaticEx();         System.out.println(ob1.number+"번 객체 생성");         System.out.println(ob1.number1+"번 객체 생성");         StaticEx ob2 = new StaticEx();         System.out.println(ob2.number+"번 객체 생성");         System.out.println(ob2.number1+"번 객체 생성");         StaticEx ob3 = new StaticEx();         System.out.println(ob3.number+"번 객체 생성");         System.out.println(ob3.number1+"번 객체 생성");     } }

5. Utility API

  유틸리티 API는 유틸리티를 모아놓은 패키지를 의미하는 것이다. java.util 패키지가 바로 그것인데, 이 패키지는 유틸리티를 모아놓다보니 클래스간의 연관성을 별로 없다. 그러나 이 클래스는 JDK1.1.x부터 지원되어왔던 것이고, 대부분의 자바 플랫폼에서도 별 무리 없이 사용할 수 있을 뿐더러, 상당히 유용한 기능들을 지원하므로 한번쯤 살펴보고 진행하자.

java.util 패키지의 주요 클래스들
컬렉션 프레임워크	Vector, Stack, HashTable
	HashSet, TreeSet, ArrayList, LinkedList, HashMap, TreeMap
자원 관련	Locale, Proprties, ResoutceBundle, PropertyResourceBundle
시간, 날짜 관련	Date, GregorianCalendar
타이머	Timer, TimerTask
압축과 해제	zip.ZipInputStream, zip.ZipOutputStream zip.jar.JarInputStream, zip..jar.JarOutputStream
기타	Arrays - 배열에 대한 정렬, 탐색 등의 부가 기능들 제공
	StringTockenizer - 문자열을 토큰을 이용해서 분리

  1) Vector

    배열은 크기가 고정되어 있으며, 배열의 크기를 넘어설 수 없다. 그러나 Vector는 배열과 다르게 크기가 가변적이며, 필요시 크기를 늘려서 제한없이 사용할 수 있다. 따라서 크기를 알 수 없는 배열을 사용해야 할 경우 유리하다. 개수가 정해지지 않은 데이터를 한 곳에 모을 경우에는 편하지만 배열보다는 속도가 느리다. 벡터에서 전체 크기를 용량이라고 부르며, 저장된 객체를 합친만큼을 크기라고 부른다.

  벡터에서 원소의 저장은 add()메서드로 이루어지며 제거는 remove()메서드를 사용한다. 저장된 객체는 get(int index)를 통해 얻을 수 있는데 Object 리턴형을 가지므로 저장했던 원래의 클래스로 형변환후 사용해야 한다.

  객체를 자주 저장하거나 복원할 경우 속도를 증가시키기 위해서는 벡터를 생성할 당시 초기 크기나 증가량을 충분히 설정할 필요가 있다. 또한 많은 수의 객체를 저장하기 전에 ensureCapacity(벡터의 최소 용량) 메서드로 용량을 원하는 만큼 한꺼번에 키워주는 것도 권장한다. 용량에 여유가 있다면 버퍼에 할당하는 회수가 많이 줄어들기 때문에 속도를 높이는 한가지 방법이다.

public class User {     private int number;     private String name;     public User(int number, String name){         this.number=number;         this.name=name;     }     public void print(){         System.out.println(number+"번 이름 : "+name);     } }

import java.util.Vector; public class VectorEx {     public static void main(String args[]){         Vector v = new Vector();         User ob1 = new User(1, "홍길동");         User ob2 = new User(2, "이순신");         User ob3 = new User(3, "박문수");         User ob4 = new User(4, "김유신");         v.add(ob1);         v.add(ob2);         v.add(ob3);         v.add(ob4);                 for(int i=0;i<v.size();i++){             User ob = (User)v.get(i);             ob.print();         }             } }

  2) Hashtable

    해시 테이블은 키 값과 대응되는 값을 저장하는 구조체인 사전 기능을 구현한 클래스이다. 쉽게 생각하면 사전을 찾을때 단어를 찾아 단어의 뜻을 찾아내는 것과 같은 이치이다. 벡터는 인덱스라는 int형의 키를 가지고 있지만, 해시 테이블은 int형이 아닌 객체 자체를 키값으로 가질 수 있다는 장점이 있다.

  키 값과 대응 값이 하나씩 짝지어지는 것을 매핑이라고 하며, 해시 테이블의 매핑은 항상 한 키에 여러개의 대응되는 값이 있어서는 않된다. 만약 같은 킷값을 이용하여 저장하려고 할 경우 먼저 있던 값에 덮어씌워지는 결과를 초래하게 된다. 또한 vector와 마찬가지로 get을 하게되면 Object형으로 리턴된다. 그러므로 클래스형으로 변환하여 사용해야 한다.

  void clear() - 모든 킷값을 제거

  Enumeration keys() -  해시 테이블의 키 값을 돌려줌

  Enumeration elements() - 해시 테이블에 저장된 객체를 돌려줌

  Object get(Object key) - 주어진 키에 대응되는 값을 돌려줌

  Ojbect put(Object key, Object value) - 키와 대응하는 것을 저장한다

  int size() - 해시 테이블의 대응 관계의 개수를 리턴한다.

  3) Enumeration

    위에서 리턴형 중에 Enumeration 클래스가 존재하는데 이 클래스는 hasMoreElements와 nextElements 두 메서드를 가지고 있다. 이를 이용하면 다음의 예와 같이 객체를 모두 얻어낼 수 있다.

for(Enumeration enu=hashtable.key(); enu.hasMoreElements() ; )     Object ob = hashtable.get(enu.nextElement());

  다음의 예는 HashTable과 Enumeration 클래스를 이용하여 전화번호부를 구성한 예이다.

import java.util.Hashtable; import java.util.Enumeration; public class HTEx {     public static void main(String args[]) {         Hashtable ht = new Hashtable();         ht.put("홍길동", "3481-1001");         ht.put("박문수", "3481-1002");         ht.put("이순신", "3481-1003");         System.out.println((String) ht.get("박문수"));         for (Enumeration enu = ht.keys(); enu.hasMoreElements(); ) {             String key = (String) enu.nextElement();             String value = (String) ht.get(key);             System.out.println("Key : " + key + " Value : " + value);         }         ht.clear();     } }

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

1. 배열의 선언과 사용

  Java에서 사용하는 배열은 C에서 사용했던 것과 비슷하다.

  자료형[] 배열명 = new 자료형[];

  위와 같이 선언하게 된다. 위와 같이 선언하는 방법을 동적할당이라고 하며, 자바에서는 동적할당을 기본으로 한다. 동적할당은 일반적인 정적할당과 달리 여러 가지 장점을 가지는데 그 중 하나가 컴파일시에 주소가 결정되는 것이 아닌 실행시에 결정된다는 장점이다. 그로 인해 많은 잇점을 얻을 수 있다. 또한 배열은 여러 가지 유용한 기능을 보유하고 있는데 아래의 예를 보자

public class ObjectA{   public static void main(String args[]){     String[] A = new String[3];       A[0) = "이순신“;       A(1) =“김좌진”;       A(2) = "박문수“;       System.out.println("크기 : " +A.length);       A.sort();       for(int i=0;i<A.length;i++)         System.out.println("배열 "+i+" : "+ A[i]);   } }

    위에서보면 배열명.length라는 변수와 배열명.sort()라는 메서드가 나왔다. 앞에는 배열의 크기를 알려주는 것이고, 두 번째는 배열안에 있는 요소를 정렬시키는 메서드이다. 이 둘은 배열을 사용하면서 우용하게 사용될 것이다.

2. 클래스 선언

  객체지향 프로그래밍은 항상 클래스 정의로부터 시작된다. 클래스를 정의하게 되면 정의된 클래스는 보통 Ojbect형이라고 하며, 최상위 클래스는 Object 자료형으로부터 상속받게 된다.

public class ObjectA{   public int i; //멤버 변수   public int j; //멤버 변수   public void add(){ //멤버 메서드     int k=i+j;     System.out.println("k="+k);   } }

위와 같이 클래스가 선언되었다. 이 클래스는 ObjectA라는 이름을 가지며, ObjectA라는 자료형이 되었다. 그럼 위와 같이 클래스를 선언한다고해서 바로 사용할 수 있을까? 절대 그렇지 않다. 위와 같이 클래스를 선언했다고 해서 메모리에 할당된 것이 아니기 때문이다. 클래스를 사용하기 위해서는 객체를 선언해야 한다. 객체의 선언은

클래스명 객체명 = new 클래스명();

  혹은

  클래스명 객체명 = null;

  이라고 기술하면 된다.

  그럼 new 키워드가 하는 일에 대해서 살펴보자. new 키워드가 하는 역할은 =을 기준으로 오른쪽의 클래스 크기만큼 메모리 어딘가에 공간을 생성한 후, 객체명에게 이 주소를 리턴시켜준다. 이렇게 함으로서 객체명으로 객체의 멤버에 접근이 가능하게 된다.

public class ObjectEx{   public static void main(String args[]){     ObjectA ob = new ObjectA();     ob.i = 19;     ob.j = 20;     ob.add();   } }

3. 생성자 메서드

  그럼 위의 예에서 객체를 선언할 때 쓰이는 문장 맨 뒤를 보자.

  클래스명 객체명 = new 클래스명();

  뒤에 클래스명() 에 붙는 가로의 역할이 바로 생성자 메서드 호출이다. 위에서 new가 하는 역할은 공간 할당 후 주소 리턴이라고 했다. 그러나 한가지 역할을 더 수행하게 되는데, 이것이 바로 생성자의 호출이다. 생성자 메서드를 정의해보자.

public class Con{   public int garo;   public int sero;   public Con(int garo, int sero){       this.garo=garo;       this.sero=sero;   }   public void width(){       int wid=garo*sero;       System.out.println("넓이 : "+wid);   } }

  생성자는 위의 예제중 Con()이라는 메서드이다. 생성자 메서드의 특징은 리턴형이 없으므로, 리턴을 할 수가 없다는 것과 메서드명이 클래스명과 같다. 생성자 메서드는 객체의 초기화를 위에 대부분 사용되며, 위에서 사용된 this 키워드는 Con 메서드를 호출한 객체를 의미한다.

public class ConEx{   public static void main(String args[]){       Con ob = new Con(10, 20);       ob.width();   } }

4. 클래스 상속

  우리가 흔히 상속이라고 하면 부모의 속성을 그대로 물려받는 것을 의미한다. 객체지향 프로그래밍에서도 역시 상속은 같은 의미로 사용된다. 부모 클래스로부터 파생시킨(상속시킨) 자식 클래스는 부모 클래스의 특성을 그대로 물려받게 된다. 이 상속은 매우 중요한 개념중의 하나로, 잘 알아두기 바란다. 상속은 이미 누군가 만들어놓은 클래스를 부모 클래스로해서 물려받아 사용하기 때문에, 부모 클래스를 재사용한다는 장점과 함께 자식 클래스에서 필요한 부분은 추가로 정의하게 되기 때문에 부모 클래스에서의 확장성이 있다.

public class Base{   public int garo;   public int sero;   public Base(int garo, int sero){     this.garo=garo;     this.sero=sero;   }   public void width(){     int wid=garo*sero;     System.out.println("넓이 : "+wid);   } }

  위와 같이 부모 클래스를 만들었다. 그럼 부모 클래스로부터 상속받는 자식 클래스를 정의해보자.

public class BaseEx extends Base{   public static void main(String args[]){     BaseEx ob = new BaseEx(10,20);     ob.width();   } }

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

1. 오버로딩

오버로딩이란 메서드의 중복을 말하는데, 같은 이름으로 여러 역할을 하도록 만드는 기술이다. 예를 들어

public class Poly {     public void width(int r){         float wid=3.14f*r*r;         System.out.println("원의 넓이 : " + wid);     }      public void width(int garo, int sero){         int wid=garo*sero;         System.out.println("사각형의 넓이 : " + wid);     }     public static void main(String args[]){         Poly poly = new Poly();         poly.width(10);         poly.width(20, 10);    }

  위에서 width()를 보자. 그러면 width(r)과 width(garo, sero)가 보이는데 이 두 메서드가 오버로딩되었다고 말할 수 있는 것이다.

  만약 width(10)으로 호출하게 되면 이 10이라는 것을 받을 수 있는 int 형 중 인수가 하나이기 때문에 width 메서드 중 위에 것이 호출되게 된다. 이것은 절차지향 프로그래밍과는 달리 객체지향 프로그래밍에서는 메서드의 이름으로 메서드가 같은 지를 판단하는 것이 아닌 메서드 인수의 타입이나 개수로 판단하기 때문에 가능한 것이다.

2. 오버라이딩

  오버라이딩은 간단히 정의해서 부모 클래스에서 정의되어 있는 메서드를 같은 이름으로 다른 역할을 재정의하고 싶을때 사용하게 된다.

  객체지향 프로그래밍은 유지보수에 초점이 맞추어져 있다. 그러다보니 비슷한 역할이라는 메서드의 이름을 통일하는 것을 더욱 좋게본다. 예를 들어 넓이를 구하는 의미인데, 어떤 메서드에서는 'width'라는 이름을 사용하고 어떤 메서드에서는 '넓이'라는 이름을 사용하면 나중에 같은 의미지만 헤메이게 될 소지가 있기 때문이다. 그러면 아래의 예를 보자.

public class Poly {     private int garo;     private int sero;     public Poly(int garo, int sero) {         this.garo=garo;         this.sero=sero;     }     public void width(){         int wid=garo*sero;         System.out.println("사각형의 넓이 : " + wid);     } }

public class Tri extends Poly {     public Tri(int garo, int sero) {         this.garo = garo;         this.sero = sero;     }     public void width() {         float wid=garo*sero*0.5f;         System.out.println("삼각형의 넓이 : " + wid);     }     public static void main(String[] args) {         Tri tri = new Tri(20, 10);         tri.width();     } }

  위의 예에서 보듯, 부모에 있는 width는 사각형을 구하기 위한 메서드였다. 그러나 Poly로부터 상속받은 Tri에서는 삼각형을 구하고자 했다. 그렇기 때문에 width라는 이름으로 넓이를 통일시키고자 Poly의 width를 Tri에서 재정의를 통해 구현한 것이다.

3. 추상 클래스

  추상 클래스는 선언만 되어 있고, 구현은 되어 있지 않은 메서드를 추상 메서드라고 하는데 추상 메서드를 하나라도 포함하게 되는 클래스를 추상클래스라고 한다. 추상메서드와 클래스는 항상 abstract라는 키워드를 붙여 줌으로서 선언하게 된다. 그럼 추상 클래스를 왜 사용해야할까? 아래의 예를 보면서 얘기해보자.

public abstract class Poly {     int garo;     int sero;     public abstract void width(); }

  우리는 Poly 클래스에 이미 가로와 세로가 선언되어져 있고, 사각형의 넓이를 구할 수 있는 메서드가 정의되어 있다는 것을 알고 Poly를 이용해서 사각형 뿐만이 아닌 삼각형의 넓이도 구하려고 한다. 그런데 Poly에서는 삼각형과 사각형의 공식이 서로 틀려 어떻게 구현되어야 할지 감을 잡을 수가 없다. 그렇기 때문에 상속받는 자식에서 구현하라는 의미로 우리는 여기서 선언만 되어 있는 width를 선언하게 된것이다. 그리고 abstract라는 키워드가 메서드와 클래스의 앞에 각각 붙어져 있는 것을 확인할 수 있다.

  가장 중요한 것은 추상 클래스로부터 상속받는 클래스에서는 추상 메서드는 반드시 오버라이딩 시켜서 사용해야 한다는 것이다. 그럼 상속받은 삼각형과 사각형 클래스를 각각 정의해보자.

public class Tri extends Poly {     public Tri(int garo, int sero) {         this.garo=garo;         this.sero=sero;     }     public void width(){         float wid=garo*sero*0.5f;         System.out.println("삼각형의 넓이 : " + wid);     }     public static void main(String[] args) {         Tri tri = new Tri(20, 10);         tri.width();     } }

public class Rect extends Poly {     public Rect(int garo, int sero) {         this.garo=garo;         this.sero=sero;     }     public void width(){         int wid=garo*sero;         System.out.println("사각형의 넓이 : " + wid);     }     public static void main(String[] args) {         Rect rect = new Rect(20, 10);         rect.width();     } }

4. 인터페이스

  자바에서는 원칙적으로 다중 상속을 금하고 있다. extends 키워드로는 두 개 이상의 클래스로부터 상속받을 수 없다는 의미이다. 그러나 다중 상속을 꼭 해야하는 경우가 있다. 이럴때 사용할 수 있는 것이 인터페이스이다. 인터페이스는 추상메서드와 변수가 아닌 상수만을 소유할 수 있다. 인터페이스에서 변수를 선언하게 되면 상수화되기 때문에 상수 선언시 값초기화를 해주어야 한다. 또한 인터페이스로부터 상속받을 때는 extends 키워드가 아닌 implements 키워드를 사용한다. 역시 인터페이스에 있는 추상메서드도 반드시 오버라이딩 시켜야 하며, 추상 메서드라고 해서 abstract를 붙이지는 않는다.

public interface Poly {     float PI=3.14f;     public void width(int r); }

public class Circle implements Poly {     public void width(int r) {         float wid = 3.14f * r * r;         System.out.println("원의 넓이 : " + wid);     }     public static void main(String[] args) {         Circle circle = new Circle();         circle.width(10);     } }

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

5.1.1 추상클래스의 개념

Abstract클래스는 빈 깡통 클래스입니다. abstract클래스는 구현이 덜 되었거나 또는 아직은 미완성 클래스이기 때문에 우리는 이 클래스를 추상 클래스라 부릅니다. 어디가 미완성일까요? 미완성 메서드를 포함하고 있기 때문에 클래스자체가 미완성이 되는 것입니다. 미완성 메서드는 어디가 미완성일까요? 메서드의 몸체가 없습니다. 몸체 없는 메서드, 이를 우리는 추상 메서드라 부릅니다. 그리고 이 추상 메서드를 단 하나라도 포함하고 있는 클래스를 추상 클래스라고 합니다.

 

 

5.1.2 추상클래스와 추상메서드

 추상클래스는 미완성 클래스이기 때문에 약점이 있습니다. 완전한 클래스가 아니기 때문에 절대 객체를 생성하지 못합니다. 당연한 것 아니겠습니까? 완성되지 않은 클래스이니 객체를 만들 수 없다는 것은 이치에 합당합니다. 이 미완성 클래스를 어디에 사용할까요? 사용방법은 다음과 같습니다.(이해하기 편하게 추상클래스를 추상아버지클래스, 이를 상속 받는 클래스를 아들클래스라고 하겠습니다. )

 

n        추상아버지 클래스는 추상 메서드를 가지고 있습니다.

n        아들 클래스는 추상 아버지클래스로부터 상속 받습니다.

n        아들은 추상 아버지 클래스의 몸체 없는 메서드를 모두 메서드 재정의와 같이 다시 만듭니다. 이것을 우리는 구현한다고 말합니다. 몸체를 달아 주는 것입니다.

n        아들 클래스는 완성된 클래스이기 때문에 객체를 생성할 수 있습니다.

 

 다음은 추상 메서드를 만드는 방법을 보여 주고 있는 예입니다.

추상 메서드를 만드는 방법

abstract class 클래스이름 { abstract 메소드선언;        // 메소드의 몸체는 없음 abstract 메소드선언;        // 메소드의 몸체는 없음 }   예)   public abstract class AbstractTest {    public abstract void abstractMethod(); }

 

메서드에 몸체가 붙지 않는다면 여러분은 반드시 abstract키워드를 붙여야 합니다. 그리고 이 abstract메서드를 하나라도 포함하고 있다면 클래스명 앞에 abstract를 붙여야 합니다. 안 붙이면 언제나 그런 것처럼 친절하게 에러를 발생 시킵니다. 아래의 에러는 추상클래스내에 추상 메서드에 abstract를 붙이지 않았을 때 발생하는 에러입니다.

 

C:\examples\5. Class for Polymorphism Java>javac AbstractTest.java AbstractTest.java:2: missing method body, or declare abstract         public void abstractMethod();                     ^ 1 error

 

아주 간단하죠. 추상 클래스는 그 자체로는 객체를 생성할 수 없다는 것을 한번 더 밝혀 두며 실제 이용하는 가장 간단한 예를 보도록 하겠습니다.

 

NewCan.java(추상 메서드를 만드는 방법)

public class NewCan extends EmptyCan{              public void sound(){                            System.out.println("EmptyCan:빈깡통은 소리가 요란하다");              }              public void who(){                            System.out.println("EmptyCan:나는 빈깡통입니다.");              }              public void sayHello(){                            System.out.println("NewCan:추상클래스 테스트입니다.");              }              public static void main(String args[]) {                            NewCan ecm = new NewCan();                            ecm.who();                            ecm.sound();                            ecm.sayHello();              } }

Empty.java(추상클래스)

public abstract class EmptyCan{      public abstract void sound();//몸체없음    public abstract void who();//몸체 없음   }

C:\examples\5. Class for Polymorphism Java>javac NewCan.java   C:\examples\5. Class for Polymorphism Java>java NewCan EmptyCan:나는 빈깡통입니다. EmptyCan:빈깡통은 소리가 요란하다 NewCan:추상클래스 테스트입니다.

 

추상클래스는 객체가 가지는 특성들을 추상화시켜 놓았을 뿐, 아직 구체화 시키지 못한 클래스이므로, 이 추상클래스를 상속하는 하위클래스에서 좀 더 구체화 시키도록 하는 방법을 사용합니다. 주의 할 것은 추상 메서드를 하나도 빼지 말고 전부 구현 해야 객체를 생성할 수 있습니다. 아들이 상속을 받아서 추상 메서드를 하나라도 남겨 두었다면 아들도 추상클래스가 됩니다. 부전자전이죠. 다음은 상속을 했지만 추상 메서드를 전부 구현 하지 않았다면 abstract클래스가 되는 것을 증명하는 예제입니다.

 

CompleteCan.java(추상 메서드를 만드는 방법)

public class CompleteCan extends IncompleteCan{              public void who(){                            System.out.println("EmptyCan:나는 빈깡통입니다.");              }              public void sayHello(){                            System.out.println("NewCan:추상클래스 테스트입니다.");              }              public static void main(String args[]) {                            CompleteCan cc = new CompleteCan();                            cc.who();                            cc.sound();                            cc.sayHello();              } }

Incomplete.java(추상클래스)

public abstract class IncompleteCan extends EmptyCan{              public void sound(){                            System.out.println("EmptyCan:빈깡통은 소리가 요란하다");                  } }

Empty.java(추상클래스)

public abstract class EmptyCan{      public abstract void sound();//몸체없음    public abstract void who();//몸체 없음   }

C:\examples\5. Class for Polymorphism Java>javac EmptyCan.java C:\examples\5. Class for Polymorphism Java>javac IncompleteCan.java C:\examples\5. Class for Polymorphism Java>javac CompleteCan.java C:\examples\5. Class for Polymorphism Java>java CompleteCan EmptyCan:나는 빈깡통입니다. EmptyCan:빈깡통은 소리가 요란하다 NewCan:추상클래스 테스트입니다.

 

추상메소드는 추상클래스와 마찬가지로 아직 구현이 이루어지지 않고 단지 그 메서드의 이름만 가지고 있다는 뜻입니다. 그래서 몸체가 없다고 말하고 있는 것입니다. 이것을 역으로 말한다면 추상메서드가 되려면 몸체가 없어야 한다라는 명제를 얻을 수 있습니다. 보통 우리가 전문적인 용어로 이야기 할 때 추상메서드는 메서드의 프로토타입만 가지고 있다라고 이야기 합니다. 

 

 

5.1.3 클래스의 구조를 디자인하기 위한 추상 클래스

 추상클래스는 클래스의 구조를 잡기 위한 방법으로 사용됩니다. 하나의 클래스를 만든다고 가정한다면 하나의 클래스에 모든 것을 전부 넣을 수는 없습니다. 이러한 방법은 별로 좋지 않은 방법이죠. 클래스가 크다고 가정한다면 작업별로 클래스를 쪼개게 됩니다. 작업을 분할 하는 것은 수평적인 개념에서 비슷한 작업끼리 묶는 것입니다. 유유상종(類類相從)이라는 말이 적당할 것 같군요. 비슷한 작업끼리 묶어서 작업별 클래스를 만드는 것입니다.

 

저 또한 초보시절의 자바 프로그램은 비슷한 작업을 묶는 것으로 시작했습니다. 하지만 수평적으로 묶는 것 조차도 작업의 설계와 분석을 해야만 이루어지는 아주 어려운 일입니다. 이 단계를 거치고 나면 작업을 레벨단위로 묶는 것을 생각하게 됩니다. 거의 1년 이상 걸리더군요. 제가 머리가 나빠서 그런지도 모르겠지만 개인적으로는 상당히 어려운 일이었습니다. 레벨 단위의 작업으로 발전하기까지는 상당히 많은 시간과 생각이 필요한 것 같습니다. 작업을 단계별로 만들어 주는 역할을 하는 것이 바로 추상 클래스의 역할입니다.

레벨 단위의 구조를 살펴 보도록 하죠.

위의 그림은 도형을 그리기 위한 클래스를 디자인 하고 있습니다. 모든 클래스에서 공통되는 작업을 상위레벨에 놓고 그 클래스를 상속 받아 각각의 다른 클래스로 분류되어지고 있습니다. 상위레벨에 존재하는 작업은 구현할 필요성이 없다고 생각하여 abstract으로 만듭니다. 즉, 하위레벨에서 구현하겠다는 것입니다. 이렇게 하였을 때의 코드를 직접 만들어 보겠습니다. 물론 Shape클래스는 abstract으로 만들어질 것이며 그 하위의 Circle, Triangle, Rectangle은 모두 Shape의 abstract메서드를 구현 할 것입니다. 구현은 대충 아래와 같이 되어 질 것입니다.

 

FigureTest.java(abstract의 레벨기법을 테스트하기 위한 예제)

abstract class Shape {              public abstract void draw();              public abstract void delete(); } class Circle extends Shape {              public void draw(){                            System.out.println("원을 그립니다");                         }              public void delete(){                            System.out.println("원모양을 지웁니다");                   } } class Triangle extends Shape {              public void draw(){                            System.out.println("삼각형을 하나, 둘, 셋, 그립니다.");                        }              public void delete(){                            System.out.println("삼각형을 지웁니다");                   } } class Rectangle extends Shape {              public void draw(){                            System.out.println("사각형을 원, 투, 쓰리, 포 그립니다.");                   }              public void delete(){                            System.out.println("사각형을 지웁니다");                   } } //abstract을 테스트하기 위한 클래스 public class FigureTest{              public static void main(String[] args){                            Circle c = new Circle();                            Triangle t = new Triangle();                            Rectangle r = new Rectangle();                            c.draw();                            t.draw();                            r.draw();                            c.delete();                            t.delete();                            r.delete();              } }

C:\examples\5. Class for Polymorphism Java>javac FigureTest.java C:\examples\5. Class for Polymorphism Java>java FigureTest 원을 그립니다 삼각형을 하나, 둘, 셋, 그립니다. 사각형을 원, 투, 쓰리, 포 그립니다. 원모양을 지웁니다 삼각형을 지웁니다 사각형을 지웁니다

 

상속과 abstract을 설명하기 위해서 어디서나 흔히 볼 수 있는 예제입니다. 이 간단한 예제가 무엇을 의미하는지 제대로 안다면 자바의 강력한 힘을 발휘할 수 있습니다. 클래스의 수평적인 작업 분할과 수직적인 작업 분할을 동시에 이용한다면 여러분은 아주 효율적인 코드를 작성할 수 있습니다. 재사용성 100%와 유지, 보수, 관리 능력까지 갖춘 잘 설계된 프로그램을 하실 수 있을 것입니다.

 

 

5.1.4 결론

추상클래스에 대하여 정리 해 보죠.

 

n         추상 메서드는 몸체 없는 프로토타입만을 가진 메서드입니다.

n         추상 메서드는 반드시 메서드이름 앞에 abstract 키워드를 명시해야 합니다.

n         추상 메서드를 단 하나라도 포함하고 있으면 이를 추상 클래스라고 합니다.

n         추상 클래스는 클래스이름 앞에 abstract를 명시해야 합니다.

n         상속을 이용하여 추상 메서드를 모두 구현한 뒤, 객체를 생성할 수 있습니다.

 

일반적인 특징은 이러하지만 추상클래스의 뒷면에 존재하는 느낌은 수직적인 작업의 분할이라는 아주 무서운 개념이 숨어 있습니다. 프로그램을 하면서 어떻게 계층적으로 프로그램을 할지를 결정하지말고 펜을 들고 작업을 분석하는 것이 옳을 것입니다. 그리고 작업 분석이 끝났다면 수직과 수평의 개념을 적용 시켜서 어느 정도 설계를 하는 것이 옳을 것입니다. 하지만, 기본적인 배경 없이는 아무것도 할 수 없으니 지금은 느낌을 얻으시기 바랍니다.

 

여러분이 클래스를 만들고 시간이 지나서 다시 여러분이 만든 클래스를 볼 기회 있을 것입니다. 절대 같은 디자인의 클래스는 만들 수 없습니다. 물론, 클래스를 만드는 기법은 비슷하지만 같은 디자인으로는 프로그램을 하려고 해도 잘 되지 않습니다. 약간의 시간이 지난 후, 과거와 현재를 비교해 보면 여러분 스스로 진화했다는 말을 사용해도 될 만큼 아주 많은 발전을 이룬 것을 볼 날이 있을 것입니다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

final 키워드는 대개 정적인 방식으로 많이 쓰입니다. 예를 들어 클래스 상수로 쓰이거나, 클래스의 상속이나 메소드 재정의(overriding)을 막기 위해서 자주 사용되죠.

상대적으로 잘 쓰이지 않지만, 초기화 이후에 값을 바꿀 수 없는 변수를 만드는 동적인 용도로도 사용이 가능합니다. 자바 언어 레퍼런스를 보면 다음과 같이 내용이 있습니다:

C나 C++에 const라는 키워드가 있는데 변수에 대해서는 final보다 const가 더 적절한 이름이라고 생각합니다. 하지만, 클래스나 메소드 정의에 부여하는 경우는 final이 아주 좋다고 생각합니다.

배열을 인자로 받아서 합계를 내는 함수가 있다고 해보죠.

이 경우 어떤 이유에서건 아래와 같이 구현된다면 해당 메소드를 사용자 입장에서는 의도하지 않은 결과를 접하게 될 가능성이 높습니다.

간단한 예를 통해서 보면 완전히 어리섞은 구현이긴 합니다. 하지만, 테스트가 없이 장문의 타이핑을 하는 환경에서는 이와 유사한 일이 일어나지 말라는 법은 없습니다.

이와 같이 정의해주면 적어도 a에 새로운 할당을 시도할 수 없게 됩니다.

3 + 4 = ?

위와 같이 더하기라는 연산을 할 때 피 연산자인 3과 4는 변하지 않습니다. 3과 4가 변한다면 사람들은 위험해서(?) 덧셈을 하지 않겠죠. :)

sum()에 인자로 제공해주는 것은 피연산자와 같습니다. 의미적으로 상수가 전달되어야 하는 경우라고 할 수 있죠. 이럴 때 final을 붙여주면 보다 의미가 명확해질 수 있습니다.

아래와 같은 구문에 왜 final을 쓰면 안되느냐는 질문을 받은 일이 있습니다.

자칫 범하기 쉬운 오류지만, result라는 변수의 용처를 명확하게 정립해보면 논리적인 오류임을 알 수 있습니다. result는 말 그대로 임시 저장소입니다. 지역 변수(local variable)은 임시(temp/temporary) 변수라고 하는데 딱 어울리는 용도로 사용한 것이죠.

세로 타원으로 그린 것이 for 문의 실행시의 논리적인 영역을 나타냅니다. 문맥(context)이라고 할 수도 있겠죠.  반복이 진행되면서 우측으로 이동하기 때문에 배열의 요소들의 이전 값을 기억하기 위해서는 별도의 저장소가 요구됩니다. 어떤 프로그래밍 언어를 배우거나 초기에 익히는 것이지만, 논리적으로 이러한 그림을 머리속에 그릴 수 있다면 더욱 복잡한 경우를 포용할 때 매우 유리합니다.

위와 같은 경우 a[0]의 값이 temp에 들어가 있어야 하고, 반복이 한 차례 더 수행되면 temp 값에 a[1]을 더한 값이 다시 할당되어져야 하니 final로 정의하는 것은 실수죠.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

클래스는 크게 일반클래스와 추상클래스로 나뉘는데 추상클래스는 본문중에 '추상메소드'가 하나 이상 포함되는 경우를 말합니다. 인터페이스는 모든 메소드가 추상메소드인 경우 선언하는 경우가 많습니다.

추상메소드라 함은 메소드의 선언부만 있고 본문이 없는 것을 말합니다. 여기서 본문은 중괄호({})로 묶여진 몸체(body)부분을 말하는데 중괄호 안이 비어있더라도 이것이 존재한다면 그것은 추상메소드가 아닙니다. 추상메소드의 선언의 예는 다음과 같습니다.

abstract public void test( int a );

즉, 메소드의 선언 후에 세미콜른(;)만을 찍어 이를 선언만 하고 구현은 자식클래스에서 하게 하는 방법입니다. 일반 클래스의 경우 상속받은 자식클래스가 반드시 부모클래스의 메소드를 '오버라이딩(overriding)'할 필요가 없지만 추상클래스를 상속받은 자식클래스는 반드시 추상메소드를 오버라이딩하여야 하기에 메소드를 강제로 구현하게 할 때 많이 쓰입니다.

추상클래스와 인터페이스의 가장 큰 차이점은 바로 '클래스'냐 아니냐의 차이입니다. 추상클래스는 엄연한 클래스로 이를 구현하는 것은 '상속(extends)'입니다. 그러나 인터페이스는 '포함(implements)'라는 키워드를 통해 구현하게 되는데 이는 자바에서 매우 중요한 차이를 가집니다.

자바는 오로지 '단일 상속'만을 지원하기 때문에 추상클래스를 상속받는 클래스는 다른 클래스를 상속받을 수 없습니다. 그러나 인터페이스를 포함하는 클래스는 다른 클래스를 상속받을 수 있습니다.

추상클래스는 일반클래스와 달리 그 자신을 new 명령어를 통해 객체를 생성할 수 없습니다. 그러나 '다형성(polymorlphism)'을 통해 자식 클래스의 객체를 생성할 수는 있습니다.

인터페이스를 쓰는 가장 큰 이유는 다중상속을 지원하지 않는 자바에서 다중상속의 장점을 가져오기 위해서입니다. 다중상속이 가지는 단점은 배제하고 오직 장점만을 취하기 위해 인터페이스를 쓰는 것입니다.

상속이란 개념은 부모클래스의 속성과 메소드를 자식클래스가 물려받는다는 것인데 쉽게 예를 들면 '자동차'라는 클래스는 '색깔', '배기량' 등의 속성과 '기름을 넣는다', '달린다' 등의 메소드를 가질 수 있습니다. 이 클래스를 상속하는 '승용차' 클래스는 별도로 선언하지 않아도 부모클래스의 '색깔', '배기량'이라는 속성과 '기름을 넣는다', '달린다'라는 메소드를 가지게 되죠.

추상클래스는 이 부모클래스가 단순히 관념적인 성격이 강할 때 많이 쓰이는데 예컨데 '새'라는 클래스는 그냥 '난다'라는 메소드를 가지지만 새의 종류에 따라 나는 방법이 조금씩 틀려 자식클래스에서 어차피 구현해야 될 부분이므로 굳이 부모클래스에서 그 내용을 구현할 필요가 없기 때문에 사용합니다.

요사이 추세는 굳이 클래스간의 조직을 표현할 필요가 없을 경우는 추상클래스를 쓰는 대신 인터페이스를 쓰는 경우가 많습니다. 인터페이스는 위에서 말씀드린바와 같이 모든 메소드가 추상메소드라서 이를 포함하는 클래스는 이들을 모두 구현해야 합니다.

추상메소드는 멤버변수(어트리뷰트)를 가지지만 인터페이스는 오직 '상수'만을 가질 수 있습니다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

■ Enumeration인터페이스

   벡터와 같이 객체들을 모아 놓은 집합에서 객체들을 하나씩 처리할 수 있는 메소드를 다음

   과 같이 제공한다.

    - boolean hasMoreElements()

       벡터에 요소가 있으면 true, 없으면 false를 반환한다.
   - Object nextElement()
       벡터에서 다음의 요소를 반환한다.
 
 
ExecuteEnumeration.java
 
import java.util.*;
class ExecuteEnumeration
{
   public static void main(String args[]){
      int j;
      Vector v=new Vector();
      for(j=0; j<args.length; j++)
         v.addElement(args[j]);
// java ExecuteEnumeration  Head     Title     100     30.5

//  ┌---------------------------------------------------┐

//  ㅣ Head ㅣ Title ㅣ 100 ㅣ 30.5 ㅣ  ㅣ   ㅣ  ㅣ   ㅣ   ㅣ   ㅣ

//  └---------------------------------------------------┘

//        ↑

//        v

      Enumeration enu = v.elements();

//  ┌----------------------------┐

//  ㅣ Head ㅣ Title ㅣ 100 ㅣ 30.5  ㅣ

//  └----------------------------┘

//        ↑

//     v=enu

      for(j=0; enu.hasMoreElements(); j++)
         System.out.println("Vector "+j+"번째 요소는 "+enu.nextElement());

// for문을 while문으로 고쳤을 경우,

//   j = 0;

//   while(enu.hasMoreElements()){

//           System.out.println("Vector "+j+"번째 요소는 "+enu.nextElement());

//    j++;

//    }
   }
}

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

  == 는 주로 primitive data type간의 비교를 위해 사용합니다.
 예를 들어
int x = 1;
int y = 1;
일 경우 x == y 는 참이 됩니다.

 하지만 두 객체를 비교 했을 경우 == 는 가리키고 있는 객체의 레퍼런스 값이 같아야 참의 값이 나옵니다.

 반면 equals() 메서드는 값의 비교가 아닌 내용상의 비교이기 때문에
 해당 객체의 내용이 같다면 레퍼런스하고 있는 위치(주소값)이 달라도 원래 의도하신대로 같은 값을 얻을수 있습니다.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

String s1 = "하하하";
String s2 = "하하하";
String s3 = new String("하하하");
String s4 = new String("하하하");

equals는 객체가 가지고 있는 내용을 비교하기 위한 메소드이며
==는 객체가 같은지 다른지 비교하는 비교연산자

if(s1 == s2)           // true
if(s1 == s3)           // false
if(s1.equals(s2))   // true
if(s3 == s4)           // false
if(s3.equals(s4))   // true

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

●벡터(Vector)

   1. 대용량의 데이터를 효과적으로 다룰 수 있는 클래스

   2. 용량의 변경이 용의

   3. 벡터에 저장하는 모든 데이터는 Object타입

   4. 어떤 종류의 객체도 함께 담을 수 있다.

   +++ 배열의 크기를 한번 정해지면 변경 불가하고 같은 종류의 데이터만

        사용할 수 있다는 단점 보안

 

벡터 생성자

   1. Vector :  초기용량이 10, 용량 초과시 크기를 두배 씩 증가

   2. Vector(int aaa) : 지정한 크기의 용량으로 초기화된 Vector 객체를 생성한다.

   3. Vector(int aaa, int bbb) : 지정한 크기의 용량으로 초기화된 벡터객체를 생성하고

                                          용량 초과시 bbb만큼 증가 시킨다.

※ 일반적으로 용량의 문제가 거의 발생하지 않기 때문에 보통 인자가 없는

    생성자를 사용하여 벡터 객체를 생성한다.      Vector v = new Vector();

 

●벡터에 객체 저장

  메소드

   1. void add(int index, Object object) - 지정한 인덱스의 위치에 객체를 추가함

   2. void addElement(Object objec) - 벡터의 끝에 객체를 추가한다

        Vector v = new Vector();

        v.add(1, "은주");             //지정한 위치에 객체 추가

        v.addElement("현규");     //마지막에 객체 추가

        v.addElement("수미");     //마지막에 객체 추가

 

●벡터로 부터 객체 삭제

  메소드

1.       Object remove(int index) – 지정한 위치의 객제를 벡터에서 제거

2.       boolean remove(Object object) – 지정한 객체를 벡터에서 제거

3.       void clear() – 벡터의 모든 요소를 제거

예) Vector v = Vector();            //벡터 생성

   v.remove(3);                        //지정한 위치의 객체 제거

   v.remove(“은주”);            //지정한 객체 제거

   v.clear();                        //벡터의 모든 요소를 제거

 

●벡터로 부터 객체 검색

  메소드

1.       Object elementAt(int index) – 지정한 위치의 객체를 리턴

2.       Object get(int index) – 지정한 위치의 객체를 리턴

※ 벡터에 요소를 추가할 때는 String형을 그대로 사용할 수 있지만 검색한 결과는 Object형이므로 사용하기 위해서는 원래 데이터형으로 캐스팅해야 한다.

예) Vector v = Vector();                        //벡터 생성

   String s = (String)v.elementAt(0);            //지정한 위치의 객체를 리턴

   String s2 = (String)v.get(1);                   //지정한 위치의 객체를 리턴

   Enumeration e = v.elements();            //Vector의 요소의 리스트를 리턴

    ^{Iterator과 비슷한 역할(저장 객체 추출)}

 

 

●벡터의 기타 메소드

1.      int capcity() – 벡터의 현재 용량의 리턴

2.      boolean contains(Object object) – 주어진 요소가 벡터에 있는지 알아낸다.

3.      int indexof(Object object) – 주어진 요소의 위치를 리턴(없으면 -1)

4.      int size() – 벡터에 포함되어 있는 요소의 수를 리턴

5.      void trimToSize() – 벡터의 용량을 현재 벡터의 크기에 맞게 수정

 

●Enumeration

벡터에 저장된 객체를 열거형으로 리턴

  Enumeration e = v.elements();               //Vector의 요소의 리스트를 리턴

     While(e.hasMoreElements()) {

    System.out.println(e.nextElement());

}

 

●Iterator

Collection에 저장된 객체를 나열 또는 열거하기 위한 인터페이스

  Iterator ie = v.iterator();         //Vector의 요소의 리스트를 리턴

  While(ie.hasNext()){

    System.out.println(ie.next());

}

 

● Stack

1.      Object를 저장하는 하나의 방법

2.       가장 나중에 들어간 데이터가 가장 먼저 밖으로 나오는 형태

LIFO(Last In First Out)

예) import java.util.*;

public class StackTest{

public static void main(String[] args){

      Stack s = new Stack();

      System.out.println(s.empty());           //스택이 비어있는지 확인 true

      s.push(“은주”);           //데이터 넣기

      s.push(“현규”);

      System.out.println(s.empty());           //false

      System.out.println(s.peek());   //가장 먼저 나올 데이타(은주)

      System.out.println(s.pop());           //스택에 저장 되어 있는 차례로 출력

      System.out.println(s.pop());

      System.out.println(s.empty());            //스택이 비어있는지 확인 true

}

}

 

●LinkedList

1.      List 인터페이스의 링크 리스트의 구현

2.      void add(int index, Object element) – 지정된 위치에 지정된 요소 삽입

void addLast(Object element) – 리스트의 마지막에 지정된 요소 추가

Object get(int index) – 지정된 위치에 있는 요소 리턴

Object getLast() – 리스트내의 마지막 요소 리턴

Object remove(int index, Object element) – 지정된 위치에 있는 요소 삭제

3.      데이터의 첨가, 삭제가 편리하고 속도가 빠르다.

 

● Map & hashing

키와 값의 쌍으로 이루어진 요소를 저장하는 자료구조

해싱이란 키객체를 처리하여 hash code(정수값)를 만들어 내는 방법이다.

 

●HashMap

Null허용, Map interface를 implements한 클래스

 

●Hashtable

Null 허용하지 않음, Map interface를 implements한 클래스

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.