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

추상 클래스

구체적이지 않은 추상적인 데이터를 담고 있는 클래스이다.

미완성되어 인스턴스화가 불가능하며, abstract 키워드를 사용한다.

추상 클래스는 추상 메서드를 포함(없어도 선언가능)할 수 있다.

추상 클래스는 자식 클래스에 상속되어 자식 클래스에 의해서만 완성된다.

여러개의 자식 클래스에서 공통적인 필드, 메서드를 추출해 만든다.

 

추상메서드

구현되지 않은 미완성 메서드. abstract 키워드로 선언한다.

추상메서드는 일반적인 메서드와 다르게 코드를 적는 블록{}이 없다.

즉, 정의만 하고 실행 내용은 없는 것.

public abstract class 추상클래스명 { //추상클래스
		abstract 리턴타입 메서드이름(매개변수, ...); //추상메서드
}

 

클래스 상속

추상 메서도는 extends 키워드를 사용해 클래스에서 상속된다.

상속받은 클래스에서 추상 클래스의 추상메서드는 반드시 오버라이딩 되어야 한다.

public class 클래스명 extends 추상클래스명 {
    @Override
    public 리턴타입 메서드이름(매개변수, ...) {
		       // 실행문
    }
}

 

//추상 클래스
public abstract class Car{
	//추상 메서드 >> 공통된 메서드
    public abstract void horn();
}

public class BenzCar{
	@Override
	public void horn(){
    	System.out.println("빵빵-")
    }
}

public class AudiCar{
	@Override
	public void horn(){
    	System.out.println("빠앙-")
    }
}

 

 

인터페이스

상속 관계가 없는 다른 클래스들이 서로 동일한 메서드를 구현해야할 때,

구현 클래스들의 동일한 사용방법과 행위를 보장한다.

interface 키워드로 인터페이스를 선언한다.

 

구성

클래스와 동일한 접근제어자(public, default)를 지정할 수 있다.

필드는 상수(public static final)로만 정의한다.

메서드는 public static으로만 정의한다.

생략되는 제어자는 컴파일러가 자동으로 추가한다.

public interface Inter{ //인터페이스 선언
    //제어자 생략가능
    //필드는 public static final
    //메서드는 public abstract
    
	public static final char A = 'a';
    static char B = 'b';
    char C = 'c';
    
    void turnOn();
}

 

구현

implement 키워드로 인터페이스를 구현한다.

추상클래스와 마찬가지로 인스턴스를 직접 생성할 수 없고,

구현부를 만들어주는 클래스가 있어야 인스턴스를 생성할 수 있다.

인터페이스의 추상메서드는 구현될 때 반드시 오버라이딩 되어야하며,

일부만 구현해야 한다면 해당 클래스를 추상클래스로 변경한다.

public interface inter{
	void turnOn();
    void turnOff();
}

public class interClass01 implements inter { 
	
    // 인터페이스의 메서드는 구현시 반드시 오버라이딩 된다.
    @Override
    public void turnOn(){
    	System.out.println("!")
    }
    @Override
    public void turnOff(){
    	System.out.println("?")
    }
}

// 일부만 구현해야하면 클래스를 추상클래스로 변경
public abstract class interClass02 implements inter { 
    @Override
    public void turnOn(){
    	System.out.println("!!!")
    }
}

 

상속

인터페이스 간의 상속은 extends 키워드를 사용한다.

클래스와 달리 다중 상속이 가능하다.

인터페이스의 구현과 상속은 동시에 사용될 수 있다.

public class Main extends D implements C {

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

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

    @Override
    void d() {
        super.d();
    }

    public static void main(String[] args) {
        Main main = new Main();
        main.a();
        main.b();
        main.d();
    }
}

interface A {
    void a();
}

interface B {
    void b();
}

interface C extends A, B {
}

class D {
    void d() {
        System.out.println("D");
    }
}

//인터페이스 C는 아무것도 선언되어 있지 않지만
//인터페이스 A,B를 상속받아 메서드 a,b를 가짐

//Main 클래스는 인터페이스 C를 구현하여 메서드 a, b를 가지고
//클래스 D를 상속받아 메서드 d도 사용할 수 있음

 

 

