후발대 10일차 수업 전체

추상클래스, 인터페이스_추상화_데이터추상화(Data Abstration)

★주요 키워드 및 내용 정리★

• 추상클래스 키워드 :abstract
• 자식 클래스에서는 extends로 추상클래스를 상속받아 구현
• 미구현된 부분을 오버라이딩 하여 꼭 구현을 해주어야 함
• 추상클래스 그 자체로는 객체 생성을 할 수 없다.
• 자손클래스에서 미구현된 부분을 다 구현했다면, 부모타입인 abstract 클래스의 타입으로도
• 객체 생성이 가능. (다형성)
• 인터페이스 키워드: implements (클래스 생성시, interface를 선택하여 클래스를 만든다)
• 인터페이스는 주로 동작을 많이 정의하며, 설계도 중 뼈대와 같은 부분을 담고 있음.
• 인터페이스를 구현받아 작성된 클래스들은 똑같은 기능이 꼭 구현이 되어 있다는 보장을 할 수 있다. (꼭 미완성된 기능을 인터페이스를 구현받은 클래스에서 오버라이딩하여 정의해야하므로!)
• 인터페이스를 구현받아 클래스의 기능이 다 구현이 되었다면, 인터페이스 타입으로 해당클래스의 객체 생성이 가능해진다. (다형성)

추상클래스, 추상메서드

l  추상클래스는 미완성 설계도를 가진 클래스라고 생각하면 된다

l  추상클래스란 추상 메서드를 선언할 수 있는 클래스. 불완전 형태

(설계만 되어있고, 구현체가 없는 것)

접근제어자, 리턴타입, 메소드명(파라메터)는 있지만 중괄호 블록 없음.

예) public int sum(int a, int b);

l  추상: 여러 가지 사물이나 개념에서 공통되는 특성이나 속성 따위를 추출하여 파악하는 작용.

l  예 ) 정녕 해가 있다면 그것은 당신들이 지금 알고 있는 것이 아니라 그 이름이 가진 어떤 추상일 뿐이오.  (출처: 네이버 지식사전)

 

l  컴퓨터 과학에서의 추상화는 복잡한 자료, 모듈, 시스템 등으로부터 핵심적인 개념 또는 기능을 간추려 내는 것을 말한다. 

l  객체 지향 관점에서의 추상화는 클래스를 정의할 때, 불필요한 부분들을 생략하고 객체의 속성 중 중요한 것에만 중점을 두어 개략화 하는 것, 즉 클래스들의 중요하고 공통된 성질들을 추출하여 슈퍼 클래스를 선정하는 개념이다.

l  추상클래스는 불완전한 형태를 가진 클래스의 형태로, 미완성된 부분을 가지고 있다.

l  추상클래스 자체로는 인스턴스를 생성할 수 없다.(상속받는 자식 클래스 없이는 그 자체로 불가능)

- 추상화를 통해 잘 설계했다면 여러개의 클래스를 정의했을 때, 중복 코드가 현저히 줄어들 것 이다.

-> 코드가 간결해지기 때문에 생산성 증가, 가독성 증가, 에러 감소, 유지 보수시 시간 단축 등의 효과!

-> 잘 만들어진 슈퍼 클래스 덕분에 코드의 재사용성이 증가한다. 

 

l  인터페이스는 하나도 만들어 지지않은 “기본 설계도”로 볼 수 있다.

è 추상클래스와 마찬가지로 객체의 인스턴스를 생성할 수 없다.

- 추상 클래스는 추상 메소드뿐만 아니라 생성자, 필드, 일반 메소드도 포함할 수 있지만 인터페이스는 오로지 추상 메소드와 상수만을 포함할 수 있다.

- 그럼 추상클래스만 쓰지 인터페이스를 왜 써? 왜? why? -> 자바는 클래스를 통한 다중 상속은 지원하지 않지만 클래스와 인터페이스를 통한 다중 상속은 지원하기 때문!

- 추상클래스나 인터페이스에 구현한 추상메소드들은 상속받는 클래스들에게 강제성을 부여! -> 꼭 오버라이딩 해서 사용해야만 함.

 

