[9주차] 추상 클래스와 인터페이스 / 인터페이스의 상속 /인터페이스 구현과 타입 변환(1)

1. 추상 클래스와 인터페이스 

[나중에 참고할 것] https://limkydev.tistory.com/188

 

(1) 추상 메서드: 메서드 본체를 완성하지 못한 메서드 //구현부가 없는 메서드

-> 선언: abstract 반환타입 메서드이름();  //세미콜론 필수, 메서드 본체(구현부) 없음

//{..} 이부분 없음

-> 추상 메서드는 public이나 protected로 지정할 수 있음

 

(2) 추상 클래스: 객체를 생성하지 못하는 클래스

- 구현 클래스를 만드는 부모 클래스로만 사용될 뿐 new 연산자로는 인스턴스를 생성하지 못함 

// 도형 클래스의  draw()메서드는 자식 클래스의 draw() 메서드와 달리 (자식: 원, 사각형 ..) 구체적인 형태가 없어 함수 구현이 불가능한 것을 생각하자

-> 주로 상속 계층에서 자식 멤버(필드,메서드)의 이름을 통일하는데 사용 

- 선언: abstract class 클래스이름 {..} 

-> public으로 지정할 수 있음

-> 필드, 생성자, 메서드 다 올 수 O   // super() 호출을 위해

-> 주로 하나 이상의 추상메서드를 포함하지만 없어도 ok

- 추상 클래스안에 있는 추상 메서드는 반드시 자식 클래스에 상속해야 함

-> 추상 메서드는 public이나 protected로 지정할 수 있음

-> 나머지 멤버는 어떤 접근지정자로도 지정할 수 있음

 

- 추상 클래스의 상속 (자식 클래스)

-> class 자식클래스이름 extends 부모추상클래스  // 다중상속 X

-> 자식클래스가 오버라이딩해서 구현해줌 (extends)

-> 자식 클래스를 통해 구현해주고 자식클래스를 통해 객체 생성함

 

//추상 클래스
abstract class Shape {
	double pi = 3.14;

	abstract void draw();	//추상 메서드

	public double findArea() {	//구현 메서드
		return 0.0;
	}
}

- 추상 클래스도 멤버 필드를 포함할 수 있음

- 추상 메서드는 본체({..})가 없음

- 추상 클래스도 구현 메서드(일반 메서드)를 포함할 수 있음

 

class Rectangle extends Shape { //추상클래스를 구현한 자식클래스
	int width, height;

	public Rectangle(int width, int height) {
		this.width = width;
		this.height = height;
	}

	public void draw() {	//부모-default이므로 public으로 가능(자식-확대만 가능)
		System.out.println("사각형을 그리다.");
	}

	public double findArea() {
		return width * height;
	}
}

public class AbstractClassDemo {
	public static void main(String[] args) {
		// Shape s = new Shape();	

		Circle c = new Circle(3);
		c.draw();
		System.out.printf("원의 넓이는 %.1f\n", c.findArea());

		Rectangle r = new Rectangle(3, 4);
		r.draw();
		System.out.printf("사각형의 넓이는 %.1f\n", r.findArea());
	}
}

- Shape 클래스는 추상 클래스이므로 new연산자(또는 생성자)를 사용해 객체를 생성할 수 없음

---

(1) 인터페이스: 클래스 간에 상호작용하는 규격으로, 사용 방법이 같은 클래스를 만드는 기술

- 선언: interface 인터페이스이름 {...} //필드, 생성자, 메서드 다 올 수 O

 

- 인터페이스의 구조

-> 필드: 상수만 가능 (상수: public static final -> 생략 가능) 

-> 메서드: abstract, default, static, private 다 가능 (기본은 public abstract -> 생략 가능)

//메서드 다 가능한건 JDK9부터 

// 구현부가 없고, 접근 지정자 생략되어 있는 메서드 = public abstract 메서드

// ex. int MAX = 10; = public static final int MAX = 10;

// ex. void sayHello(); = public abstract void sayHello();

 

- 인터페이스 구현 (구현 클래스)

-> class 자식클래스 implements 부모인터페이스 {..}

-> class 자식클래스 implements 부모인터페이스1, 부모인터페이스2{..}

