[Java] 14일차 : 인터페이스(interface)

 

 

인터페이스(interface)란?
클래스를 위한 탬플릿으로서의 기능을 수행하는 추상 클래스의 한 종류

• 인터페이스는 interface라는 키워드를 사용하여 선언하며, 메소드 시그너처와 상수 선언(static과 final이 둘 다 선언되는 변수 선언)만을 포함할 수 있다. 
• 자바 8미만의 인터페이스는 모든 메소드가 선언만 있고 정의가 없는 추상 메소드만 선언 가능
• 인퍼테이스 내의 필드는 상수 선언만 한다.
• 클래스에서 인터페이스 구현하기 위해서는 implements한 클래스는 해당 인터페이스의 모든 추상 메소드를 재정의 해야 한다. 
• 인터페이스는 다중 상속이 가능함. 다중 상속은 ","(콤마)로 구분하여 여러 개의 인터페이스를 상속할 수 있다.
• 인터페이스끼리 상속 할 경우 extends 키워드를 사용한다.
• ▶ 특징
• 클래스간 결합도를 낮출 수 있다.
• 표준화가 가능
• 개발시간을 단축할 수 있다. 

형식

 

인터페이스 멤버 

▶ 상수 필드 (constant field)

• 인터페이스는 상수 필드만 선언 가능하며, 런타임 시 변경 할 수 없다.
• 상수 필드는  public final static만 가능하며, public final static를 생략 할 수 있지만 생략해도 다음과 같다.
•  public final static 자료형 필드명 = 초리값;
• static {} 초기화 블록으로 초기화가 불가능하며 상수 필드를 선언하면서 초기화 해야 한다.

▶ 추상 메소드(abstract method)

• 자바 8미만의 인터페이스는 모든 메소드가 선언만 있고 정의가 없는 추상 메소드만 선언 가능
• 접근제어자의 생략은 가능하지만, 기술하는 경우에는 public만 가능
• 추상메소드에 public abstract 키워드를 붙이지 않아도 다음과 같다. public abstract 리턴타입 메소드명([인수]);
• 인터페이스를 구현한 클래스는 추상 클래스가 아닌 경우 인터페이스의 모든 추상 메소드를 재정의 해야 한다.

▶ 디폴트 메소드(default method)

• 자바 8부터 사용 가능
• 디폴트 메소드는 인터페이스에 선언되지만, 정의가 된 메소드로 구현클래스에서 재정의가 가능하다.
• 디폴트 메소드가 허용된 이유는 기존 인터페이스를 확장해서 새로운 기능을 추가할 목적

▶ 정적 메소드(static method)

• 자바 8부터 사용 가능
• 디폴트 메소드와 달리 객체가 없어도 인터페이스만으로 호출이 가능하다.

▶private 메소드

• 자바 9부터는 private 메소드를 정의 할 수 있다. 

package ch08.unit06;

public class Ex01 {

	public static void main(String[] args) {
		// Demo1 d = new Demo1 (); // 컴오류
		// 인터페이스는 추상 클래스의 일종으로 객체 생성 불가

		// 인터페이스는 구현클래스의 상위 클래스와 유사
		Demo1 dm = new Test1(); // 업캐스팅
		dm.disp();

		// dm.sub(); // 컴오류
		((Test1) dm).sub(); // 다운캐스팅

		System.out.println(Demo1.A);
		// Demo1.B = 200 ; // 컴오류 final 필드는 값 변경 불가
	}

}

//인터페이스는 메소드가 선언만 있고 정의가 없는 abstract 클래스의 일종
interface Demo1 {
	public static final int A = 10;
	int B = 20; // 필드는 public static final을 붙이지 않아도 public static final됨

	// 인터페이스 메소드 public abstract만 가능
	public abstract void disp();

	void print(); /// 메소드는 public abstract를 붙이지 않아도 public abstract됨

	// public void write() {} // 컴오류 인터페이스에서 메소드의 구현은 불가
}

// 인터페이스 구현
// 인터페이슨를 구현하는 클래스는 추상클래스가 아닌 경우에는 인터페이스의 
// 모든 메소드를 재정의 해야함 

class Test1 implements Demo1 {

	@Override
	public void disp() {
		System.out.println("disp()...");

	}

	@Override
	public void print() {
		System.out.println("print()...");

	}

	public void sub() {
		System.out.println("sub()...");
	}

}

 

 

package ch08.unit06;

public class Ex02 {

	public static void main(String[] args) {
		DemoImp12 d1 = new DemoImp12();
		
		d1.disp();
		d1.print();
		d1.sub();
		System.out.println();
		
		//업 캐스팅
		Ademo2 d2 = new DemoImp12();
		Bdemo2 d3 = new DemoImp12();
		
		d2.disp();
		//d2.print(); 컴오류
		
		d3.print();
		((Ademo2)d3).disp(); // Ademo2, Bdemo2 가 구현되었으므로 가능
		
		((DemoImp12)d3).sub(); // 다운 캐스팅 

	}

}

interface Ademo2 {
	public void disp() ;
		
	}
interface Bdemo2 {
	public void print ();
}

//2개 이상의 인터페이스 구현
class DemoImp12 implements Ademo2, Bdemo2 {

	@Override
	public void print() {
		System.out.println("print()....");
		
	}

	@Override
	public void disp() {
		System.out.println("disp()....");
		
	}
	public void sub() {
		System.out.println("sub()....");
	}
}

package ch08.unit06;

public class Ex03 {

