스파르타 코딩 클럽 3주차 2일

클래스 설계시 고려사항 
1. CRC Card Layout 를 작성한다.
2. 역할 책임 관계를 명확히 설계한다. 

 

추상 클래스와 추상 메소드와 this

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

    void fly(int x, int y, int z) {
        printLocation();
        System.out.println("이동합니다.");
        // this는 class내부에 있는 변수와 인스턴스 내부에 있는 변수를 구분하기 위해 사용
        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 main {
    public static void main(String[] args) {
        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);
    }
}

인터페이스(implementation)

인터페이스는 자식 메소드에서 꼭 재정의를 해줘야 합니다. 

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);
//        bird.printLocation(); // compile error
    }
}

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

1. 추상클래스는 미완성된 설계도

2. 인터페이스는 기본 설계도이다.

추상클래스는 미완성되었으므로 확장이 용이하고 다중상속 불가, 모든 메서드가 추상 메서드가 아님

인터페이스는 무조건 자식 메소드에서 오버라이딩해서 사용해야하고 다중상속 가능. 모든 메서드가 추상 메서드

 

인터페이스와 추상 클래스를 사용하는 이유
1. 설계시 인터페이스와 추상클래스를  미리 선언해두면 개발시 기능 구현에만 집중할 수 있다. 즉 개발자는 비즈니스 로직에만 집중할 수 있게 된다.

2. 공통의 인터페이스와 추상 클래스를 선언해두면, 선언과 구현을 구분할 수 있다.

 

인터페이스
1. 구현하려는 객체의 동작의 명세
2. 다중 상속 가능

3. implements를 이용하여 구현
4. 메소드 시그니처(이름, 파라미터, 리턴 타입)에 대한 선언만 가능

 

추상클래스
1. 클래스를 상속받아 이용 및 확장을 위함
2. 다중 상속 불가능 , 단일 상속
3. extends를 이용하여 구현
4. 추상메소드에 대한 구현 가능

 

객체지향 과제

요구사항

1. 사람은 자식, 부모님, 조부모님이 있다.
2. 모든 사람은 이름, 나이, 현재 장소정보(x,y좌표)가 있다.
3. 모든 사람은 걸을 수 있다. 장소(x, y좌표)로 이동한다.
4. 자식과 부모님은 뛸 수 있다. 장소(x, y좌표)로 이동한다.
5. 조부모님의 기본속도는 1이다. 부모의 기본속도는 3, 자식의 기본속도는 5이다.
6. 뛸때는 속도가 기본속도대비 +2 빠르다.
7. 수영할때는 속도가 기본속도대비 +1 빠르다.
8. 자식만 수영을 할 수 있다. 장소(x, y좌표)로 이동한다.

위 요구사항을 만족하는 클래스들을 바탕으로, Main 함수를 다음 동작을 출력(`System.out.println`)하며 실행하도록 작성하시오. 이동하는 동작은 각자 순서가 맞아야 합니다.

1. 모든 종류의 사람의 인스턴스는 1개씩 생성한다.
2. 모든 사람의 처음 위치는 x,y 좌표가 (0,0)이다.
3. 모든 사람의 이름, 나이, 속도, 현재위치를 확인한다.
4. 걸을 수 있는 모든 사람이 (1, 1) 위치로 걷는다.
5. 뛸 수 있는 모든 사람은 (2,2) 위치로 뛰어간다.
6. 수영할 수 있는 모든 사람은 (3, -1)위치로 수영해서 간다.

 

Human.java

public class Human{
    String name;
    int age;
    int speed;
    int x,y;

    public Human(String name, int age, int speed, int x, int y)
    {
        this.name = name;
        this.age = age;
        this.speed=speed;
        this.x=x;
        this.y=y;
    }

    // 생성자
    public Human(String name, int age, int speed)
    {
        this(name,age,speed,0,0);
    }

    public  String getLocation()
    {
        return "("+x+","+y+")";
    }
    protected void printWhoAmI()
    {
        System.out.println("My name is "+ name +"age : "+age);
    }
}

 

Child.java

public class Child extends Human implements Walkable,Runable,Swimable{
    public Child(String name, int age)
    {
        super(name,age,5,0,0);
    }
    @Override
    public void walk(int x,int y)
    {
        printWhoAmI();
        System.out.println("walk spped" + speed);
        this.x=x;
        this.y=y;
        System.out.println("walk to" + getLocation());
    }
    @Override
    public void runa(int x,int y)
    {
        printWhoAmI();
        System.out.println("run spped" + (speed +2));
        this.x=x;
        this.y=y;
        System.out.println("walk to" + getLocation());
    }
    @Override
    public void swim(int x,int y)
    {
        printWhoAmI();
        System.out.println("swim spped" + (speed +1));
        this.x=x;
        this.y=y;
        System.out.println("walk to" + getLocation());
    }
}

 

Parent.java

 

public class Parent extends Human implements Walkable, Runable{
    public Parent(String name, int age) {
        super(name, age, 3);
    }
    @Override
    public void runa(int x, int y) {
        printWhoAmI();
        System.out.println("run speed: " + (speed + 2));
        this.x = x;
        this.y = y;
        System.out.println("Ran to " + getLocation());
    }

    @Override
    public void walk(int x, int y) {
        printWhoAmI();
        System.out.println("walk speed: " + speed);
        this.x = x;
        this.y = y;
        System.out.println("Walked to " + getLocation());
    }
}

main.java

import java.util.ArrayList;
import java.util.Vector;

public class main{
    public static void main(String[] args)
    {
        Human child = new Child("나",20);
        Human parent = new Parent("엄마", 50);

        Human[] humans = {parent,child};
        for (Human human : humans) {
            System.out.println(human.name + ", 나이: " + human.age + ", 속도: " + human.speed + ", 장소: " + human
                    .getLocation());
        }
        System.out.println("<활동 시작>");
        for (Human human : humans) {
            if (human instanceof Walkable) {
                ((Walkable) human).walk(1, 1);
                System.out.println(" - - - - - - ");
            }
            if (human instanceof Runable) {
                ((Runable) human).runa(2, 2);
                System.out.println(" - - - - - - ");
            }
            if (human instanceof Swimable) {
                ((Swimable) human).swim(3, -1);
                System.out.println(" - - - - - - ");
            }
        }
    }

}

 

Runable.java

public interface Runable{
    void runa(int x,int y);
}

Swimable.java

public interface Swimable{
    void swim(int x,int y);
}

Walkable.java

public interface Walkable{
    void walk(int x,int y);
}