AWS BACK DAY 8. "상속과 인터페이스를 이용한 객체 지향 프로그래밍: 추상 클래스와 인터페이스"

이강용·2023년 1월 10일

Java - 기초

Java 기초

목록 보기

8/26

접근 지정자

단축어

alt+shift+s : getter & setter
ctrl+M : 전체화면

생성자

필드의 기본값(디폴트)을 설정하여 사용할 수 있는 형태로 만듦
기본 생성자 -> 매개변수가 없는 생성자
모든 클래스는 생성자가 반드시 존재하며 하나 이상 가질 수 있음
생성자 선언을 생략하면 컴파일러는 다음과 같은 기본 생성자 추가
클래스 내에 생성자가 하나도 없을 경우 컴파일러가 내용이 비어있는 기본 생성자를 자동으로 생성함
(주의) 생성자가 1개 이상 존재할 경우 컴파일러가 기본으로 생성자를 생성하지 않음

클래스간 겹치는 변수가 있을 때

extends class명

기본 생성자 생성 단축키 : ctrl + space + enter

Class A
Class B extends A : 메모리는 B & A
Class C extends A : 메모리는 C & A

부모가 가진 메소드를 자식에서 재정의 하는것이
@Override (주소값도 달라짐)

why?

Class는 Upcasting(상위 - 생략가능), Downcasting(하위 - 생략불가능)

자식 타입은 부모 타입으로 자동 형변환 가능

상위(클래스)는 하위(클래스)를 포함한다고 생각해야한다.

추상 클래스 (Abstract class)

추상(abstract)
실체들 간에 공통퇴는 특성을 추출한 것
- 예1 : 새, 곤충, 물고기 -> 동물(추상)
- 예2 : 삼성, 현대 ,LG ->회사 (추상)

추상 클래스(abstract class) :
실체 클래스들의 공통되는 필드와 메소드 정의한 클래스
추상 클래스는 실체 클래스의 부모 클래스 역할(단독 객체 x)

추상 클래스의 용도
실체 클래스의 공통된 필드와 메소드의 이름 통일할 목적

실체 클래스를 설계자가 여러 사람일 경우
실체 클래스마다 필드와 메소드가 제각기 다른 이름을 가질 수 있음
실체 클래스를 작성할 때 시간 절약
실체 클래스는 추가적인 필드와 메소드만 선언

실체 클래스 설계 규격을 만들고자 할때
실체 클래스가 가져야 할 필드와 메소드를 추상 클래스에 미리 정의
실체 클래스는 추상 클래스를 무조건 상속 받아 작성

추상 클래스 선언
클래스 선언에 abstract 키워드 사용
- New 연산자로 객체 생성하지 못하고 상속을 통해 자식 클래스만 생성 가능

추상 클래스 (특징)
1. 자식 클래스가 사용할 멤버의 이름 통일
2. 추상 메서드를 가지고 있는 클래스
3. 추상 클래스는 객체 생성 불가 (변수 선언은 가능)
4. 반드시 상속하여 추상메서드를 Override(재정의)하여 구현해야 함

구현방법

추상 클래스에는 메소드의 선언부만 작성(코드블럭이 없음) - 추상 메서드
실체 클래스(자식클래스)에서 메서드의 실행 내용 작성(오버라이딩(Overriding))

추상 클래스는 ✨항상 추상 메서드를 포함한다. 구현코드(함수 몸체)가 없음

기본형태

abstract int add(int x, int y);

예제

public abstract class Animal {
	
	public String kind;
	
	public void breath3() {
		System.out.println("숨을 쉽니다.");
	}
	// 추상 메서드 ( 무조건 추상 클래스가 존재 해야함 )
	// 추상 메서드는 실행 소스코드가 있는 코드 블럭이 없음
	public abstract void sound(); //추상메서드는 실행을 자식 클래스에서 함
}

main

public class AnimalEx {

	public static void main(String[] args) {
		
		Cat cat = new Cat();
		Dog dog = new Dog();
		
		dog.sound();
		cat.sound();
		System.out.println("-------------");
		
		
		// Animal 클래스는 추상 클래스이기 때문에 객체 생성은 불가능
		// Animal 클래스 타입의 변수 선언은 문제가 없음
		Animal animal = null; //new Animal(); 안됨
		
		// 다형성 응용
		animal = new Dog(); // 자식 클래스의 객체는 부모 클래스 타입의 변수에 저장 가능(대입)
		animal.sound();
		
		animal = new Cat();
		animal.sound();
		
		System.out.println("-------------");
		animalSound(new Dog());
		animalSound(new Cat());
		animalSound(cat);
		animalSound(dog);
	
	}
		public static void animalSound(Animal animal) {
			animal.sound();
		}
}

🎉 조금 더 쉬운 예를 보자

package j14_추상;

public abstract class Transportation {

	// 추상 메소드
	public abstract void go();
	
	public abstract void stop();
	
}

탈것 이라는 운송수단을 추상으로 표현해보자. 탈것의 운송수단에는 버스, 택시, 비행기, 기차 등 이있다. 이를 포함하는 Transportation 추상클래스를 생성한다.

