2명이서 각자 DB server와 Application server를 맡는게 좋을까?

• BE developer database operation(queries, schema design) and the business logic layer (services, controllers) 모두를 다룰 줄 알아야 한다.
• 병목현상 : debugging, testing, evolving application을 위해 database에 변경이 생길 때마다 기다려야 함

그럼? end-to-end ownership of features

modules, functionalities에 따라 분류해, 각각의 features마다 DBdesign + businessLogic + API development을 모두 다루도록 하기

DB server와 Application server로 분리

1st. Requirement Gathering and Planning

(both)

Output

Detailed requirement document and task assignment.

Detail task

• Clearly define the requirements for each feature. • Break down the service into manageable modules (e.g., “Publisher Management,” “Book Management,” “Stock Management,” etc.).

• Assign features to each person. For example:

    •    Person 1: Handles Publisher Management and Book Inventory.
    •    Person 2: Handles Orders and Stock Management.

2nd. High-Level System Architecture Design

(both)

Output

Architecture diagram (data flow, service-to-service communication, etc.)

detailed task

• Design the overall architecture of the system, including the application server (Spring Boot) and database server (MySQL, PostgreSQL, etc.).

• Agree on a shared structure for your REST API design (e.g., /publishers, /books, /orders).

3rd. Database Design and Schema Definition

(Each Person for Their Feature)

Output

• ER Diagrams for your features. • JPA entities with relationships and proper annotations (@OneToMany, @ManyToOne, etc.).

detailed task

• Each person will design the database schema for their feature(s). For example:

•    Person 1: Designs tables for Publisher, Book, and BookInventory.
•    Person 2: Designs tables for Order, Stock, and Return.

• Define the relationships (one-to-many, many-to-many) using JPA annotations in Spring Boot. • Use tools like Flyway or Liquibase to manage migrations and keep the database schema consistent.

migration Tool의 사용

4th. JPA Entity Modeling

(Each Person for Their Feature)

Output

JPA entity classes for each feature.

Detailed task

• Create JPA entity classes that represent your database tables.

• Example for Person 1 (Publisher Management):

•    Publisher, Book, BookInventory entities.

• Example for Person 2 (Order Management):

•    Order, Stock, Return entities.

• Define relationships, constraints, and cascading operations where needed.

5th. Repository Layer

(Each Person for Their Feature)

Output

Repository classes to interact with the database.

Detailed task

• Create Spring Data JPA repositories for each entity. • Use repositories to handle CRUD operations for the database. • Example for Person 1

        •    PublisherRepository, BookRepository.

• Example for Person 2:

•    OrderRepository, StockRepository.

• Implement custom queries for complex retrievals using @Query annotations or JPA method conventions.

6th. Service Layer Implemetation

(Each Person for Their Feature)

output

Service classes that contain all the business logic.

detailed task

• Implement the service classes that contain the business logic for your assigned features. • Example for Person 1:

•    PublisherService: Logic for adding, editing, and retrieving publishers.
•    BookInventoryService: Logic for managing book stock and availability.

• Example for Person 2:

•    OrderService: Logic for processing orders, handling returns, and updating stock.
•    StockService: Logic for adjusting stock levels and validating transactions.

• Use @Transactional to manage transactions where multiple database operations need to happen atomically.

7th. REST API Development

(Each Person for Their Feature)

output

REST API endpoints for each feature.

detailed task

• Implement controllers to expose the business logic via RESTful APIs.
• Example for Person 1:

• Create endpoints like /publishers, /books, /inventory.
• Example:
  • GET /publishers to list all publishers.
  • POST /books to add a new book.
    • Example for Person 2:
• Create endpoints like /orders, /stock, /returns.
• Example:
  • POST /orders to place a new order.
  • GET /orders/{id} to get order details.
    • Ensure you handle validation, error handling, and responses in a standardized way (e.g., returning HTTP status codes and proper error messages).

8th. Security and Authentication

(Both)

output

Secured APIs with user authentication and role-based access.

detailed task

• Implement security using Spring Security to protect sensitive endpoints.
• Define roles and permissions (e.g., admin vs regular users).
• Use JWT tokens or OAuth for user authentication.
• Secure routes like /inventory, /orders with proper role-based access control.

9th. Testing

(Each Person for Their Feature)

output

A suite of tests to ensure both database interactions and APIs work as expected.

detailed task

• Write unit tests for your service layer to ensure business logic is working correctly.
• Write integration tests for your REST APIs to ensure they respond correctly to requests.
• Use JUnit, Mockito, and Spring Boot's testing features for this.

10th. Database and Application Server Setup

(Both)

output

Fully functional database and application servers, ready for use.

detailed task

• Set up the database server (MySQL, PostgreSQL) on a cloud platform or local environment.
• Set up the Spring Boot application server. • Configure database connections in application.properties or application.yml.

11th. CI/CD and Deployment

(Both)

output

Deployed application with automated testing and deployment processes.

detailed task

• Use Docker to containerize both the application and database servers for consistent deployment.
• Set up a CI/CD pipeline (e.g., GitHub Actions, Jenkins, GitLab CI) to automate testing and deployment.
• Deploy the application to a cloud platform (AWS, Azure, GCP) or use a container orchestration tool like Kubernetes.

12th. Final Integration and Optimization

(Both)

output

Finalized and optimized backend ready for production.

detailed task

• Integrate all features and ensure that they work together smoothly.
• Perform load testing to ensure that the application can handle the expected number of users.
• Optimize performance for any database queries that are slow or APIs that are inefficient.

연관관계에 걸린 두 엔티티의 모든 정보를 조회해야하는 경우가 있는가 하면, 두 엔티티 중 하나의 정보만 조회해도 되는 경우도 있다.

프록시란?

em.getReference() : DB 쿼리가 안나가는데 객체가 조회가 되는 것.

• em.find()는 DB를 조회해서 실제 entity 객체를 조회하는 반면, hibernate가 내부의 라이브러리를 이용해 가짜 엔티티객체 (프록시)를 줌
• proxy : 1) 실제 클래스를 상속받아 만들어 겉 모양이 같음 2) 실제 객체의 reference(=target)을 보관함

  프록시 특징

1. proxy object는 처음 사용할 때 한 번만 초기화
2. 프록시 객체를 초기화 할 때 프록시 객체가 실제 엔티티로 바뀌는 게 아님. 접근 가능해지는 것이지 내부의 참조만 target으로 가지게 될 뿐
3. 원본 entity를 상속받기에 타입 체크시 주의 : ==대신 instanceof사용
4. Persistence Context에 찾는 entity가 이미 있으면 em.getReference를 호출해도 실제 entity를 반환 1) 이미 1차캐시에 있는데 proxy로 반환해봐야 얻을 수 있는 이점이 없음 2) 한 PersistenceContext에 존재하고 PK가 동일하면 동일성을 보장하기 위해서
5. PersistenceContext의 도움을 받을 수 없는 준영속상태일 때 proxy를 초기화하면 문제 발생

즉시로딩과 지연로딩

    @Entity
    public class Member {
        @Id @GeneratedValue
        private Long id;

        @Column(name = "username")
        private String name;

        @ManyToOne(fetch = FetchType.Lazy)
        @JoinColumn(name = "team_id")
        private Team team;
    }

    Member member = em.find(Member.class, 1L);
    //member.team은 프록시임
    Team team = member.getTeam();
    team.getName(); //실제 team을 사용하는 시점에 초기화; DB조회

실무에선, 모든 연관관계에 지연로딩만 사용해야 함

• JPQL fetch조인이나 entity 그래프기능을 사용해야 함.
• 즉시로딩을 사용하면 예상치 못한 SQL이 발생
• 또한 JPQL에서 N+1 문제를 일으킴
  • 처음 query를 하나 날렸는데 그것 때문에 추가 query가 n개 나간다고 해서 N+1문제라고 한다.

    → ManyToOne``OneToOne은 기본이 즉시로딩이므로 Lazy로 설정해야 함.

persistence Cascade

WHEN AND WHY? 특정 entity를 persist할 때 연관된 entity도 함께 persist하고 싶을 때 특히, 어떤 entity가 단일 Entity에 완전히 종속적일 때; 다른 entity와 연관관계가 없을 경우

• 예를 들어, 부모 Entity를 저장할 때 자식 entity도 함께 저장하는 경우

association mapping과 아무 관련이 없음. 그저 함께 Persist하는 편리함을 제공할 뿐

종류

• ALL
• Persist
• Remove

  orphan Object

  부모 Entity와 association이 끊어진 자식 entity를 자동으로 삭제 orphanRemoval = true

참조하는 곳이 하나일 때만 사용해야 함. 특정 Entity가 개인 소유할 때 사용해야 함.

CascadeType.ALL, orphanRemoval=true

• 두 옵션을 모두 활성화할 때, 부모entity를 통해 자식의 생명 주기를 관리할 수 있음
• 스스로 생명주기를 관리하는 entity는 em.persist() 후 em.remove()로 제거한다.

DDD(도메인 주도 설계)의 Aggregate Root개념을 구현할 때 유용.

Object-RDB Mapping

entity mapping

DDL(DataDefinitionLanguage)을 application 실행 시점에 자동 생성 → database schema(Tables, Field/columns, relationships ...)가 자동 생성됨

• 이때 database dialect를 사용하여 적절한 DDL생성
• 테이블 중심에서 객체 중심으로
• 개발 서버에서만 사용해야 함! (운영 서버에서는 사용 ㄴㄴ or 다듬어서 사용)

  개요

hibernate.hbm2ddl.auto

• 운영 장비에는 절대 create, create-drop, update 사용하면 안됨
• local서버에서만 update, create사용하자

Object - table mapping

@Entity

@Entity가 붙은 클래스를 entity라 하고, JPA가 관리한다. 실제 DB 테이블과 매핑되는 핵심 클래스로, 데이터베이스의 테이블에 존재하는 컬럼들을 필드로 가지는 객체

속성 name

JPA에서 사용할 entity의 이름. 기본값 = 클래스 명

field와 Column mapping

@Column 매핑 사용

속성은 다음과 같다

enum타입의 경우 @Enumerated(EnumType.STRING)

매핑하지 않으려면 @Transient

긴 것은 @Lob이용

PrimaryKey mapping

• 기본 키 제약 조건: null 아님, 유일, 변하면 안된다.

• but, 미래까지 이 조건을 만족하는 자연키는 찾기 어렵다. 대리키(대체키)를 사용하자. 예를 들어 주민등록번호도 기본 키로 적절하기 않다.

  ⟹ 권장: Long형 + 대체키 + 키 생성전략(AUTO_INCREMENT, SEQUENCE_OBJECT 사용 등)

  • 직접 할당: @Id만 사용
  • 자동 생성 : @GeneratedValue 사용

1) IDENTITY 전략 : 기본 키 생성을 데이터베이스에 위임

• MySQL, PostgresQL,,
• JPA는 보통 트랜잭션 커밋 시점에 INSERT SQL 실행한다 그러나 AUTO_ INCREMENT는 데이터베이스에 INSERT SQL을 실행한 이후에 PK값이 나오기 때문에
• 따라서 IDENTITY 전략은 em.persist() 시점에 즉시 INSERT SQL 실행 하고 DB에서 식별자를 조회

    @Entity
    public class Member {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;

2) SEQUENCE 전략

database sequence = 유일한 값을 순서대로 생성하는 DB Object

