추상화
추상화
- 추상화는 반대로 기존 클래스들의 공통적인 요소들을 뽑아서 상위 클래스를 만들어 내는 것입니다.
abstract 제어자
- 주로 클래스와 메서드를 형용하는 키워드로 사용되는데, 메서드 앞에 붙은 경우를 ‘추상 메서드(abstract method)’, 클래스 앞에 붙은 경우를 ‘추상 클래스(abstract class)’라 각각 부릅니다.
- 추상 메서드는 충분히 구체화되지 않은 ‘미완성 메서드’이며, 미완성 메서드를 포함하는 클래스는 ‘미완성 클래스’를 의미하는 추상 클래스가 됩니다.
추상 클래스
- 추상 클래스는 앞서 설명한 대로 미완성 설계도이기 때문에 메서드 바디가 완성되기 전까지 이를 기반으로 객체 생성이 불가합니다.
- 객체도 생성하지 못하는 미완성 클래스를 만드는 이유
추상 클래스는 상속 관계에 있어 새로운 클래스를 작성하는 데 매우 유용합니다.
상위 클래스에서는 선언부만을 작성하고, 실제 구체적인 내용은 상속을 받는 하위 클래스에서 구현하도록 비워둔다면 설계하는 상황이 변하더라도 보다 유연하게 변화에 대응할 수 있습니다.
추상 클래스는 자바 객체지향 프로그래밍의 마지막 기둥인 추상화를 구현하는데 핵심적인 역할을 수행합니다.
추상화를 한마디로 정리하면 “객체의 공통적인 속성과 기능을 추출하여 정의하는 것”
- 오버라이딩을 통해 추상 클래스로부터 상속받은 추상 메서드의 내용을 구현하여 메서드를 완성시킬 수 있고, 이렇게 완성된 클래스를 기반으로 해당 객체를 생성할 수 있습니다.
abstract class Animal {
public String kind;
public abstract void sound();
}
class Dog extends Animal { // Animal 클래스로부터 상속
public Dog() {
this.kind = "포유류";
}
public void sound() { // 메서드 오버라이딩 -> 구현부 완성
System.out.println("멍멍");
}
}
class Cat extends Animal { // Animal 클래스로부터 상속
public Cat() {
this.kind = "포유류";
}
public void sound() { // 메서드 오버라이딩 -> 구현부 완성
System.out.println("야옹");
}
}
class DogExample {
public static void main(String[] args) throws Exception {
Animal dog = new Dog();
dog.sound();
Cat cat = new Cat();
cat.sound();
}
}
// 출력값
멍멍
야옹
final 키워드
- final 키워드는 필드, 지역 변수, 클래스 앞에 위치할 수 있으며 그 위치에 따라 그 의미가 조금씩 달라지게 됩니다.
클래스: 변경 또는 확장 불가능한 클래스, 상속 불가
메서드: 오버라이딩 불가
변수: 값 변경이 불가한 상수 - 공통적으로 변경이 불가능하고 확장할 수 없다는 점에서 유사하다고 할 수 있습니다.
final class FinalEx { // 확장/상속 불가능한 클래스
final int x = 1; // 변경되지 않는 상수
final int getNum() { // 오버라이딩 불가한 메서드
final int localVar = x; // 상수
return x;
}
}
인터페이스(interface)
- 기본적으로 인터페이스도 추상 클래스처럼 자바에서 추상화를 구현하는 데 활용된다는 점에서 동일하지만, 추상 클래스에 비해 더 높은 추상성을 가진다는 점에서 큰 차이가 있습니다.
추상 클래스는 메서드 바디가 없는 추상 메서드를 하나 이상 포함한다는 점 외에는 기본적으로 일반 클래스와 동일하다고 할 수 있습니다.
반면 인터페이스는 기본적으로 추상 메서드와 상수만을 멤버로 가질 수 있다는 점에서 추상 클래스에 비해 추상화 정도가 더 높다고 할 수 있습니다.
public interface InterfaceEx {
public static final int rock = 1; // 인터페이스 인스턴스 변수 정의
final int scissors = 2; // public static 생략
static int paper = 3; // public & final 생략
public abstract String getPlayingNum();
void call() //public abstract 생략
}
인터페이스의 구현
- “구현하다”라는 의미를 가진 implements 키워드를 사용합니다.
- 특정 인터페이스를 구현한 클래스는 해당 인터페이스에 정의된 모든 추상메서드를 구현해야 합니다.
즉, 어떤 클래스가 특정 인터페이스를 구현한다는 것은 그 클래스에게 인터페이스의 추상 메서드를 반드시 구현하도록 강제하는 것을 의미합니다.
다른 말로, 어떤 클래스가 어떤 인터페이스를 구현한다는 것은 그 인터페이스가 가진 모든 추상 메서드들을 해당 클래스 내에서 오버라이딩하여 바디를 완성한다는 의미를 가집니다.
class 클래스명 implements 인터페이스명 {
... // 인터페이스에 정의된 모든 추상메서드 구현
}
인터페이스 다중적 구현
- 인터페이스는 다중적 구현이 가능합니다.
interface Animal { // 인터페이스 선언. public abstract 생략 가능.
public abstract void cry();
}
interface Pet {
void play();
}
class Dog implements Animal, Pet { // Animal과 Pet 인터페이스 다중 구현
public void cry(){ // 메서드 오버라이딩
System.out.println("멍멍!");
}
public void play(){ // 메서드 오버라이딩
System.out.println("원반 던지기");
}
}
class Cat implements Animal, Pet { // Animal과 Pet 인터페이스 다중 구현
public void cry(){
System.out.println("야옹~!");
}
public void play(){
System.out.println("쥐 잡기");
}
}
public class MultiInheritance {
public static void main(String[] args) {
Dog dog = new Dog();
Cat cat = new Cat();
dog.cry();
dog.play();
cat.cry();
cat.play();
}
}
// 출력값
멍멍!
원반 던지기
야옹~!
쥐 잡기
- 특정 클래스는 다른 클래스로부터의 상속을 받으면서 동시에 인터페이스를 구현할 수 있습니다.
abstract class Animal { // 추상 클래스
public abstract void cry();
}
interface Pet { // 인터페이스
public abstract void play();
}
class Dog extends Animal implements Pet { // Animal 클래스 상속 & Pet 인터페이스 구현
public void cry(){
System.out.println("멍멍!");
}
public void play(){
System.out.println("원반 던지기");
}
}
class Cat extends Animal implements Pet { // Animal 클래스 상속 & Pet 인터페이스 구현
public void cry(){
System.out.println("야옹~!");
}
public void play(){
System.out.println("쥐 잡기");
}
}
public class MultiInheritance {
public static void main(String [] args) {
Dog dog = new Dog();
Cat cat = new Cat();
dog.cry();
dog.play();
cat.cry();
cat.play();
}
}
// 출력값
멍멍!
원반 던지기
야옹~!
쥐 잡기
인터페이스의 장점
- 기본 코드 에서 Provider클래스를 Provider2클래스로 교체해야하는 상황일 경우,
public class InterfaceExample {
public static void main(String[] args) {
User user = new User(); // User 클래스 객체 생성
user.callProvider(new Provider()); // Provider 객체 생성 후에 매개변수로 전달
}
}
class User { // User 클래스
public void callProvider(Provider provider) { // Provider 객체를 매개변수로 받는 callProvider 메서드
provider.call();
}
}
class Provider { //Provider 클래스
public void call() {
System.out.println("무야호~");
}
}
// 출력값
무야호~
- 하드 코딩
public class InterfaceExample {
public static void main(String[] args) {
User user = new User(); // User 클래스 객체 생성
user.callProvider(new Provider2()); // Provider객체 생성 후에 매개변수로 전달
}
}
class User { // User 클래스
public void callProvider(Provider2 provider) { // Provider 객체를 매개변수로 받는 callProvider 메서드
provider.call();
}
}
class Provider2 { //Provider 클래스
public void call() {
System.out.println("야호~");
}
}
// 출력값
야호~
- 추상화 적용
interface Cover { // 인터페이스 정의
public abstract void call();
}
public class Interface4 {
public static void main(String[] args) {
User user = new User();
// Provider provider = new Provider();
// user.callProvider(new Provider());
user.callProvider(new Provider2());
}
}
class User {
public void callProvider(Cover cover) { // 매개변수의 다형성 활용
cover.call();
}
}
class Provider implements Cover {
public void call() {
System.out.println("무야호~");
}
}
class Provider2 implements Cover {
public void call() {
System.out.println("야호~");
}
}
//출력값
야호~
- 이제 Provider 클래스의 내용 변경 또는 교체가 발생하더라도 User 클래스는 더 이상 코드를 변경해주지 않아도 같은 결과를 출력해 낼 수 있습니다.
- 인터페이스는 기능이 가지는 역할과 구현을 분리시켜 사용자로 복잡한 기능의 구현이나 교체/변경을 신경 쓰지 않고도 코드 변경의 번거로움을 최소화하고 손쉽게 해당 기능을 사용할 수 있도록 합니다.
- 선언과 구현을 분리시켜 개발시간을 단축할 수 있고, 독립적인 프로그래밍을 통해 한 클래스의 변경이 다른 클래스에 미치는 영향을 최소화할 수 있다는 큰 장점이 있습니다.
추상화 예제
- 추상화 적용 전
//카페 손님
public class CafeCustomer {
public String CafeCustomerName;
public void setCafeCustomerName(String cafeCustomerName) {
this.CafeCustomerName = cafeCustomerName;
}
}
//CafeCustomer 클래스로부터 단골손님A와 단골손님B 상속
public class CafeCustomerA extends CafeCustomer {
}
public class CafeCustomerB extends CafeCustomer {
}
//카페 사장님
public class CafeOwner {
public void giveItem(CafeCustomerB cafeCustomerB) {
System.out.println("give a glass of strawberry latte to CafeCustomer B");
}
public void giveItem(CafeCustomerA cafeCustomerA) {
System.out.println("give a glass of iced americano to CafeCustomer A");
}
}
//메뉴 주문
public class OrderExample {
public static void main(String[] args) throws Exception {
CafeOwner cafeowner = new CafeOwner();
CafeCustomerA a = new CafeCustomerA();
CafeCustomerB b = new CafeCustomerB();
cafeowner.giveItem(a);
cafeowner.giveItem(b);
}
}
// 출력값
give a glass of iced americano to CafeCustomer A
give a glass of strawberry latte to CafeCustomer B
- 추상화 적용 후
interface Customer {
String getOrder();
}
class CafeCustomerA implements Customer {
public String getOrder(){
return "a glass of iced americano";
}
}
class CafeCustomerB implements Customer {
public String getOrder(){
return "a glass of strawberry latte";
}
}
class CafeOwner {
public void giveItem(Customer customer) {
System.out.println("Item : " + customer.getOrder());
}
}
public class OrderExample {
public static void main(String[] args) throws Exception {
CafeOwner cafeowner = new CafeOwner();
Customer cafeCustomerA = new CafeCustomerA();
Customer cafeCustomerB = new CafeCustomerB();
cafeowner.giveItem(cafeCustomerA);
cafeowner.giveItem(cafeCustomerB);
}
}
// 출력값
Item : a glass of iced americano
Item : a glass of strawberry latte
- 인터페이스를 사용하지 않았을 때 손님의 수만큼 giveItem() 메서드가 필요했던 CafeOwner 클래스가 Customer 인터페이스 사용 후에 단 한 개의 giveItem 메서드로 구현이 가능해졌습니다.