디폴트 메서드와 static 메서드

 

디폴트 메서드

추상메서드의 기본적인 구현을 제공하는 메서드

메서드 앞에 default 키워드를 붙이며 블럭{}이 존재한다.

접근 제어자는 public이고 생략이 가능하다.

추상 메서드가 아니므로 인터페이스 구현체에서 필수로 오버라이딩 하지 않고, 바로 사용가능하다.

 

static 메서드

인터페이스의 static 메서드도 클래스 멤버처럼 객체없이 호출이 가능히다.

접근제어자는 public이다.(생략가능)

public class Main implements A { // A인터페이스를 구현한 Main클래스
	
    //추상메서드 : 재정의(오버라이딩)이 필수
    @Override
    public void a() {
        System.out.println("A");
    }

    public static void main(String[] args) {
        Main main = new Main();
        
        // 추상메서드
        main.a();
        
        // 디폴트 메서드 : 재정의 없이 바로 사용가능하다.
        main.aa();
        System.out.println();

        // static 메서드 : 클래스 메서드처럼 인터페이스명.으로 바로 사용가능
        A.aaa();
    }
}

interface A {

    // 추상메서드
    void a();
    
    // 디폴트 메서드
    default void aa() {
        System.out.println("AA");
    }
    // static 메서드
    static void aaa() {
        System.out.println("static method");
    }
}

 

다형성

 

타입변환

 

1) 자동 타입 변환

인터페이스 변수 = 구현 객체는 자동으로 변환이 일어난다.

2) 강제 타입 변환

구현 객체 타입 변수 = (구현 객체 타입) 인터페이스 변수는 강제적으로 변환이 필요하다.

public class Main {
    public static void main(String[] args) {

        // A 인터페이스에 구현체 B 대입
        A a1 = new B();
        a1.a();
        // a1.b(); // 불가능

        System.out.println("\nB 강제 타입변환");
        B b = (B) a1;
        b.a();
        b.b(); // 강제 타입변환으로 사용 가능
        System.out.println();

        // A 인터페이스에 구현체 B를 상속받은 C 대입
        A a2 = new C();
        a2.a();
        //a2.b(); // 불가능
        //a2.c(); // 불가능

        //강제 타입변환
        C c = (C) a2;
        c.a();
        c.b(); // 강제 타입변환으로 사용 가능
        c.c(); // 강제 타입변환으로 사용 가능


    }
}

interface A {
    void a();
}

class B implements A {
    @Override
    public void a() {
        System.out.println("B.a()");
    }
    public void b() {
        System.out.println("B.b()");
    }
}

class C extends B {
    public void c() {
        System.out.println("C.c()");
    }
}

 

 

추상클래스와 인터페이스의 차이

추상클래스는 다중상속이 불가능하다.

인터페이스는 다중상속이 가능하다.

 

추상클래스는 클래스 간의 연관관계를 구축하는데 사용한다.

인터페이스는 클래스와 별도로 구현 객체가 같은 동작을 한다는 것을 보장하기 위해 사용한다.

 

사용처

추상클래스	인터페이스
상속받을 클래스들의 공통 멤버가 많아 중복 멤버를 통합할 때 멤버에 public 이외의 접근제어자 선언이 필요할 때 non-static, final 선언이 필요할 때 요구사항과 함께 구현 세부 정보의 기능을 지정할 때 명확한 계층구조(클래스간에 의미있는 연관관계)를 구축할 때	어플리케이션의 기능을 정의하는 것을 추상화 할 때 서로 관련성이 없는 클래스를 묶어줄 때 다중 상속(구현)을 통한 설계를 할 때

 

+) 참고

[추상 클래스와 인터페이스에 관한 정보 블로그]

https://inpa.tistory.com/entry/JAVA-%E2%98%95-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4-vs-%EC%B6%94%EC%83%81%ED%81%B4%EB%9E%98%EC%8A%A4-%EC%B0%A8%EC%9D%B4%EC%A0%90-%EC%99%84%EB%B2%BD-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0#%EC%B6%94%EC%83%81_%ED%81%B4%EB%9E%98%EC%8A%A4_%EC%A0%95%EB%A6%AC