[24.09.20금]슈퍼코딩w4:Java-인터페이스

📚 오늘 공부한 강의

36강 : 인터페이스 v1
37강 : 인터페이스 v2

💛 36강 : 인터페이스 v1

🐥 인터페이스란

인간이나 사물, 시스템 간에 커뮤니케이션이 가능하도록 설계한 상호 작용 방식

1. 유저 인터페이스
   => 유저 <-> 사물|시스템

2. 시스템 인터페이스
   => 사물|시스템 <-> 사물|시스템

🐥 Java OOP에서의 인터페이스

자바 객체간 커뮤니케이션이 가능하도록 기능 구현을 설계(= 메소드)하는 추상화 문법

🐥 인터페이스 문법

🐥 인터페이스 자동적용

🐥 인터페이스 특징

👉 실습: 인터페이스 구현하기

< 준비 >
이전에 구현한 “Animal”, “Fish”, “Person”, “Bird” 클래스 사용

< 진행 >
Flyable, walkable 구현하기
각각 잘 변환되는 거 확인

Animal.java

public abstract class Animal {
    // 속성
    protected String gender;

    // 행위
    public abstract void eat(String food);
    public abstract void sleep();
}

Fish.java

public class Fish extends Animal {
    // 속성
    private boolean havingPoison;
    private String livingSea;

    // 행위

    @Override
    public void eat(String food) {
        System.out.printf("물고기가 %s 을 주둥이로 먹습니다.\n", food);
    }

    @Override
    public void sleep() {
        System.out.println("물고기가 잠을 자고 있습니다.");
    }
    public void swim(){
        System.out.println("물고기가 헤엄을 치고 있습니다.");
    }
}

Person.java

public class Person extends Animal implements Walkable {
    private String name;
    private String job;
    private int height;

    @Override
    public void eat(String food) {
        System.out.printf("사람이 %s을 젓가락으로 먹는다.\n", food);
    }

    @Override
    public void sleep() {
        System.out.println("사람이 자고 있습니다.");
    }

