추상 클래스(Abstract class) vs 인터페이스

<추상 클래스>

 

추상 메소드를 포함하는 클래스

 

*추상 메소드: 선언만 있고(원형이 존재한다), 정의는 없는(내용이 없다: {}블록이 존재하지 않는다) 메소드 

-> 일반 메소드도 포함할 수 있다. 한 개 이상의 추상 메소드가 있다면 추상 클래스로 본다.

-> 추상클래스는 상속을 받아 사용된다.

 

*콘크리트 클래스(상속받은 클래스, 하위 클래스): 딱딱한, 확고한, 내용이 있는. 추상 메소드를 재정의(오버라이딩) 해서 사용한다. 

 

 

-용도

클래스 설계시, 뼈대 및 설계도의 역할(상속은 거의 추상클래스의 형태로 나타난다) 

 

 

-추상 클래스 인스턴스 생성

1)추상 클래스 만으로는 인스턴스를 만들 수 없다: 상위 클래스-상위 생성자 불가(상-상X)

 

2)하위 클래스(콘크리트 객체)를 이용해 인스턴스를 만든다.(오버라이딩)★(하-하)

 

3)추상 클래스 추상 객체 = new 콘크리트 생성자(); -> 가능은 하다. 잘 사용하진 않는다.(상-하)

 

 

<예제>

 

 
abstract class Sum { //추상 클래스
    public abstract String toString();
    // {}블록이 없는 메소드 -> 추상 메소드
 
    public String sum(int i, int k) {
        int sum = i + k;
        return " " + sum;
    }
}
 
class Sum_s1 extends Sum { //상속
    public String toString() {
        return "class Sum_s1 extends Sum";
    } // toString 오버라이딩(반드시 재정의)
}
 
class Sum_s2 extends Sum {
    public String toString() {
        return "class Sum_s2 extends Sum";
    }
}
 
public class SumMain {
    public static void main(Stirng args[]) {
 
        Sum_s1 s1 = new Sum_s1();
        System.out.println(s1.sum(10, 20));
        System.out.println(s1.toString());
 
        Sum_s2 s2 = new Sum_s2();
        System.out.println(s2.sum(10, 20));
        System.out.println(s2.toString());
    }
}
 
 

 

 

 

<인터페이스>

 

: 추상메소드로만 구성된 클래스(일반 메소드는 단 한 개도 포함되지 않음, 내용이 1도 없다) 
-> 변수는 존재, 거의 상수 

인터페이스는 상속(extends)이라는 표현을 사용하지 않는다.

-> 상속해줄 게 없기 때문★ 대신, '적용(implements)'한다는 표현을 사용한다,(모든 것에 적용 가능)
-> 하위 클래스 = 구현 클래스 

 

 

-장점

1)공동 작업시 충돌을 방지할 수 있다.

 

2)유지보수가 편리하다.(규격만 맞으면 다른 부품으로 대체 가능)

 

 

-인터페이스 인스턴스 생성
1)인터페이스 인터페이스 객체변수 = new 인터페이스 생성자(); -> (상-상 X) 메모리 할당 불가

2)구현클래스 구현클래스 객체변수 = new 구현클래스 생성자(); -> (하-하 O) 가능은 하다 
: 구현클래스에서 인터페이스 재정의(오버라이딩)

 

★3)인터페이스 인터페이스 객체변수 = new 구현클래스 생성자(); -> (상-하 O) 주로 이 다형성 방식 이용★
-> 적은 기능으로 정확한 사용 가능하게 만드는 목적(간단하게), 쉽게 바뀌어도 안 된다. 

 

 

<예제>

 

 
interface B { // class라고 하지 않음
    void display(String s);
}
 
class D1 implements B { //extends X -> implements
    String str = "";
    public void display(String s) {
        str = s;
        System.out.println("클래스 D1객체 이용: " + s);
    }
}
 
class D2 implments B {
    String str = "";
    public void display(String s) {
        str = s;
        System.out.println("클래스 D2객체 이용: " + s);
 
    //하위클래스에서는 확장메소드 추가 가능
    }
}
 
class IR2 {
    public static void main(String args[]) {
 
        B memo;
        memo = new D1();
        memo.display("석모도");
 
        D1 d1 = (D1)memo;
        //객체 형변환 -> new 생성하면 전혀 다른 객체 생성
        System.out.println("d1.str");
 
        memo = new D2();
        memo.display("강화도");
 
        D2 d2 = (D2)memo;
        System.out.println(d2.str);
        //memo가 d1, d2 등으로 쓰임 -> 
    }
}
 

 

 

 

<다중 구현>

 

다중 상속은 원칙적으로 불가능하지만, interface만 다중 구현이 허용된다.
두 개 이상의 인터페이스를 받는 경우는 조작하는 데 혼란이 올 수 있기 때문에 다형성을 사용해 인스턴스를 생성하지 않는다.

-> 하위객체-하위생성자 사용

 

 

<예제>

 

 
interface Green {
    public String greenColor();
}
 
class Greenmp implements Green {
    public String greenColor()    {
        return "초록색입니다.";
    }
}
 
interface Red {
    public String redColor();
}
 
class Redmp implements Red {
    public String redColor() {
        return "빨간색입니다.";
    }
}
 
class Color implements Green, Red {
    public String greenColor() {
        return "초록색";
    {
 
    public String RedColor() {
        return "빨간색";
    }
} //다중상속은 인터페이스만 허용된다!
 
public class ColorMain {
    public static void main(String args[]) {
        Green g = new Greenmp();
        System.out.println(g.greenColor());
 
        Red r = new Redmp();
        System.out.println(r.redColor());
 
        Color c = new Color();
        //다중상속 구현클래스는 하위객체 사용
        //혼란을 방지하기 위해
        System.out.println(c.greenColor() + c.redColor());
    }
}