//수업 클래스
class Class {
    private final String className;

    public Class(String className) {
        this.className = className;
    }

    public String getClassName() {
        return className;
    }
}

//학생 클래스
class Student {
    private String name;
    private Class enrolledClass;

    public Student(String name, Class enrolledClass) {
        this.name = name;
        this.enrolledClass = enrolledClass;
    }

    public void showClassInfo() {
        System.out.println(name + " 학생은 " + enrolledClass.getClassName() + " 수업에 등록되어 있습니다.");
    }
}

public class UnidirectionalRelationship {
    public static void main(String[] args) {
        Class classLecture = new Class("수학");
        Student student = new Student("김철수", classLecture);

        student.showClassInfo();
    }
}

//주문 클래스
class Order {
    private String orderId;
    private Customer customer;

    public Order(String orderId, Customer customer) {
        this.orderId = orderId;
        this.customer = customer;
    }

    public String getOrderId() {
        return orderId;
    }

    public Customer getCustomer() {
        return customer;
    }
}

//고객 클래스
class Customer {
    private String name;
    private List<Order> orders;

    public Customer(String name) {
        this.name = name;
        this.orders = new ArrayList<>();
    }

    public void addOrder(Order order) {
        orders.add(order);
    }

    public void showOrders() {
        System.out.println(name + "의 주문 목록:");
        for (Order order : orders) {
            System.out.println(" - 주문 ID: " + order.getOrderId());
        }
    }
}

/**
 * 양방향 관계
 */
public class BidirectionalRelationship {
    public static void main(String[] args) {
        Customer customer = new Customer("박웅석");
        Order order1 = new Order("001", customer);
        Order order2 = new Order("002", customer);

        customer.addOrder(order1);
        customer.addOrder(order2);

        customer.showOrders();
    }
}

class Bank {
    private String name;

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

    public String getName() {
        return name;
    }
}

class Customer {
    private String name;
    private List<Bank> banks; // 고객이 거래하는 은행들

    public Customer(String name) {
        this.name = name;
        this.banks = new ArrayList<>();
    }

    public void addBank(Bank bank) {
        banks.add(bank); // 고객이 은행과 거래 시작
    }

    public void showBanks() {
        System.out.println(name + " 고객이 거래하는 은행들:");
        for (Bank bank : banks) {
            System.out.println(" - " + bank.getName());
        }
    }
}

/**
 * 단방향 다대다 관계
 */
public class UnidirectionalManyToMany {
    public static void main(String[] args) {
        Bank bank1 = new Bank("국민은행");
        Bank bank2 = new Bank("신한은행");

        Customer customer = new Customer("김철수");
        customer.addBank(bank1);
        customer.addBank(bank2);

        customer.showBanks();
    }
}

class Customer {
    private String name;
    private List<Bank> banks; // 고객이 거래하는 은행들

    public Customer(String name) {
        this.name = name;
        this.banks = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void addBank(Bank bank) {
        banks.add(bank); // 고객이 은행과 거래 시작
        bank.addCustomer(this); // 은행도 고객을 "알게 함"
    }

    public void showBanks() {
        System.out.println(name + " 고객이 거래하는 은행들:");
        for (Bank bank : banks) {
            System.out.println(" - " + bank.getName());
        }
    }
}

class Bank {
    private String name;
    private List<Customer> customers; // 은행이 거래하는 고객들

    public Bank(String name) {
        this.name = name;
        this.customers = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void addCustomer(Customer customer) {
        customers.add(customer); // 은행에 고객 추가
    }

    public void showCustomers() {
        System.out.println(name + " 은행의 고객들:");
        for (Customer customer : customers) {
            System.out.println(" - " + customer.getName());
        }
    }
}

/**
 * 양방향 다대다 관계
 */
public class BidirectionalManyToMany {
    public static void main(String[] args) {
        Bank bank1 = new Bank("국민은행");
        Bank bank2 = new Bank("신한은행");

        Customer customer1 = new Customer("김철수");
        Customer customer2 = new Customer("이영희");

        // 고객이 은행과 거래 시작
        customer1.addBank(bank1);
        customer1.addBank(bank2);
        customer2.addBank(bank1);

        // 출력 확인
        customer1.showBanks();
        bank1.showCustomers();
    }
}

// 고객 클래스
class Customer {
    private String name;
    private List<Account> accounts; // 고객의 계좌 목록

    public Customer(String name) {
        this.name = name;
        this.accounts = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void addAccount(Account account) {
        accounts.add(account);
    }

    public void showAccounts() {
        System.out.println(name + " 고객의 계좌:");
        for (Account account : accounts) {
            System.out.println(" - 계좌 번호: " + account.getAccountId() + ", 잔액: " + account.getBalance());
        }
    }
}

// 은행 클래스
class Bank {
    private String name;
    private List<Account> accounts; // 은행의 계좌 목록

    public Bank(String name) {
        this.name = name;
        this.accounts = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void addAccount(Account account) {
        accounts.add(account);
    }

    public void showAccounts() {
        System.out.println(name + " 은행의 계좌:");
        for (Account account : accounts) {
            System.out.println(" - 계좌 번호: " + account.getAccountId() + ", 고객: " + account.getCustomer().getName());
        }
    }
}

// 연관 클래스: Account (고객과 은행을 연결)
class Account {
    private String accountId;
    private double balance;
    private Date openedDate;
    private Customer customer; // 연관된 고객
    private Bank bank;         // 연관된 은행

    public Account(String accountId, double balance, Customer customer, Bank bank) {
        this.accountId = accountId;
        this.balance = balance;
        this.openedDate = new Date(); // 현재 날짜로 계좌 개설일 설정
        this.customer = customer;
        this.bank = bank;

        // 관계 설정
        customer.addAccount(this);
        bank.addAccount(this);
    }

