[Java] 인터페이스와 추상클래스

 

추상클래스는 abstarct를 사용하고 인터페이스는 interface를 사용하면 구현할 수 있습니다. 하지만 언제 추상클래스를 사용하고 언제 인터페이스를 사용해야 할까요? 아마 많은 주니어 개발자분들이 명쾌한 답을 내놓지 못할 것이라고 생각합니다. 저 또한 추상클래스와 인터페이스의 적절한 사용 용도를 인지하지 못한 채 개발을 해왔습니다. 그래서 이번에 추상클래스와 인터페이스에 대해 알아 보고자 합니다.

 

 

추상클래스

 

추상클래스는 일반클래스와 별반 다를 것이 없습니다. 단지, 추상 메서드를 선언하여 상속을 통하여 자손 클래스에서 완성하도록 유도하는 클래스입니다. 그래서 미완성 설계도라고도 표현합니다.

 

기본적으로 아래 코드와 같이 작성하게 됩니다.

public abstract class 클래스이름{
	public abstract void 메서드이름();
}

 

상속을 위한 클래스이기 때문에 필드에 따로 객체를 생성할 수 없습니다. 

package interface_abstract;

public class main{
	public static void main(String[] args) {
    	//만약 추상클래스를 new연산자로 생성하려면 에러가 발생
		creature c = new creature();//Cannot instantiate the type creature 오류 발생
	}
}

 

또한 추상 메서드가 아닌 이상 상속 받는 클래스에 일반 메서드를 오버라이딩 할 필요는 없습니다. 만약 추상클래스에서 추상메서드를 구현했다면 반드시 상속받는 클래스에서 오버라이딩을 해주어야합니다. 아래 코드를 보시면 eat과 walk 메서드는 추상 메서드이므로 상속받는 클래스에서 오버라이딩을 해주어야합니다.

package interface_abstract;

public abstract class creature {
	private String name;
	private String home;
	
	public creature(String name, String home) {
		this.name = name;
		this.home = home;
	}
	
	public abstract void eat();//추상메서드
	public abstract void walk();//추상메서드
	
	@Override
	public String toString() {
		return this.name + "은(는) " + this.home + "에 삽니다.";
	}
}

 

human 추상클래스의 부모클래스인 creature에서 추상메서드를 선언해주었기 때문에 creature 추상클래스를 상속받는 human 추상클래스에 오버라이딩 해주어야 합니다. 만약 추상메서드가 아닌 일반메서드라면 반드시 오버라이딩을 해줄 필요는 없습니다.

package interface_abstract;

public abstract class human extends creature{

	public human(String name, String home) {
		super(name, home);
	}
	
	@Override
	public void eat() {
		System.out.println("밥을 먹습니다.");//오버라이딩을 반드시 해주어야 합니다.
	}
	
	@Override
	public void walk() {
		System.out.println("이족보행을 합니다.");//오버라이딩을 반드시 해주어야 합니다.
	}
}

 

 

 

인터페이스

 

추상클래스가 미완성 설계도라면 인터페이스는 기본 설계도라고 할 수 있습니다. 추상클래스처럼 다른 클래스를 작성하는데 도움을 주지만 추상 클래스와 다르게 다중상속(구현)이 가능합니다.

 

public interface 인터페이스이름{
	public abstract void 메서드이름();//추상메서드
	public void 메서드이름();//일반메서드
}

 

인터페이스는 추상클래스와 다르게 추상메서드든 일반메서드든 반드시 오버라이딩을 해주어야 합니다. 

package interface_abstract;

public class messi extends human implements talkable, swimmable{

	public messi(String name, String home) {
		super(name, home);
	}
	
	@Override
	public void talk() {
		System.out.println("입으로 말을 합니다.");
	}
    
//	implements로 구현한 swimmable의 메서드를 주석처리하였을 때
//	The type messi must implement the inherited abstract method swimmable.swim() 에러가 발생
//	@Override
//	public void swim() {
//		System.out.println("자유형, 평형 등을 합니다.");
//	}
}

 

 

