Bibliothek

// 인터페이스 A
interface ADemo
{
	public void write();
	//public abstract void write();
}

// 인터페이스 B
interface BDemo
{
	public void print();
	//public abstract void print();
}

 ※ 인터페이스는 2개 이상을 구현(implements)할 수 있다.
    → 클래스가 다중 상속이 되지 않는 부분을 보완(보충)하는 개념

// 클래스
//class DemoImpl
//class DemoImpl extends ADemo, BDemo 불가능
//class DemoImpl implements ADemo, BDemo
//		↓
// 추상 클래스 - 두 인터페이스를 구현한 추상 클래스
//abstract class DemoImpl implements ADemo, BDemo
//		↓
// 클래스 - 두 인터페이스를 구현한 추상 클래스
class DemoImpl implements ADemo, BDemo
{
	/*
	public void write();
	public void print();
	*/
	
	// JDK 1.5(5.0)에서는 인터페이스 메소드를 
	// 오버라이딩(Overriding)할 때
	// 『@Override』 어노테이션(annotation)을 사용할 수 없다.
	// JDK 1.6(6.0) 이후부터 적용 가능한 문법이다.
	// 단, 상속받은 클래스의 메소드를 오버라이딩(Overriding)할 때에는
	// JDK 1.5(5.0)에서도 『Override』 어노테이션(annotation) 사용이 가능하다.
	@Override
	public void write()
	{
		System.out.println("ADemo 인터페이스 메소드 write()...");
	}

	@Override
	public void print()
	{
		System.out.println("BDemo 인터페이스 메소드 print()...");		
	}
}

클래스 - main() 메소드를 포함하는 외부의 다른 클래스(동일 패키지)

public class Test123
{
	public static void main(String[] args)
	{
		//ADemo ob = new ADemo();	//-- 인터페이스 → 인스턴스 생성 불가
		//BDemo ob = new BDemo();	//-- 인터페이스 → 인스턴스 생성 불가
		
		// ADemo, BDemo 인터페이스를 구현(implements)한 클래스
		// (→ DemoImpl)
		// 기반의 인스턴스 생성
		DemoImpl ob1 = new DemoImpl();

		ob1.write();
		ob1.print();
		//--==>>ADemo 인터페이스 메소드 write()...
		//		BDemo 인터페이스 메소드 print()...


		ADemo ob2 = new DemoImpl();		//-- 업 캐스팅
		BDemo ob3 = new DemoImpl();		//-- 업 캐스팅

		//ob2.print();	//--==>> 에러 발생
		//ob3.write();	//--==>> 에러 발생

		ob3.print();
		ob2.write();
		//--==>> BDemo 인터페이스 메소드 print()...
		//		 ADemo 인터페이스 메소드 write()...
	
		((BDemo)ob2).print();
		((ADemo)ob3).write();
		//-- DemoImpl 클래스가 두 인터페이스를 모두 구현했기 때문에 가능하다.
		//   만약 DemoImpl 클래스가 이들 중 한 인터페이스만 구현했다면
		//   이 구문은 런타임 에러 발생하는 구문이 된다.
		//--==>> BDemo 인터페이스 메소드 print()...
		//		 ADemo 인터페이스 메소드 write()...

		// ○ 다운 캐스팅
		((DemoImpl)ob3).write();
		//--==>> ADemo 인터페이스 메소드 write()...

	}
}

○ 인터페이스(Interface)란
   완전히 미완성된 채로 남겨져 인터페이스 안에 존재하는 그 어떤 메소드도 몸체(정의부, 구현부)가 없기 때문에 사실상 실행 부분이 존재하지 않는다. 클래스를 위한 템플릿으로써의 기능을 수행하는 추상 클래스의 한 종류이다.

○ 인터페이스는 클래스와 달리 다중 상속이 가능하며 인터페이스 자체도 상속된다.
   기존의 C++ 언어 등에서 지원되는 다중 상속이 사용 과정에서 많은 문제점을 노출시켰기 때문에 자바에서는 다중 상속의 개념을 인터페이스라는 개념으로 변형하여 인터페이스를 통해 다중 상속을 구현하는 방법을 지원한다.

○ 인터페이스는 상수와 추상 메소드만 가질 수 있으며 인터페이스 안의 메소드들은 접근제어지시자를 명시하지 않아도
   『public』 으로 설정되어 클래스에서 구현(implements)함으로써 바로 접근이 이루어질 수 있다.