    public String getAccountId() {
        return accountId;
    }

    public double getBalance() {
        return balance;
    }

    public Customer getCustomer() {
        return customer;
    }

    public Bank getBank() {
        return bank;
    }
}

/**
 * 연관 클래스를 이용한 다대다 관계
 */
public class AssociationClassManyToMany {
    public static void main(String[] args) {
        // 은행 생성
        Bank bank1 = new Bank("국민은행");
        Bank bank2 = new Bank("신한은행");

        // 고객 생성
        Customer customer1 = new Customer("김철수");
        Customer customer2 = new Customer("이영희");

        // 계좌 생성 (연관 클래스 사용)
        new Account("001", 1000.0, customer1, bank1);
        new Account("002", 2000.0, customer1, bank2);
        new Account("003", 1500.0, customer2, bank1);

        // 출력 확인
        customer1.showAccounts();
        bank1.showAccounts();
    }
}

// 상위 클래스
class Animal {
    protected String name;

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

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 하위 클래스 1
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

// 하위 클래스 2
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void meow() {
        System.out.println(name + " is meowing.");
    }
}

/**
 * 일반화 관계
 */
public class GeneralizationRelationship {
    public static void main(String[] args) {
        // 상위 클래스 타입으로 하위 클래스 참조
        Animal dog = new Dog("콜라");
        Animal cat = new Cat("사이다");

        // 상위 클래스의 메서드 호출
        dog.eat();
        cat.eat();

        // 하위 클래스의 메서드 호출
        if (dog instanceof Dog) {
            ((Dog) dog).bark();
        }

        if (cat instanceof Cat) {
            ((Cat) cat).meow();
        }
    }
}

// Player 클래스 (부분 객체)
class Player {
    private String name;

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

    public String getName() {
        return name;
    }
}

// Team 클래스 (전체 객체)
class Team {
    private String name;
    private List<Player> players; // 팀에 속한 선수들

    public Team(String name) {
        this.name = name;
        this.players = new ArrayList<>();
    }

    public void addPlayer(Player player) {
        players.add(player); // 선수 추가
    }

    public void showPlayers() {
        System.out.println(name + " 팀의 선수 목록:");
        for (Player player : players) {
            System.out.println(" - " + player.getName());
        }
    }
}

/**
 * 집합 관계
 */
public class AggregationRelationship {
    public static void main(String[] args) {
        // 선수 생성
        Player player1 = new Player("김으장");
        Player player2 = new Player("임수정");

        // 팀 생성
        Team team = new Team("FC 서울");

        // 팀에 선수 추가
        team.addPlayer(player1);
        team.addPlayer(player2);

        // 팀 정보 출력
        team.showPlayers();
    }
}

// 객실 클래스 (부분 객체)
class Room {
    private String name;

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

    public String getName() {
        return name;
    }
}

// 호텔 클래스 (전체 객체)
class Hotel {
    private String name;
    private List<Room> rooms;

    public Hotel(String name) {
        this.name = name;
        this.rooms = new ArrayList<>();
    }

    public void addRoom(String roomName) {
        rooms.add(new Room(roomName)); // 호텔이 객실을 소유
    }

    public void showRooms() {
        System.out.println(name + "의 객실 목록:");
        for (Room room : rooms) {
            System.out.println(" - " + room.getName());
        }
    }
}

/**
 * 구성 관계
 */
public class CompositionRelationship {
    public static void main(String[] args) {
        // 호텔 생성
        Hotel hotel = new Hotel("포포인츠호텔");

        // 객실 추가
        hotel.addRoom("711-싱글스탠다드");
        hotel.addRoom("856-더블스탠다드");

        hotel.showRooms();
    }
}

// Customer 클래스
class Customer {
    private String name;

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

    public String getName() {
        return name;
    }
}

// Order 클래스
class Order {
    private int id;

    public Order(int id) {
        this.id = id;
    }

    // Customer를 의존적으로 사용하는 메서드
    public void processOrder(Customer customer) {
        System.out.println("Processing order ID: " + id + " for customer: " + customer.getName());
    }
}

/**
 * 의존 관계
 */
public class DependencyRelationship {
    public static void main(String[] args) {
        // Customer 객체 생성
        Customer customer = new Customer("송양해");

        // Order 객체 생성
        Order order = new Order(123);

        // Order가 Customer를 의존적(임시)으로 사용
        // 한 클래스가 다른 클래스의 객체나 메서드를 임시로 참조 하는 관계
        order.processOrder(customer);
    }
}

// 인터페이스 (Vehicle)
interface Vehicle {
     //인터페이스에서 정의한 책임(메서드)
    void start();
    void stop();
}

// 구현 클래스 1 (Car)
// 인터페이스에서 정의한 메서드를 구현
class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car is starting.");
    }

    @Override
    public void stop() {
        System.out.println("Car is stopping.");
    }
}

// 구현 클래스 2 (Bike)
// 인터페이스에서 정의한 메서드를 구현
class Bike implements Vehicle {
    @Override
    public void start() {
        System.out.println("Bike is starting.");
    }

    @Override
    public void stop() {
        System.out.println("Bike is stopping.");
    }
}

// 메인 클래스
public class RealizationRelationship {
    public static void main(String[] args) {
        // Vehicle 타입으로 Car와 Bike 객체를 참조
        Vehicle car = new Car();
        Vehicle bike = new Bike();

        //인터페이스에서 정의한 책임을 처리
        car.start();
        car.stop();

        bike.start();
        bike.stop();
    }
}