• oracle, PostgresQL, H2

    @Entity
    @SequenceGenerator(
        name = "MEMBER_SEQ_GENERATOR",
        sequenceName = "MEMBER_SEQ",
        initialValue = 1, allocationSize = 50)
    public class Member {
        @Id
        @GeneratedValue(strategy = GenerationType.SEQUENCE)
        private Long id;

TABLE 전략

키 생성 전용 테이블을 하나 만들어서 database sequence를 흉내내는 전략

• 모든 DB에 적용가능
• 성능이 안좋음

association mapping

• 객체의 reference와 table의 foreign Key를 mapping
• table은 FK로 join해서 연관 Table을 찾음
• 객체는 참조를 사용해서 연관된 객체를 찾음

1. 단방향 mapping만으로 일단 설계를 완료해야 함

테이블 설계를 같이 그리면서 객체 설계가 일어나야 함 이때 단방향으로 설계를 끝내야 함

단방향으로 이미 설계가 완료된 것

단지 역방향으로 조회하기 위해 단방향을 필요할 때만 또 추가해서 양방향을 만드는 것이다.

• JPQL에서 역방향으로 탐색해야할 일이 많음
• 어플리케이션 개발 때 추가

  양방향 association

• table의 경우, FK가 다른 테이블에서 PK이므로 FK하나로 양쪽을 다 알 수 있다(양쪽으로 join가능)
• 객체의 양방향 관계는 사실상 서로 다른 2개의 단방향 관계이다.

  따라서 객체의 두 관계 중 하나를 연관관계의 주인으로 지정해 이것 만이 외래키를 관리(등록, 수정)할 수 있어야 한다.

  FK가 있는 쪽을 주인으로 정하자. 비즈니스적으로 중요한 쪽이 주인이 되는 것이 아니다.

• 1 : N이면 N이 주인
• 주인이 아닌쪽은 읽기만 가능
• 주인은 mappedBy속성을 사용하면 ㄴㄴ, 주인이 아닌 쪽이 mappedBy로 주인을 지정해야 함

주의점

1. 연관관계 Owner에 값을 입력해야 한다. 또한 순수한 객체 관계를 고려해 항상 양쪽에 값을 입력해야 한다.

2. 양쪽에 값을 입력할 수 있도록 association helper method를 작성하자.

3. 무한 loop

lombok에서 toString()만드는 것은 웬만하면 쓰지 마라

JSON생성 라이브러리 : controller에는 Entity를 반환하면 안된다.

3. 연관관계 mapping시 고려사항

1) 다중성 2) 단방향, 양방향 3) 연관관계의 주인

@JoinColumn(name = "매핑할 외래키 이름")

다대일 (가장 많이 쓰는.)

일대다

• 다대일의 반대
• entity가 관리하는 FK가 다른 테이블에 존재
• 연관관계 관리를 위해 추가로 UPDATE sql 실행

  ⟹ 다대일 양방향으로 사용하자. (객체에서 참조를 하나 더 넣는 한이 있더라도)

  일대일

• DB입장에선 외래 키의 DB 유니크 제약조건이 추가된 것
• 한마디로 정리하면, 객체는 상응하는 table만 관리할 수 있다 (주 테이블에 FK가 있는 경우만 제시한 것임) (대상 테이블에 FK가 있는 경우도 가능)

다대다 : 쓰면 안됨

• RDB는 정규화된 Table2개로 다대다 관계를 표현할 수 없음
• 연결테이블을 추가해서 일대다 + 다대일 관계로 풀어내야 함

4. 상속관계 association mapping

• RDB는 상속관계가 없음
• 조인전략을 기본으로 하되, 너무 단순하고 확장성이 없는 경우 단일테이블 전략으로 전환하자.

전략1. @Inheritance(strategy = InheritanceType.JOINED)

장점 : 1) Data가 정규화, 설계가 깔끔 2) 제약조건을 아이템에 걸어서 맞출 수 있음 3) 저장공간 효율화

단점 : 1) 조회시 join을 많이 사용, 성능 저하 2) 조회 쿼리가 복잡 3) 데이터 저장시 Insert sql 2번 호출

전략2. @Inheritance(strategy = InheritanceType.SINGLE_TABLE)

dtype을 자동으로 추가해 줌

장점 1) join이 필요가 없으므로 조회가 빠름 2) 조회 쿼리가 단순

단점 1) ((치명적)) 자식 엔티티가 매핑한 칼럼은 모두 null허용 2) 단일 테이블에 모든 것을 저장하므로 테이블이 커질 수 있어 상황에 따라 성능저하 가능

전략3. (아무도 추천하지 않는 전략) @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)

@MappedSuperclass

상속관계 매핑이 전혀 아니라, 단순히 entity가 공유하는 속성을 같이 쓰고 싶을 때 주로 등록일, 수정일, 등록자, 수정자 같은 전체 엔티티에서 공통 으로 적용하는 정보를 모을 때 사용

주로 registerDate, lastModifiedDate, registorName, modifierName과 같은 전체 entity에서 공통으로 적용하는 정보를 모을 때 사용

부모 클래스를 상속 받는 자식 클래스에 매핑 정보만 제공 조회

검색 불가(em.find(BaseEntity) 불가)

직접 생성해서 사용할 일이 없으므로 추상 클래스 권장

참고로, 엔티티 객체에서 extend할 수 있는 것은 @MappedSuperclass이거나 @Entity인 엔티티만 가능하다.

객체 지향 프로그래밍 vs relational DB

패러다임 불일치

객체답게 모델링 할수록 매핑작업만 늘어날뿐.

상속 연관관계 데이터 타입 데이터 식별 방법

객체를 java Collection에 저장하듯이 DB에 저장할 수 없을까?

S. 이 고민에서 나온게 JPA

ORM : Object-Relational Mapping

• 객체는 객체대로
• RDB는 RDB대로
• 프레임워크를 이용해 중간에서 mapping

  장점

  SQL중심 → 객체 중심의 개발 가능

• 생산성
• 유지보수

  패러다임 불일치 해결

JPQL

한마디로 객체 지향 SQL

• SQL을 추상화해서 여러 DB에 맞는 dialect사용하게끔해서 의존성 없앰
• 테이블이 아닌 객체를 대상으로 검색하는 객체지향 query

JPA

1. 항상 Entity Manager Factory를 만들어야 한다; 데이터베이스 하나씩 묶여서 돌아가는 것
2. 작업을 해야하면 꼭 Entity Manager를 통해서 작업을 해야한다.
3. JPA의 모든 작업은 transaction 안에서 일어나야 한다.
   • transaction 시작
   • 필요한 로직 실행
   • commit

핵심1. [ORM]

객체랑 RDB랑 어떻게 매핑을 해서 쓸 것인가?

핵심2. persistence context

"Entity를 영구 저장하는 환경."

내부 구현이 어떻게 되는가?

application과 database사이의 중간 매개체

Entity Manager를 통해 Persistence Context에 접근

하지만 EntityManger 도 자신의 인스턴스를 관리해줄 곳이 필요한데 그런 공간을 만들어 주는 곳이 EntityManagerFactory 이다. (Factory같은 경우는 한번 생성하는데 비용이 많이 들기 때문에 한번 생성 후 애플리케이션 전체에 공유)

EntityMangerFactory 생성 시 커넥션 풀도 만들어 준다

Entity의 4가지 상태

1. new/transient : JPA와 전혀 관련 없는 상태
2. managed : Persistence Context에 '관리'
3. detached : Entity를 PersistencContext에서 '분리'
4. removed : 객체를 삭제한 상태

   특징과 이점

   

1. Entity 등록 : transaction단위로 등록하므로 쓰기 지연이 됨

    EntityManager em = emf.createEntityManager();
    EntityTransaction transaction = em.getTransaction();
    //EntityManager는 데이터 변경시 transaction을 시작해야 한다
    transaction.begin(); //transaction시작

    em.persist(memberA); //쓰기지연 SQ저장소에 INSERT 저장하고 1차 캐시에 memberA를 저장함.
    em.persist(memberB); //쓰기지연 SQ저장소에 INSERT 저장하고 1차 캐시에 memberA를 저장함.
    //여기까지 INSERT SQL을 DB에 보내지 않음

    transaction.commit(); //커밋하는 순간 flush()호출 : DB에 SQL저장소에 있던 쿼리를 보냄 

2. Entity 수정 : PersistencContext의 "쓰기 지연 → 변경 감지(dirty checking)"로 인해 DB 데이터의 수정을 Java의 컬렉션에 데이터를 수정하듯이 할 수 있다.

⟹ 수정 후 다시 em.persist(member)할 필요가 없다 쓰기 지연 SQL 저장소 : JPA는 transaction이 commit되는 시점에 변경을 반영함.

Member member1 = em.find(Member.class, 1L); // 조회
member1.setName("ha");

em.persist(member1) // ???

transaction.commit();

1차 캐시 내부 공간에서 만약 사용자가 em.persist를 하면 snapshot으로 해당 객체를 저장 member.setName('ha') 와 같은 코드로 setter를 호출해서 데이터를 바꿀 때 기존에 있던 스냅 샷과 바꾼 Member 객체 간 데이터를 비교해서 다르다면 Update 쿼리문을 자동으로 날려준다

3. Entity삭제

    Member memberA = em.find(member.class, "memberA");
    em.remove(memberA); //entity삭제

4. 동일성보장 : EntityManager에서 같은 객체를 불렀을 때 동일성을 보장

Member a = em.find(Member.class, "memberA"); 
member b = em.find(Member.class, "memberB");  
a == b ?? // true

*flush ≡ persistenceContext의 변경 내용을 DB에 반영하는 것

과정

flush 자동 호출 : i) transaction이 commit될 때 ii) JPQL 쿼리 실행할때 자동으로

or em.flush() (직접 호출하는 방법, 자동으로 ㄴㄴ)

ㄱ. dirty checking 변경 감지 ㄴ. 수정된 entity를 쓰기 지연 SQL 저장소에 등록 ㄷ. 쓰기 지연 SQL저장소의 쿼리를 DB에 전송

주의점

• 1차 cache를 지우는 게 아님
• persistence context를 지우는 것도 아님
• transaction이라는 작업 단위. commit직전에만 동기화하면 됨

public interface Beverage {
    String getDescription();
    double cost();
}

concrete component class

• Component 인터페이스를 구현하며, 기본적인 동작을 정의합니다.
• 이 클래스는 실제 객체를 나타냄

public class Espresso implements Beverage {
    @Override
    public String getDescription() {
        return "Espresso";
    }

    @Override
    public double cost() {
        return 1.99;
    }
}

decorator abstract class

• Component 인터페이스를 구현
• 내부적으로 Component 타입의 객체를 포함

public abstract class BeverageDecorator implements Beverage {
    protected Beverage beverage;

    public BeverageDecorator(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription();
    }
}

concrete decorator class

Decorator 클래스를 확장하여 추가적인 기능을 제공; 이 클래스는 동적으로 기능을 추가할 때 사용

public class Milk extends BeverageDecorator {
    public Milk(Beverage beverage) {
        super(beverage);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }

    @Override
    public double cost() {
        return beverage.cost() + 0.50;
    }
}

client에서 활용

1. 기본 객체 생성: ConcreteComponent 객체를 생성합니다. 이 객체는 기본적인 기능을 가지고 있습니다.