	public static void main(String[] args) {
		Demo3 d = new Test3();
		d.print();
		

	}

}
interface Demo3{
	public void print();
	public void disp();
	
}
//추상 클래스는 인터페이스의 모든 메소드를 구현하지 않아도됨
abstract class DemoImp13 implements Demo3{
	@Override
	public void disp() {
		System.out.println("disp()...");
	}
}
class Test3 extends DemoImp13{
	
	public void print() {
		System.out.println("disp()...");
	}
	
	
}

 

package ch08.unit06;

public class Ex04 {

	public static void main(String[] args) {
		Cdemo4 d= new DemoImp4();
		d.print();

	}

}
interface Ademo4{
	public void print();
	
}
interface Bdemo4{
	public void disp();
}

//인터페이스는 다중 상속 가능
interface Cdemo4 extends Ademo4, Bdemo4{
	public void sub();
	
}

class DemoImp4 implements Cdemo4{

	@Override
	public void print() {
		System.out.println("print...");
		
	}

	@Override
	public void disp() {
		System.out.println("disp...");
	}

	@Override
	public void sub() {
		System.out.println("sub...");
	}
	
}

package ch08.unit06;

public class Ex05 {
	public static void main(String[] args) {
		Store st = new Store();
		
		Fruit f = new Orange();
		st.sell(f);
		
		st.sell(new Apple());
		
	}
}

/*
 - 인터페이스 특징
  : 클래스간의 결합도를 낮출 수 있다.
  : 표준화가 가능하다. 
  : 개발 시간을 단출할 수 있다. 
 */

interface Fruit {
	public int gerPrice();
	public String getName();
	
}

class Apple implements Fruit{

	@Override
	public int gerPrice() {
		return 1500;
	}

	@Override
	public String getName() {
		return "사과";
	}
	
}
class Orange implements Fruit{

	@Override
	public int gerPrice() {
		return 1000;
	}

	@Override
	public String getName() {
		return "오렌지";
	}
	
}
class Store { 
	public void sell(Fruit f) {
		System.out.println(f.getName()+":"+f.gerPrice());
}
}

 

디폴트 메소드 

• 자바 8부터 사용 가능
• 디폴트 메소드는 인터페이스에 선언되지만, 정의가 된 메소드로 구현클래스에서 재정의가 가능
• 디폴트 메소드는 public를 생략해도 public 특성을 갖는다.
• 디폴트 메소드를 사용하기 위해서는 반드시 인터페이스를 구현한 클래스의 객체를 생성한 후에만 사용 가능
• 인터페이스를 상속 받은 인터페이스는 디폴트 메소드를 재정의하거나 다시 추상 메소드로 선언 할 수 있다.

형식

 

package ch08.unit06;

public class Ex06 {

	public static void main(String[] args) {
		int s = Demo6.sum(10);
		System.out.println(s);
		
		Demo6 d = new DemoImp16();
		int x = d.max(10, 5);
		d.write(x);
		
	}

}

interface Demo6 {
	public void write(int n);

	public static int sum(int n) {
		int s = 0;
		for (int i = 1; i <= n; i++) {
			s += i;
		}
		return s;
	}
	
	
	// default 키워드로 메소드 구현, JDk 8부터 가능 
	// 구현 클래스에서 재정의 기능 
	public default int max(int m, int n) {
		return m > n ? m : n;
	}
}

class DemoImp16 implements Demo6 {

	@Override
	public void write(int n) {
		System.out.println("결과 :"+n);
		
	}
	
}

 

 

 

정적(static)메소드

• 자바 8부터 사용 가능
• 디폴트 메소드와 달리 객체가 없어도 인터페이스만으로 호출이 가능
• static 메소드는 public를 생략해도 public 특성을 갖는다.

 

 

private 메소드

• 자바 9부터 private 메소드를 정의 할 수 있다.

형식

 

 

인터페이스(interface)의 상속 

• 인터페이스는 다른 인터페이스를 상속 받을 수 있으며, extends 키워드를 사용 한다.
• 인터페이스는 다중 상속을 지원

 

 

클래스에서 인터페이스 구현 

• 인터페이스는 클래스를 위한 템플릿이기 때문에 class 에서 implements 키워드를 이용하여 구현해야 한다.
• 클래스는 동시에 2개 이상의 인터페이스를 implements 할 수 있다.
• 인터페이스를 implements한 클래스는 인터페이스의 상위 인터페이스가 제공하는 추상 메소드를 포함해 모든 메소드를 구현(override)해야 하며 그렇지 않은 경우 해당 클래스를 추상(abstract) 클래스로 선언해야 한다.

 

 

익명 구현 객체 

• 구현 클래스의 작성을 생략하고  new  수식이 있는 곳에서 바로 구현 객체를 생성할 수 있다.

 

인터페이스 참조형의 형 변환

• 인터페이스는 상위클래스와 마찬가지로 형 변환 없이 바로 구현클래스를 참조 할 수 있다.
• 인터페이스를 구현하지 않은 클래스와는 형변환이 되지 않는다.
• 구현 클래스를 인터페이스로 형 변환 후 다시 구현 클래스로 형 변환은 반드시 강제 캐스팅을 해야 한다.
• ▶업 캐스팅 인터페이스 객체명 = 구현클래스객체;
• ▶다운 캐스팅 : 구현클래스 객체명 = (구현클래스) 인터페이스 객체;
•  

package ch08.unit06;

public class Ex07 {

	public static void main(String[] args) {
		// 인터페이스 익명 구현
		
		Demo7 obj = new Demo7() {
			
			@Override
			public void disp() {
				System.out.println("disp...");
			}
		};
		
		obj.disp();
	}

}

interface Demo7{
	public void disp();
}