추상클래스 vs 인터페이스

 

결국 추상클래스만으로도 충분히 인터페이스의 역할을 대신 할 수 있습니다. 그런데 왜 굳이 2가지로 나눠서 사용할까요? 이론상 추상클래스만으로 인터페이스 역할을 대신할 순 있지만 실제로 개발을 하다보면 둘의 사용용도는 다르다는 걸 알 수 있습니다.

 

사용용도의 차이점

추상클래스는 IS -A "~이다."

인터페이스는 HAS -A "~을 할 수 있는"

 

자바의 특성상 한 개의 클래스만 상속이 가능하기 때문에 해당 클래스의 구분을 추상클래스 상속을 통해 해결하고, 해당 클래스가 할 수 있는 기능들에 대해서는 여러 개의 상속(구현)이 가능한 인터페이스로 구현합니다. 

 

추상클래스 말고 전부 인터페이스로 기능을 구현하면 안되나? 라고 생각하실 수도 있는데 위에서 언급한 바와 같이 인터페이스만 이용하여 클래스의 기본 틀(기능)을 구성하게 된다면 인터페이스 내의 정의한 모든 메서드들을 다시 오버라이딩 해야 하는 번거로움이 있습니다. 불필요한 메서드까지 오버라이딩 해야 합니다. 

 

반대로 추상클래스로만 클래스의 기능을 구현하면 안되나? 라고 생각하실 수도 있는데 위에서 언급한 바와 같이 자바는 하나의 클래스만 상속할 수 있습니다. 

 

따라서 추상클래스와 인터페이스를 적절히 섞어 개발을 해야합니다.

 

예제를 보여드리겠습니다.

 

 

 

creature 추상클래스

package interface_abstract;

public abstract class creature {
	private String name;
	private String home;
	
	public creature(String name, String home) {
		this.name = name;
		this.home = home;
	}
	
	public abstract void eat();
	public abstract void walk();
	
	@Override
	public String toString() {
		return this.name + "은(는) " + this.home + "에 삽니다.";
	}
}

인간과 동물 모두 생명체라는 것을 구현한 creature 추상클래스입니다. 생명체라면 이름과 사는 곳이 있고 먹고 걷기 때문에 eat과 walk 추상메서드를 구현했습니다. toString 같은 경우 최상위 객체인 object 클래스에 있는 메서드로 creature메서드에서 다시 오버라이딩 하였습니다. object 클래스는 extends를 통해 상속하지 않아도 자동으로 상속됩니다.

 

human 추상클래스

package interface_abstract;

public abstract class human extends creature{

	public human(String name, String home) {
		super(name, home);
	}
	
	@Override
	public void eat() {
		System.out.println("밥을 먹습니다.");
	}
	
	@Override
	public void walk() {
		System.out.println("이족보행을 합니다.");
	}
}

인간(human)은 creature 추상클래스로부터 상속을 받습니다. human 클래스에서 eat과 walk를 오버라이딩 하였습니다. 동물과 다르게 인간은 밥을 해먹고, 사족보행이나 헤엄이 아닌 이족보행을 통해 걷기 때문이죠.

 

animal 추상클래스

package interface_abstract;

public abstract class animal extends creature{

	public animal(String name, String home) {
		super(name, home);
	}
	
}

동물(animal) 추상클래스는 creature 추상클래스로부터 상속을 받습니다. 동물마다 사족보행을 할수도 있고, 이족보행을 할 수도 있어서 animal 클래스에서 오버라이딩을 하지않았습니다. 또 동물은 육식일 수도 있고 초식일 수도 있기 때문에 오버라이딩을 하지 않았습니다. 밑에 tiger클래스와 elephant 클래스에서 따로 오버라이딩을 하게 됩니다.

 

messi 클래스

package interface_abstract;

public class messi extends human implements talkable, swimmable{

	public messi(String name, String home) {
		super(name, home);
	}
	