// 인터페이스- 다중 구현 가능 (구현은 상속이랑 거의 똑같음)

 

- 인터페이스의 상속 (자식 인터페이스) // 뒤에 또 나옴

-> interface 자식인터페이스 extends 부모인터페이스 {..}

-> interface 자식인터페이스 extends 부모인터페이스1, 부모인터페이스2 {..}

// 인터페이스 - 다중 상속 가능

 

- 인터페이스의 장점

-> 인터페이스를 준수하면 통합에 신경 쓰지 않고, 다양한 형태로 새로운 클래스를 개발할 수 있다

-> 자바는 클래스의 다중 상속을 지원하지 않지만, 인터페이스로 다중 상속 효과를 간접적으로 얻을 수 있다.

 

+) class 자식클래스 extends 부모클래스 implements 부모인터페이스1, 부모인터페이스2{..} 가능

// 클래스는 상속 1번만 가능, 그러나 인터페이스 구현은 여러 개 가능 

---

 

#1)

// 인터페이스 A

interface A { 

method1(); //구현부X-> 추상 메서드

method2();

}

 

// 인터페이스 A를 구현한 구현 클래스 C1

class C1 implements A {

method1() {..}

}

// 추상클래스 하나를 구현하지 않았기 때문에 그대로 사용할 수 없음 (method2())

 

// 인터페이스 A를 구현한 구현 클래스 D1

class D1 implements A {

method1(){..}

method2(){..}

}

//method2()도 구현함 -> 사용가능 

 

 

#2)음

// 인터페이스 A

interface A {

method1();

method2(){...}  //default 메서드 (구현부는 있지만, 접근 지정자가 없음 = default)

}

 

// 인터페이스 A를 구현한 구현 클래스  C1

class C1 implements A {

method1(){..}

}

//method2는 추상메서드가 아니기 때문에 구현하지 않아도 됨 -> 사용 가능

 

// 인터페이스 A를 구현한 구현 클래스  C1

class D1 implements A {

method1(){...}

method2(){...}

}

//method2()를 인터페이스에서 상속받아 오버라이딩 해줌

 

- 디폴트 메서드는 오버라이딩 될 수 있지만, 정적 메서드는 오버라이딩 될 수 없다.

// 오버라이딩: 상속관계- 자식에서 다시 정의 (부모꺼를 내껄로 만든다!는 느낌)

// 추상메서드를 자식클래스에서 구현하는 것도 오버라이딩임

- 디폴트 메서드는 인스턴스 메서드이므로 객체를 생성한 후 호출하지만, 정적 메서드는 인터페이스로 직접 호출한다.

---

- 인터페이스 vs 추상 클래스

분류	인터페이스	추상클래스
구현 메서드	포함 불가(단, 디폴트 메서드와 정적 메서드는 예외0)	포함 가능
인스턴스 변수	포함 불가능	포함 가능
다중 상속	가능	불가능
디폴트 메서드	선언 가능	선언 불가능
생성자와 main()	선언 불가능	선언 가능
상속에서의 부모	인터페이스	인터페이스, 추상 클래스
접근 범위	모든 멤버를 공개	추상 메서드를 최소한 자식에게 공개

---

2. 인터페이스의 상속

(1) 인터페이스 상속 //상속 - 부모꺼 사용

- interface 자식인터페이스 extends 부모인터페이스{..}

- interface 자식인터페이스 extends 부모인터페이스1, 부모인터페이스2{..}

-> 인터페이스는 다중 상속 가능 //상속할 인터페이스가 여러개라면 쉼표(,)로 연결한다

 

(2) 인터페이스 구현 

- class 클래스이름 implements 인터페이스이름 {..}

- class 자식클래스 implements 부모인터페이스1, 부모인터페이스2{..}

-> 인터페이스는 다중 구현 가능 //구현할 인터페이스가 여러개라면 쉼표(,)로 연결한다

 

+) class 자식클래스 extends 부모클래스 implements 부모인터페이스1, 부모인터페이스2{..} 가능

+) 클래스는 다중상속 불가능인거 잊지말기!

 