○ 특징
   - 추상 클래스의 일종으로 선언만 있고 정의가 없다.
   - final 변수는 가질 수 있다. (상수의 개념)
   - 인터페이스는 『public static final』 상수만 만들 수 있다.
   - 인터페이스를 구현하기 위해서는 『extends』 대신에
     『implements』를 이용한다.
   - 하나 이상의 인터페이스를 implements 할 수 있다.
   - 인터페이스를 implements 한 클래스는 
     인터페이스의 모든 메소드를 Overriding 해야 한다.
   - 인터페이스가 다른 인터페이스를 상속받을 수 있으며
     이 때, 『extends』 키워드를 사용한다.
 또한, 클래스와 달리 인터페이스는 다중 상속이 가능하다.

/*===========================
  ■■■ 클래스 고급 ■■■
  - 인터페이스(Interface)
=============================*/

// 인터페이스
interface Demo
{
	public static final double PI = 3.141592;

	// 인터페이스의 멤버 변수는 
	// 『static final』 을 별도로 명시하지 않아도
	// 자동으로 『static final』 인 상태~!!!
	public int a = 10;
	
	// 인터페이스의 메소드는 선언만 가능(정의, 구현 불가)
	// 자동으로 『abstract』인 상태~!!!
	//public abstract void print();
	public void print();
	/*
	public void print()
	{
		System.out.println("PI : " + PI);
	}
	*/
}

// 클래스
//class DemoImpl
//class DemoImpl extends Demo 
//class DemoImpl implements Demo
//			↓
// 추상 클래스 - 인터페이스를 구현하는 추상 클래스
//abstract class DemoImpl implements Demo
// 클래스 - 인터페이스를 구현하는 클래스
class DemoImpl implements Demo
{
	@Override
	public void print()
	{
		System.out.println("인터페이스 메소드 재정의...");
	}
	
	public void write()
	{
		System.out.println("클래스에 정의된 메소드");
	}
}



// 클래스 - main() 메소드를 포함하고 있는 외부 클래스(동일 패키지)
public class Test122
{
	public static void main(String[] args)	
	{
		//Demo ob = new Demo();		//-- 생성 불가~!!!
		//-- 인터페이스를 가지고 인스턴스 생성을 하는 것은 불가능하다.

		//DemoImpl ob = new DemoImpl();
		//-- Demo 소유의 print() 메소드 재정의 후 가능~!!!

		//DemoImpl obTemp = new DemoImpl();
		//Demo ob = (Demo)obTemp;
		//Demo ob = obTemp;

		// ○ 업캐스팅
		// 인터페이스 객체는 상위 객체
		Demo ob = new DemoImpl();
		ob.print();
		//--==>> 인터페이스 메소드 재정의


		//ob.write();
		//--==>> 에러 발생(컴파일 에러)
		
		// ○ 다운 캐스팅
		((DemoImpl)ob).write();
		//--==>> 클래스에 정의된 메소드

		System.out.println(Demo.PI);		//-- static 이기 때문에...
		//--==>> 3.141592

		System.out.println(Demo.a);			//-- static 이기 때문에...
		//--==>> 10

		//Demo.a = 30;						//-- final 이기 때문에... (상수이기 때문에)
		//--==>> 에러 발생

	}
}

캐스팅이란 타입 변환을 말한다. 자바에서 클래스에 대한 캐스팅은 업캐스팅과 다운 캐스팅으로 나뉜다.

※ 업캐스팅(Upcasting)

​

자바에서 서브 클래스는 슈터 클래스의 속성을 상속받기 때문에, 서브 클래스의 객체는 슈퍼 클래스의 멤버를 모두 가진다. 서브 클래스는 수퍼 클래스의 모든 특성을 상속받는다는 말이다. 따라서, 서브 클래스는 슈퍼 클래스로 취급될 수 있다. 이 때, 업캐스팅(Upcasting)이란, 서브 클래스의 객체가 슈퍼 클래스 타입으로 형변환 되는 것을 말한다.

​

다시 말하자면, 슈퍼 클래스의 레퍼런스 변수가 서브 클래스로 객체화된 인스턴를 가리킬 수 있게 되는 것이다.

"사람은 동물이다" 정도로 생각하면 된다.