	@Override
	public void talk() {
		System.out.println("입으로 말을 합니다.");
	}
	
	@Override
	public void swim() {
		System.out.println("자유형, 평형 등을 합니다.");
	}
}

메시는 human 추상클래스를 상속받습니다. 그리고 talkable, swimmable 인터페이스를 상속(구현)받습니다. 메시는 사람이기에 말을 할 수도 있고 수영을 할 수 있습니다. 인간일 경우 수영을 할 때 자유형이나 평형 등을 할 수 있습니다. 

 

tiger 클래스

package interface_abstract;

public class tiger extends animal implements swimmable{

	public tiger(String name, String home) {
		super(name, home);
	}

	@Override
	public void swim() {
		System.out.println("개헤엄을 합니다.");
	}

	@Override
	public void eat() {
		System.out.println("육식을 합니다.");
	}

	@Override
	public void walk() {
		System.out.println("사족보행을 합니다.");
	}

}

호랑이는 animal 추상클래스로부터 상속을 받습니다. 호랑이는 메시와 다르게 말은 할 수 없기에 수영 관련된 swimmable 인터페이스만 상속(구현)받습니다. 호랑이는 육식이므로 eat 메서드를 오버라이딩을 해주었고 또한 사족보행을 하기 때문에 walk 메서드 또한 오버라이딩 해주었습니다. 메시는 자유형을 하는 반면 호랑이는 개헤엄을 통해 수영하므로 swimmable 인터페이스의 swim 메서드를 오버라이딩 해주었습니다.

 

elephant 클래스

package interface_abstract;

public class elephant extends animal{

	public elephant(String name, String home) {
		super(name, home);
	}

	@Override
	public void eat() {
		System.out.println("초식을 합니다.");
	}

	@Override
	public void walk() {
		System.out.println("사족보행을 합니다.");
	}

}

코끼리도 호랑이와 마찬가지로 animal 클래스를 상속받습니다. 하지만 수영을 할 수 없기에(할수도 있겠지만 못한다고 가정하겠습니다.) swimmable 인터페이스를 상속(구현)받지 않습니다. 또한 말도 할 수 없기 때문에 talkable 인터페이스 또한 상속(구현)받지 않습니다.

 

talkable 인터페이스

package interface_abstract;

public interface talkable {
	public void talk();
}

말 할 수 있는 기능을 구현한 인터페이스입니다.

 

swimmable 인터페이스

package interface_abstract;

public interface swimmable {
	public void swim();
}

수영할 수 있는 기능을 구현한 인터페이스입니다.

 

main 클래스

package interface_abstract;

public class main{

	public static void main(String[] args) {
		messi m = new messi("메시", "아파트");
		tiger t = new tiger("호랑이", "정글");
		elephant e = new elephant("코끼리", "초원");
				
		//메시
		String str1 = m.toString();
		System.out.println(str1);
		m.eat();
		m.walk();
		m.talk();
		m.swim();
		//호랑이
		System.out.println("---------------------");
		String str2 = t.toString();
		System.out.println(str2);
		t.eat();
		t.walk();
		t.swim();
		//코끼리
		System.out.println("---------------------");
		String str3 = e.toString();
		System.out.println(str3);
		e.eat();
		e.walk();
	}
}

 

실행결과

추상클래스 사용 시기 : 상속관계를 쭉 타고 올라갔을 때 같은 조상클래스를 상속하는 데 기능까지 완벽히 똑같은 기능이 필요한 경우

인터페이스 사용 시기 : 상속관계를 쭉타고 올라갔을 때 다른 조상클래스를 상속하는데 같은 기능이 필요한 경우 

 

그럼 이제 추상클래스와 인터페이스에 대해 감이 오시나요? 이상 추상클래스와 인터페이스에 대해 알아보았습니다.

 

읽어주셔서 감사합니다.

 

conference

 

자바 추상클래스란?

추상클래스와 인터페이스의 용도, 차이점, 공통점

자바 인터페이스란?

추상클래스 vs 인터페이스 왜 사용할까?