자바에서 추상 클래스를 선언하고 사용하는 방법은 무엇인가요?

Q1: 자바에서 추상 클래스란 무엇인가요?
A1: 추상 클래스(Abstract Class)는 하나 이상의 추상 메서드(구현이 없는 메서드)를 포함할 수 있는 클래스입니다. 직접 인스턴스를 생성할 수 없고, 서브클래스가 상속받아 구현하도록 설계된 클래스입니다.

Q2: 자바에서 추상 클래스를 선언하는 문법은 어떻게 되나요?
A2: `abstract` 키워드를 클래스 선언 앞에 붙여서 선언합니다. 예:
```java
public abstract class Animal {
// 클래스 내용
}
```

Q3: 추상 클래스에 추상 메서드를 선언하는 방법은?
A3: 메서드 선언에 `abstract` 키워드를 사용하며, 메서드 몸체(블록)를 작성하지 않습니다. 예:
```java
public abstract void sound();
```

Q4: 추상 클래스 내에는 일반 메서드를 포함할 수 있나요?
A4: 네, 추상 클래스는 일반 메서드(구현된 메서드)도 포함할 수 있습니다.

Q5: 추상 클래스에서 생성자를 사용할 수 있나요?
A5: 네, 추상 클래스도 생성자를 가질 수 있으며, 서브클래스가 객체 생성 시 자동 호출됩니다.

Q6: 추상 클래스의 인스턴스를 직접 생성할 수 있나요?
A6: 아니요. 추상 클래스는 직접 인스턴스화 할 수 없으며, 반드시 서브클래스가 상속받아 구체적으로 구현해야 합니다.

Q7: 추상 클래스를 상속받아 사용하는 방법은?
A7: 일반 클래스에서 `extends` 키워드로 추상 클래스를 상속받고, 추상 메서드를 모두 구현하여야 합니다. 예:
```java
public class Dog extends Animal {
@Override
public void sound() {
System.out.println("멍멍");
}
}
```

Q8: 서브클래스가 추상 메서드를 구현하지 않으면 어떻게 되나요? A8: 서브클래스도 추상 메서드를 갖게 되므로 추상 클래스가 되어야 하며, 인스턴스를 생성할 수 없습니다.

Q9: 인터페이스와 추상 클래스의 차이는 무엇인가요?
A9:
- 추상 클래스는 상태(필드)를 가질 수 있으나, 인터페이스는 기본적으로 상태를 가지지 않습니다(상수 제외).
- 추상 클래스는 단일 상속만 가능하지만, 인터페이스는 다중 구현이 가능합니다.
- 인터페이스 메서드는 기본적으로 추상 메서드이며 자바 8 이후 디폴트 메서드도 가능합니다.

Q10: 예제 코드로 추상 클래스 선언 및 사용법을 보여주세요.
A10:
```java
// 추상 클래스 선언
public abstract class Animal {
public abstract void sound(); // 추상 메서드

public void sleep() { // 일반 메서드
System.out.println("잠을 잡니다.");
}
}

// 추상 클래스 상속 및 구현
public class Dog extends Animal {
@Override
public void sound() {
System.out.println("멍멍");
}
}

// 실행 클래스
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.sound(); // 출력: 멍멍
dog.sleep(); // 출력: 잠을 잡니다.
}
}
```

요약하면, 자바에서 추상 클래스는 `abstract` 키워드를 사용해 선언하며, 추상 메서드를 포함해 서브클래스가 반드시 구현하도록 강제하는 역할을 합니다. 직접 인스턴스 생성 불가하며, 상속받은 클래스는 반드시 추상 메서드를 구현해야만 합니다.

자바에서 추상 클래스는 ‘미완성 설계도’와 같다고 생각하면 됩니다. 즉, 추상 클래스는 어떤 공통된 특징이나 기능을 담아 놓았지만, 모든 구체적인 내용을 다 채우지 않고 일부는 나중에 직접 만든 클래스에서 꼭 채우도록 미뤄둔 클래스입니다.

추상 클래스를 선언하려면, 클래스 이름 앞에 `abstract` 키워드를 붙입니다. 그리고 추상 메소드도 만들 수 있는데, 이것은 ‘어떤 기능을 반드시 만들어 주세요’라고 표시하는 메소드입니다. 여기에는 몸체(내용)를 적지 않고, 나중에 이 클래스를 상속받은 다른 클래스가 그 내용을 직접 만들어야 합니다.

기본 문법

```java
// 추상 클래스 선언
abstract class Animal {
// 일반 메소드 (이미 내용이 있는 메소드)
void breathe() {
System.out.println("숨쉬기");
}

// 추상 메소드 (내용 없이 선언만 함)
abstract void sound();
}
```

- 위 예제에서 `Animal` 클래스는 동물의 공통된 특성을 담고 있어요.
- `breathe()`는 숨쉬기라는 공통 기능이므로 내용을 다 적어 두었고,
- `sound()`는 동물이 내는 소리인데, 종류마다 다를 수 있어서 내용을 비워두고, 상속받는 쪽에서 꼭 만들어 달라고 한 것입니다.

