[Java] 자바 추상 메소드, 추상 클래스와 인터페이스

[ 추상 메소드(abstract method) ]

[ 추상 메소드 ]

- 하위 클래스에서 반드시 오버라이딩 해야하는 메소드

- 추상 메소드가 포함된 클래스를 상속받는 하위 클래스가

추상 메소드를 구현하기 위해 사용

- 추상 메소드는 선언부만이 존재하며 구현부는 작성 x

[ 형식 ]

abstract 반환타입 메소드명 ( );

[ 추상 클래스(abstract class) ]

[ 추상 클래스 ]

- 하나 이상의 추상 메소드를 포함하는 클래스

- 객제 지향프로그래밍에서 중요한 특징인 다형성을 가지는 메소드의 집합을 정의

- 추상 클래스를 사용하면 작업을 수평적 분할이 가능, 레벨 단위 구조 형태로 관리 가능

- 추상 클래스는 자체적으로 객체 생성이 불가능 하므로

반드시 하위 클래스를 통한 추상 메소드를 먼저 구현해야 후 객체 생성을 해야함.

[ 추상 클래스 예제 ]

// -- abstract class --
abstract class EmptyCan{
	// -- abstract method --
	public abstract void sound();
	public abstract void who();
	// 추상 클래스의 특징 : 일반 메소드 또한 가질 수있음
	public void doSth() {
		sound();
		who();
	}
}

public class AbstractClassTest extends EmptyCan{
	
	// -- method overriding --
	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) {
		AbstractClassTest nc = new AbstractClassTest();
//		EmptyCan ec = new EmptyCan(); -- Error : 추상 클래스는 인스턴스 생성 불가
		EmptyCan ec = nc; 	// 추상 클래스를 상속받아 재정의한 하위 클래스이기 때문에 오류 발생 x 
		
		ec.sound();
		ec.who();
//		ec.sayHello();
		nc.sayHello();
		
		ec.doSth();
	}
}

/* [출력 결과]
    EmptyCan : 빈 깡통은 소리가 요란하다
    EmptyCan : 나는 빈 깡통입니다.
    NewCan : 추상클래스 테스트입니다.
    EmptyCan : 빈 깡통은 소리가 요란하다
    EmptyCan : 나는 빈 깡통입니다.
*/

[ 인터페이스(interface) ]

[ 인터페이스 ]

- 추상 메소드만을 포함하는 추상클래스의 일종

- 메소드는 묵시적으로 public abstract로 선언

- 인터페이스에 정의한 변수는 public static final 키워드를 생략해도

자동으로 public static final이 적용되어 상수로 선언된다.

- 구현을 위해 implements 키워드를 사용

- extends 키워드를 통한 상속으로는 다중 상속을 지원하지 않기 때문에

implements를 통한 다중 상속으로 이를 해결

- 자체적으로 객체 생성이 불가능 하기 때문에 Implements를 사용하여

상속(구현)받은 하위 클래스(구현체)에서 반드시 override를 통해 구현 필요

- 인터페이스는 추상클래스의 일종이기 때문에 구현을 받는 구현체에서

인터페이스의 메소드를 반드시 구현해야 한다는 강제성을 가짐

[ 인터페이스 사용 예제 1 ]

class Animal{
	String name;
	void setName(String name) {
		this.name = name;
	}
}

// Animal 클래스를 상속받는 Ant, Panda 클래스
class Ant extends Animal{ }
class Panda extends Animal { }

// 객체를 전달받아 객체에 따라 다른 출력을 수행하는 AnimalBarking 클래스
class AnimalBarking {
	void barking(Ant ant) {
		System.out.println("개미는 갬갬...");
	}
	void barking(Panda panda) {
		System.out.println("판다는 팜팜...");
	}
}

public class TestCode {
	
	public static void main(String[] args) {
		Ant ant = new Ant();
		Panda panda = new Panda();
		AnimalBarking ab = new AnimalBarking();
		
		ab.barking(ant);
		ab.barking(panda);
	}
}

/* [출력 결과]
    개미는 갬갬...
	판다는 팜팜... 
*/

위의 예제에서는 Animal 클래스를 상속받는 Ant, Panda 클래스와,
Ant, Panda 두 객체를 매개변수로 전달받아 출력하는 barking() 메소드를 가진
AnimalBarking 클래스가 작성되어 있다.

만약 AnimalBarking 클래스에서 오버로딩하고 있는 barking() 메소드가 단지 Ant, Panda
두 객체를 전달받는 것이 아니라 무수히 많은 객체를 매개변수로서 전달받을 경우
매번 매개변수 타입이 다른 형태로 오버로딩을 해줘야 한다.

[ 인터페이스 사용 예제 2 ]

// Snail, Dog 클래스가 추가될 경우
(... 생략 ...)

class Ant extends Animal{ }
class Panda extends Animal{ }
class Snail extends Animal{ }
class Dog extends Animal{ }

class AnimalBarking {
	void barking(Ant ant) {
		System.out.println("개미는 갬갬...");
	}
	void barking(Panda panda) {
		System.out.println("판다는 팜팜...");
	}
	void barking(Snail snail) {
		System.out.println("달팽이는 핑핑...");
	}
	void barking(Dog dog) {
		System.out.println("강아지는 댕댕...");
	}
}

(... 생략 ...)