2. 데코레이터 적용: ConcreteDecoratorA와 ConcreteDecoratorB를 순차적으로 적용하여 기능을 확장합니다. 각 데코레이터는 Component 객체를 인수로 받아 기능을 확장

3. 재할당(다형적 참조)을 통한 확장된 객체 사용: 확장된 객체를 사용하여 결과를 출력합니다. 각 데코레이터는 이전의 상태를 기반으로 추가 기능을 제공하므로, 결과적으로 객체의 기능이 단계적으로 확장

   public class CoffeeShop {
    public static void main(String[] args) {
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() + " $" + beverage.cost());
   
        beverage = new Milk(beverage);
        System.out.println(beverage.getDescription() + " $" + beverage.cost());
   
        beverage = new Mocha(beverage);
        System.out.println(beverage.getDescription() + " $" + beverage.cost());
    }
   }

[I/O에서의 decorator pattern]

import java.io.*;

public class InputStreamDecoratorExample {
    public static void main(String[] args) {
        String filePath = "example.txt";

        try {
            // FileInputStream을 생성합니다.
            InputStream fileInputStream = new FileInputStream(filePath);

            // FileInputStream을 BufferedInputStream으로 데코레이팅합니다.
            InputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

            // BufferedInputStream을 LineNumberInputStream으로 데코레이팅합니다.
            LineNumberInputStream lineNumberInputStream = new LineNumberInputStream(bufferedInputStream);

            // 파일을 읽고 출력합니다.
            int data;
            while ((data = lineNumberInputStream.read()) != -1) {
                System.out.print((char) data);

                // 줄바꿈 문자일 때 줄 번호를 출력합니다.
                if (data == '\n') {
                    System.out.println("Line number: " + lineNumberInputStream.getLineNumber());
                }
            }

            // 스트림을 닫습니다.
            lineNumberInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ㄱ. 접근 제어자 : public, protected, private ㄴ. 기타 제어자 : static, abstract, final, synchronized, (관례상 이 순서) ㄷ. 리턴 타입 ㄹ. 메서드 이름 ㅁ. parameter list ㅂ. Exception List

정의 : method invocation과 method definition을 연결하는 과정

early binding; static binding

컴파일 시점에 메서드 정의와 메서드 호출을 연결하는 방식

• 정적 메서드 호출; 클래스명이 아닌 심지어 객체를 통해 호출할 때도 * method hiding이 일어나는 경우 : 참조된 타입에 의해 결정(late binding이랑 반대)

• 오버로딩 * 컴파일러는 각 메서드 호출에 대해 올바른 메서드 정의를 찾고, 이를 컴파일 시점에 결정하므로

late binding; dynamic binding

실행 시점에 메서드 정의와 메서드 호출을 연결하는 방식 (동적 바인딩)

• 오버라이딩 (다형성)
• java는 기본적으로 late binding을 사용

  polymorphism

정의

("다양한 형태") 한 객체가 여러 타입의 객체로 취급될 수 있는 것

다형적 참조 + 메서드 overriding 으로 구현되는 것

핵심 2가지

1. 부모는 자식을 품을 수 있다.

Parent poly = new Parent() Parent poly = new Child() Parent poly = new GrandChild()

상속관계는 부모 방향으로 찾아 올라갈 수는 있으나 자식방향으로 찾아 내려갈 수는 없다. poly.childMethod() : ㄴㄴ (캐스팅 필요)

2. overriding 된 메서드가 항상 우선권을 가짐

객체 자체가 사실상 자식 인스턴스도 포함할 때, 그 자식에서 override된 메서드로 작동한다; 실행 시점에 객체의 실제 타입에 따라 호출되는 메서드가 결정

public class OverridingMain {
    public static void main(String[] args) {
//자식 변수가 자식 인스턴스 참조
        Child child = new Child();
        System.out.println("Child -> Child"); 
        System.out.println("value = " + child.value);//value = child
        child.method(); //childmethod
//부모 변수가 부모 인스턴스 참조
        Parent parent = new Parent(); 
        System.out.println("Parent -> Parent"); 
        System.out.println("value = " + parent.value);//value = 
        parent.method(); //parentmethod
//부모 변수가 자식 인스턴스 참조(다형적 참조)
        Parent poly = new Child();
        System.out.println("Parent -> Child"); 
        System.out.println("value = " + poly.value); //변수는 오버라이딩X value = parent
        poly.method(); //메서드 오버라이딩! : childmethod

casting

1) downcasting : (원래 부모 타입인 걸) 자식타입으로 변경

    Parent poly1 = new Child();
    Parent poly2 = new Parent();
    Child child1 = (Child) poly1; 
    Child child2 = (Child) poly2;  //runtime error
    child1.childMethod(); ((Child) poly1).childMethod();
    child2.childMethod() //execute impossible

• poly의 타입은 그래로! 자바에선 항상 value-copy!!

• poly와 child모두 같은 참조값(e.g. x001)을 참조함

• 재할당외에는 변수의 내용을 바꿀수 있는 게 없음

• memory상에 자식이 존재하지 않는 경우, 실패하는 문제가 생성된다. casting 표시를 항상 해줘야 한다.

2) upcasting : 자식타입을 부모타입으로 변경

    Child child = new Child();
    Parent parent1 = (Parent) child; //캐스팅 표시
    Parent parent2 = child; //권장

• 객체를 생성하면 해당 타입의 부모타입은 항상 생성되는데,

• memory상에 부모가 존재하므로 upcasting은 항상 성공하고, casting 생략도 가능

• 업캐스팅된 객체는 부모 클래스 타입으로만 참조되기 때문에, 자식 클래스에서 정의된 메서드나 필드에는 접근할 수 없다

  instanceOf의 사용

  public class CastingMain5 {
    public static void main(String[] args) { 
    Parent parent1 = new Parent(); 
    System.out.println("parent1 호출"); 
    call(parent1); // if false
    Parent parent2 = new Child();
    System.out.println("parent2 호출"); 
    call(parent2); //if true
  }
     private static void call(Parent parent) {
         parent.parentMethod();
         if (parent instanceof Child) {
            System.out.println("Child 인스턴스 맞음"); 
            Child child = (Child) parent; 
            child.childMethod();
        }
    }
  }

주의

static method에는 다형성이 적용되지 않는다

class Parent {
    public static void staticMethod() {
        System.out.println("Parent static method");
    }

    public void instanceMethod() {
        System.out.println("Parent instance method");
    }
}

class Child extends Parent {
    public static void staticMethod() {
        System.out.println("Child static method");
    }

    @Override
    public void instanceMethod() {
        System.out.println("Child instance method");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();

        // 정적 메서드 호출
        parent.staticMethod(); // Parent static method 출력
        Parent.staticMethod(); // Parent static method 출력
        Child.staticMethod();  // Child static method 출력

        // 인스턴스 메서드 호출 (다형성 적용)
        parent.instanceMethod(); // Child instance method 출력
    }
}

final 메소드는 애초에 override가 안되니까 당연히 다형성을 적용할 수 없다.

적용

[toString()과 다형성]

class Parent {
    @Override
    public String toString() {
        return "This is a Parent object";
    }
}

class Child extends Parent {
    @Override
    public String toString() {
        return "This is a Child object";
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child(); // 업캐스팅

        // toString() 메서드 호출
        System.out.println(parent.toString()); // This is a Parent object
        System.out.println(child.toString());  // This is a Child object
    }
}

[clone()]

class Parent {
    private int value;

    public Parent(int value) {
        this.value = value;
    }

    // 복사 생성자
    public Parent(Parent other) {
        this.value = other.value;
    }

    public Parent clone() {
        return new Parent(this); // 복사 생성자를 사용하여 객체 복사
    }

    @Override
    public String toString() {
        return "Parent{" + "value=" + value + '}';
    }
}

• 참고로 접근 제어자가 protected에서 public으로 확장되었다.

  class Child extends Parent {
    private int extraValue;
  
    public Child(int value, int extraValue) {
        super(value);
        this.extraValue = extraValue;
    }
  
    // 복사 생성자
    public Child(Child other) {
        super(other); // 부모 클래스의 복사 생성자 호출
        this.extraValue = other.extraValue;
    }
  
    @Override
    public Child clone() {
        return new Child(this); // 복사 생성자를 사용하여 객체 복사
    }
  
    @Override
    public String toString() {
        return "Child{" + "value=" + super.toString() + ", extraValue=" + extraValue + '}';
    }
  }
  

원래 clone()의 리턴타입은 `Object`이다. 그런데 리턴타입을 `Child`로 바뀌었다. 이를 오버라이딩이라 할 수 있는가?
- override의 예외라 봐야 한다.
- covariant return type은 자바에서 오버라이딩할 때 리턴 타입을 부모 클래스 메서드의 리턴 타입의 하위 타입으로 변경할 수 있게 해주는 예외적인 규칙


```java
public class Main {
    public static void main(String[] args) {
        Child original = new Child(10, 20);
        Child copy = original.clone(); // 복사 생성자를 사용하여 객체 복사

        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);
    }
}

• 기본적으로 얕은 복사만 수행하는 clone()을 깊은 복사를 수행하도록 override할 수 있다.
• 다형성을 이용하여 실제 타입에 맞는 재정의된 메서드를 사용할 수 있게 되었다.

class A extends B

상속되지 않는 것.

아래 3가지 빼고는 모두 상속됨 (초기화 블록은 다루지 않음)

1. 생성자(Constructor)

• 자식 클래스는 부모 클래스의 생성자를 상속받지 않음

• 생각해보면 당연한 것; 자식 클래스는 자신의 생성자를 명시적으로 정의해야 함

• 부모 클래스의 생성자를 호출하려면 super() 키워드를 사용

  2. private 멤버 변수 및 메서드

• 자식 클래스는 부모 클래스의 private 멤버 변수와 메서드를 직접 상속받지 않음

• 그러나 메서드를 이용한 접근은 가능 : 부모 클래스의 public 또는 protected 메서드를 통해 접근할 수 있다.

  3. static 메서드

• static 메서드는 클래스 자체에 속하므로 상속의 개념이 아님

• 따라서 자식 클래스는 부모 클래스의 static 메서드를 상속받지 않지만, 부모 클래스의 static 메서드를 사용할 수 있긴 하다.

  public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.accessMethods();
  
        Parent.staticMethod(); // 가능: static 메서드는 클래스 이름으로 접근
        Child.staticMethod(); // 가능: 부모 클래스의 static 메서드를 자식 클래스 이름으로도 접근 가능
    }
  }

  상속시 주의사항

  1. constructor 상속

• base class의 constructor는 상속이 안됨

• derived class에서 사용하려면, super를 이용

  1. 자식클래스의 first statement에서 사용해야 함
  2. 자식의 필드를 super의 인자로 전달할 수 없다.(왜냐하면, 부모의 생성자 호출 시점에 필드는 초기화 되지 않기에)
  3. 별다른 super를 호출하지 않는다면 부모의 no-argument constructor가 호출된다
  4. 따라서 부모 클래스에 매개변수가 있는 생성자만 정의된 경우(기본 생성자를 따로 정의하지 않으면 java에서 만들지 않음), super를 쓰지 않으면 컴파일 에러가 발생한다.

2.this constructor for constructor chaining

• 다른 생성자를 활용해 정의하는 것
• 반드시 생성자의 첫 번째 문장이어야 함

*this와 super를 동시에 쓸 수 없음

주의 : this로 호출된 다른 constructor에서 super를 호출하는 것은 가능

3. private 멤버는 다른 클래스에서 사용될 수 없다.

proxy access 는 가능

    // 부모 클래스
class SuperClass {
    // 슈퍼클래스의 private 메서드
    private void privateMethod() {
        System.out.println("Private method in SuperClass");
    }

    // 슈퍼클래스의 public 메서드
    public void publicMethod() {
        System.out.println("Public method in SuperClass calling the private method");
        privateMethod();  // private 메서드를 호출
    }
}

// 자식 클래스
class SubClass extends SuperClass {
    // 자식 클래스에서 슈퍼클래스의 public 메서드를 통해 간접적으로 private 메서드를 호출
    public void accessSuperPrivateMethod() {
        System.out.println("SubClass calling SuperClass's publicMethod");
        publicMethod();  // 슈퍼클래스의 public 메서드를 호출, 이 메서드는 내부적으로 private 메서드를 호출
    }
}

public class Main {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.accessSuperPrivateMethod();  // SubClass를 통해 슈퍼클래스의 private 메서드에 간접적으로 접근
    }
}

4. package access

• protected 멤버에 대해, 다른 패키지에 정의된 자식 클래스는 접근이 가능하다.
• public만 package에 자유롭다; protected, default, private은 안된다.

* 같은 package의 클래스들은 같은 namespace에 들어가 다른 package내 같은 이름과 구분해 준다.

5.final : 상속 방지 // override 금지

• final class : 상속 방지
• final method : override 금지
• final field : constant처리

6. Access 허용 변화 : 허용치를 높인다; 제한은 불가

활용

[활용 예시 - StringTokenizer를 상속받아 기능 강화]

원래 StringTokenizer는 한 번에 한 번씩 문자열의 토큰을 생성하는 기능을 제공하지만, 기본적으로 두 번째 순회 또는 반복을 지원하지 않는다

하지만 상속으로 기능을 강화할 수 있다

import java.util.StringTokenizer;

public class CustomStringTokenizer {
    private String originalString;
    private StringTokenizer tokenizer;
    private String delim;
    private boolean returnDelims;

    // Constructor for default delimiters
    public CustomStringTokenizer(String str) {
        this.originalString = str;
        this.delim = " \t\n\r\f"; // default delimiters
        this.returnDelims = false;
        this.tokenizer = new StringTokenizer(str);
    }

    // Constructor with custom delimiters
    public CustomStringTokenizer(String str, String delim) {
        this.originalString = str;
        this.delim = delim;
        this.returnDelims = false;
        this.tokenizer = new StringTokenizer(str, delim);
    }

    // Constructor with custom delimiters and returnDelims flag
    public CustomStringTokenizer(String str, String delim, boolean returnDelims) {
        this.originalString = str;
        this.delim = delim;
        this.returnDelims = returnDelims;
        this.tokenizer = new StringTokenizer(str, delim, returnDelims);
    }

    // Reset method: reinitialize the tokenizer
    public void reset() {
        this.tokenizer = new StringTokenizer(this.originalString, this.delim, this.returnDelims);
    }

    // Delegate methods to the tokenizer
    public boolean hasMoreTokens() {
        return tokenizer.hasMoreTokens();
    }

    public String nextToken() {
        return tokenizer.nextToken();
    }

    // Main method for demonstration
    public static void main(String[] args) {
        CustomStringTokenizer tokenizer = new CustomStringTokenizer("Hello World");

        while (tokenizer.hasMoreTokens()) {
            System.out.println(tokenizer.nextToken());
        }

        // Reset the tokenizer
        tokenizer.reset();

        while (tokenizer.hasMoreTokens()) {
            System.out.println(tokenizer.nextToken());
        }
    }
}

Object class

• java.lang에 포함 -> 자동으로 import
• 모든 클래스의 조상
• equals, toString method는 모든 클래스가 상속 받음

equals 정의법

1. null 검사 + 같은 타입인지 검사

2. Object o에서 o는 반드시 타입 캐스팅되어야 한다. 그 후에 필드 동일성을 검사한다.

public boolean equals(Object otherObject) {
  if(otherObject == null) { 
      return false;
    } else if (getClass( ) != otherObject.getClass( )) { 
        return false;
    } else {
    Employee otherEmployee = (Employee)otherObject; r
    eturn (name.equals(otherEmployee.name) &&
hireDate.equals(otherEmployee.hireDate)); 
    }
}

getClass() VS instanceof operator

모두 타입 체크 용

getClass()는 final 메서드다 => override불가능

1. obj instanceof ClassA

• true : classA 거나 그 자식 클래스 타입
• false : 그 외

2. 차이를 예시로 이해하자

   class Parent {}
   

class Child extends Parent {}

public class Main { public static void main(String[] args) { Parent parent = new Parent(); Child child = new Child(); Parent parentChild = new Child();

    System.out.println(parent instanceof Parent); // true
    System.out.println(child instanceof Child);   // true
    System.out.println(child instanceof Parent);  // true
    System.out.println(parentChild instanceof Parent); // true
    System.out.println(parentChild instanceof Child);  // true
}

}

```java
class Parent {}

class Child extends Parent {}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Child child = new Child();
        Parent parentChild = new Child();

        System.out.println(parent.getClass() == Parent.class); // true
        System.out.println(child.getClass() == Child.class);   // true
        System.out.println(parentChild.getClass() == Parent.class); // false
        System.out.println(parentChild.getClass() == Child.class);  // true
    }
}

getClass() 메서드는 다형성(polymorphism)에서 부모 클래스 타입의 변수로 참조된 자식 클래스 객체의 정확한 타입을 알 수 있게 해준다.

class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }

    public void fetch() {
        System.out.println("Dog is fetching");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }

    public void scratch() {
        System.out.println("Cat is scratching");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal1 = new Dog();
        Animal myAnimal2 = new Cat();

        // 다형성을 이용하여 상위 클래스 타입 변수로 메서드 호출
        myAnimal1.makeSound(); // 출력: Bark
        myAnimal2.makeSound(); // 출력: Meow

        // instanceOf를 사용하여 실제 객체 타입에 따라 다른 동작 수행
        if (myAnimal1 instanceof Dog) {
            Dog myDog = (Dog) myAnimal1;
            myDog.fetch(); // 출력: Dog is fetching
        }

        if (myAnimal2 instanceof Cat) {
            Cat myCat = (Cat) myAnimal2;
            myCat.scratch(); // 출력: Cat is scratching
        }
    }
}