class Person{
	String name;
	Person(String name){
		this.name = name;
	}
}
class Student extends Person{
	String check;
	Student(String name){
		super(name);
	}
}
public class Practices {
	public static void main(String[] args) {
		Student stu = new Student("홍길동");
		Person per = student;
		per.name = "이름입니다";
		
		per.check = "이름입니다."; //컴파일 타임 에러가 난다.
		}
}

위 코드에서 슈퍼클래스 타입의 레퍼런스 per이 서브클래스 객체 stu를 가리키도록 되는 것이 업캐스팅이다.

업캐스팅을 통하여 Person타입의 per은 Student 객체를 가리키지만, per은 Person 타입이기 때문에 per로는 Person클래스의 멤버에만 접근이 가능하다. 그렇기 때문에 per.check 에서 컴파일 타임 에러가 발생했던 것이다.

※ 다운캐스팅(DownCasting)

​

업캐스팅과 반대로 캐스팅 하는 것을 다운캐스팅(Downcasting)이라고 한다. 자신의 고유한 특성을 잃은 서브클래스의 객체를 다시 복구시켜주는 것을 말하는데, 다시말하자면 업캐스팅 된 것을 다시 원상태로 돌리는 것을 말한다.

class Person{
	String name;
	Person(String name){
		this.name = name;
	}
}
class Student extends Person{
	String check;
	Student(String name){
		super(name);
	}
}
public class Practices {
	public static void main(String[] args) {
		Person per = new Student("홍길동");
		
		Student stu = (Student)per;
		stu.name = "김가나";
		stu.check = "확인용";
		}
}

우선 업캐스팅과의 차이점은 명시적으로 타입을 지정해야 한다는 것이다. 그리고 업캐스팅이 선행되어야 한다.

​

Person per = new Student("홍길동");

우선 이 코드에서 업캐스팅이 실행되었다.

​

이후 Student stu = (Student)per; 에서 다운캐스팅을 하였는데 보면 (Student)로 형변환을 해주었다. 다운캐스팅은 이와같이 명시적으로 타입 변환을 해 주어야 한다.

※ 실습

/*=======================================
  ■■■ 클래스 고급 ■■■
  - 상속 관계에 있는 클래스들 간의 캐스팅
  - 업 캐스팅, 다운 캐스팅
========================================*/

// super class, 부모 클래스, 상위 클래스
class SuperTest121
{
	public int a = 10, b = 20;

	public void write()
	{
		System.out.println("슈퍼 클래스 write() 메소드");
	}
	
	public int hap()
	{
		return a + b;
	}
}

// sub class, 자식 클래스, 하위 클래스
class SubTest121 extends SuperTest121
{
	public int b = 100, c = 200;

	@Override
	public int hap()
	{
		return a + b + c;
	}

	public void print()
	{
		System.out.println("서브 클래스 print() 메소드...");		
	}
}

// main() 메소드를 포함하고 있는 외부의 다른 클래스(동일 패키지)
public class Test121
{
	public static void main(String[] args)
	{
		// sub class 기반 인스턴스 생성
		SubTest121 ob1 = new SubTest121();
		System.out.println("ob1.b : " + ob1.b);
		//--==>> ob1.b : 100

		// ○ 업 캐스팅
		//SuperTest121 ob2;
		SuperTest121 ob2 = ob1;
		//-- 『SuperTest121 ob2 = (SuperTest121)ob1;』 과 동일한 구문

		/*
		학생 인경 = new 학생();
		인간 사람 = 인경;			//『인간 사람 = (인간)인경;』과 동일한 구문

		byte a = 10;
		short b = a;				// 『short b = (short)a;』과 동일한 구문
		*/

		System.out.println("ob2.b : " + ob2.b);
		//--==>> ob2.b : 20
		//-- 변수는 객체별로 따로 할당되므로
		//   변수 b는 ob2의 변수이다.


		System.out.println("합 : " + ob2.hap());
		//--==>> 합 : 310
		//-- hap() 메소드는 오버라이딩(Overriding)되어 있고
		//   ob2 는 ob1 을 업캐스팅한 상태의 객체이므로
		//   『SuperTest121』의 hap() 메소드를 호출하는 것이 아니라
		//   『SubTest121』에서 재정의한 hap() 메소드를 호출하게 된다.
		//   즉, 메소드는 업캐스팅이 되더라도
		//   재정의(덮어쓰기)한 이상... 원래의 기능으로 되돌릴 수 없다.


		ob2.write();
		//--==>> 슈퍼 클래스 write() 메소드

		//ob2.print();
		//--==>> 에러 발생(컴파일 에러)

		
		// ○ 다운 캐스팅
		((SubTest121)ob2).print();
		

		// ※ 추가 관찰-------------------------------------------------
		//    다운 캐스팅 가능 여부

		SuperTest121 ob3 = new SuperTest121();
		SubTest121 ob4;


		//System.out.println(ob3.c);
		//--==>> 에러 발생(컴파일 에러)
		//-- 상위 객체는 하위 객체의 멤버에 접근하는 것이 불가능하다.
		
		
		//ob4 = ob3;
		//--==>> 에러 발생(컴파일 에러)
		//-- 상위 객체는 하위 객체에 담을 수(참조할 수) 없다.
		
		
		ob4 = (SubTest121)ob3;
		//--==>> 에러 발생(런타임 에러)
		//-- 작성된 구문의 문법적인 구조만 봤을 때
		//   다운 캐스팅이 이루어지는 상황이다.
		//	 하지만, 정상적인 캐스팅이 이루어지지 않는다.
		//   현재 SubTest121 객체에 대해 메모리 할당이 이루어지지 않은 상태이기 때문에
		//   다운 캐스팅은 불가능한 것이다.


	}

}

