인터페이스와 다형성(DAO) 활용하기

인터페이스(Interface).

인터페이스(Interface)는 객체 지향 프로그래밍에서 클래스나 다른 인터페이스와의 상호 작용을 정의하는 추상 형태의 구조입니다. 인터페이스는 메서드, 상수 또는 추상 메서드의 집합으로 구성됩니다. 
클래스가 인터페이스를 구현하면, 해당 클래스는 인터페이스에서 정의된 메서드를 모두 구현해야 합니다.

인터페이스는 다음과 같은 특징을 가지고 있습니다:

추상화: 
인터페이스는 실제 구현을 갖지 않는 추상적인 개념입니다. 
인터페이스는 어떤 클래스가 가져야 하는 메서드와 상수의 목록을 정의하며, 해당 클래스는 인터페이스를 구현하여 이를 실제로 구현해야 합니다.

다중 상속: 클래스는 하나의 클래스만 상속받을 수 있지만, 인터페이스는 여러 개의 인터페이스를 구현할 수 있습니다. 이를 통해 다중 상속과 유사한 효과를 얻을 수 있습니다.

표준화: 인터페이스는 클래스 간에 표준화된 메서드나 기능을 제공하여 일관된 인터페이스를 가진 클래스들을 구현할 수 있게 합니다. 이를 통해 코드의 재사용성과 유지 보수성을 향상시킬 수 있습니다.

다형성: 인터페이스를 구현한 클래스들은 동일한 인터페이스 타입으로 다룰 수 있습니다. 이를 통해 다형성을 활용하여 유연하고 확장 가능한 코드를 작성할 수 있습니다.

interface 인터페이스 이름{

    public static final float pi = 3.14F;
    public void makeSomething();
}

interface Calc {
    double PI = 3.14;
    int ERROR = -99999999;

    int add(int a, int b);
    int subtract(int a, int b);
    int times(int a, int b);
    int divide(int a, int b);
}

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

    @Override
    public int subtract(int a, int b) {
        return a - b;
    }
}

class CompleteCalc extends Calculator {

    @Override
    public int times(int a, int b) {
        return a * b;
    }

    @Override
    public int divide(int a, int b) {
        if (b == 0) {
            return ERROR;
        }
        return a / b;
    }

    public void showInfo() {
        System.out.println("Complete!");
    }
}

public class Main {
    public static void main(String[] args) {
        Calc calc = new CompleteCalc();
        
        int num1 = 10;
        int num2 = 2;

        System.out.println(num1 + "+" + num2 + "=" + calc.add(num1, num2));
        System.out.println(num1 + "-" + num2 + "=" +calc.subtract(num1, num2));
        System.out.println(num1 + "*" + num2 + "=" +calc.times(num1, num2));
        System.out.println(num1 + "/" + num2 + "=" +calc.divide(num1, num2));
        // showInfo() 메서드는 사용할 수 없음
    }
}

 

인터페이스와 다형성.

하나의 인터페이스를 여러 객체가 구현하게 되면 
클라이언트 프로그램은 인터페이스의 메서드를 활용하여 여러 객체의 구현을 사용할 수 있음 ( 다형성)

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

// DAO 인터페이스
interface UserDAO {
    void save(User user);
    User getById(int id);
    List<User> getAll();
    void update(User user);
    void delete(int id);
}

// 구체적인 DAO 클래스
class MySQLUserDAO implements UserDAO {
    private List<User> userList = new ArrayList<>();

    public MySQLUserDAO() {
    }

    public void save(User user) {
        // MySQL 데이터베이스에 사용자 정보를 저장하는 로직을 구현합니다.
        userList.add(user);
        System.out.println("Saved user: " + user);
    }

    public User getById(int id) {
        // MySQL 데이터베이스에서 해당 ID의 사용자 정보를 조회하는 로직을 구현합니다.
        for (User user : userList) {
            if (user.getId() == id) {
                return user;
            }
        }
        return null;
    }

    public List<User> getAll() {
        // MySQL 데이터베이스에서 모든 사용자 정보를 조회하는 로직을 구현합니다.
        return userList;
    }

    public void update(User user) {
        // MySQL 데이터베이스의 사용자 정보를 업데이트하는 로직을 구현합니다.
        for (int i = 0; i < userList.size(); i++) {
            if (userList.get(i).getId() == user.getId()) {
                userList.set(i, user);
                System.out.println("Updated user: " + user);
                return;
            }
        }
    }

    public void delete(int id) {
        // MySQL 데이터베이스에서 해당 ID의 사용자 정보를 삭제하는 로직을 구현합니다.
        for (Iterator<User> iterator = userList.iterator(); iterator.hasNext();) {
            User user = iterator.next();
            if (user.getId() == id) {
                iterator.remove();
                System.out.println("Deleted user with ID: " + id);
                return;
            }
        }
    }
}

// 사용자 정보 클래스
class User {
    private static int nextId = 1;

    private int id;
    private String name;
    private String email;

    public User(String name, String email) {
        this.id = nextId++;
        this.name = name;
        this.email = email;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

// 메인 클래스
public class Main {
    public static void main(String[] args) {
        UserDAO userDAO = new MySQLUserDAO();

        User user1 = new User("John Doe", "johndoe@example.com");
        User user2 = new User("Jane Smith", "janesmith@example.com");

        userDAO.save(user1);
        userDAO.save(user2);

        User retrievedUser = userDAO.getById(user1.getId());
        System.out.println("Retrieved User: " + retrievedUser);

        List<User> allUsers = userDAO.getAll();
        System.out.println("All Users: " + allUsers);

        user2.setEmail("newemail@example.com");
        userDAO.update(user2);

        userDAO.delete(user1.getId());
    }
}