클래스가 오직 하나의 객체만 가지도록 함. 객체 하나 생성시 많은 자원을 필요로 하는 경우 이 패턴을 사용.

사용 사례

• Logging
• Caches
• Registry Settings
• Access External Resources : Printer, Device Driver, Database

구현

• 생성자를 private으로
• 생성된 단 하나의 인스턴스를 반환하는 static method구현

*Lazy Initialization = 인스턴스가 실제로 필요할 때까지 생성되지 않는 방식

i) Simple Locking

단일 스레드 환경: 단일 스레드 환경에서는 동기화 없이도 안전하게 싱글턴을 생성할 수 있습니다. 간단한 구현: 코드가 비교적 간단하며, 동기화에 따른 성능 저하가 없습니다.

public class Singleton
{
   private Singleton() {}
   private static Singleton uniqueInstance;
   public static Singleton getInstance()
   {
        synchronized(Singleton.class) {
            if (uniqueInstance == null)
                   uniqueInstance = new Singleton();
}
         return uniqueInstance;
   }
}

멀티스레드 환경에서 안전하지 않음: 동기화를 하지 않기 때문에, 멀티스레드 환경에서는 여러 스레드가 동시에 인스턴스를 생성하려 할 수 있습니다.

ii) Double-checked Locking

멀티스레드 환경에서 안전함: 두 번의 체크와 동기화를 통해 인스턴스가 동시에 여러 번 생성되는 것을 방지합니다. 성능 최적화: 필요할 때만 동기화를 사용하여 성능 저하를 최소화합니다.

public class Singleton2
{
  private Singleton2() {}

  private volatile static Singleton2 uniqueInstance;

  public static Singleton2 getInstance()
     {
          if (uniqueInstance == null) { // single checked 
            synchronized(Singleton2.class) {
                  if (uniqueInstance == null)    // double checked
                     uniqueInstance = new Singleton();
              }
        }    

        return uniqueInstance;
     }
}

1. 먼저 instance가 존재하는지 검사한다. 즉 동기화 블록이 먼저 실행되지 않는다. 따라서 오버헤드를 방지
2. volatile키워드 사용

• cashe가 아닌 main memory에 저장됨
• 따라서 변수의 값을 모든 스레드에 동일하게 보이도록 보장; 변수가 변경될 때 모든 스레드가 그 변경을 볼 수 있게 함
• volatile을 사용하지 않으면, 인스턴스의 초기화가 완료되기 전에 다른 스레드가 이 인스턴스를 사용할 가능성이 있습니다. volatile 키워드는 이런 문제를 방지해줍니다.

iii) "Eager" initialization

멀티스레드 환경에서 안전함: 클래스가 로드될 때 인스턴스가 생성되므로 동기화가 필요 없습니다. 간단하고 직관적: 구현이 매우 간단하며, 성능 문제가 없습니다.

public class Singleton
{
   private Singleton() {}
   private static Singleton uniqueInstance = new Singleton();

   public static Singleton getInstance()
   {
         return uniqueInstance;
   }
}

지연 초기화 불가: 클래스 로딩 시점에 인스턴스가 생성되기 때문에, 사용하지 않더라도 메모리를 차지합니다.

특징1. thread-safe

1. Eager Initialization을 사용할 경우, Singleton 인스턴스는 클래스가 로드될 때 JVM에 의해 한 번만 생성된다

• 클래스 로드 : JVM에 의해 단 한 번만 이루어지며, 이 시점에서 클래스의 모든 정적 멤버들이 초기화 된다

2. 로드 시점은 스레드 접근 시점 이전에 발생
3. 따라서 무조건 thread-safe; 추가적인 동기화가 필요 없음

특징2. 클래스가 처음 참조될 때, 즉 클래스의 어떤 멤버가 처음으로 접근될 때 인스턴스가 생성됨

즉 위의 예시에서 Singleton.getInstance()가 실행될 때 인스턴스가 생성된다

when & why

i) 인스턴스 생성이 복잡하지 않거나 리소스를 많이 소모하지 않는 경우에 적합 ii) application이 실행될 때 항상 인스턴스가 필요한 경우

옵저버 패턴(Observer Pattern)에서는 한 객체의 상태가 바뀌면 그 객체에 의존하는 다른 객체들한테 연락이 가고, 자동으로 내용이 갱신되는 방식으로 일대다(one-to-many) 의존성을 정의한다.

예시로 기억하자

e.g.

WeatherData 객체는 온도, 습도, 기압 정보를 가지고 있으며, 해당 정보가 변경될 때마다 다음의 세 객체에 데이터가 갱신되어야 한다. 1)현재 날씨 2) 날씨 예보 3) 기상 통계

쓰레기 코드

class WeatherData {
    getTemperature()
    getHumidity()
    getPressure()
    measurementsChanged() // 기상 관측값이 갱신되면 해당 메소드가 호출됨