추상 클래스 사용법

추상 클래스는 직접 ‘new’로 객체를 만들 수 없어요. 대신 추상 클래스를 상속받은 자식 클래스에서 그 추상 메소드를 반드시 구체적으로 만들어야 합니다.

```java
// Animal을 상속받는 구체적인 클래스
class Dog extends Animal {
// 추상 메소드를 꼭 구현해야 한다!
void sound() {
System.out.println("멍멍");
} }

class Cat extends Animal {
void sound() {
System.out.println("야옹");
}
}
```

이제 사용할 때는 이렇게 쓸 수 있어요:

```java
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.breathe(); // 숨쉬기 출력
dog.sound(); // 멍멍 출력

Animal cat = new Cat();
cat.breathe(); // 숨쉬기 출력
cat.sound(); // 야옹 출력
}
}
```

요약

- `abstract` 키워드로 추상 클래스를 만듦
- 추상 클래스 안에 추상 메소드(`abstract` + 메소드 선언만) 가능
- 추상 클래스는 직접 객체 생성 불가
- 추상 클래스를 상속받는 자식 클래스가 추상 메소드를 반드시 구현해야 함
- 공통 기능은 추상 클래스에, 다를 수 있는 기능은 추상 메소드로 만들어 유연하게 코드를 작성할 수 있음

이렇게 하면 여러 종류의 객체를 비슷하면서도 다르게 다룰 수 있어서 편리합니다.

자바에서 추상 클래스 선언과 사용법 요약:

- 추상 클래스 선언 :
`abstract` 키워드를 클래스 앞에 붙여 선언한다.
예) `public abstract class Animal { ... }`

- 특징 :
1. 인스턴스 생성 불가 (new로 직접 생성 못함)
2. 추상 메서드(선언만 있고 구현은 없는 메서드)를 포함할 수 있음
3. 일반 메서드(구현된 메서드)도 포함 가능
4. 구체 클래스로부터 상속받아 추상 메서드를 반드시 구현해야 함

- 사용법 :
1. 추상 클래스는 상속을 통해 확장된다.
2. 자식 클래스에서 추상 메서드를 오버라이드하여 구현한다.
3. 자식 클래스 객체를 생성하여 사용한다.

핵심 포인트
- `abstract` 키워드로 추상 클래스를 만들고, 직접 객체 생성 불가
- 추상 메서드를 선언해 서브클래스에 구현 강제
- 추상 클래스는 '템플릿 역할'과 공통 기능 구현 제공 목적
- 다형성 다룰 때 매우 유용

---

간단 예시
```java
abstract class Animal {
abstract void sound(); // 추상 메서드

void breathe() { // 일반 메서드
System.out.println("숨을 쉰다.");
}
}

class Dog extends Animal {
@Override
void sound() {
System.out.println("멍멍");
}
}

public class Main {
public static void main(String[] args) {
Animal dog = new Dog(); // 추상 클래스 타입 참조변수 가능
dog.sound(); // "멍멍"
dog.breathe(); // "숨을 쉰다."
}
}
```

이를 통해 추상 클래스는 공통 인터페이스 제공과 구현 강제, 코드 재사용을 동시에 가능하게 함을 알 수 있다.

자바 추상 클래스 선언 및 사용법

1. 추상 클래스 선언
- 키워드: `abstract`
- 형식:
```java
abstract class 클래스명 {
// 필드
// 생성자
// 일반 메서드
// 추상 메서드 (선언만, 구현 없음)
abstract 리턴타입 메서드명(매개변수);
}
```

2. 추상 메서드 정의
- 구현 없이 시그니처만 작성
- 서브클래스에서 반드시 구현해야 함

3. 추상 클래스 특징
- 인스턴스 생성 불가 (`new` 불가)
- 상속하여 사용
- 일반 메서드와 추상 메서드 모두 포함 가능

4. 추상 클래스 사용 예시
```java abstract class Animal {
abstract void sound();
void sleep() {
System.out.println("잠자다");
}
}

class Dog extends Animal {
void sound() {
System.out.println("멍멍");
}
}

public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.sound(); // 멍멍
dog.sleep(); // 잠자다
}
}
```

요약:
- `abstract` 키워드로 추상 클래스/메서드 선언
- 추상 클래스는 인스턴스 생성 불가
- 서브클래스가 추상 메서드 구현 필수
- 추상 클래스는 공통 기능 정의 및 강제 구현에 사용

자바에서 추상 클래스를 선언하고 사용하는 방법

1. 추상 클래스 선언
- 키워드: `abstract`
- 문법: `public abstract class 클래스명 { ... }`
- 특징:
- 인스턴스 생성 불가
- 추상 메서드 포함 가능 (`abstract` 메서드)
- 구체적 메서드(일반 메서드)도 포함 가능

2. 추상 메서드 선언
- 키워드: `abstract`
- 문법: `public abstract 반환타입 메서드명(매개변수);`
- 특징:
- 메서드 본체가 없음(세미콜론으로 끝남)
- 서브 클래스에서 반드시 구현(오버라이드)해야 함