○ 업 캐스팅, 다운 캐스팅이 정상적으로 이루어지는 경우 
    
   1. 하위 객체 생성 //-- check~!!! 
   2. 상위 = 하위 // 업 캐스팅. 정상. 
   3. 하위 = 상위 // 에러 발생. 
   4. 하위 = (하위)상위; // 다운 캐스팅. 정상 

○ 업 캐스팅, 다운 캐스팅이 정상적으로 이루어지지 않는 경우 

   1. 상위 객체 생성; //-- check~!!! 
   2. 하위 = 상위; // 에러 발생. 
   3. 하위 = (하위)상위; // 다운 캐스팅. 런타임 에러 발생. 

※ 업 캐스팅은 항상 가능. 다운 캐스팅은 경우에 따라 가능. 

○ 추상 클래스(Abstract)는
   선언만 있고 정의가 없는 하나 이상의 메소드(추상 메소드)를 갖는 클래스로 하위 클래스에서 오버라이딩(Overriding)할 것으로 예상되는 메소드에 대해 메모리 낭비 없이 미리 호출 계획을 세워두기 위해 만든다.

○ 형식 및 구조
   [접근제어지시자] abstract class 클래스명([매개변수], ...)
   {
         [접근제어지시자] abstract 자료형 메소드명([매개변수], ...);
   }

○ 특징
   클래스가 적어도 하나 이상의 추상 메소드를 포함할 때, 그 클래스는 클래스 앞에 『abstract』키워드를 붙여 추상 클래스로 명시해야 하며, 추상 클래스로 선언한 경우에는 불완전한 형태의 클래스이므로 객체를 생성할 수 없다.

추상 메소드가 존재하지 않는 추상 클래스마저도 객체를 생성할 수 없는 것이다. 즉, 추상 클래스는 독립적으로 존재할 수 없기 때문에 상속을 위해서만 존재하며 추상 클래스에서 상속받은 하위 클래스에서는 반드시 추상 메소드를 오버라이딩(Overrideing)해야 한다.

※ 『abstract』 키워드는
    클래스와 메소드에서만 사용할 수 있으며 멤버 변수나 로컬 변수에서는 사용 불가능하다.

/*============================
  ■■■ 클래스 고급 ■■■
  - 추상 클래스(Abstract)
==============================*/

// 추상 클래스
abstract class SortInt120
{
	private int[] value;

	protected void sort(int[] value)
	{
		this.value = value;
		sorting();
	}
	
	// 추상 메소드
	protected abstract void sorting();

	protected int dataLength()
	{
		return value.length;
	}
	
	// 『final』 키워드로 인해
	// 이 클래스 SortInt120 을 상속받는 클래스에서
	// 이 메소드를 재정의(Method Overriding)할 수 없다.
	protected final int compare(int i, int j)
	{
		int x = value[i];
		int y = value[j];
		if (x == y)
			return 0;
		else if(x > y)
			return 1;
		else 
			return -1;
	}