----------------------------------------------------------------------------------------------

 

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

    - 인터페이스

    1. 구현하려는 객체의 동작의 명세

    2. 다중 상속 가능

    3. implements를 이용하여 구현(키워드)

    4. 메소드 시그니처(이름, 파라미터, 리턴 타입)에 대한 선언만 가능

   

    - 추상클래스

    1. 클래스를 상속받아 이용 및 확장을 위함

    2. 다중 상속 불가능 , 단일 상속

    3. extends를 이용하여 구현(키워드)

    4. 추상메소드에 대한 구현 가능

    5. 추상클래스 자체로는 객체 생성이 불가능

 

 

인터페이스와 추상 클래스의 차이

추상클래스(Abstract Class)는 인터페이스의 역할도 하면서 클래스의 기능도 가지고 있는 자바의 돌연변이 같은 클래스이다. 혹자는 추상클래스는 인터페이스로 대체하는것이 좋은 디자인이라고도 얘기한다. 추상 클래스는 인터페이스와는 달리 일반 클래스처럼 객체변수, 생성자, private 메서드 등을 가질 수 있다.

 

private 메서드는 클래스 내에서만 사용되는 메서드로 다른 클래스에서 호출이 불가능하다.

 

 

수업 코드

  // 원격 강의자료 복습

abstract class Bird {
    private int x, y, z;

    void fly(int x, int y, int z){
        printLocation();
        System.out.println("이제 이동합니다~");
        this.x = x;
        this.y=y;
        if(flyable(z)){
            this.z=z;
        } else {
            System.out.println("그 높이로는 날수 없습니다.");
        }
        printLocation();
    }

    abstract boolean flyable(int z);

    public void printLocation() {
        System.out.println("현재위치: (" + x + "," + y + "," + z + ")");
    }
}
-------------------------------
class Pigeon extends Bird {

    @Override
    boolean flyable(int z) {
        return z< 10000;
    }
}

-------------------------------
class Peacock extends Bird {

    @Override
    boolean flyable(int z) {
        return false;
    }
}

----------------------------------
public class Prac  {
    public static void main(String[] args) {
//추상클래스자체는 인스턴스 생성 안됨
// 하지만 자식 객체로 추상클래스를 구현해 놓았으므로 추상클래스 타입(부모타입)으로
// 객체 생성은 가능하다. 
						// Bird bird = new Bird(); (x)
// Bird pigeon = new Pigeon(); (가능)
Pigeon pigeon = new Pigeon();
Peacock peacock = new Peacock();
               // Bird pigeon = new Pigeon();
     //   Bird peacock = new Peacock();
        System.out.println("-- 비둘기 --");
        pigeon.fly(1, 1, 3);
        System.out.println("-- 공작새 --");
        peacock.fly(1, 1, 3);
        System.out.println("-- 비둘기 --");
        pigeon.fly(3, 3, 30000);
    }
}

---------------------------------------------------
// 원격 강의자료 interface 복습

interface Bird {
    void fly(int x, int y, int z);
}

class Pigeon implements Bird{
    private int x,y,z;

    @Override
    public void fly(int x, int y, int z) {
        printLocation();
        System.out.println("날아갑니다.");
        this.x = x;
        this.y = y;
        this.z = z;
        printLocation();
    }
    public void printLocation() {
        System.out.println("현재 위치 (" + x + ", " + y + ", " + z + ")");
    }
}

public class Main {

    public static void main(String[] args) {
        Bird bird = new Pigeon();
        bird.fly(1, 2, 3);
    }
}

--------------------

// 1) 추상클래스 실습예제 : Animal

abstract class Animal{
    String name;
    int age;
    // 울음 소리는 하위 클래스에서 정의!
    String howling;


    Animal(String name, int age){
        this.name = name;
        this.age = age;
    }


    void howl() {
        System.out.println(this.howling + " 내 이름은 " + this.name +", " + age+ "살 "+ "이다옹!");
    }

    // 추상 메소드! 상속받는 클래스는 무조건 오버라이딩 해야 함! -> 강제성 부여
    abstract void charming();

}

class Cat extends Animal{
    Cat(String name, int age){
// 생성자는 상속이 안되므로 super작성
        super(name,age);
        this.howling="야옹";

    }

    // 메소드 오버라이딩
    void charming() {
        System.out.println("부비부비!");
    }
}

class Dog extends Animal{
    Dog(String name, int age){
        super(name, age);
        this.howling = "멍멍!";
    }
		