package j14_추상;

public class Airplane extends Transportation {

	@Override
	public void go() {
		// TODO Auto-generated method stub
	
	}
	@Override
	public void stop() {
		// TODO Auto-generated method stub
	
	}
}

Transportation을 상속받는 Airplane 클래스를 생성한다. 부모 클래스(추상클래스)를 상속받기 때문에 부모 클래스의 메서드를 재정의 해서 사용하는데 몸체(Body)가 없다.

package j14_추상;

public class Subway extends Transportation{
	
	@Override	// @시작하는 문법을 어노테이션이라 한다.
	public void go() {
		System.out.println("지하철을 타고 출발");
	}
	@Override
	public void stop() {
		System.out.println("지하철을 타고 도착");
	}

	public void checkRoute() {
		System.out.println("지하철 노선 확인");
	}

}

마찬가지로 Trans 부모(추상)클래스를 상속 받고 재정의된 메서드에는 문장을 추가하였다.
그리고 새로운 메서드 checkroute()를 새롭게 정의하였다.

package j14_추상;

public class Taxi extends Transportation {

	@Override	// @시작하는 문법을 어노테이션이라 한다.
	public void go() {
		System.out.println("택시를 타고 출발");
	}
	
	@Override
	public void stop() {
		System.out.println("택시를 타고 도착");
	}
	
	public void checkTaxiNumber() {
		System.out.println("택시 번호 확인");
	}
}

Taxi 클래스 역시 Trans 클래스를 상속받아 재정의 및 새롭게 정의를 함

package j14_추상;

public class Main {
	
	public static void main(String[] args) {
		Transportation tp = new Subway();
		
		Transportation tp2 = new Taxi();
		
		tp.go();
		tp.stop();
		tp2.go();
		tp2.stop();	
	}
}

자식(Subway) 클래스 있는 CheckRoute() 메서드는 main문에서 호출할 수 없음
public void checkRoute() { System.out.println("지하철 노선 확인"); }
자식(Taxi) 클래스 있는 checkTaxiNumber() 메서드는 main문에서 호출할 수 없음
public void checkTaxiNumber() { System.out.println("택시 번호 확인"); }

인터페이스

구현 코드가 없는 인터페이스

인터페이스(interface)는 클래스 혹은 프로그램이 제동하는 기능을 명시적으로 선언하는 역할을 함
인터페이스는 추상메서드와 상수로만 이루어져있음
구현된 코드가 없기 때문에 인터페이스로 인스턴스를 생성할 수 없음

📌 인터페이스의 특징
다중 상속 가능
- 인터페이스는 껍데기만 존재하여 클래 상속 시 발생했던 모호함이 없음
- 그렇기에 다중 상속이 가능
추상 메서드와 상수만 사용가능
- 인터페이스에는 구현 코드를 생성할 수 없음
생성자 사용 불가
- 인터페이스 객체가 아니므로 생성자를 사용할 수 없음
메서드 오버라이딩 필수
- 자식클래스는 부모 인터페이스의 추상 메서드를 모두 오버라이딩 해야함

인터페이스 사용 이유

추상 클래스를 통해 객체들 간의 네이밍을 통일할 수 있고 이로 인해 코드의 가독성과 유지보수가 향상
확장에는 Open 변경에는 Close 구조, 객체(인스턴스) 간 결합도 (코드 종속성)를 낮춘 유연한 방식의 개발이 가능

✏️ 코드 종속성이란?
- 각각의 메서드 간의 결합도를 의미하며 인터페이스를 활용하면 한 메서드를 수정하였을 때, 다른 메서드도 수정해야 하는 상황을 줄여준다는 의미

인터페이스 만들기


public interface Calc{
double PI = 3.14;   //인터페이스에서 선언한 변수는 컴파일 과정에서 상수로 변환
int ERROR = -999999999;

int add(int num1, int num2);
int substact(int num1, int num2);
int times(int num1, int num2);
int divide(int num1, int num2);
}// 인터페이스에서 선언한 메서드는 컴파일 과정에서 추상메서드로 변환

클래스에서 인터페이스 구현하기

public abstract class Calculator implements Calc{
@Override
public int add(int num1, int num2){
return num1 + num2;
}

@Override
public int substract(int num1, int num2){
return num1 - num2;
	}
}

클래스 완성하고 실행하기

public class CompleteCalc extends Calculator{
@Override
public int times(int num1, int num2){
return num1 * num2;
}
@Override
public int divide(int num1, num2){
if(num2 != 0)
return num1/num2;
else
return Calc.ERROR;

public void showInfo(){
System.out.println("Calc 인터페이스를 구현하였습니다.");
	}
 }

CompleteCalc 클래스 실행하기

public class CalculatorTest{
	public static void main(String[] args) {
    int num1 = 10;
    int num2 = 5;
    
    CompleteCalc calc = new CompleteCalc();
    System.out.println(calc.add(num1,num2));
    System.out.println(calc.substract(num1,num2));
    System.out.println(calc.times(num1,num2));
    System.out.println(calc.devide(num1,num2));
    calc.showInfo();
    	}
    }