Test113~Test117
완전히 미완성된 채로 남겨져 인터페이스 안에 존재하는 그 어떤 메소드도
몸체(정의부)가 없기 때문에 사실상 실행 부분이 존재하지 않는다.
클래스를 위한 템플릿으로써의 기능을 수행하는 추상 클래스의 한 종류이다.
기존의 C++언어 등에서 지원되는 다중 상속이
사용 과정에서 많은 문제점을 노출시켰기 대문에
자바에서는 다중 상속의 개념을 인터페이스라는 개념으로 변형하여
인터페이스를 통해 다중 상속을 구현하는 방법을 지원한다.
인터페이스 안의 메소드들은 접근제어지시자를 명시하지 않아도 (원래는 디폴트임!)
『public』으로 설정되어 클래스에서 구현(implements)함으로써
바로 접근이 이루어질 수있다.
// 인터페이스
interface Demo
{
public static final double PI = 3.141592;
// 인터페이스의 멤버 면수는
// 『static final』을 별도로 명시하지 않아도
// 자동으로 『static final』인 상태~!!!
public int a = 10; //-- 안됌 static final 상수만 가질 수 있음!! 그런데 됌! 엥
// 인터페이스의 메소드는 선언만 가능(정의 불가)
// 자동으로 『abstract』인 상태
//public void print()
/*
{
System.out.println("PI : " + PI); // 메소드를 선언만 해야지 정의하는건 안댐
}
*/
//public abstract void print();
public void print(); //-- 어차피 모든 메소드가 추상이기 때문에 abstract생략 가능~!!
}
// class DemoImpl
// class DemoImpl extends Demo ( X )
// abstract class DemoImpl extends Demo ( X )
// class DemoImpl implements Demo ( X )
//추상 클래스 - 인터페이스를 구현하는 추상 클래스
//abstract class DemoImpl implements Domo
// ↓ (print를 정의하는 순간 abstract뗀다)
//클래스 - 인터페이스를 구현하는 클래스
class DemoImpl implements Demo
{
//public void print();
@Override
public void print()
{
System.out.println("클래스에 정의된 메소드...");
}
public void write()
{
System.out.println("클래스에 정의된 메소드...");
}
}
// main() 메소드를 포함하고 있는 외부의 다른 클래스
public class Test113
{
public static void main(String[] args)
{
//Demo ob = new Demo(); // 인터페이스는 인스턴스 생성불가~!!
//DemoImpl ob = new DemoImpl(); //추상클래스는 print만 건들이면 생성가능한데 지금은 안댐
//-- print() 메소드 재정의 후 가능~!!!
//DemoImpl obTemp = new DemoImpl(); //더이상 추상이아니고 클래스이기 때문에 인스턴스 생성 가능!
//Demo ob = (Demo)obTemp; //DemoImpl는 오버라이딩으로 덮어쓰기 다해서 클래스가 된 아이니까! 업캐스딩 가능한~!!
//Demo ob = obTemp;
//new DemoImpl(); 만 해도 인스턴스 생성됨!! 근데 이제 우리가 담아둘게 필요하니까 앞에 DemoImpl 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
//Demo.a = 30; //-- final 이기 때문에....
//--==>> 에러발생
}
}
// 인터페이스 -> 이안에는 추상메소드밖에 못오기 때문에 abstract 생략 가넝한~!!
interface ADemo
{
public void write();
}
// 인터페이스
interface BDemo
{
public 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 abstract void write();
public abstract void print();
*/
// ※ JDK 1.5(5.0)에서는 인터페이스 메소드를
// 오버라이딩(Override)할 때
// 『@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 인터페이스 메소드 write()...");
}
}
// main() 메소드를 포함하고 있는 외부의 다른클래스
public class Test114
{
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 인터페이스 메소드 write()...
ADemo ob2 = new DemoImpl(); //--업 캐스팅
BDemo ob3 = new DemoImpl(); //--업 캐스팅
//ob2.print(); //--==>> 에러 발생 ADemo 에는 print없어서 안됨!
//ob3.write(); //--==>> 에러 발생 BDemo 에는 write없어서 안됨!
ob3.print();
ob2.write();
//--==>>BDemo 인터페이스 메소드 write()...
// ADemo 인터페이스 메소드 write()...
((BDemo)ob2).print();
((ADemo)ob3).write();
//--==>>BDemo 인터페이스 메소드 write()...
// ADemo 인터페이스 메소드 write()...
//가넝한~!! 왜냐면 DemoImpl 가 print랑 write를 둘다 구현했으니까~!!!
//--DemoImpl 클래스가 두 인터페이스를 모두 구현했기 때문에 가능하다.
// 만약 DemoImpl 클래스가 이들 중 한 인터페이스만 구현한 상황이라면
// 이 구문은 런타임 에러 발생하는 구문이 된다.
// 다운 캐스팅
((DemoImpl)ob3).write(); //check~!!
//--==>> ADemo 인터페이스 메소드 write()...
}
}
// 인터페이스
interface Demo
{
public void write();
public void print();
}
// 인터페이스를 구현하는 추상 클래스
abstract class DemoImpl implements Demo
{
@Override
public void write()
{
System.out.println("write() 메소드 재정의...");
}
//public abstract void print();
}
// 추상 클래스를 상속받는 추상 클래스
//abstract class DemoImplSub extends DemoImpl
// ↓
// 추상 클래스를 상속받는 클래스
class DemoImplSub extends DemoImpl
{
@Override
public void print()
{
System.out.println("print() 메소드 재정의");
}
}
// main() 메소드를 포함하고 있는 외부의 다른클래스
public class Test115
{
public static void main(String[] args)
{
//Demo ob1 = new Demo();
//-- 인터페이스 -> 인스턴스 생성 불가
//DemoImpl ob2 = new DemoImpl();
//-- 추상 클래스 -> 인스턴스 생성 불가
DemoImplSub ob3 = new DemoImplSub();
ob3.write();
ob3.print();
//--==>> write() 메소드 재정의...
// print() 메소드 재정의
}
}
클래스 extends 클래스
클래스 extends 추상클래스
인터페이스 extends 인터페이스
인터페이스 extends 인터페이스, 인터페이스
추상클래스 implements 인터페이스
추상클래스 implements 인터페이스, 인터페이스
클래스 implements 인터페이스
클래스 implements 인터페이스, 인터페이스
※ 인터페이스는 클래스와는 달리 다중 상속이 가능하며,
인터페이스 자체도 상속된다.
※ 인터페이스 멤버 변수인 데이터는
접근제어지시자를 명시하지 않아도 기본 상수(primitive constant)인
static final 의 변경자로 설정된다.
클래스에서 인터페이스를 추가하여 사용할 경우
인터페이스를 구현하는 클래스는
인터페이스의 상위 인터페이스가 제공하는 추상 메소드를 포함한
모든 메소드를 구현하지 않을 경우
추상(abstract) 클래스로 선언해야 한다.
형식
- 인터페이스는 메소드를 선언만 하고 정의는 없다.
- 인터페이스를 implements 할 경우 반드시 하위 클래스는
인터페이스의 모든 메소드를 오버라이딩(Overriding)해야 한다.
- 인터페이스는 자동적으로 다음과 같이 처리된다.
멤버 변수 : public static final
메소드 : public abstract
- 다중 상속은 콤마(『,』)로 구분되며
여러 개의 인터페이스를 상속할 수 있다.
- 인터페이스 끼리 상속할 경우는 『implements』가 아니라 『extends』키워드를 사용한다.
인터페이스의 선언
인터페이스는 클래스 내부 구현을 제외한 참조형만 선언한 것이므로
메소드를 선언만 하고 정의할 수 없다.
또한, 클래스에서의 변수는 값이 변할 수 있지만
인터페이스에서의 변수는 상수처럼 값이 바뀔 수 없기 때문에
선언 시에 미리 값을 할당해 놓아야 한다.
인터페이스의 구현
인터페이스는 클래스를 위한 템플릿이기 때문에
사용 가능한 인터페이스가 되기 위해서는
자바 프로그램에서 인터페이스를 구현해 주어야 하는데
이러한 기능을 하는 것이 『implements』 에약어이다.
클래스는 동시에 두 개 이상의 인터페이스를
implements 할 수 있다~!!!
// 인터페이스
interface ADemo
{
public void write();
}
// 인터페이스
interface BDemo
{
public void print();
}
// ※ 클래스는 다중 상속을 지원하지 않지만,
// 인터페이스는 다중 상속을 지원한다.
// 두 인터페이스(ADemo,BDemo)를 상속받은 인터페이스
interface CDemo extends ADemo, BDemo
{
//public void write();
//public void print();
public void test();
}
// 클래스
// class Demoimpl
// ↓
// 추상 클래스 - CDemo 인터페이스를 구현하는 추상 클래스
// 두 인터페이스(ADemo,BDemo)를 상속받은 인터페이스(CDemo)를 구현한 추상 클래스
//abstract class DemoImpl implements CDemo
// ↓
// 두 인터페이스(ADemo,BDemo)를 상속받은 인터페이스(CDemo)를 구현한 후 모든 메소드를 재정의한 클래스
class DemoImpl implements CDemo
{
@Override
public void test()
{
System.out.println("test()...");
}
@Override
public void write()
{
System.out.println("write()...");
}
@Override
public void print()
{
System.out.println("print()...");
}
}
// main()메소드를 포함하고 있는 외부의 다른 클래스
public class Test116
{
public static void main(String[] args)
{
// 두 인터페이스르 상속받은 인터페이스를 구현하고
// 모든 메소드를 재정의한 클래스에 대한 인스턴스 생성
DemoImpl ob = new DemoImpl();
ob.test();
ob.write();
ob.print();
}
}
/*
test()...
write()...
print()...
계속하려면 아무 키나 누르십시오 . . .
*/