		// 메소드 오버라이딩
    void charming() {
        System.out.println("배 까고 드러눕기!");
    }
}

public class Prac {
    public static void main(String[] args) {
        Cat a = new Cat("나비", 5);
        Dog b = new Dog("바둑이", 3);

        a.howl();
        b.howl();

        a.charming();
        b.charming();
    }
}

----------------------------------
2) 추상클래스 실습예제 : 도형(삼각형, 사각형, ...) 면적 구하기



// 면적(Figure)라는 클래스는 추상클래스다. 
// 가로와 세로를 파라미터로 받아 넓이(area)를 구하는 추상메서드가 있다. 

// 사각형형은 면적을 상속받아 넓이를 구하는 추상메서드를 완성합니다.
// 삼각형은 ...""  ""

// 메인클래스에서 삼각형과 사각형 객체를 생성하여 
// 두수를 인자로 넘겨받아 넓이를 구해 봅니다. 

abstract class Figure {    // 추상 클래스

    abstract void area(int a, int b); // 추상 메서드
// 넓이 구하는 공식을 바디(실행코드 부분)에 알맞게 구현.

}

 

// 사각형 클래스

class Square extends Figure {

    void area(int a, int b) {

        System.out.println("사각형의 넓이 : "+(a*b));

    }

}

 

class Triangle extends Figure {

    void area(int a, int b) {

        System.out.println("삼각형의 넓이 : "+(a*b/2));

    }

}

 

class FigureMain {

    public static void main(String[] args) {

        Square square = new Square();

        square.area(10, 7);

        

        Triangle triangle = new Triangle();

        triangle.area(15, 8);

    }    

}

------------------------------------------

// 1) 인터페이스 실습예제 : 택시미터기

//Meter(택시 미터기)인터페이스는 start와 stop이라는 추상 메소드를 가지고 있습니다.
// stop메소드는 달린 거리에 해당하는 값(distance)를 매개변수로 받아
// 요금을 반환하는 메소드입니다.
// Meter인터페이스를 구현하는 택시 클래스를 완성해 보세요.
// 요금은 distance x 2로 계산이 됩니다. (stop 메서드) 


public interface Meter {
    public int BASE_FARE = 3000;
    // 기본요금(인터페이스에 정의한 변수는 상수라서 변경할 수 없다.)
    public abstract void start();
    public abstract int stop(int distance);
}




--------
public class Taxi implements Meter {
    // Meter인터페이스의 start와 stop메소드를 구현해야 합니다.
    public void start() {
        System.out.println("운행을 시작합니다.");
    }

    public int stop(int distance) {
// 요금 변수는 아래와 같이 만들어 요금을 계산하는 식을 작성해 줍니다.
// 즉 운행이 종료되면 요금을 알 수 있도록 프로그램을 만들어 줍니다.
        int fare = BASE_FARE + distance * 2;
        System.out.println("운행을 종료합니다. 요금은 " + fare + "원입니다.");
        return fare;
    }
}
------------
public class MeterExam{
    public static void main(String[] args){
  // 운행을 시작하고, 거리를 입력해서 요금이 인쇄되는 코드를 작성해 보세요.
        Taxi taxi = new Taxi();
        taxi.start();
        taxi.stop(20);


    }
}
-------------------------------
// 2) 인터페이스 실습예제 : 자율 주행차
interface OperateCar{
    void start();
    void stop();
    void setSpeed(int speed);
    void turn(int degree);
}

class AutoCar implements OperateCar{

    @Override
    public void start() {
        System.out.println("자동차가 출발합니다.");
    }

    @Override
    public void stop() {
        System.out.println("자동차가 정지합니다.");
    }

    @Override
    public void setSpeed(int speed) {
        System.out.println("자동차가 속도를 " + speed + "km/h 로 바꿉니다.");
    }

    @Override
    public void turn(int degree) {
        System.out.println("자동차가 방향을 " +degree +"도 만큼 바꿉니다.");

    }
}

public class Prac {
    public static void main(String[] args) {
// 인터페이스는 그 기능을 꼭 구현할 것을 강제하므로 동작을 할 거라고 보장할 수 있다. 
            OperateCar car = new AutoCar();
            car.start();
            car.setSpeed(30);
            car.turn(30);
            car.stop();
    }
}