추상화(absratct)와 인터페이스(Interface)

조용근·2024년 1월 19일

자바 정리

목록 보기

4/21

추상 클래스

추상적인 데이터를 담고 있는 클래스(실체가 존재하지 않는다.)
//즉, 미완성 메서드이다.
추상 메서드가 하나라도 있는 클래스는 반드시 추상 클래스로 선언해야 한다.
//public abstract void sound();
추상 메서드는 상속 받는 자식 클래스가 반드시 오버라이딩해서 사용해야 함.
//추상 메서드는 실체가 존재하지 않기 때문이다.
//오버라이딩 하지 않으면 자식도 추상 클래스이어야함.

추상 클래스를 미완성으로 남겨 놓은 이유

추상 클래스를 상속받는 자식 클래스의 주제에 따라 상속 받는 메서드의 내용이 달라질 수 있기 때문이다.
부모(추상) 클래스에서 선언부만 작성하고, 구현부(실제 내용)은 상속 받는 클래스에서 구현하도록 남겨 놓는 개념이다.

추상 클래스 사용 방법

abstract class 클래스 이름{
}

이렇게 클래스 선언부에 abstract를 써주면 된다.

public void hello(){//선언부
	//구현부
}

추상클래스는 추상메서드를 포함하고 있다는 점을 제외하고는 일반적인 클래스와 똑같다. 위와 같이 선언부만 작성하고 구현부는 작성하지 않은 메서드가 추상메서드이다.

위와 같이 추상 메서드는 반드시 오버라이딩이 되야 한다.

오버라이딩을 해준 메서드들은 호출해서 출력이 가능하다.

다음 예제들을 살펴보자

abstract class Animals {
    // 추상 메서드 선언
    abstract void makeSound();
}

class Dog extends Animals {
    // 추상 메서드 구현
    void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animals {
    // 추상 메서드 구현
    void makeSound() {
        System.out.println("Meow!");
    }
}

public class AbstMain {
    public static void main(String[] args) {
        Animals dog = new Dog();
        Animals cat = new Cat();

        dog.makeSound();  // Woof!
        cat.makeSound();  // Meow!
    }
}

부모(추상)클래스에서 만든 메서드를 자식 클래스에서 상속 받아 사용한다.

public class Animals2 extends AnimalValue{
    String sound;

    //추상메서드 구현(재정의)
    @Override
    void sound(String sound){
        this.sound = sound;
    }
    @Override
    void behavior(){
        System.out.println(sound);
    }

    public static void main(String[] args) {
        Animals2 tiger = new Animals2();

        tiger.sound("어흥");
        tiger.behavior();
    }
}
//추상클래스
abstract class AnimalValue{
    abstract void sound(String sound);
    abstract void behavior();
}

@ Oerride가 붙은 메서드는 반드시 부모클래스 or 인터페이스에서 명시되어야 한다. //재정의 시 오타로 인한 오류를 막아주는 역할이다.

추상 클래스의 객체 생성

결론부터 말하면 불가능하다. 즉, 상속구조에서 부모 클래스를 나타내는 역할로만 사용되므로, new 생성자를 통해 객체를 바로 생성할 수 없다.
단, 부모 클래스를 호출하는 super()을 사용해서 추상 클래스 생성자 호출이 가능하다.

//부모 클래스
abstract class Shape{
    public String type;

    public Shape(String type){
        this.type = type;
    }
    public abstract void draw();
}

//자식 클래스
class Circle extends Shape{
    public double radius;

    public Circle(String type, double radius){
        super(type);
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + type + "with radius " + radius);
    }
}
class Rectangle extends Shape{
    public double width;
    public double height;

    public Rectangle(String type, double width, double height){
        super(type);
        this.width = width;
        this.height = height;
    }
    @Override
    public void draw(){
        System.out.println("Drawing a " + type + "with radius " + width);
    }
}

public class ShapeMain {
    public static void main(String[] args) {
        Shape circle = new Circle("circle ", 5.0);
        Shape rectangle = new Rectangle("rectangle ", 4.0,3.0);

        circle.draw();
       rectangle.draw();

    }
}

인터페이스

일종의 추상 클래스라고 볼 수 있다. 하지만 추상 클래스와 인터페이스는 약간의 차이점이 존재한다.

인터페이스 사용 방법

interface 인터페이스이름{
	public static final 타입 이름 = 값;
    public abstract 메서드이름 (매개변수);
}

모든 멤버변수는 public static final, 모든 메서드는 public abstract를 선언해야 하지만, 이를 생략할 수 있다.

// 인터페이스 선언
interface Drawable {
    void draw(); //public abstract void draw (추상 메서드 선언) 
}

// 인터페이스 구현하는 클래스
class Circle1 implements Drawable {
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 또 다른 인터페이스 구현하는 클래스
class Rectangle1 implements Drawable {
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Drawable d1 = new Circle1();
        Drawable d2 = new Rectangle1();

        d1.draw();  // Drawing a circle.
        d2.draw();  // Drawing a rectangle.
    }
}

!!보통의 경우, interface를 상속받을 때 implements를 사용하지만, interface가 interface를 상속받을 때는 extends를 사용한다.!!

추상 클래스와의 차이점

추상 메서드의 구현:
인터페이스는 모든 멤버 메서드가 기본적으로 추상이며, 구현을 포함하지 않는다.
//추상 클래스는 추상 메서드와 일반 메서드를 모두 포함할 수 있다.
멤버 변수:
인터페이스에 선언된 변수는 기본적으로 public, static,final이며, 변경할 수 없는 상수로 초기화해야 한다.
//추상 클래스는 final이 아닌 변수를 포함할 수 있으며, 멤버 변수가 상태를 가질 수 있다.
다중 상속:
인터페이스는 여러 개를 구현할 수 있다.
//추상 클래스는 다중 상속이 불가능하다.(한 클래스는 하나의 추상 클래스만 상속 받을 수 있다.)

interface A {
    void doingA();
}

interface B {
    void doingB();
}

interface C extends A, B {
    
}

인터페이스는 인터페이스로부터만 상속 가능하다.
다중 상속이 가능하다!

생성자:
인터페이스는 생성자를 가질 수 없다.
//추상 클래스는 생성자를 가질 수 있다.(자식 클래스 생성 시 초기화 과정 진행 가능)
접근 제어자:
인터페이스의 모든 메서드는 기본적으로 public(private도 가능하긴 하다.)
//추상 클래스의 메서드는 public,protected,private 등 다양한 접근 제어자를 가질 수 있다.
용도:
인터페이스는 서로 다른 클래스가 구현할 수 있는 공통의 행동을 정의할 때 사용된다.
즉, "할 수 있는" 행동을 명시한다.
//추상 클래스는 관련 클래스 사이의 공통적인 상태와 행동을 공유하는 데 사용된다.
//즉, "하는 방법"을 부분적으로 제공하고, 나머지는 자식 클래스에서 구현하도록 남겨둔다.
디자인 의도:
인터페이스는 어떤 클래스가 어떤 일을 할 수 있는지 정의하는 데 사용된다.
//추상 클래스는 재사용 가능한 코드를 제공하는 데 초점을 맞춘다. 즉, 추상 클래스를 상속하는 클래스의 기본적인 형태를 제공한다.