	// 『final』 키워드로 인해
	// 이 클래스 SortInt120 을 상속받는 클래스에서
	// 이 메소드를 재정의(Method Overriding)할 수 없다.
	protected final void swap(int i, int j)
	{
		int temp = value[i];
		value[i] = value[j];
		value[j] = temp;
	}
}

// SortInt120 클래스를 상속받은 클래스 → 일단은 추상 클래스
// → 추상 메소드 『sorting()』을 Overriding → 일반 정상 클래스
public class Test120 extends SortInt120
{
	/*
	protected void sort(int[] value)
	{
		this.value = value;
		sorting();
	}
	
	// 추상 메소드
	protected abstract void sorting();

	protected int dataLength()
	{
		return value.length;
	}

	protected final int compare(int i, int j)
	{
		int x = value[i];
		int y = value[j];
		if (x == y)
			return 0;
		else if(x > y)
			return 1;
		else 
			return -1;

	}

	protected final void swap(int i, int j)
	{
		int temp = value[i];
		value[i] = value[j];
		value[j] = temp;
	}	
	*/
	
	int i,j;

	static int[] data = {7, 10, 3, 8, 7};

	
	@Override
	protected void sorting()
	{
		// 정의 → 완성
		// selection sort
		for (i = 0; i < dataLength() - 1; i++)
		{
			for (j = i + 1; j < dataLength(); j++)
			{
				if(compare(i, j) == 1)
					swap(i, j);
			}
		}

	}

	public static void main(String[] args)
	{
		Test120 ob = new Test120();
		
		System.out.print("Source Data : ");
		for (int n : data)
			System.out.print(n + " ");
		System.out.println();
		
		ob.sort(data);

		System.out.print("Sorted Data : ");
		for (int n : data)
			System.out.print(n + " ");
		System.out.println();
	}
}

○ 메소드 오버라이딩(Method Overriding)의 특징

   - 메소드 이름, 리턴타입, 파라미터, 파라미터 수나 타입이 완전히 일치해야 한다.
 

  - 반드시 상속 관계가 있어야 한다.

   - 재정의된 하위 클래스의 메소드 접근제어지시자는 상위 클래스의 메소드 접근제어지시자보다 범위가 크거나 같아야 한다. 예를 들어, 상위 클래스 메소드의 접근제어지시자가 『protected』인 경우 하위 클래스가 이 메소드를 오버라이딩하는 경우 접근제어지시자는 『protected』 또는 『public』이어야 한다.

   - 『static』, 『final』, 『private』 메소드는 오버라이딩(Overriding)할 수 없다.

   - Exception 의 추가가 불가능하다. 즉, 상위 클래스의 메소드가 가지고 있는 기존 예외 사항에 새로운 Exception 을 추가하는 것은 불가능하다는 것이다.

/*============================
  ■■■ 클래스 고급 ■■■
  - 상속(Inheritance)
==============================*/

// 부모 클래스
class SuperTest119
{
	private int a = 5;
	protected int b = 10;
	public int c = 20;

	public void write()
	{
		System.out.println("Super write() 메소드 : " + a + " : " + b + " : " + c );
	}
}

// 자식 클래스
class SubTest119 extends SuperTest119
{
	protected int b = 100;
	
	public void print()
	{
		//System.out.println("Sub print() 메소드 : " + a + " : " + b + " : " + c );
		//-- 슈퍼클래스에서 선언된 변수 a 에는 접근할 수 없다.
		//   → private 변수이기 때문에...
		System.out.println("Sub print() 메소드 : " + b + " : " + c );

		//System.out.println("Sub print() 메소드 : " + b );
		//System.out.println("Sub print() 메소드 : " + this.b);
		//System.out.println("Sub print() 메소드 : " + super.b);
		//-- 변수 b 는 접근 방법에 따라 
		//   다른 b 로 접근 및 출력이 이루어진다.
		//   슈퍼클래스에서 선언된 b, 서브클래스에서 선언된 b

		//System.out.println("Sub print() 메소드 : " + c);
		//System.out.println("Sub print() 메소드 : " + this.c);
		//System.out.println("Sub print() 메소드 : " + super.c);		
		//-- 변수 c 는 접근하는데 아무런 제약과 제한이 없다.
		//   슈퍼클래스에서 선언된 c

	}

	@Override
	public void write()
	{
		//System.out.println("Sub write() 메소드 : " + a + " : " + b + " : " + c);	
		//-- 슈퍼클래스에서 선언된 변수 a 에는 접근할 수 없다.
		//   → private 변수이기 때문에...
		System.out.println("Sub write() 메소드 : " + b + " : " + c);
	}
	
}