<정리>
* 상속- 클래스는 클래스끼리, 인터페이스는 인터페이스끼리 상속 (상속은 같은애들끼리만!)
* 구현- 인터페이스를 클래스로 구현 가능 (클래스는 인터페이스로 구현 불가능)  //당연함

---

(3) 인터페이스와 상수

interface Coin {
	int PENNY = 1, NICKEL = 5, DIME = 10, QUARTER = 25;
}

public class Coin1Demo {
	public static void main(String[] args) {
		System.out.println("Dime은 " + Coin.DIME + "센트입니다.");
	}
}

- Coin 인터페이스에서 변수(필드)가 상수로 초기화되어있음 

//인터페이스의 필드는 상수로만 가능하므로 문제없음

- Coin.DIME

-> 인터페이스의 필드(상수) 접근 방법: 인터페이스이름.필드명

 

public class Coin2Demo implements Coin {
	public static void main(String[] args) {

		System.out.println("Dime은 " + DIME + "센트입니다.");

	}
}

-> 클래스 Coin2Demo는 Coin 인터페이스를 구현함 (implements)

// Coin 인터페이스가 추상메서드 포함하지 않으므로 메서드 구현할 필요없이 그냥 사용하면 됨

-> Coin 인터페이스의 구현 클래스이므로 상수를 직접 사용할 수 있음 

// 원래는 클래스.상수 but, '클래스.' 굳이 안해도 OK (구현 클래스 내부이기 때문) 

---

(4) Comparable 인터페이스 : 객체를 비교하기 우한 규격으로 사용되는 인터페이스

// 기본적으로 제공 (따로 선언할 필요X) ??? 맞나

public interface Comparable {
	int compareTo(Object other);
}

- compareTo(): 다른 객체보다 크면 양수, 동일하면 0, 작으면 음수를 반환함 // 엥 추상메서드라며..?????

-> compareTo()는 추상메서드임 (구현부 X)

- Object 클래스: Object 클래스는 최상위 클래스임 (업캐스팅 가능)

 

class Circle implements Comparable {
	double radius;

	public Circle(double radius) {
		this.radius = radius;
	}

	@Override
	public int compareTo(Object o) {	
		Circle c = (Circle) o;	
		if(this.radius > c.radius) return 1;
		else if (this.radius == c.radius) return 0;
		else return -1;
	}



public class CircleDemo {
	public static void main(String[] args) {
		Circle c1 = new Circle(5.0);
		Circle c2 = new Circle(6.0);

		if (c1.compareTo(c2) > 0)
			System.out.println("첫 번째 원이 두 번째 원보다 크다.");
		else if (c1.compareTo(c2) == 0)
			System.out.println("두 원의 크기가 같다.");
		else
			System.out.println("첫 번째 원이 두 번째 원보다 작다.");
	}
}

- Comparable 인터페이스를 구현하는 Circle 클래스

-> Comparable 인터페이스에 포함된 추상 메서드 compareTo()를 구현해줘야 사용가능함

-> compareTo(): 다른 객체보다 크면 양수(1), 동일하면 0, 작으면 음수(-1)를 반환함

 

- Circle 클래스의 객체 2개 생성

-> c1: radius = 5.0

-> c2: radius = 6.0

 

- compareTo()에 Circle 클래스를 받아서 업캐스팅 // Object는 최상위 클래스, 따라서 모든 클래스가 다 올 수 있음

-> Object o = c1

- Circle c = (Circle) o;  (다운 캐스팅)

// Circle 클래스로 업캐스팅된 Object 클래스의 객체(o)를 다시 Circle 클래스로 다운 캐스팅하여 사용한다.

-> c1.compareTo(c2) // this가 c1(기준), c가 c2가 되어 비교함

-> this.radius > c.radius

---

3. 인터페이스의 구현과 타입 변환

public interface Controllable {
	default void repair() {
		System.out.println("장비를 수리한다.");
	}

	static void reset() {
		System.out.println("장비를 초기화한다.");
	}

	void turnOn();	
	void turnOff();
}

- public 인터페이스 Controllable 

- 디폴트 메서드 repair()

- 정적 메서드 reset()

-> repair()과 reset()은 오버라이딩 안해줘도 상관X (해도 ㄱㅊ)

// 추상 메서드만 오버라이딩 필수임

- 추상 메서드 turnon(), turnoff()  //구현부가 없는 추상 메서드이므로 구현할 때 반드시 오버라이딩 해줘야 함 

// 인터페이스에서 생략- public abstract 

public class TV implements Controllable {