    @Override
    public void walk(){
        System.out.println("사람이 걷고 있습니다.");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Robot.java

public class Robot implements Walkable {
    // 속성
    private String robotID;
    private String modelName;
    private String color;


    @Override
    public void walk() {
        System.out.println("로봇ID " + this.robotID + "니가 걷고 있습다.");
    }

    public void helpPerson(Person person){
        String name = person.getName();
        System.out.println("로봇이 인간 " + name + "을 돕습니다.");
    }

    public Robot(String robotID) {
        this.robotID = robotID;
    }
}

Bird.java

public class Bird extends Animal implements Flyable {
    private long weight;
    private String color;

    // 행위
    @Override
    public void eat(String food) {
        System.out.printf("새가 %s 을 부리로 쪼아 먹고 있습니다.\n", food);
    }

    @Override
    public void sleep() {
        System.out.println("새가 잠을 자고 있습니다.");
    }

    @Override
    public void fly(){
        System.out.println("새가 날고 있습니다.");
    }
}

Airplane.java

public class Airplane implements Flyable {
    // 속성
    private String airplaneID;
    private long remainingFuelAmount;
    private long maximumCapacity;

    @Override
    public void fly() {
        System.out.println("비행기 ID(" + airplaneID + ")가 납니다.");
    }

    public void refillFuel(long fuel){
        remainingFuelAmount += fuel;
    }

    public Airplane(String airplaneID) {
        this.airplaneID = airplaneID;
    }
}

Flyable.java

public interface Flyable {
    // 속성
    long atmosphereLimit = 476; // 대기권

    default void fly(){
        System.out.println("<정보> 현재 이 사물은 날고 있습니다.");
    }

    static void printLanding(){
        System.out.println("<경보> 현재 이 사물은 공중에 있습니다.");
    }
}

Walkable.java

public interface Walkable {

    void walk();
}

InterfaceTest.java

public class InterfaceTest {

    public static void main(String[] args){
        // 속성
//        System.out.println(Flyable.atmosphereLimit);
//        Flyable.atmosphereLimit = 100;

        // Flyable
        Flyable bird = new Bird();
        Flyable airplane = new Airplane("AB1112");

//        bird.fly();
//        airplane.fly();
//
        // Walkable
        Walkable person = new Person();
        Person person2 = new Person();
        person2.setName("아이유");

        Walkable robot = new Robot("RB1233");

        person.walk();
        robot.walk();

        if ( robot instanceof Robot ){
            Robot robot2 = (Robot) robot;
            robot2.helpPerson(person2);
        }
    }
}

🐥 인터페이스 디폴트 메소드

🐥 인터페이스 정적 메소드

👉 실습: 인터페이스 구현하기 V.2

< 준비 >
이전에 구현한 클래스 재사용

< 진행 >
Flyable Default Method, static method 구현
Drone을 Default와 static method로 구현합니다.

Drone.java

public class Drone implements Flyable {
    // 속성
    private String droneID;
    private long remainingFuelAmount;
    private long remainingFileStorage;

    public void takePicture(){
        Flyable.printLanding();
        System.out.println("이 드론은 사진을 찍고 있습니다.");
    }
}

💛 37강 : 인터페이스 v2

🐥 Java 인터페이스 = Java 계약서 = Java 객체 역할

🐥 ＇철수’ 객체와 여러 역할들

👉 실습: ‘철수’ 구현하기

< 준비 >
구현 할 때 필요한 ‘여자 클래스’, ‘남자 클래스’, ‘아기클래스’ 만들기

< 진행 >
1. 역할 Role 구현하기 ( 남편, 아빠, 회사원, 아내 )

• 디폴트로 구현

2. 업무 능력은 보통이지만, 가정적인 남자 ‘철수’ 구현하기
3. 같은 객체가 다른 대상과 역할에 맞게 잘 동작하는 부분 확인.

Female.java

public class Female implements EmployeeRole, Wife {
    // 속성
    private String name;
    private int age;
    private String job;

    @Override
    public void workTogether(EmployeeRole employeeRole) {
        String name = employeeRole.getName();
        System.out.println(name + "인 직장동료와 업무를 하고 있습니다.");
    }

    @Override
    public void takeCareHusband(HusbandRole husband) {
        String name = husband.getName();
        System.out.println(name + "인 남편을 케어해줍니다.");
    }

    @Override
    public String getName() {
        return this.name;
    }

    public Female(String name) {
        this.name = name;
    }
}

Male.java

public class Male extends FamilyMan implements FamilyRole, EmployeeRole {
    private int age;
    private String job;

    @Override
    public void workTogether(EmployeeRole employeeRole) {
        String name = employeeRole.getName();
        System.out.println(name + "인 직장동료와 업무를 하고 있습니다.");
    }

    @Override
    public String getName() {
        return this.name;
    }

    public Male(String name) {
        this.name = name;
    }
}

Baby.java

public class Baby {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public Baby(String name) {
        this.name = name;
    }
}

HusbandRole.java

public interface HusbandRole {

    void takeCareWife(Wife wife);
    default void sayLoveEveryDay(){
        System.out.println("우리 아내 사랑합니다~");
    }

    String getName();
}

DaddyRole.java

public interface DaddyRole {

    void educateBaby(Baby baby);
    default void sayLoveEveryDay(){
        System.out.println("우리 아기 사랑합니다~");
    }
}

EmployeeRole.java

public interface EmployeeRole {

    void workTogether(EmployeeRole employeeRole);

    String getName();
}

Wife.java

public interface Wife {

    void takeCareHusband(HusbandRole husband);
    String getName();
}

InterfaceTest.java

public class InterfaceTest {
    public static void main(String[] args){
        // Male 3개 남편, 아빠, 회사원
        HusbandRole male = new Male("철수");
        Wife wife = new Female("아이유");

        male.sayLoveEveryDay();
        male.takeCareWife(wife);

        // 이어서 아빠
        DaddyRole maleDaddy = (DaddyRole) male;
        Baby baby = new Baby("정우성");

        maleDaddy.educateBaby(baby);
        maleDaddy.sayLoveEveryDay();

        // 회사원
        EmployeeRole maleEmployee = (EmployeeRole) maleDaddy;
        EmployeeRole maleEmployeeTwo = new MaleTwo("민철");


        maleEmployee.workTogether(maleEmployeeTwo);
     }
}

🐥 인터페이스 활용

👉 실습: ‘철수’ 개선하기

< 준비 >
이전 구현 하던거 계속 구현

< 진행 >
1. 인터페이스 중복 확인 하기
2. ’DadRole’과 ‘husbandRole’ 묶어서 ‘familyRole’로 관리하기
3. ‘민철’ 추가하고, 추상클래스로 공통화하기

🐥 인터페이스 | 추상클래스 정리

FamilyMan.java

public abstract class FamilyMan implements FamilyRole {
    protected String name;
    @Override
    public void educateBaby(Baby baby) {
        String name = baby.getName();
        System.out.println(name + " 아기를 열심히 교육하고 있습니다.");
    }

    @Override
    public void takeCareWife(Wife wife) {
        String name = wife.getName();
        System.out.println(name + "인 아내를 성심성의껏 케어합니다.");
    }

}

FamilyRole.java

public interface FamilyRole extends DaddyRole, HusbandRole {
    @Override
    default void sayLoveEveryDay() {
        DaddyRole.super.sayLoveEveryDay();
        HusbandRole.super.sayLoveEveryDay();
    }
}

MaleTwo

public class MaleTwo extends FamilyMan implements FamilyRole, EmployeeRole {

    @Override
    public void workTogether(EmployeeRole employeeRole) {
        String name = employeeRole.getName();
        System.out.println(name + "인 직장동료와 업무를 하고 있습니다.");
    }

    @Override
    public String getName() {
        return this.name;
    }

    public MaleTwo(String name) {
        this.name = name;
    }
}