// main() 메소드를 포함하고 있는 외부의 다른 클래스(동일 패키지)
public class Test119
{
	public static void main(String[] args)
	{
		// 하위 클래스(SubTest119) 인스턴스 생성
		SubTest119 ob = new SubTest119();

		ob.print();
		//--==>> Sub print() 메소드 : 100 : 20
		
		// write() 메소드를 Override 하기 이전 상황
		ob.write();
		//--==>> Super write() 메소드 : 5 : 10 : 20

		//write() 메소드를 Override 한 이후의 상황
		//--==>> Sub write() 메소드 : 100 : 20

		System.out.println("--------------------------------------------------- 구분선");

		System.out.println(ob.b);
		//--==>> 100

		//System.out.println(ob.super.b);

		System.out.println( ((SuperTest119)ob).b);
		//--==>> 10
		// ※ 슈퍼부름

		//((SuperTest119)ob).write();
		//--==>> sub write() 메소드 : 100 : 20
		// 메소드는 덮어쓰는것, 이미 덮어써버렸기 때문에 sub가 호출됨
		// ※ 메소드와 변수를 꼭~!!! 구분하여 정리할 것~!!! check~!!!

		
	}
}

 다음과 같은 프로그램을 구현한다.
 단, 상속의 개념을 적용하여 작성할 수 있도록 한다.

 실행 예)
 임의의 두 정수 입력(공백 구분) : 20 15
 연산자 입력(+ - * /) : -
 >> 20 - 15 = 5.00
 계속하려면 아무 키나 누르세요...

/*============================
  ■■■ 클래스 고급 ■■■
  - 상속(Inheritance)
==============================*/

import java.util.Scanner;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

// super class
class Aclass
{
	protected int x, y;
	protected char op;

	Aclass()
	{
	}

	void write(double result)
	{
		System.out.printf(">> %d %c %d = %.2f\n", x, op, y, result);
	}
}
// sub class → Aclass를 상속받는 클래스
class Bclass extends Aclass 
{
	/*
	protected int x, y;
	protected char op;

	void write(double result)
	{
		System.out.printf(">> %d %c %d = %.2f\n", x, op, y, result);
	}
	*/
	Bclass() 
	{	
		
	}
	
	boolean input() throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("임의의 두 정수 입력(공백 구분) : ");  //	20 15
		String temp = br.readLine();							// "20 15"
		String[] strArr = temp.split("\\s");					//-- 구분자 → 공백					
		// String[] strArr = {"20", "15"};

		// ※ 문자열.split("구분자");
		// "사과 딸기 바나나".split("\\s"); → {"사과", "딸기", "바나나"}

		if(strArr.length != 2)
			return false;
		//-- false 를 반환하며 input() 메소드 종료
		//   이 조건을 수행할 경우
		//   아래에 수행해야 하는 코드가 남아있더라도
		//   결과값을 반환하며 메소드는 종료된다.
		
		x = Integer.parseInt(strArr[0]);
		y = Integer.parseInt(strArr[1]);
		
		System.out.print("연산자 입력(+ - * /) : ");
		op = (char)System.in.read();
		
		/*
		if(op != '+' && op != '-' && op != '*' && op != '/')
		{
			return false;
		}

		return true;
		*/

		if (op == '+' || op == '-' || op == '*' || op == '/')
		{
			return true;
		}
		return false;
	
	}//end input()

	double calc()
	{
		double result = 0;
		
		switch(op)
		{
			case '+' : result = x + y; break;
			case '-' : result = x - y; break;
			case '*' : result = x * y; break;
			case '/' : result = (double)x / y; break;
		}

		return result;
	
	} //end calc()
}

// main() 메소드를 포함하고 있는 외부의 다른 클래스(동일 패키지)
public class Test118
{
	public static void main(String[] args) throws IOException
	{
		Bclass ob = new Bclass();

		if(!ob.input())
		{
			System.out.println("Error...");
			return;
		}

		double result = ob.calc();

		ob.write(result);
	}
}

// 실행 결과
/* 
임의의 두 정수 입력(공백 구분) : 20 15
연산자 입력(+ - * /) : -
>> 20 - 15 = 5.00
계속하려면 아무 키나 누르십시오 . . .
*/