3. 추상 클래스 상속 및 구현
- 서브 클래스는 추상 클래스를 상속받음 (`extends`)
- 서브 클래스는 추상 메서드를 모두 구현(오버라이드)해야 인스턴스를 생성할 수 있음
- 만약 서브 클래스가 추상 메서드를 구현하지 않으면, 서브 클래스도 추상 클래스로 선언해야 함

4. 사용 예시
```java
abstract class Animal { public abstract void sound();
public void breathe() {
System.out.println("숨을 쉽니다.");
}
}

class Dog extends Animal {
@Override
public void sound() {
System.out.println("멍멍");
}
}

public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.sound(); // 출력: 멍멍
dog.breathe(); // 출력: 숨을 쉽니다.
}
}
```

요약:
- `abstract` 키워드로 추상 클래스와 추상 메서드를 선언
- 서브 클래스에서 추상 메서드를 반드시 구현
- 추상 클래스는 직접 인스턴스 생성 불가, 서브 클래스 인스턴스 생성 후 활용

- `abstract` 키워드를 사용해 클래스 선언: `public abstract class 클래스명 { ... }`
- 추상 메서드는 `abstract` 키워드로 선언하며, 몸체 없음: `public abstract 반환타입 메서드명(매개변수);`
- 추상 클래스는 직접 객체 생성 불가: `new 추상클래스()` 금지
- 추상 클래스를 상속받는 서브클래스는 추상 메서드를 반드시 구현하거나, 서브클래스도 추상 클래스로 선언
- 추상 클래스는 일반 메서드와 멤버 변수도 가질 수 있음
- 추상 클래스 참조 변수는 서브클래스 인스턴스를 가리킬 수 있음 (다형성 활용)

자바에서 추상 클래스는 객체 지향 프로그래밍의 중요한 개념 중 하나로, 공통적인 속성과 메서드를 정의하면서도 인스턴스를 생성할 수 없는 클래스를 말합니다.

추상 클래스는 다른 클래스들이 상속받아 구체적인 구현을 제공할 수 있도록 하는 역할을 합니다.

이번 포스트에서는 자바에서 추상 클래스를 선언하고 사용하는 방법에 대해 알아보겠습니다.

1. 추상 클래스 선언하기추상 클래스는 `abstract` 키워드를 사용하여 선언합니다.

추상 클래스는 일반 클래스와 마찬가지로 필드와 메서드를 가질 수 있지만, 하나 이상의 추상 메서드를 포함해야 합니다.

추상 메서드는 구현이 없는 메서드로, 서브클래스에서 반드시 구현해야 합니다.

```javaabstract class Animal { // 필드 String name; // 생성자 public Animal(String name) { this.name = name; } // 추상 메서드 abstract void sound(); // 일반 메서드 void eat() { System.out.println(name + " is eating."); }}```위의 예제에서 `Animal` 클래스는 추상 클래스이며, `sound()` 메서드는 추상 메서드로 선언되어 있습니다.

`eat()` 메서드는 일반 메서드로, 서브클래스에서 상속받아 사용할 수 있습니다.



2. 추상 클래스 상속받기추상 클래스를 상속받는 서브클래스는 반드시 모든 추상 메서드를 구현해야 합니다.

그렇지 않으면 서브클래스도 추상 클래스로 선언해야 합니다.

```javaclass Dog extends Animal { public Dog(String name) { super(name); } // 추상 메서드 구현 @Override void sound() { System.out.println(name + " says: Woof!"); }}class Cat extends Animal { public Cat(String name) { super(name); } // 추상 메서드 구현 @Override void sound() { System.out.println(name + " says: Meow!"); }}```위의 예제에서 `Dog`와 `Cat` 클래스는 `Animal` 클래스를 상속받고, `sound()` 메서드를 구현하고 있습니다.



3. 추상 클래스 사용하기추상 클래스를 사용하여 객체를 생성할 수는 없지만, 서브클래스의 객체를 생성하여 사용할 수 있습니다.

```javapublic class Main { public static void main(String[] args) { Animal dog = new Dog("Buddy"); Animal cat = new Cat("Whiskers"); dog.sound(); // 출력: Buddy says: Woof! dog.eat(); // 출력: Buddy is eating. cat.sound(); // 출력: Whiskers says: Meow! cat.eat(); // 출력: Whiskers is eating. }}```위의 코드에서 `Dog`와 `Cat` 클래스의 객체를 생성하고, 각각의 `sound()`와 `eat()` 메서드를 호출하고 있습니다.

결론자바에서 추상 클래스는 코드의 재사용성과 유연성을 높여주는 중요한 개념입니다.

추상 클래스를 통해 공통적인 기능을 정의하고, 서브클래스에서 구체적인 구현을 제공함으로써 객체 지향 프로그래밍의 원칙을 잘 따를 수 있습니다.

추상 클래스를 적절히 활용하면 코드의 유지보수성과 확장성을 크게 향상시킬 수 있습니다.