    public void measurementsChanged() {
        float temp = getTemperature();
        float humidity = getHumidity();
        float pressure = getPressure();

        currentWeatherDisplay.update(temp, humidity, pressure);
        forecastWeatherDisplay.update(temp, humidity, pressure);
        staticsticDisplay.update(temp, humidity, pressure);
    }
}

문제점 : 다른 화면을 추가하고자 한다면 measurementsChanged() 메소드를 고쳐야 함 해결책 : 바뀔 수 있는 부분을 encapsulate 해야 함

observer pattern을 사용한 개선

1. subject + subject impl

public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

class WeatherData implements Subject {
    registerObserver()
    removeObserver()
    notifyObserver()

    getTemperature()
    getHumidity()
    getPressure()
    measurementsChanged()
}

구체적인 code

public class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
        observers = new ArrayList<Observer>();
    }

    public void registerObserver(Observer o) {
        observers.add(o);
    }

    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged() {
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }

}

2. observer interface 정의

새로 갱신된 subject 데이터를 전달하는 interface를 정의해야 함

interface Observer {
    update() // 새로 갱신된 주제 데이터를 전달하는 인터페이스
}

3. observer의 공통된 기능을 interface로 정의

이 예시의 경우, 화면에 표시하는 기능이 공통되므로 이를 interface로 정의한다.

interface DisplayElement {
    display() // 화면에 표현시키는 인터페이스
}

4. 2,3의 interface를 구현한 객체 만들기

class CurrentWeather implements Observer, DisplayElement{
    update()
    display() { // 현재 측정 값을 화면에 표시 }
}

class ForcastWeather implements Observer, DisplayElement{
    update()
    display() { // 날씨 예보 표시 }
}

class StatisticsDisplay implements Observer, DisplayElement{
    update()
    display() { // 평균 기온, 평균 습도 등 표시 }
}

하나만 구체적인 코드를 보자면,

public class StatisticsDisplay implements Observer, DisplayElement {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum= 0.0f;
    private int numReadings;
    private WeatherData weatherData;

    public StatisticsDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float temp, float humidity, float pressure) {
        tempSum += temp;
        numReadings++;

        if (temp > maxTemp) {
            maxTemp = temp;
        }

        if (temp < minTemp) {
            minTemp = temp;
        }

        display();
    }

    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
            + "/" + maxTemp + "/" + minTemp);
    }
}

5. if, 새로운 객체 DiscomfortDisplay를 추가한다면?

class DiscomfortDisplay implements Observer, DisplayElement{
    update()
    display() { // 불쾌지수를 화면에 표시 }
}

main

public class WeatherStation {

    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();

        CurrentConditionsDisplay currentDisplay = 
            new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);

        weatherData.removeObserver(forecastDisplay);
        weatherData.setMeasurements(62, 90, 28.1f);
    }
}

특징 : loose coupling

• The only thing the subject knows about an observer is that it implements a certain interface. 객체간 결합도가 낮은 이유임.
• We can add or remove new observers at any time. 옵저버를 언제든 새로 추가, 제거할 수 있다.
• We never need to modify the subject to add new types of observers. 새로운 형식의 옵저버라 할 지라도 주제를 전혀 변경할 필요가 없다.
• We can reuse subjects or observers independently of each other. 주제와 옵저버는 서로 독립적으로 재사용 할 수 있다.
• Changes to either the subject or an observer will not affect the other. 주제나 옵저버가 바뀌더라도 서로에게 영향을 미치지 않는다.

핵심 구현 포인트

Observer_impl

1. Subject_impl을 필드로 가지고 있어야 함

2. Observer_impl 생성자 : 해당 필드 초기화 + observer배열에 등록

    private Subject_impl s;
   
    public Observer_impl(Subject_impl ss) {
        this.s = ss;
        s.registerObserver(this)
    }

3. update구현 : 정보 전달 받는 메서드 *update는 Observer interface에 정의. 이를 구현해야 함

• 이때 Subject의 정보를 받아올 수 있도록 한다.

• Subject_impl에 정의된 execute() (* notifyObserver와 정보 전달 기능을 하는 메서드)에 쓰인다.

방법1. Subject가 변경된 데이터를 update 메서드의 인자로 직접 전달 (위 예시)

public interface Observer {
    void update(int newNumber);
}