위의 코드와 같이 barking() 메소드를 매번 오버로딩해야 한다.
이럴 경우 아래와 같이 인터페이스를 활용하여 수정할 수 있다.

[ 인터페이스 예제 3 ]

// Interface는 본래 별개의 파일로 저장하는 것이 일반적이다
interface AnimalInterface{
	// 추상 메소드 선언
	String getName();	// 묵시적으로 abstract로 선언
	abstract String getBarking();
}

class Animal{
	String name;
	void setName(String name) {
		this.name = name;
	}
}

// Animal 클래스를 상속받는 Ant, Panda, Snail 클래스
class Ant extends Animal implements AnimalInterface{
	@Override
	public String getName() {
		return "개미";
	}
	@Override
	public String getBarking() {
		return "갬갬...";
	} 
}

class Panda extends Animal implements AnimalInterface{
	@Override
	public String getName() {
		return "판다";
	}
	@Override
	public String getBarking() {
		return "팜팜...";
	} 
}

class Snail extends Animal implements AnimalInterface{
	@Override
	public String getName() {
		return "달팽이";
	}
	@Override
	public String getBarking() {
		return "핑핑...";
	} 
}

class AnimalBarking {
	// interface 객체를 매개변수로 받을 수 있게 변경
	void barking(AnimalInterface a_interface) {
		System.out.println(a_interface.getName() + "는 " + a_interface.getBarking());
	}
}

public class TestCode {
	
	public static void main(String[] args) {
		Ant ant = new Ant();
		Panda panda = new Panda();
		Snail snail = new Snail();
		AnimalBarking ab = new AnimalBarking();
		
		ab.barking(ant);
		ab.barking(panda);
		ab.barking(snail);
	}
}

/* [출력 결과]
	개미는 갬갬...
    판다는 팜팜...
    달팽이는 핑핑...
*/

인터페이스를 활용한 코드에서 Ant, Panda, Snail과 같은 클래스들은
AnimalInterface라는 인터페이스를 상속(구현)받고 있다.

이때 구현받은 각 클래스들은 인터페이스에서 명시되어 있는 추상 메소드인
getName()과 getBarking()을 반드시 구현(오버로딩)해줘야 한다.

인터페이스를 활용하면 위와 같이 공동 작업을 위한 클래스가 늘어나더라도
한 개의 인터페이스를 통해 해결 가능하다.

[ 기본 메소드(Default Methods) ]

- JDK 8버전 이후로부터 기본 메소드(Default method) 사용 가능

- 본래 인터페이스의 메소드는 추상메소드로서 구현체를 가질 수 없음

- 기본 메소드를 사용하면 구현된 형태의 메소드 작성 가능

- 기본 메소드의 경우 메소드의 반환타입 앞에 default 키워드를 붙여 선언

[ 기본 메소드 예제 ]

interface AnimalInterface{
	String getName();
	String getBarking();
	
    // 기본 메소드(default method) 선언
	default void animalBarking() {
		System.out.println(getName() + "는 " + getBarking());
	}
}

class Animal{
	String name;
	void setName(String name) {
		this.name = name;
	}
}

// Animal 클래스를 상속받는 Ant, Panda 클래스
class Ant extends Animal implements AnimalInterface{
	@Override
	public String getName() {
		return "개미";
	}
	@Override
	public String getBarking() {
		return "갬갬...";
	} 
}

class Panda extends Animal implements AnimalInterface{
	@Override
	public String getName() {
		return "판다";
	}
	@Override
	public String getBarking() {
		return "팜팜...";
	} 
}

class Snail extends Animal implements AnimalInterface{
	@Override
	public String getName() {
		return "달팽이";
	}
	@Override
	public String getBarking() {
		return "핑핑...";
	} 
}

/*
class AnimalBarking {
	// interface 객체를 매개변수로 받을 수 있게 변경
	void barking(AnimalInterface a_interface) {
		System.out.println(a_interface.getName() + "는 " + a_interface.getBarking());
	}
}
*/

public class TestCode {
	
	public static void main(String[] args) {
		Ant ant = new Ant();
		Panda panda = new Panda();
		Snail snail = new Snail();
		
		ant.animalBarking();
		panda.animalBarking();
		snail.animalBarking();
	}
}

기본 메소드를 활용하면 따로 Animalbarking 클래스 없이 인터페이스에서의 구현을 통해 출력 가능.
또한 기본 메소드는 실제 클래스에서 오버라이딩하여 다르게 구현하여 사용 가능함

[ 스태틱 메소드(Static Methods) ]

- JDK 8버전 이후로부터 사용 가능

- 인터페이스에 스태틱 메소드를 구현할 경우 `인터페이스명.스태틱메소드명`처럼

일반 클래스의 스태틱 메소드와 같이 사용 가능.

[ 스태틱 메소드 예제 ]

interface AnimalInterface{
	static void display() {
		System.out.println("AnimalInterface의 스태틱 메소드입니다.");
	}
}

public class TestCode {
	public static void main(String args[]){
    	// 일반 클래스의 스태틱 메소드와 같이 객체 생성없이 호출 가능
    	AnimalInterface.display();
    }
}

/* [출력 결과]
	AnimalInterface의 스태틱 메소드입니다.
*/

저작자표시 비영리 변경금지

티스토리툴바