	@Override
	public void turnOn() {
		System.out.println("TV를 켠다.");
	}

	@Override
	public void turnOff() {
		System.out.println("TV를 끈다.");
	}

	@Override
	public void repair() {
		System.out.println("TV를 수리한다.");
	}
}

- Controllable 인터페이스를 구현하는 TV클래스 (implements)

-> Controllable 인터페이스에 정의된 추상 메서드들은 구현 클래스에서 무조건 구현해줘야 함 

- turnon()과 turnoff() 오버라이딩 (구현)

-> 추상 메서드이므로 오버라이딩 안하면 에러 발생

-> 무조건 public이어야 함

-> 인터페이스) 추상 메서드 접근지정자 생략- public abstract 

-> 부모인 인터페이스보다 접근범위가 좁으면 안되기 때문 (상속과 비슷함)

- repair()은 오버라이딩 할 의무는 없지만 해도 상관 없음 (필수는 X, 필요시에만 해주면 됨)

 

public class Computer implements Controllable {
	public void turnOn() {
		System.out.println("컴퓨터를 켠다.");
	}

	public void turnOff() {
		System.out.println("컴퓨터를 끈다.");
	}
	
	@Override
	public void repair() {
		System.out.println("컴퓨터를 수리한다.");
	}
}

- controllable 인터페이스를 구현하는 Computer 클래스

- TV 클래스와 동일함 

//@override는 그냥 프로그램내에서 추가하냐 내가 오버라이딩을 직접 작성하냐의 차이임 (내가 걍 써줘도 ㄱㅊ)

 

public class ControllableDemo {
	public static void main(String[] args) {
		TV tv = new TV();
		Computer com = new Computer();

		tv.turnOn();
		tv.turnOff();
		tv.repair();
		com.turnOn();
		com.turnOff();
		com.repair();
		Controllable.reset();
		// tv.reset();
		// com.reset();
	}
}

- TV tv = new TV();

- Computer com = new Computer();

-> 인터페이스의 구현 클래스들의 객체를 생성

// 인터페이스는 객체 생성을 못함

- 정적 메서드는 인터페이스로 직접 호출해야 함

- reset()은 정적 메서드이므로 객체로 접근 불가 (인터페이스 소속임)

-> 객체로 접근하면 오류

// 원래도 정적메서드는 상속불가인거 잊지말기

 

 

(Notebook 클래스 추가)

interface Portable {
	void inMyBag();	
}

public class Notebook extends Computer implements Portable {

	public void inMyBag() {
		System.out.println("노트북은 가방에 있다.");
	}

	public void turnOn() {
		System.out.println("노트북을 켠다.");
	}

	public void turnOff() {
		System.out.println("노트북을 끈다.");
	}

	public static void main(String[] args) {
		Notebook n = new Notebook();

		n.turnOn();
		n.turnOff();
		n.inMyBag();
	}

}

- Portable 인터페이스

- void inMyBag();

-> 구현부가 없는 추상 메서드임 (public abstract)

-> 구현하는 클래스에서 구현 필요함 (안하면 에러)

 

- class Notebook extends Computer implements Portable{..}

-> Notebook 클래스는 Computer 클래스를 상속받고 Portable 인터페이스를 구현함 

// Computer 클래스와 Portable 인터페이스를 둘 다 받아오는 느낌..

- public void inMyBag() {..}

-> 추상 메서드 구현(오버라이딩)해줌 

// 그냥 자식 클래스 부분에서 메서드를 새로 정의하거나 구현하는 것도 다 오버라이딩임

- turnon(), turnoff()을 필요에 따라 오버라이딩 (필수X)

-> 이미 Computer 클래스에서 구현해주었기 때문에 필수는 X

-> Computer 클래스에서 Controllable 인터페이스의 추상 메서드를 구현한 메서드를 자신에 맞게 오버라이딩 해줌

// Notebook 클래스는 Computer 클래스를 상속받으므로 Computer 클래스의 메서드를 상속받음