public class DigitObserver implements Observer {
    @Override
    public void update(int newNumber) {
        System.out.println("DigitObserver: " + newNumber);

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

방법2. Observer_impl이 Subject_impl에 대한 참조를 갖도록 하기

public interface Observer {
    void update(NumberGenerator generator);
}

public class DigitObserver implements Observer {
    @Override
    public void update(NumberGenerator generator) {
        System.out.println("DigitObserver: " + generator.getNumber());

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Subject_impl

1. 전달할 정보 정의 위 예시의 경우 temperature, humidity, pressure

2. Observer인터페이스에 정의된 update()메서드를 모든 observer에 대해 실행시키는 notifyObservers()

   public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
   }

3. execute기능 메서드 : 정보 업데이트(중요) + notifyObservers를 실행시키는 메소드를 만든다.

• 정보를 새로 업데이트 하는 기능. 1번에 정의된 곳에 할당.
• notifyObserver를 꼭 실행시켜 통해 update를 실행시키고, 이는 1번에 정의된 필드를 활용한다.

code로 이해하자.

Restaurant : client

public class Restaurant { //client
    SimpleBurgerFactory factory;

    public Restaurant(SimpleBurgerFactory factory) {
        this.factory = factory;
    }

    public Burger orderBurger(String type) {
        Burger burger = factory.createBurger(type);

        burger.prepare();
        burger.cook();

        return burger;
    }

}

SimpleBurgerFactory : factory

public class SimpleBurgerFactory {

    public Burger createBurger(String type) {
        Burger burger = null;

        if(type.equals("beef")) {
            burger = new BeefBurger();
        } else if (type.equals("veggie")) {
            burger = new VeggieBurger();
        }

        return burger;
    }
}

Burger : Product

public abstract class Burger {
    public abstract void prepare();

    public abstract void cook();
}

VeggieBurger : Concrete Product

public class VeggieBurger extends Burger {
    public void prepare() {
        System.out.println("Veggie preparing");
    }

    public void cook() {
        System.out.println("Veggie cooking");
    }
}

BeefBurger : Concrete Product

public class BeefBurger extends Burger {
    public void prepare() {
        System.out.println("BeefBurger preparing");
    }

    public void cook() {
        System.out.println("BeefBurger cooking");
    }
}

Factory Method Pattern

creation design pattern

위 UML로 구현하는게 결론인데 코드 예시로 기억하자.

Restaurant : creator

public abstract class Restaurant {

//    public Restaurant(SimpleBurgerFactory factory) {
//        this.factory = factory;
//    }
    // 더이상 다른 객체에 의존할 필요가 없어짐!

    public Burger orderBurger() {
        Burger burger = createBurger();
        burger.prepare();
        burger.cook();
        return burger;
    }

    public abstract Burger createBurger(); //이게 Factory Method!!!!
}

BeefBurgerRestaurant : Concrete Creator

public class BeefBurgerRestaurant extends Restaurant {

    @Override
    public Burger createBurger() {
        return new BeefBurger();
    }
}

VeggieBurgerRestaurant : Concrete Creator

public class VeggieBurgerRestaurant extends Restaurant {

    @Override
    public Burger createBurger() {
        return new VeggieBurger();
    }
}

Burger : Product

public interface Burger {
    public abstract void prepare();

    public abstract void cook();
}

BeefBurger : Concrete Product

public class BeefBurger implements Burger {
    public void prepare() {
        System.out.println("BeefBurger preparing");
    }

    public void cook() {
        System.out.println("BeefBurger cooking");
    }
}

VeggieBurger : concrete product

public class VeggieBurger implements Burger {
    public void prepare() {
        System.out.println("Veggie preparing");
    }

    public void cook() {
        System.out.println("Veggie cooking");
    }
}

main

import java.util.Scanner;

public class RestaurantMain {
    public static void main(String[] args) {
        Restaurant beefRestaurant = new BeefBurgerRestaurant();
        Restaurant veggieRestaurant = new VeggieBurgerRestaurant();

        Burger burger1 = beefRestaurant.orderBurger();
        Burger burger2= veggieRestaurant.orderBurger();

    }
}

Factory Method는 반드시 Concrete Product를 반환해야 한다.

when and why?

product construction code와 product application code를 분리

-> 새 product를 다른 코드의 수정없이 사용가능

특정 객체의 정확한 type과 dependency를 모를 때

"A proven solution to a commmon problem in a specified context"

분류

Creational

• Abstract Factory
• Builder
• Factory Method
• Prototype
• Singleton

  Structural

• Adapter
• Bridge
• Composite
• Decorator
• Façade
• Flyweight
• Proxy

  Behavioral

• Chain of Responsibility
• Command
• Interpreter
• Iterator
• Mediator
• Memento
• Observer
• State
• Strategy
• Template Method
• Visitor

  Law

1. 서로 상호작용을 하는 객체 사이에서는 가능하면 느슨하게 결합하는 디자인을 사용해야 한다.

• observer pattern에서 잘 드러남

2. 클래스는 확장에 대해서는 열려 있어야 하지만 코드 변경에 대해서는 닫혀 있어야 한다. 이를 Open-Closed Principle (OCP)라 한다.

• decorator pattern에서 잘 드러남

Iterator<T> 인터페이스를 만족하는 모든 클래스의 객체는 Iterator<T>타입으로 사용될 수 있다.

Iterator<T>는 독립적으로 존재 ㄴㄴ

• 반드시 컬렉션 객체와 연관되어야 하며, 보통 컬렉션의 내부 클래스(inner class)로서 iterator 메서드를 통해 사용

• Iterator는 내부 데이터 구조를 순회함 Object next() 내부 구조에서 다음 항목을 반환합니다. boolean hasNext() 구조 내에 더 많은 항목이 있는지 여부를 반환합니다. void remove() 현재 항목을 구조에서 제거합니다.

ArrayList에서 Iterator사용

• ArrayList에서 Iterator를 사용하려면, 먼저 ArrayList로부터 이를 얻어야 합니다.
• 예를 들어, Iterator<String> iterator = myArrayList.iterator();와 같이 사용

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

public class ArrayListIteratorExample { public static void main(String[] args) { // ArrayList 생성 및 요소 추가 ArrayList myArrayList = new ArrayList<>(); myArrayList.add("A"); myArrayList.add("B"); myArrayList.add("C");

    // Iterator를 통해 요소 순회
    Iterator<String> iterator = myArrayList.iterator();
    while (iterator.hasNext()) {
        String item = iterator.next();
        System.out.println(item);

        // 요소 "B"를 제거
        if (item.equals("B")) {
            iterator.remove();
        }
    }

    // 제거 후 ArrayList 출력
    System.out.println("After removal:");
    for (String item : myArrayList) {
        System.out.println(item);
    }

}

}

```java
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ConcurrentModificationException;

public class GenericManager<T> {
    private ArrayList<T> items;

    public GenericManager() {
        this.items = new ArrayList<>();
    }

    // 요소 추가 메서드
    public void addItem(T item) {
        items.add(item);
    }

    // 요소 제거 메서드
    public void removeItem(T item) {
        items.remove(item);
    }

    // 이터레이터를 사용하여 리스트를 순회하는 메서드
    public void iterateItems() {
        try {
            for (Iterator<T> iterator = items.iterator(); iterator.hasNext(); ) {
                T item = iterator.next();
                System.out.println(item);
                // 특정 조건을 만족하면 요소를 제거
                if (/* 조건 */ item.equals("B")) {
                    iterator.remove();
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("ConcurrentModificationException 발생: 이터레이터 사용 시 리스트를 직접 수정할 수 없습니다.");
        }
    }

    public static void main(String[] args) {
        GenericManager<String> manager = new GenericManager<>();
        manager.addItem("A");
        manager.addItem("B");
        manager.addItem("C");

        System.out.println("초기 리스트:");
        manager.iterateItems();

        System.out.println("요소 제거 후 리스트:");
        manager.iterateItems();
    }
}

사용자 정의 컬렉션과 Iterator

import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomCollection<T> implements Iterable<T> {
    private T[] items;
    private int size;

    @SuppressWarnings("unchecked")
    public CustomCollection(int capacity) {
        items = (T[]) new Object[capacity];
        size = 0;
    }

    // 요소 추가 메서드
    public void add(T item) {
        if (size == items.length) {
            throw new IllegalStateException("컬렉션이 가득 찼습니다.");
        }
        items[size++] = item;
    }

    // 요소 제거 메서드
    public void remove(T item) {
        for (int i = 0; i < size; i++) {
            if (items[i].equals(item)) {
                for (int j = i; j < size - 1; j++) {
                    items[j] = items[j + 1];
                }
                items[--size] = null;
                return;
            }
        }
        throw new NoSuchElementException("요소가 컬렉션에 없습니다.");
    }

    // 컬렉션의 크기 반환 메서드
    public int size() {
        return size;
    }

    // 이터레이터를 반환하는 메서드
    @Override
    public Iterator<T> iterator() {
        return new CustomIterator();
    }

    // 내부 클래스: CustomIterator
    private class CustomIterator implements Iterator<T> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < size;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return items[currentIndex++];
        }

        @Override
        public void remove() {
            if (currentIndex <= 0) {
                throw new IllegalStateException("next()를 먼저 호출해야 합니다.");
            }
            CustomCollection.this.remove(items[currentIndex - 1]);
            currentIndex--;
        }
    }

    public static void main(String[] args) {
        CustomCollection<String> customCollection = new CustomCollection<>(10);
        customCollection.add("A");
        customCollection.add("B");
        customCollection.add("C");

        System.out.println("초기 컬렉션:");
        for (String item : customCollection) {
            System.out.println(item);
        }

        // 이터레이터를 사용하여 "B" 요소 제거
        Iterator<String> iterator = customCollection.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("B")) {
                iterator.remove();
            }
        }

        System.out.println("요소 제거 후 컬렉션:");
        for (String item : customCollection) {
            System.out.println(item);
        }
    }
}

내가 구현한 iterator for 사용자 정의 hashmap

    public void printElements() {
        for (int i = 0; i < a.size(); i++) {
            LinkedList<Pair<K, V>> bucket = a.get(i);
            System.out.println("Bucket " + i + ":");

            Iterator<Pair<K, V>> iterator = bucket.iterator();
            while (iterator.hasNext()) {
                Pair<K, V> pair = iterator.next();
                System.out.println("  " + pair.getKey() + " -> " + pair.getValue());
            }
        }
    }


    @Override
    public Iterator<Pair<K, V>> iterator() { 

        return new Iterator<Pair<K, V>>() {
            private int i = 0;
            Iterator<Pair<K, V>> bucketIterator = a.get(i).iterator(); //

            @Override
            public boolean hasNext() {
                while(!bucketIterator.hasNext()) {
                    i++;
                    if (i >= a.size()) {
                        return false;
                    }
                    bucketIterator = a.get(i).iterator();
                }
                return true;
                //returns whether the Linked List has a next element //your code
            }

            @Override
            public Pair<K, V> next() {
                if(!hasNext()) {
                    throw new NoSuchElementException();
                }
                return bucketIterator.next();
                //returns the next element of the linked List // your code
            }
        };
    }

primitive type은 사용 불가; class Type만

당연히 array도 가능하겠죠?

generic method

 public class Utility {

    // 제네릭 메서드
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"Hello", "World"};

        // 제네릭 메서드 호출
        Utility.<Integer>printArray(intArray);
        Utility.<String>printArray(stringArray);
    }
}

generic class; parameterized class

public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Pair{" +
               "key=" + key +
               ", value=" + value +
               '}';
    }

    public static void main(String[] args) {
        // String과 Integer 타입을 사용하는 Pair 객체
        Pair<String, Integer> pair1 = new Pair<String, Integer>("One", 1);
        System.out.println(pair1);

        // String과 String 타입을 사용하는 Pair 객체
        Pair<String, String> pair2 = new Pair<String, String>("Hello", "World");
        System.out.println(pair2);

        // Integer와 Double 타입을 사용하는 Pair 객체
        Pair<Integer, Double> pair3 = new Pair<Integer, Double>(42, 3.14);
        System.out.println(pair3);
    }
}

binding; T에 가능한 타입을 제약

1. 제네릭을 특정 인터페이스나 부모 클래스에 바인딩하는 경우:

• extends 키워드를 사용합니다.
• 인터페이스나 부모 클래스에 바인딩되면 제네릭 타입이 특정 인터페이스나 클래스의 서브타입이어야 합니다.

public class MyClass<T extends Comparable> {
    // 이 코드는 T가 Comparable 타입만 가능하도록 강제합니다.
}

2. 제네릭을 여러 타입에 바인딩하는 경우:

• 여러 인터페이스에 바인딩할 수 있습니다.
• 하나의 클래스에만 바인딩할 수 있으며, 클래스는 항상 첫 번째로 나와야 합니다.

  public class MyClass<T extends Employee & Comparable & Iterable> {
    // 이 코드는 T가 Employee의 서브클래스이면서 동시에 Comparable 및 Iterable 인터페이스를 구현해야 한다는 것을 강제합니다.
    // 확장된 클래스(Employee)는 항상 첫 번째로 나와야 합니다.
  }

import java.util.ArrayList;

정의

length가 변할 수 있는 배열

array : 만들어지는 순간 길이 고정

원리

array를 private 필드로 가지고 있음 + 꽉 찰때마다 더 긴 array가 생성되어 이동

문법

ArrayList<T> aList = new ArrayList<T>(); //초기는 capacity 10
ArrayList<String> bList = new ArrayList<String>(20)

사용

항상 array를 대체하는 것은 아님

• ArrayList 객체는 array보다 비효율적
• '[]' 사용 불가
• ArrayList의 요소는 class type이어야 함. primitive type은 불가능 ; 물론 automatic boxing, unboxing으로 해결

method

사용자 정의 클래스 타입

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

add(E e)

ArrayList<Person> list = new ArrayList<>();
list.add(new Person("Alice", 30));
list.add(new Person("Bob", 25));
System.out.println(list);

add(int index, E element)

list.add(1, new Person("Charlie", 35));
System.out.println(list);

get(int index)

Person p = list.get(1);
System.out.println(p);

set(int index, E element)

list.set(1, new Person("David", 40));
System.out.println(list);

remove(int index)

list.remove(2);
System.out.println(list);

remove(Object o)

list.remove(new Person("Alice", 30));
System.out.println(list);

removeRange(int fromIdx, int toIdx)

ArrayList의 상위 클래스인 AbstractList클래스에서 protected메소드로 정의되어 있음 따라서 ArrayList를 상속받은 커스텀클래스를 통해 removeRange를 사용해야 함

import java.util.ArrayList;

class CustomArrayList<E> extends ArrayList<E> {
    @Override
    protected void removeRange(int fromIndex, int toIndex) {
        super.removeRange(fromIndex, toIndex);
    }
}
public class Main {
    public static void main(String[] args) {
        CustomArrayList<Person> list = new CustomArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Charlie", 35));
        list.add(new Person("David", 40));
        list.add(new Person("Eve", 22));

        System.out.println("Before removeRange: " + list);

        list.removeRange(1, 4);

        System.out.println("After removeRange: " + list);
    }
}

clear()

list.clear();
System.out.println(list);

contains(Object o)

boolean contains = list.contains(new Person("Alice", 30));
System.out.println(contains);

indexOf(Object o)

int index = list.indexOf(new Person("Alice", 30));
System.out.println(index);

lastIndexOf(Object o)

int lastIndex = list.lastIndexOf(new Person("Alice", 30));
System.out.println(lastIndex);

ensureCapacity(int minCapacity)

최소 용량 보장

trimToSize()

리스트의 용량을 현재 크기로 줄임

toArray()

Object[] array = list.toArray();
for (Object obj : array) {
    System.out.println(obj);
}

지정된 배열에 리스트의 모든 요소를 포함시킴

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Charlie", 35));
        list.add(new Person("David", 40));
        list.add(new Person("Eve", 22));

        System.out.println("Original list: " + list);

        // Person 배열로 변환
        Person[] personArray = list.toArray(new Person[0]);

        for (Person p : personArray) {
            System.out.println(p);
        }
    }
}

인자로 전달된 배열이 list보다 작은경우 새 배열을 만들어 전달.

clone()

얕은복사!!

ArrayList<Person> clonedList = (ArrayList<Person>) list.clone();
System.out.println(clonedList);

• input stream : keyboard or from a file
• output stream : screen or to a file

  file

• file(; ASCII file) : 모든 컴퓨터에서 동일하기에 송수신 가능
• binary file : 같은 컴퓨터, 같은 언어에서 읽을 수 있음, textfile보다 효율적, 자바 binary file의 경우 platform에 독립적임

writing to a text file

PrintWriter 객체를 이용해야 함

import

    import java.io.PrintWriter;
    import java.io.FileOutputStream;
    import java.io.FileNotFoundException;

try-catch block 밖에 PrintWriter 객체가 선언되어야 함

local객체이면 안되므로

파일명을 사용하려면 FileOutputStream(_filename)을 이용해야 함

    PrintWriter outputStreamName; 
    outputStreamName = new PrintWriter(new FileOutputStream(FileName));

file 존재시 : 옛날 자료 사라짐

따라서 outputStreamName = new PrintWriter(new FileOutputStream(FileName, true)); 를 이용해야 함 ; 덧붙이기 모드

file 존재x시 : 새로운 파일 생성

print,println를 사용하여 file에 쓸 수 있음

outputStreamName.close()

• file에 연결했던 stream을 자원을 해제함

  buffer

  physical writing to a file이 느림이에, 즉시 쓰지 않고 temporary location에 저장하는데 이곳이 buffer.

  close()할 때나 buffer에 data가 쌓였을 때,flush()가 호출되어 buffer의 데이터가 file에 한 번에 쓰임

  주의점

  program terminates abnormally

  bufferd data날라감

  close 전에 reopen하려 할 때

  파일이 제대로 읽히지 않거나 파일에 손상을 가져옴

  가능한한 빨리 닫아야 함

reading from a text file

Scanner 객체를 이용

import

    import java.util.Scanner;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;

파일명을 이용하려면 FileInputStream(_filename)을 이용해야 함

* keyboard input을 이용하려면 단순히 Scanner(System.in)이용

    Scanner inputStream = null;

    try {
        inputStream = new Scanner(new FileInputStream(FileName));
    } catch (FileNotFoundException e){
        System.exit(0);
    }

    int n1 = inputStream.nextInt();
    int n2 = inputStream.nextInt();
    int n3 = inputStream.nextInt();

    inputStream.nextLine(); //다음 줄로

    inputStream.close();

text file 끝 처리

• 끝을 넘어서 read하려고 하면 예외가 던져짐
• 이를 해결하기 위해 hasNextLine(),hasNextInt()메서드를 활용

  String line = null;
  int count = 0;
  while (inputStream.hasNextLine()) {
    line = inputStream.nextLine();
    count++;
    outputStream.println(count + " " + line);
  }

BufferedReader객체를 이용한 읽기

import

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;

파일명을 이용하려면 FileReader(_filename)을 이용해야 함

BufferedReader inputStream = null
try {
    inputStream = new BufferedReader(new FileReader(_filename));
    String line = inputStream.readLine();
    System.out.println(line);
} catch (FileNotFoundException e) {
    e.getMessage();
} catch (IOException e) {
    e.getMessage();
}

method

readLine()

• line을 읽어 String 반환
• end of file일 때 null 리턴; IOException 예외 throw 안함

  read()

• 각 char를 읽어 해당하는 int값 반환
• end of file일 때 -1 리턴

  skip(Long n)

  n개의 char 생략

Reading number

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
        String fileName = "numbers.txt";
        BufferedReader reader = null;

        try {
            reader = new BufferedReader(new FileReader(fileName));
            String line;

            // Read and convert single numbers on separate lines
            line = reader.readLine();
            if (line != null) {
                int intValue = Integer.parseInt(line);
                System.out.println("Integer value: " + intValue);
            }

            line = reader.readLine();
            if (line != null) {
                double doubleValue = Double.parseDouble(line);
                System.out.println("Double value: " + doubleValue);
            }

            // Read and convert multiple numbers on a single line
            line = reader.readLine();
            if (line != null) {
                StringTokenizer tokenizer = new StringTokenizer(line);
                while (tokenizer.hasMoreTokens()) {
                    String token = tokenizer.nextToken();
                    int number = Integer.parseInt(token);
                    System.out.println("Tokenized integer value: " + number);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

IOException

checked exception임 exception을 상속받음;;

FileNotFoundException

I/O상황에서 예외일 때 대부분 이 예외가 던져짐

NoSuchElementException

파일 끝에서 read를 시도할 때

관련 주제

[Path Names]

file name이 인자로 들어갈때의 전제 : 같은 디렉토리에 있다.

따라서 같은 디렉토리에 없다면, the full or relative path name을 제시해야 한다.

정의

full path name

•    Unix/Linux: /home/user/documents/file.txt
•    Windows: C:\Users\User\Documents\file.txt

relative path name

•    . (현재 디렉터리)와 .. (상위 디렉터리) 등을 사용할 수 있습니다.
•    예시:
•    현재 디렉터리가 /home/user인 경우:
•    documents/file.txt (현재 디렉터리에서 documents 디렉터리 안의 file.txt 파일)
•    ../other_user/file.txt (현재 디렉터리의 상위 디렉터리인 /home 디렉터리 안의 other_user 디렉터리의 file.txt 파일)

사용

윈도우

BufferedReader inputStream = new BufferedReader(new FileReader ("C:\\dataFiles\\goodData\\data.txt"));

UNIX

BufferedReader inputStream =
        new BufferedReader(new
        FileReader("/user/sallyz/data/data.txt"));

[stream redirection]

• System.in: 표준 입력 스트림으로, 일반적으로 키보드 입력을 처리합니다.
• System.out: 표준 출력 스트림으로, 일반적으로 화면에 정상 출력을 나타냅니다.
• System.err: 표준 오류 스트림으로, 일반적으로 화면에 오류 메시지를 나타냅니다.

다른 스트림으로 redirection하기

예를 들어, 에러 메시지를 화면이 아닌 파일에 기록하기

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class Main {
    public static void main(String[] args) {
        // 원래 System.err는 콘솔을 가리킵니다.
        System.err.println("This error message will go to the console.");

        PrintStream errStream = null;
        try {
            // 새로운 PrintStream 객체를 생성하여 "errMessages.txt" 파일에 출력
            errStream = new PrintStream(new FileOutputStream("errMessages.txt"));

            // System.err을 errStream으로 리다이렉션
            System.setErr(errStream);

            // 이제 System.err로 출력되는 메시지는 파일에 기록됩니다.
            System.err.println("This error message will go to the file.");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 리다이렉션한 스트림을 닫음
            if (errStream != null) {
                errStream.close();
            }
        }

        // 리다이렉션 후, 다시 콘솔로 출력되는지 확인 (일반적으로는 프로그램 종료 전까지 유지됨)
        System.err.println("This error message will also go to the file.");
    }
}

[File 객체]

wrapper class 같은 거

import java.util.Scanner;
import java.io.File;
import java.io.PrintWriter;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

public class FileclassDemo {
    public static void main(String[] args) {
        Scanner keyboard = new Scanner(System.in);
        String line = null;
        String filename = null;
        line = keyboard.nextLine();
        filename = Keyboard.nextLine();
        File fileobj = new File(filename);

        while(fileobj.exists()) {
            System.out.println("해당 파일 이름이 이미 존재\n 다른 거");
               filename = keyboard.nextLine();
            fileobj = new File(filename);
        }

    }
}

throwing an exception

unusual한 무언가가 일어났을 때 신호를 보내는 기작

handling the exception

exceptional case를 다루는 코드

1. throws 메서드를 이용하기

pass the buck

예외만 던지는 메서드

• 해당 메서드는 try, catch블록을 가지고 있으면 안됨; 따라서 throws clause를 사용해 catch를 안함을 나타냄
• 이 메서드는 try블록 안에서 invoke됨; 해당 try블록을 가진 다른 메서드가 exception handling을 책임짐 즉, throws메서드는 throw만 함
• 여러개의 exception를 throw할 수 있도록 throws뒤에 여러 exception 타입을 명시할 수 있음

  2. try(throw)-catch-finally

  try : 정상 흐름!!

  i) exception ㄴㄴ

• try블록 끝까지 실행
• catch블록 skip
• catch블록 다음에 있는 코드까지 실행

  ii) exception ㅇㅇ

  중간에 throw 예외 객체
• 오류가 발생하면 예외 객체를 만들고 이를 throw함
• try block 멈춤; 남은 try블록 skip
• catch block을 call함

catch : 예외 흐름!!

던져진 예외 객체를 인자로 받음

* 메서드 정의는 아님

• catch블록에서 잡을 수 있는 객체의 타입을 명시함
• 던져진 exception의 identifier를 정의

  multiple catch block

• 특정 exception 타입만 catch할 수 있으므로 여러 개의 catch 블록은 타당
• 하지만 순서가 중요하다; Specific이 먼저 오도록!!

finally : 마무리 흐름!!

i) ㄱ. 정상 흐름 ㄴ. finally ii) ㄱ. 예외 catch ㄴ. finally iii) ㄱ. 예외 catch 실패 ㄴ. finally ㄷ. method 종료, 밖으로 exception object 던져짐

try를 시작만 해도 finally는 반드시 호출됨

try, catch안에서 잡을 수 없는 예외가 발생해도 finally는 반드시 호출

주로 try에서 사용한 자원을 해제할 때 주로 사용

exception class

predefined exception class

check exception

1) catch 블록에서 포착하거나 2) throws 키워드로 예외 선언을 해야 함

uncheck exception

예외를 잡아서 처리하지 않아도 throws키워드를 생략할 수 있다

package exception.basic.unchecked;
/**
* RuntimeException을 상속받은 예외는 언체크 예외가 된다. */
 public class MyUncheckedException extends RuntimeException {
     public MyUncheckedException(String message) {
         super(message);
     }
}

 package exception.basic.unchecked;
 public class Client {
     public void call() {
         throw new MyUncheckedException("ex");
     }
}

package exception.basic.unchecked;
/**
* UnChecked 예외는
* 예외를 잡거나, 던지지 않아도 된다.
* 예외를 잡지 않으면 자동으로 밖으로 던진다. */
 public class Service {
     Client client = new Client();
/**
* 필요한 경우 예외를 잡아서 처리하면 된다. */
     public void callCatch() {
         try {
             client.call();
         } catch (MyUncheckedException e) {
//예외 처리 로직
System.out.println("예외 처리, message=" + e.getMessage()); }
System.out.println("정상 로직"); }
/**
* 예외를 잡지 않아도 된다. 자연스럽게 상위로 넘어간다.
* 체크 예외와 다르게 throws 예외 선언을 하지 않아도 된다. */
     public void callThrow() {
         client.call();
} }

check exception과 다르게 (예외를 처리할 수 없을 때 밖으로 던지는) throws예외 선언을 컴파일러가 체크하지 않기 때문에 '언체크' 예외이다.

특징

모든 predefined exception class는

String타입을 인자로 받는 생성자를 가짐

해당 인자를 리턴하는 getMessage accessor가 있음

주의점 2가지를 일관되게 사용해야 함

동일한 예외에 대해서는 일관된 방식으로 처리 즉, 특정 예외를 catch 블록에서 처리하지 않으면 throws 키워드로 선언해야 하고, 반대로 catch 블록에서 처리하면 throws 키워드로 선언할 필요가 없어

사용자 정의 exception class

predefined exception class를 상속받아야 함

최소 2개이상의 생성자를 정의해야 함

Public class MyException extends Exception{
    // variables
    public MyException() {
        super("default message");
        //perform other tasks
        }
    public MyException(VariableType var){
        super(var+ "rest of message");
        //perform other tasks
    }
    //other methods if needed
}

1. 문자열 매개변수를 갖는 생성자: 이 생성자는 super를 호출하여 매개변수를 인자로 사용해야 함
2. 기본 생성자: 이 생성자는 super를 호출하여 기본 문자열을 인자로 사용해야 함

Exception controlled loops

import java.util.Scanner;
import java.util.InputMismatchException; //unchecked

public class InputMismatchExceptionDemo {
    public static void main(String[] args) {
        Scanner keyboard = new Scanner(System.in);
        int number = 0;
        boolean done = false;

        while (!done) {
            try {
                System.out.println("Enter a whole num");
                number = keyboard.nextInt();
                done = true;
            }
            catch (InputMismatchException e) {
                keyboard.nextline(); //예외가 발생한 후에는 여전히 잘못된 입력이 남아있으므로 이를 소비.
                System.out.println("Not a correclty written whole number");
            }
        }
        System.out.println("You entered " + number);
    }
}

Separate Computation Process

• multiple operation을 concurrently하게 할 수 있게 함

  Parallel execution

• multiple threads를 동시에

  Single Sequential Flow

• each thread는 코드를 선형적으로 처리함

  Shared Resource

• Thread는 고유의 메모리 공간을 가지지 않음

• 대신 프로세스의 메모리와 자원을 공유함 * 각 프로세스는 다른 프로세스와 메모리 공간을 공유하지 않음 * 프로세스의 메모리 공간 : 코 데 힙 스 * 스레드는 독립적인 스택을 가짐, 같은 코드, 데이터, 힙 영역을 공유함

특성

Lightweight

• Thread간 전환 비용 << process간 전환 비용

  easy to spawn

• Threadclass orRunnableinterface로 쉽게 생성가능 * Runnable 선호; 다른 클래스 상속 가능하므로

  priority 존재

• 1~10까지
• 5가 디폴트

사용

multithreading

언제

• parallel processing(프로세스 내) 향상
• user반응성 증가
• cpu의 idle 시간 활용
• priority에 다른 작업 처리 가능

  run()구현 -> start()로 스레드 생성 후 run실행

  class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " is running: " + i);
            try {
                Thread.sleep(1000); // 1초 대기
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
  }
  

public class RunnableExample { public static void main(String[] args) { Thread thread1 = new Thread(new MyRunnable()); Thread thread2 = new Thread(new MyRunnable());

    // 스레드를 시작
    thread1.start();
    thread2.start();
}

}

## synchronization
#### 왜
- multithreading은 asynchronous처리를 하게 하는데 필요할 때 synchronicity하게 처리 할 수 있어야 한다.
- `synchronized`를 이용
#### 언제
- thread interference 방지
- consistency 문제 방지
- data corruption 방지
### 작동 방식
#### `synchronized`
e.g. `public synchronized void produce()`
ㄱ. thread가 synchronized method실행시 해당 객체를 lock함
ㄴ. 하나의 thread만 lock을 할 수 있음 ⟹ 따라서 해당 메서드는 그 스레드만 작동 가능
ㄷ. method가 끝나면 lock은 해제됨
#### `wait()`

스레드는 `notify()`or`notifyAll()`메서드가 호출될 때까지 기다린다.
#### `notify()`or`notifyAll()`
- `notify()` 대기 중인 스레드 중 하나를 활성상태로 전환
- `notifyAll()` 대기 중인 모든 스레드를 활성 상태로 전환

\*메서드

| Method                    | Meaning                                                                                   |
|---------------------------|-------------------------------------------------------------------------------------------|
| Thread currentThread()    | returns a reference to the current thread                                                 |
| Void sleep(long msec)     | causes the current thread to wait for msec milliseconds                                   |
| String getName()          | returns the name of the thread.                                                           |
| Int getPriority()         | returns the priority of the thread                                                        |
| Boolean isAlive()         | returns true if this thread has been started and has not yet died. Otherwise, returns false. |
| Void join()               | causes the caller to wait until this thread dies.                                         |
| Void run()                | comprises the body of the thread. This method is overridden by subclasses.                |
| Void setName(String s)    | sets the name of this thread to s.                                                        |
| Void setPriority(int p)   | sets the priority of this thread to p.                                                    |

[static] : 바깥 클래스와 관련 없음, 인스턴스에 소속되지 않음

• static nested class

  [non-static] : 바깥 클래스의 인스턴스에 소속, 구성요소

• inner class
• local class (inner + localVar에 접근)
• anonymous class (local + class에 이름이 없음)

주의점

같은 시그니처인 method

• inner class의 method가 불림
• outer class의 method를 사용할 수 없고, 새로 정의해야 함

public class OuterClass {
    private int outerValue = 10;

    // 외부 클래스의 메서드
    public void display() {
        System.out.println("Outer class display method. outerValue: " + outerValue);
    }

    public class InnerClass {
        private int innerValue = 5;

        // 내부 클래스의 메서드
        public void display() {
            System.out.println("Inner class display method. innerValue: " + innerValue);

            // 외부 클래스의 메서드를 호출
            OuterClass.this.display();
        }

        public void invokeOuterDisplay() {
            // 외부 클래스의 display 메서드를 호출하는 방법
            OuterClass.this.display();
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();

        // 내부 클래스의 display 메서드 호출
        inner.display();

        // 내부 클래스에서 외부 클래스의 display 메서드 호출
        inner.invokeOuterDisplay();
    }
}

Outer class 어디에 정의해도 무관

주로 helping class로 사용 (private으로 해야함)

inner, outer private 멤버는 서로 접근 가능

public class OuterClass {
    private int outerValue = 10;

    // 외부 클래스의 private 메서드
    private void outerPrivateMethod() {
        System.out.println("Outer class private method.");
    }

    public class InnerClass {
        private int innerValue = 5;

        // 내부 클래스의 private 메서드
        private void innerPrivateMethod() {
            System.out.println("Inner class private method.");
        }

        // 내부 클래스의 메서드
        public void innerMethod() {
            // 외부 클래스의 private 인스턴스 변수 참조
            System.out.println("Accessing outer class private variable: " + outerValue);

            // 외부 클래스의 private 메서드 호출
            outerPrivateMethod();
        }
    }

    // 외부 클래스의 메서드
    public void outerMethod() {
        InnerClass inner = new InnerClass();

        // 내부 클래스의 private 인스턴스 변수 참조
        System.out.println("Accessing inner class private variable: " + inner.innerValue);

        // 내부 클래스의 private 메서드 호출
        inner.innerPrivateMethod();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();

        // 내부 클래스의 메서드 호출
        inner.innerMethod();

        // 외부 클래스의 메서드 호출
        outer.outerMethod();
    }
}

compile시 두개가 별도의 .class파일로 생성됨

• ClassName.class
• ClassName$InnerClassName.class

상속과 nested class

outer class를 상속받은 class

• nested class를 가지게 됨
• outer class의 해당 nested class를 override할 수는 없음

  inner class, outer class 모두 다른 클래스를 상속받을 수 있음

static nested class

static

outer class의 instance member 접근 불가 outer class의 class member 접근 가능

사용하는 상황

outer class의 static method에 static nested class의 객체를 이용할 때

static nested class가 static 멤버를 가져야 할 때

public class NestedOuter {  

    private static int outClassValue = 3;  
    private int outInstanceValue = 2;  

    static class Nested {  
        private int nestedInstanceValue = 1;  

        public void print() {  
            // 자신의 멤버에 접근  
            System.out.println(nestedInstanceValue);  

            // 바깥 클래스의 인스턴스 멤버에 접근에는 접근할 수 없다.  
            //System.out.println(outInstanceValue);  
            // 바깥 클래스의 클래스 멤버에는 접근할 수 있다. private도 접근 가능  
            System.out.println(NestedOuter.outClassValue); 
        }  
    }  
}
-----------------------------------------------------------
package nested.nested;  

public class NestedOuterMain {  

    public static void main(String[] args) {  
        Nested.StaticNestedClass nested = new Nested.StaticNestedClass();
        nested.print();  

        System.out.println("nestedClass = " + nested.getClass());  
    }  
}

(public) Inner class

정의

outer class의 instance 멤버에 직접 접근 가능

⟹ inner class 내부에서만 사용할 멤버를 public으로 만들 필요가 없음

inner class는 outer class를 reference함.

public class OuterClass {
    private int outerValue = 10;

    // Public method를 통해 내부 클래스의 메서드를 호출
    public void doSomething() {
        InnerClass inner = new InnerClass();
        inner.innerMethod();
    }

    // 내부 클래스
    private class InnerClass {
        // 외부 클래스의 메서드를 호출하여 특정 작업을 수행
        private void innerMethod() {
            System.out.println("Inner method is accessing outerValue: " + outerValue);
            helperMethod(); // 외부 클래스의 private 메서드 호출
        }
    }

    // 외부 클래스의 private 메서드; 이걸 public으로 안해도 됨
    private void helperMethod() {
        System.out.println("Helper method is doing some work.");
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.doSomething();
    }
}

anonymous class

사용

보통 인터페이스나 추상 클래스를 구현하거나 확장하기 위해 사용됨

interface Greet {
    void sayHello();
}

public class AnonymousClassExample {
    public static void main(String[] args) {
        // Greet 인터페이스를 구현하는 익명 클래스
        Greet greeter = new Greet() {
            @Override
            public void sayHello() {
                System.out.println("Hello from anonymous class!");
            }
        };

        // 익명 클래스 메서드 호출
        greeter.sayHello();

        // 또 다른 예제: 여러 메서드를 가진 사용자 정의 클래스를 확장한 익명 클래스
        GreeterClass greeterClass = new GreeterClass() {
            @Override
            public void greet() {
                System.out.println("Greetings from extended anonymous class!");
            }
        };

        greeterClass.greet();
        greeterClass.sayGoodbye();
    }
}

// 또 다른 사용자 정의 클래스
class GreeterClass {
    public void greet() {
        System.out.println("Hello from GreeterClass!");
    }

    public void sayGoodbye() {
        System.out.println("Goodbye from GreeterClass!");
    }
}

규칙

1. Abstract method가 있으면 무조건 그 class는 abstact class이다.
2. abstract method는 private이 될 수 없음
3. abstract class는 인스턴스를 만들 수 없음

• abstract class의 생성자는 객체를 생성할 수 없다. 대신 상속받은 자식 클래스에서 super로 사용가능하다.

4. 그럼에도 타입으로서 인정되기에 파라미터로 사용가능.

pure abstract class ≡ 모든 메서드가 abstract method인 클래스

• 실행 로직을 전혀가지고 있지 않은, 그저 다형성을 위한 부모 타입으로써의 껍데기.

• JAVA_interface

사용하는 이유

• 의미없는 기능 just 상속용 base class의 인스턴스가 생성되면?
  • abstract class!로 해결
  • abstact class는 인스턴스를 만들 수 없음
• 새로운 자식 class를 만들 때 까먹고 override하지 않을 문제
  • abstract method는 직접 정의하도록 자바에서 제약을 줌
  • abstact method는 자식 클래스가 반드시 오버라이딩해서 사용해야 함
  • 그렇지 않으면 자식도 추상 클래스가 되어야 함

1. 코드를 공유하는 경우; 공통된 메서드, 필드가 많은 경우
2. protected와 private 접근 제어자는 서브클래스와 클래스 내부에서의 접근을 제어하여, 적절한 캡슐화를 제공함
3. non-static member 사용

정의

method heading + constant로만 구성

• method definition ㄴㄴ
• field ㄴㄴ
• "abstract" method의 모음; 그렇다고 abstract를 정의에 쓰면 안됨

  interface도 type임

  parameter로 쓰일 수 있음

  constants

  public static final (굳이 안적어도 됨)

implements

여러개의 interface를 implement할 수 있음

i) abstract class가 구현하는 경우

모든 method define 할 필요 없음 define하지 않은 method는 abstract로 표시

ii) non-abstract class가 구현하는 경우

모든 method define 필요

주의점

public!!

모든 method가 public으로 declare되어야 함 implement하는 class도 interface에 있는 method를 define할 때 public으로 해야함.

inconsistent interfaces

같은 constant define but value 상이

같은 method signature(header; 메소드 이름, 파라미터 리스트) 다른 return type

class VS interface

공통점

1) (파일명 = Interface명).java 로 쓰임 2) 컴파일시 .class로 byte code가 나타남

차이점

interface의 inheritance

다중 상속 가능

interface A {
    void methodA();
}

interface B {
    void methodB();
}

interface C extends A, B {
    void methodC();
}

상속관계에 있는 interface를 구현한 class

base interface, derived interface의 모든 method를 구현해야 함

Comparable interface

single sorting method에 이용

Arrays.sort()를 사용하려면 Comparable을 implement한 objects만 가능

public int compareTo(Object other)만 구현하면 됨

같은 type일 때, 정의한 기준에 따라 비교 가능

아니라면 ClassCastException throw

return 값

java.lang => import 필요 ㄴㄴ

public class Person implements Comparable<Person> {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        return this.name.compareTo(other.name);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }

    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };

        Arrays.sort(people);

        for (Person person : people) {
            System.out.println(person);
        }
    }
}