이상민

[혼공자바 6주차] Chapter 10~11

sm1118sm — Sat, 16 Aug 2025 16:56:53 +0900

10-1 예외 클래스

예외란?
- 실행 중 발생하는 오류를 객체로 표현한 것.
- 프로그램이 비정상 종료되지 않도록 예외 처리가 필요.
예외의 종류
- 일반 예외
  - 컴파일 단계에서 예외 처리 강제
  - 예: ClassNotFoundException, IOException, InterruptedException
- 실행 예외
  - 실행 중 발생, 예외 처리 선택
  - 예: NullPointerException, ArrayIndexOutOfBoundsException, NumberFormatException
대표 실행 예외
- NullPointerException → null 객체 접근 시 발생
- ArrayIndexOutOfBoundsException → 잘못된 배열 인덱스
- NumberFormatException → 잘못된 문자열 숫자 변환
- ClassCastException → 잘못된 타입 변환

10-2 예외 처리

1. 기본 구조

try {
    // 예외가 발생할 가능성이 있는 코드
} catch (ExceptionType e) {
    // 예외가 발생했을 때 실행할 코드
} finally {
    // 예외 발생 여부와 관계없이 항상 실행되는 코드 (선택사항)
}

2. 다중 catch

try {
    // 예외 발생 가능 코드
} catch (FileNotFoundException e) {
    // 파일 관련 예외 처리
} catch (IOException e) {
    // 입출력 관련 예외 처리
} catch (Exception e) {
    // 그 외 모든 예외 처리 (가장 마지막에 위치해야 함)
}

3. 예외 처리 방법 2가지

1. 직접 처리 (try-catch-finally)

프로그램 내에서 예외를 직접 잡아서 처리합니다.
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("0으로 나눌 수 없습니다.");
}

예외가 발생해도 프로그램이 비정상 종료되지 않고 계속 실행됩니다.

2. 떠넘기기 (throws 키워드 사용)

예외를 메서드에서 처리하지 않고, 호출한 쪽으로 예외를 넘깁니다.

public void readFile(String fileName) throws IOException {
FileReader reader = new FileReader(fileName);
}

throws 뒤에 발생할 수 있는 예외 타입을 명시합니다.

이 메서드를 호출하는 곳에서는 반드시:
- 다시 예외를 처리하거나 (try-catch)
- 또 다른 메서드로 예외를 떠넘겨야 합니다.

public static void main(String[] args) throws IOException {
readFile("data.txt"); // IOException 발생 가능
}

예외를 떠넘기는 방식은 라이브러리 개발이나 일괄 예외 처리 시 유용합니다.
단, 반드시 예외가 처리될 곳이 최종적으로 있어야 프로그램이 정상 작동합니다.

직접 처리	try-catch-finally로 예외 처리	try { ... } catch { ... }
떠넘기기	throws로 호출자에게 예외 전달	void foo() throws IOE

11-1 java.lang 패키지

Object
- 모든 클래스의 최상위 부모
- 주요 메서드: toString(), equals(), hashCode(), clone()
Wrapper 클래스
- 기본 타입을 객체로 다룰 수 있게 해줌
- Integer, Double, Boolean 등
- 자동 박싱/언박싱 지원
String / StringBuilder / StringBuffer
- String: 불변(immutable) 문자열
- StringBuilder: 가변(mutable), 동기화 X, 빠름
- StringBuffer: 가변, 동기화 O, 멀티스레드 환경 안전
Math
- 수학 관련 유틸 클래스
- abs(), random(), pow(), round() 등
System
- 시스템 관련 기능
- exit(), currentTimeMillis(), gc()

11-2 java.util 패키지 (자주 쓰는 유틸 모음)

컬렉션 프레임워크
- List : 순서 O, 중복 O (예: ArrayList, LinkedList)
- Set : 순서 X, 중복 X (예: HashSet, TreeSet)
- Map : key-value 쌍, key 중복 X (예: HashMap, TreeMap)
Arrays
- 배열 관련 유틸
- sort(), binarySearch(), copyOf(), toString()
Collections
- 컬렉션 관련 유틸
- sort(), max(), min(), shuffle()
Date / Calendar
- Date: 날짜와 시간 표현 (구버전)
- Calendar: 날짜 계산 가능
- (실무에서는 java.time 패키지(LocalDate, LocalDateTime 등) 권장)
Random
- 난수 생성기
- nextInt(), nextDouble()

기본 숙제(필수) : 10-2 확인 문제 2번 문제 풀고 과정 설명하기

① 생성자나 메소드의 선언 끝 부분에 사용되어 내부에서 발생된 예외를 떠넘긴다.

맞는 설명입니다.

throws는 메소드 또는 생성자 선언부에서 사용되며, 해당 메소드에서 발생할 수 있는 예외를 호출한 쪽으로 떠넘기겠다는 의미입니다.

② throws 뒤에는 떠넘겨야 할 예외를 쉼표(,)로 구분해서 기술한다.

맞는 설명입니다.

throws IOException, SQLException처럼 여러 개의 예외를 쉼표로 구분하여 나열할 수 있습니다.

③ 모든 예외를 떠넘기기 위해 간단하게 throws Exception으로 작성할 수 있다.

맞는 설명입니다.

예외를 포괄적으로 처리하고 싶을 때 throws Exception으로 모든 예외를 떠넘길 수 있습니다. 다만 좋은 방식은 아니지만, 설명은 맞습니다.

④ 새로운 예외를 발생시키기 위해 사용된다.

틀린 설명입니다.

throws는 예외를 발생시키는 것이 아니라 예외를 떠넘기는 데 사용됩니다.
새로운 예외를 발생시킬 때는 throw 키워드를 사용합니다.
예: throw new IOException("오류 발생")

추가 숙제(필수) : java.lang 패키지에 속하는 주요 클래스와 용도를 정리해서 포스팅하기

1. Object

모든 클래스의 최상위 부모 클래스입니다.
자바의 모든 클래스는 Object를 자동으로 상속받습니다.
주요 메서드:
- toString() – 객체 정보를 문자열로 반환
- equals() – 객체 비교
- hashCode() – 해시코드 반환
- clone() – 객체 복사 등

2. String

문자열을 다루기 위한 클래스 (불변, immutable).
한 번 생성된 문자열은 변경되지 않습니다.
"문자열" 리터럴은 내부적으로 String 객체입니다.
주요 메서드: length(), charAt(), substring(), equals(), concat() 등

3. Math

수학 연산을 위한 메서드 제공 클래스 (static 메서드만 존재)
주요 메서드:
- abs(), sqrt(), pow(), max(), min(), random()

4. System

시스템 관련 기능을 제공하는 클래스
주요 기능:
- System.out.println() – 출력
- System.currentTimeMillis() – 현재 시간
- System.exit(0) – 프로그램 종료
- 환경 변수 접근 등

5. Wrapper 클래스

int	Integer	숫자형 데이터를 객체로 다룸
double	Double	실수형 객체
boolean	Boolean	논리값 객체
char	Character	문자형 객체
byte	Byte	바이트 객체
short	Short	작은 정수형 객체
long	Long	긴 정수형 객체
float	Float	단정도 실수 객체

주요 기능:
- 박싱(Boxing), 언박싱(Unboxing)
- parseInt(), valueOf(), toString()

6. Class

클래스 정보를 표현하는 클래스
리플렉션(reflection) 기능을 제공하여 클래스 이름, 메서드, 필드 등을 동적으로 접근 가능

Class<?> clazz = String.class; System.out.println(clazz.getName());

[혼공자바 5주차] Chapter 08~09

sm1118sm — Fri, 8 Aug 2025 21:00:24 +0900

08-1 인터페이스

1. 인터페이스란?

인터페이스는 추상 메서드의 집합.
상수, 추상 메서드, 디폴트 메서드, 정적 메서드 포함 가능 (Java 8부터).
다형성 구현의 핵심 수단.

2. 인터페이스 선언

interface InterfaceName {
    // 상수
    int MAX = 100;

    // 추상 메서드
    void methodA();

    // default 메서드 (Java 8~)
    default void methodB() {
        System.out.println("기본 구현");
    }

    // static 메서드 (Java 8~)
    static void staticMethod() {
        System.out.println("정적 메서드");
    }
}

3. 인터페이스 구현

implements 키워드 사용

class MyClass implements InterfaceName {
    @Override
    public void methodA() {
        System.out.println("구현체");
    }
}

4. 다중 구현 가능

클래스는 하나의 클래스만 상속할 수 있지만, 여러 인터페이스는 동시에 구현 가능.

interface A { void a(); }
interface B { void b(); }

class C implements A, B {
public void a() { }
public void b() { }
}

5. 인터페이스의 용도

표준화된 설계를 제공
다형성을 활용한 유연한 프로그래밍 가능
콜백 구조나 의존성 주입 등에서도 많이 사용됨

08-2 타입 변환과 다형성

1. 자동 타입 변환 (Upcasting / 자동 형변환)

자식 타입 → 부모 타입으로 변환할 때
컴파일러가 자동으로 처리
명시적인 형변환 연산자 (타입)이 필요 없음

class Animal {
    void sound() { System.out.println("Animal sound"); }
}

class Dog extends Animal {
    void bark() { System.out.println("Dog bark"); }
}

Animal a = new Dog();  // 자동 타입 변환 (업캐스팅)
a.sound();             // Dog 클래스에서 오버라이딩한 메서드가 호출됨

2. 강제 타입 변환 (Downcasting / 명시적 형변환)

부모 타입 → 자식 타입으로 변환할 때
명시적으로 형변환을 지정해야 함
실제로 객체가 자식 타입이어야 함 (아니면 ClassCastException 발생)

Animal a = new Dog();  // 업캐스팅
Dog d = (Dog) a;       // 다운캐스팅 (강제 타입 변환)
d.bark();              // 자식 클래스의 메서드 사용 가능

3. instanceof 연산자 (안전한 다운캐스팅용)

객체가 특정 클래스의 인스턴스인지 확인 가능
다운캐스팅 전에 사용하면 안전

if (a instanceof Dog) {
Dog d = (Dog) a;
d.bark();
}

09-1 중첩 클래스와 중첩 인터페이스 소개

1. 중첩 클래스란?

클래스 내부에 선언된 또 다른 클래스
관련된 클래스를 하나로 묶어 구조화 가능
외부 클래스와 긴밀한 관계가 있을 때 사용

2. 중첩 클래스의 종류

정적 중첩 클래스 (static)	static 키워드 사용, 외부 클래스 인스턴스 없이 사용 가능
인스턴스 중첩 클래스 (non-static)	외부 클래스의 인스턴스가 있어야 사용 가능
지역 클래스 (local class)	메서드 내에서 선언된 클래스
익명 클래스 (anonymous class)	이름이 없는 클래스, 주로 일회성 구현

3. 정적 중첩 클래스

class Outer {
    static class Nested {
        void print() {
            System.out.println("정적 중첩 클래스");
        }
    }
}

// 사용 예
Outer.Nested nested = new Outer.Nested();
nested.print();

4. 인스턴스 중첩 클래스

class Outer {
    class Inner {
        void print() {
            System.out.println("인스턴스 중첩 클래스");
        }
    }
}

// 사용 예
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.print();

5. 지역 클래스

메서드 내부에 선언되는 클래스
메서드 실행 시에만 사용 가능

void method() {
    class Local {
        void msg() {
            System.out.println("지역 클래스");
        }
    }
    Local local = new Local();
    local.msg();
}

6. 익명 클래스

이름 없는 일회용 클래스
주로 인터페이스 또는 추상 클래스의 즉석 구현에 사용

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 클래스 실행");
    }
};

new Thread(r).start();

7. 중첩 인터페이스

클래스 또는 인터페이스 내부에 선언된 인터페이스
일반적으로 외부 클래스에서만 구현하도록 설계

class Button {
    interface OnClickListener {
        void onClick();
    }
}

09-2 익명 객체

1. 익명 객체란?

클래스 이름 없이 객체를 생성하는 방식
주로 일회성으로 사용할 클래스의 객체를 간단히 만들 때 사용
이름이 없는 클래스를 선언하고 동시에 객체를 생성

2. 익명 객체 생성 방식

부모 클래스를 상속받거나, 인터페이스를 구현한 객체를 생성할 때 사용
형식:

부모클래스 변수 = new 부모클래스() {
// 메소드 오버라이딩 등 내용 작성
};

Parent field = new Parent() {
    void work() {
        System.out.println("출근합니다.");
    }

    @Override
    void wake() {
        System.out.println("6시에 일어납니다.");
    }
};

→ 이 경우, Parent 클래스를 상속받은 익명 객체를 생성함→ 필드나 지역 변수에 저장해서 사용 가능

3. 사용 위치에 따른 예시

필드에 익명 객체 저장:

Person field = new Person() {
    void work() { ... }
    @Override
    void wake() { ... }
};

메소드 내 지역 변수에 저장:

Person localVar = new Person() {
    void walk() { ... }
    @Override
    void wake() { ... }
};

메소드 매개값으로 전달:

method2(new Person() {
    void study() { ... }
    @Override
    void wake() { ... }
});

4. 익명 구현 객체

인터페이스를 구현할 때도 익명 객체 생성 가능
형식:

인터페이스 변수 = new 인터페이스명() {
// 메소드 구현
};

RemoteControl field = new RemoteControl() {
    @Override
    public void turnOn() {
        System.out.println("TV를 켭니다.");
    }

    @Override
    public void turnOff() {
        System.out.println("TV를 끕니다.");
    }
};

기본 숙제(필수) : 클래스를 선언할 때 인터페이스는 어떻게 선언될 수 있는지 정리하기

1. 인터페이스 선언 기본 형식

[접근제어자] interface 인터페이스이름 {
    // 상수 필드
    // 추상 메서드
    // default 메서드
    // static 메서드
    // private 메서드 (Java 9부터)
}

2. 인터페이스 구성 요소

1) 상수 필드

인터페이스에서 선언되는 필드는 자동으로 public static final이 됩니다.

int MAX = 100; // 자동으로 public static final int MAX = 100;

2) 추상 메서드

인터페이스의 메서드는 기본적으로 public abstract입니다.
자바 8부터는 default, static 메서드도 가능해졌습니다.

void doSomething(); // 자동으로 public abstract void doSomething();

3) default 메서드 (Java 8+)

인터페이스에 구현을 포함할 수 있는 방법.
반드시 default 키워드를 사용해야 하며, 오버라이드할 수 있습니다.

default void print() {
System.out.println("기본 출력");
}

4) static 메서드 (Java 8+)

클래스처럼 인터페이스명으로 접근합니다.

static void staticMethod() {

System.out.println("인터페이스 static 메서드");

}

5) private 메서드 (Java 9+)

인터페이스 내부의 default나 static 메서드에서 코드 중복을 줄이기 위한 내부 유틸리티용 메서드.

static void staticMethod() {
System.out.println("인터페이스 static 메서드");
}

3. 인터페이스 구현

클래스에서 구현 (implements)

interface Animal {
    void sound();
}

class Dog implements Animal {
    public void sound() {
        System.out.println("멍멍");
    }
}

여러 인터페이스 구현 가능: 자바는 다중 상속을 지원하지 않지만, 인터페이스는 여러 개 구현 가능.

interface A { void a(); }
interface B { void b(); }

class C implements A, B {
public void a() { System.out.println("A"); }
public void b() { System.out.println("B"); }
}

4. 인터페이스 상속

인터페이스도 다른 인터페이스를 상속할 수 있습니다. 이때는 extends 키워드를 사용하고, 다중 상속도 가능.

interface A {
void a();
}

interface B extends A {
void b();
}

5. 익명 클래스에서 인터페이스 구현

Runnable task = new Runnable() {
    public void run() {
        System.out.println("작업 실행");
    }
};

또는 자바 8 이상에서는 람다식도 사용 가능 (단, 추상 메서드가 하나인 경우 — 함수형 인터페이스)

Runnable task = () -> System.out.println("작업 실행");

추가 숙제(선택) : p.443 (09-1) 확인 문제 3번 풀어보기

[혼공자바 4주차] Chapter 07

sm1118sm — Sun, 27 Jul 2025 15:39:24 +0900

07-1 상속

1. 상속의 개념

부모 클래스의 필드와 메서드를 자식 클래스가 물려받는 것.
코드 재사용을 높이고 유지 보수를 쉽게 만듦.

2. 상속 문법

class 자식클래스 extends 부모클래스 {
// 자식 클래스 내용
}

한 클래스만 상속 가능 (자바는 단일 상속).

3. 부모 생성자 호출 (super)

자식 객체 생성 시 먼저 부모 객체가 생성됨.
부모 생성자를 명시적으로 호출하려면 super() 사용.
부모에 매개변수 있는 생성자가 있으면 반드시 super(매개변수)로 호출해야 함.

4. 메서드 오버라이딩 (재정의)

자식 클래스가 부모 클래스의 메서드를 다시 정의하는 것.
조건:
- 메서드 이름, 매개변수 동일
- 접근 제한자는 더 좁게 못 바꿈
- @Override 애너테이션 권장 사용

5. final 키워드

final class: 상속 불가
final method: 오버라이딩 불가

07-2 타입 변환과 다형성

1. 타입 변환(Type Conversion)

자동 타입 변환 (자동 형변환, Upcasting)
- Animal animal = new Cat(); 가능
- 자식 객체를 부모 타입으로 저장 가능
- 상속 관계에서만 가능
- 변수는 부모 타입이지만, 메서드는 자식 클래스에서 재정의된 것을 실행 (동적 바인딩)
강제 타입 변환 (다운캐스팅, Downcasting)
- 부모 타입으로 저장된 객체를 다시 자식 타입으로 변환할 때 사용
- 문법: 자식타입 변수 = (자식타입) 부모객체;

Parent parent = new Child();
Child child = (Child) parent;

2. 다형성 (Polymorphism)

같은 타입(부모 클래스)으로 다양한 자식 객체를 참조할 수 있는 성질
실행 결과는 자식 클래스에 따라 다름
필드는 부모 기준으로 접근 → 자식 필드는 사용 불가
메서드는 오버라이딩된 자식 메서드가 호출됨 (다형성의 핵심)

Parent parent = new Child(); // 자동 타입 변환
parent.method(); // Child에 오버라이딩된 메서드 실행됨

3. 타입 변환 예시

A a = new D(); (가능)
B b = new D(); (가능)
C c = new E(); (가능)
B b = new E(); (불가능: 상속 관계 X)

07-3 추상 클래스 (Abstract Class)

1. 추상 클래스란?

실체가 없는 클래스, 객체 생성 불가
공통 필드나 메서드를 정의하여 상속 전용으로 사용
abstract 키워드 사용

public abstract class Animal {
public abstract void sound(); // 추상 메서드
}

2. 추상 메서드

구현 없이 선언만 존재
자식 클래스에서 반드시 오버라이딩 필요

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

3. 추상 클래스의 용도

공통된 기능은 추상 클래스에 작성
세부 기능은 자식 클래스에서 구현
예: Animal → Dog, Cat, Phone → SmartPhone

4. 추상 클래스 활용 예시

abstract class Phone {
    String owner;
    public Phone(String owner) { this.owner = owner; }
    abstract void internetSearch();
}

class SmartPhone extends Phone {
    public SmartPhone(String owner) {
        super(owner);
    }
    @Override
    void internetSearch() {
        System.out.println("인터넷 검색 중...");
    }
}

기본 숙제(필수) : 클래스의 타입 변환에는 어떤 것이 있는지 정리하고 공유하기

1. 업캐스팅 (Upcasting)

자식 클래스 → 부모 클래스로 변환하는 것
자동 형 변환이 일어남 (명시적 형변환 필요 없음)
안전함, 자식 객체는 부모의 형태를 항상 가짐

class Animal {
    void sound() {
        System.out.println("동물이 소리를 냅니다.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("멍멍!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal ani = dog;  // 업캐스팅 (자동 형변환)
        ani.sound();       // OK
        // ani.bark();     // 오류: 부모 타입으로는 자식의 기능 사용 불가
    }
}

2. 다운캐스팅 (Downcasting)

부모 클래스 → 자식 클래스로 변환하는 것
명시적 형변환이 필요함
실제로 자식 타입의 인스턴스여야 안전함
잘못된 다운캐스팅은 ClassCastException 발생
잘못된 다운캐스팅 예 :
Animal ani = new Animal(); // 실제로는 Animal 객체
Dog dog = (Dog) ani; // 오류 발생: ClassCastException
dog.bark();

Animal ani = new Dog();       // 업캐스팅
Dog dog = (Dog) ani;          // 다운캐스팅 (명시적으로 형변환)
dog.bark();                   // OK

3. instanceof 연산자 (다운캐스팅 전에 확인)

다운캐스팅 시 예외를 방지하기 위해 instanceof로 객체의 실제 타입을 확인하는 것이 좋습니다.

if (ani instanceof Dog) {
    Dog dog = (Dog) ani;
    dog.bark();
} else {
    System.out.println("다운캐스팅 불가");
}

추가 숙제(선택) : p.389 (07-3) 확인 문제 3번을 풀고 풀이 과정 설명하기

// 추상 클래스
public abstract class HttpServlet {
    public abstract void service();
}

// LoginServlet 클래스
public class LoginServlet extends HttpServlet {
    @Override
    public void service() {
        System.out.println("로그인 합니다.");
    }
}

// FileDownloadServlet 클래스
public class FileDownloadServlet extends HttpServlet {
    @Override
    public void service() {
        System.out.println("파일 다운로드 합니다.");
    }
}

// 메인 클래스
public class HttpServletExample {
    public static void main(String[] args) {
        method(new LoginServlet());           // "로그인 합니다." 출력
        method(new FileDownloadServlet());    // "파일 다운로드 합니다." 출력
    }

    public static void method(HttpServlet servlet) {
        servlet.service();
    }
}

풀이 과정 설명

1. 추상 클래스 만들기

public abstract class HttpServlet {
public abstract void service(); // 추상 메서드
}

HttpServlet은 추상 클래스입니다.
service()는 몸체가 없는 추상 메서드로 선언되어, 자식 클래스가 반드시 구현해야 합니다.

2. 자식 클래스: LoginServlet 정의

public class LoginServlet extends HttpServlet {
    @Override
    public void service() {
        System.out.println("로그인 합니다.");
    }
}

추상 메서드 service()를 오버라이딩합니다.
출력문: "로그인 합니다."

3. 자식 클래스: FileDownloadServlet 정의

public class FileDownloadServlet extends HttpServlet {
    @Override
    public void service() {
        System.out.println("파일 다운로드 합니다.");
    }
}

역시 service()를 오버라이딩.
출력문: "파일 다운로드 합니다."

4. 메인 클래스: 다형성 활용

public class HttpServletExample {
    public static void main(String[] args) {
        method(new LoginServlet());           // → "로그인 합니다."
        method(new FileDownloadServlet());    // → "파일 다운로드 합니다."
    }

    public static void method(HttpServlet servlet) {
        servlet.service();  // 다형성 적용: 실제 객체의 오버라이딩된 메서드 실행
    }
}

method()는 HttpServlet 타입을 매개변수로 받지만,
실제로는 LoginServlet, FileDownloadServlet 객체를 전달하므로
각각의 service() 구현이 실행됩니다.

[혼공자바 3주차] Chapter 06

sm1118sm — Sun, 20 Jul 2025 19:46:32 +0900

혼자공부하는 자바 3주차 (p.234 ~ p.329)

06. 클래스

06-1 객체 지향 프로그래밍

클래스	객체를 만들기 위한 설계도
객체	클래스로부터 생성된 실체, new 클래스이름(); 으로 생성
new 연산자	객체를 생성하고 생성자 호출, 객체 번지를 리턴
클래스 변수	클래스 타입으로 선언된 변수 (객체 참조 저장)
인스턴스	객체는 클래스의 인스턴스
클래스 멤버	클래스 내 선언된 필드, 메서드, 생성자

06-2 필드

필드 선언	클래스 중괄호 {} 안에서 선언. 생성자/메서드 내부에서는 ❌
필드 사용	클래스 내부에서는 바로 사용 가능, 외부에서는 객체 생성 후 접근 필요

public class Car {

String model; // 필드

}

06-3 생성자

기본 생성자	컴파일러가 자동 추가 (다른 생성자 없을 경우)
명시적 생성자	개발자가 직접 정의한 생성자. 선언하면 기본 생성자는 생성되지 않음
매개변수	생성자 호출 시 전달받는 값
객체 초기화	필드 초기화 or 메서드 호출로 설정
오버로딩	매개변수가 다른 생성자를 여러 개 선언
this()	자신의 다른 생성자를 호출할 때 사용

public class Car {

String model;

Car() {

this("기본 모델");

}

Car(String model) {

this.model = model;

}

06-4 메서드

선언부	리턴 타입, 메서드 이름, 매개변수 포함
void	리턴값이 없음을 의미
return 문	리턴 타입이 있을 경우 반드시 필요
호출	메서드이름(값, ...) 형태
오버로딩	동일한 이름의 메서드를 여러 개 선언. 조건: 매개변수 타입/개수/순서 다름

public void printInfo() {
System.out.println("정보 출력");
}

public void printInfo(String name) {
System.out.println("이름: " + name);
}

06-5 인스턴스 멤버와 정적 멤버

인스턴스 멤버	객체 생성 후 사용할 수 있는 멤버 (필드, 메서드)
this	인스턴스 자신을 가리키는 참조자
정적 멤버 (static)	클래스에 고정된 멤버. 객체 없이도 사용 가능
싱글톤	프로그램에서 단 하나만 생성되도록 보장되는 객체
final 필드	한 번 초기화되면 변경 불가
상수	final static으로 선언된 불변 값

public class Calculator {
    static final double PI = 3.14159;  // 상수
    final int id;                     // final 필드

    Calculator(int id) {
        this.id = id;
    }
}

06-6 패키지와 접근 제한자

패키지 선언	클래스 상단에 package 패키지명; 형태로 작성
import 문	다른 패키지의 클래스 사용 시 필요
접근 제한자	외부 접근 제어 목적. 클래스, 필드, 메서드, 생성자 등에 사용

package com.example.car;
import java.util.Scanner;

접근 제한자 종류

public	모든 클래스에서 접근 가능
protected	같은 패키지 + 자식 클래스에서 접근
(default)	같은 패키지 내에서만 접근
private	해당 클래스 내부에서만 접근 가능

Getter / Setter 예시

public class Member {
    private String name;

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

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

기본 숙제(필수) : 어렵게나 중요하다고 생각하는 용어를 혼공용어 노트에 정리하고 공유하기

추가 숙제(선택) : 객체 지향 프로그래밍의 개념 정리하기

객체 지향 프로그래밍 : 객체를 하나씩 조립해서 완성된 프로그램을 만드는 기법

1. 필드

클래스에 선언된 변수
객체의 속성(데이터)을 저장
보통 private으로 선언하고 getter/setter로 접근

public class Person {
private String name; // 필드
private int age; // 필드
}

2. 생성자

객체 생성 시 자동 호출되는 메서드
클래스 이름과 같고, 리턴 타입 없음
오버로딩 가능

public class Person {
    String name;

    // 기본 생성자
    public Person() {
        this.name = "홍길동";
    }

    // 매개변수 있는 생성자
    public Person(String name) {
        this.name = name;
    }
}

3. 메서드

동작/기능을 정의
객체의 행동을 구현
returnType methodName(매개변수) { }

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

4. 인스턴스 멤버

객체가 생성되어야만 사용할 수 있는 멤버
필드, 메서드 앞에 static이 없는 경우

public class Car {
    int speed = 0; // 인스턴스 필드

    void run() {    // 인스턴스 메서드
        System.out.println("달립니다.");
    }
}

// 사용
Car c = new Car();
c.run();  // 인스턴스 메서드 호출

5. 정적 멤버

클래스 자체에 속하는 멤버
객체 생성 없이 사용 가능
static 키워드 사용

public class MathUtil {
    static double PI = 3.14; // 정적 필드

    static int square(int x) { // 정적 메서드
        return x * x;
    }
}

// 사용
double p = MathUtil.PI;
int result = MathUtil.square(5);

6. 패키지

관련 클래스들을 논리적으로 묶는 공간
파일 상단에 package 선언
폴더 구조와 연동

package myapp.utils;

import를 통해 다른 패키지의 클래스 사용 가능

import myapp.utils.MyClass;

7. 접근 제한자

public	어디서든 접근 가능
protected	같은 패키지 + 상속받은 클래스에서 가능
default (없을 경우)	같은 패키지 내에서만 접근 가능
private	해당 클래스 내부에서만 접근 가능

public class Person {
    public String name;       // 어디서든 접근 가능
    protected int age;        // 같은 패키지 + 자식 클래스
    String address;           // default (같은 패키지)
    private String password;  // 클래스 내부만
}

파이썬 자료구조 (3) 스택, 큐, dfs, bfs

sm1118sm — Tue, 15 Jul 2025 20:29:57 +0900

2025.07.15 (화)

12:00 ~ 15:00

백준 알고리즘 문제 풀이

10828번 (스택)
9012번 (괄호)
4949번 (균형잡힌 세상)
1260번 (DFS와 BFS)
1966번 (프린터 큐)

· 1260번 (DFS와 BFS): DFS는 재귀함수로, BFS는 deque를 사용해 구현했습니다. 노드를 오름차순으로 방문하기 위해 정렬을 추가했고, DFS와 BFS의 차이점과 특성을 체감하며 학습할 수 있는 좋은 기회였습니다.

· 1966번 (프린터 큐): 큐를 이용해 우선순위를 고려하여 특정 문서가 언제 출력되는지 계산하는 문제였습니다. 반복문 탈출 조건을 정확히 맞추는 것이 관건이었고, 큐의 순환 처리도 연습할 수 있었습니다.

· 10828번 (스택): 스택의 기본 동작을 구현하는 문제로, push, pop, top 등의 기능을 구현하며 Python의 리스트 활용법을 다시 정리할 수 있었습니다.

· 9012번 (괄호), 4949번 (균형잡힌 세상): 여는 괄호와 닫는 괄호의 균형을 판단하는 문제였습니다. 스택 자료구조의 실전 활용을 익히는 데 도움이 되었고, 조건문에서의 흐름 제어에 대해 복습할 수 있었습니다.

1260번 — DFS와 BFS

핵심 정리

DFS: 재귀
BFS: deque
노드 방문 순서를 오름차순으로 하기 위해 정렬 필요

코드

결과

1966번 — 프린터 큐

핵심 정리

우선순위 큐 처리
현재 문서가 언제 출력되는지 체크하는 흐름 익힘

코드

결과

10828번 — 스택

핵심 정리

스택 기본 기능 구현 (push, pop, size, empty, top)
Python 리스트로 스택 구조 익히기

코드

결과

9012번 — 괄호

핵심 정리

괄호 짝이 맞는지 판별
스택을 활용한 조건문 흐름 제어 학습

코드

결과

4949번 — 균형잡힌 세상

핵심 정리

다양한 괄호 형태 ((), []) 처리
조건 분기와 예외 처리 중요

코드

결과

[혼공자바 2주차] Chapter 04 ~ 05

sm1118sm — Mon, 7 Jul 2025 22:34:17 +0900

혼자공부하는 자바 2주차 (p.156 ~ p.232)

04. 조건문과 반복문

04-1 조건문: if, switch

구문설명

if (조건) { 실행문; }	조건이 참이면 블록 실행
if ... else	조건이 거짓이면 else 블록 실행
if ... else if ... else	다중 조건 분기 처리
switch (변수) { case 값: ... break; default: ... }	변수의 값에 따라 분기 실행

예제 코드 (switch):

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();

switch (a % 3) {
    case 1:
        System.out.println(1);
        break;
    case 2:
        System.out.println(2);
        break;
    default:
        System.out.println(3);
}

break 문이 없으면 다음 case로 "fall through" 하니 주의!

04-2 반복문: for, while, do-while

구문	설명
for (초기식; 조건; 증감)	반복 횟수가 정해졌을 때
while (조건)	조건이 참일 동안 반복
do { ... } while (조건);	최소 한 번은 실행 후 조건 검사

break: 반복문 강제 종료
continue: 다음 반복으로 건너뜀

for (int i = 0; i < 5; i++) {
    if (i == 3) continue;
    System.out.println(i); // 0 1 2 4
}

05. 참조 타입

05-1 참조 타입과 참조 변수

기본 타입: byte, short, char, int, long, float, double, boolean
참조 타입: 배열, 클래스, 인터페이스, 열거형 등
메모리 구조:
- 메서드 영역: 클래스 정보, static
- 힙 영역: 객체 저장
- 스택 영역: 지역 변수 저장
참조 비교: ==은 주소(번지) 비교 → 같은 객체 참조 여부 확인
null: 객체가 없음을 의미하며, 이를 통해 NullPointerException 발생 가능

⚠️ null인 참조 변수로 메소드나 필드를 호출하면 예외 발생

05-2 배열

배열 선언: int[] arr;, String[] names;
배열 생성:

int[] arr = {1, 2, 3};
String[] names = new String[3];

배열 길이: arr.length
다차원 배열:

int[][] matrix = new int[2][3];
System.out.println(matrix.length);         // 2
System.out.println(matrix[0].length);      // 3

향상된 for문:

for (int score : arr) {
    System.out.println(score);
}

향상된 for문은 인덱스가 필요 없을 때 간결하게 사용 가능

05-3 열거 타입 (Enum)

선언:

enum Week { MONDAY, TUESDAY, ..., SUNDAY }

사용:

Week today = Week.FRIDAY;
System.out.println(today);

특징:
- 타입 안정성 제공
- 코드 가독성 향상

열거형은 switch문과 함께 자주 사용됩니다.

기본 숙제

p.142 직접 해보는 손코딩 실행 후 결과 화면 캡쳐하기

추가 숙제

p.223 하단 확인 문제 6번 풀고 정리하기

전체 구조

public class Main { public static void main(String[] args) { ... } }

Main 클래스는 실행 진입점(main 메서드)을 가지고 있습니다.
Scanner를 이용해 사용자 입력을 반복적으로 받아 처리합니다.

주요 변수 설명

int studentNum = 0;

int[] scores = {0,};

Scanner scanner = new Scanner(System.in);

변수명설명

studentNum	학생 수를 저장하는 정수 변수 (초기값: 0)
scores	학생들의 점수를 저장할 정수형 배열 (초기엔 {0}으로 초기화됨)
scanner	사용자 입력을 받기 위한 Scanner 객체

메뉴 루프

while(true) {
    System.out.println("1.학생수 | 2.점수입력 | 3.점수리스트 | 4.분석 | 5.종료");
    ...
    int a = Integer.parseInt(scanner.nextLine());

무한 루프 (while(true))로 사용자가 5. 종료를 선택할 때까지 계속 실행
사용자에게 메뉴를 보여주고, 숫자(1~5)를 입력 받음 → int a

조건별 분기 처리

1. a == 1 → 학생 수 입력

studentNum = Integer.parseInt(scanner.nextLine());

scores = new int[studentNum];

사용자로부터 학생 수 입력 받아 studentNum에 저장
해당 크기만큼의 scores 배열 새로 생성 → 이전 내용은 초기화됨

2. a == 2 → 점수 입력

for (int i = 0; i < scores.length; i++) {
System.out.print("scores[" + i + "]> ");
scores[i] = Integer.parseInt(scanner.nextLine());
}

학생 수만큼 반복하며 점수 입력 받음
입력 받은 점수를 scores 배열에 저장

3. a == 3 → 점수 리스트 출력

for (int i = 0; i < scores.length; i++) {
System.out.println("scores[" + i + "]> " + scores[i]);
}

scores 배열에 저장된 점수들을 출력함

4. a == 4 → 최고 점수 및 평균 분석

int max = 0;
double avg = 0;

for (int i = 0; i < scores.length; i++) {
    if (max < scores[i]) {
        max = scores[i];
    }
    avg += scores[i];
}
System.out.println("최고 점수: " + max);
System.out.println("평균 점수: " + avg / scores.length);

최고 점수(max)를 0부터 시작해서 갱신
평균(avg)은 합계를 누적해서 마지막에 전체 인원수로 나눔
max < scores[i] 조건으로 최댓값 탐색

5. 그 외 (else) → 프로그램 종료

System.out.println("프로그램 종료");

break;

1~4 외의 숫자(예: 5)가 입력되면 종료 메시지를 출력하고 while 루프 탈출

[혼공자바 1주차] Chapter 01 ~ 03

sm1118sm — Tue, 1 Jul 2025 17:26:52 +0900

혼자공부하는 자바 1주차 (p.28 ~ p.153)

01. 자바 시작하기

01-1 프로그래미닝 언어와 자바

프로그래밍 언어란? 사람이 이해할 수 있는 언어로, 기계어와 인간 언어의 중간 다리 역할. (C, Java, Python 등)
파일 구성: .java (소스파일) → javac 컴파일 → .class 바이트코드 → java 실행 (JVM 사용)
JDK: 자바 개발 키트. JRE + 컴파일러 + 디버깅 도구 포함.
환경변수 설정 필수: JAVA_HOME, Path

팁: Windows 기준 시스템 속성 > 고급 > 환경 변수 에서 등록 가능.

01-2 이클립스 개발 환경 구축

Eclipse: 오픈소스 IDE로 자동 완성, 디버깅, 프로젝트 관리 지원.
워크스페이스: 이클립스의 작업 폴더
뷰(View): 코드 편집, 콘솔 등 기능 창
퍼스펙티브(Perspective): 개발 유형에 맞춘 뷰 레이아웃 구성

추천: IntelliJ IDEA는 상용이지만 UI와 자동 완성이 더 뛰어남.

01-3 자바 프로그램 개발 과정

클래스: 자바의 기본 단위. class 클래스이름 { ... }
main() 메소드: 자바 프로그램의 실행 시작점
주석: // 한 줄, /* 여러 줄 */
실행문: 변수 선언, 메소드 호출 등. ; 필수!

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

02. 변수와 타입

02-1 변수

변수란? 메모리의 특정 위치에 이름을 붙인 것
변수 선언: 타입 변수명;
변수 범위: 선언된 블록 내부에서만 유효

02-2 기본 타입

타입예시설명

int	int a = 10;	정수형
float	float b = 1.5f;	소수점 포함 실수
char	char c = 'A';	문자 하나
String	String s = "Java";	문자열 객체
boolean	boolean flag = true;	참/거짓

char은 ' 사용, String은 " 사용!

02-3 타입 변환

자동 변환: 작은 타입 → 큰 타입 (데이터 손실 없음)

int a = 3;
double d = a; // 자동 변환

강제 변환: 큰 타입 → 작은 타입 (데이터 손실 가능)

double d = 3.9;
int a = (int) d; // a는 3

문자열 → 숫자 변환

int n = Integer.parseInt("123");
double d = Double.parseDouble("3.14");

02-4 변수와 시스템 입출력

출력

System.out.println("Hello"); // 줄바꿈
System.out.print("Hello");   // 줄바꿈 없음
System.out.printf("나이: %d", 25);

입력 (Scanner 사용)

Scanner sc = new Scanner(System.in);
int num = sc.nextInt();

nextLine()은 한 줄 전체 읽기, next()는 단어 단위로 읽기

03. 연산자

03-1 연산자와 연산식

연산자: +, -, *, /, % (산술), ==, != (비교), &&, || (논리), =, += (대입)
연산 방향: 대부분 왼→오, 대입은 오→왼
우선순위: 괄호(())로 명확히 정리 가능

03-2 연산자 종류

종류	예시	설명
증감	i++, --j	값 1 증가/감소
비교	a == b	같은지 비교
논리	a && b, !a	조건 결합
대입	x += 2	연산 후 대입
삼항	(조건) ? A : B	조건식 결과 분기

기본 숙제 -> JDK 설치 화면 인증하기

bin : 개발할 대 필요한 도구들이 있습니다. 자바 컴파일러와 자바 실행 명령어가 이 폴더에 저장되어 있습니다.

conf : 자바 개발자, 배포자 및 최종 사용자가 편집할 수 있는 설정 파일들이 저장되어 있습니다.

include : 자바를 C언어로 작성된 프로그램과 통합하는데 필요한 파일이 저장되어 있습니다.

jmods : 컴파일된 자바 모듈들이 저장되어 있습니다.

lib : 자바 프로그램 실행 환경과 관련된 세부 정보 파일들이 저장되어 있습니다.

기타 파일 : 라이선스 및 jdk 릴리즈 정보 등이 저장되어 있습니다.

추가 숙제 -> p.110 확인 문제 9번에 들어갈 코드를 2가지 이상 작성해보기

9. var1부터 var4까지 + 연산을 수행해서 int 타입 result 변수에 9가 저장되도록 코드를 작성해보세요.

long var1 = 2L;

float var2 = 1.8f;

double var3 = 2.5;

String var4 = "3.9";

int result = (int) var1 + 이 부분 채우기;

System.out.println(result);

나의 답

1. (int) (var1 + var2 + var3 + (int) Double.parseDouble(var4))

2. (int) var1 + (int) var2 + (int) (var3 + Double.parseDouble(var4))

파이썬 자료구조 (2) 투 포인터

sm1118sm — Wed, 25 Jun 2025 21:37:52 +0900

투 포인터 알고리즘 : 리스트에 순차적으로 접근해야 할 때 두 개의 점의 위치를 기록하면서 처리하는 알고리즘을 의미합니다.

흔히 2, 3, 4, 5, 6, 7번 학생을 지목해야 할 때 간단히 2번부터 7번까지의 학생이라고 부르곤 합니다.

리스트에 담긴 데이터에 순차적으로 접근해야 할 때는 시작점과 끝점 2개의 점으로 접근할 데이터의 범위를 표현할 수 있습니다.

투 포인터를 활용하여 다음과 같은 알고리즘으로 문제를 해결할 수 있습니다.

시작점과 끝점이 첫 번째 원소의 인덱스를 가리키도록 합니다.
현재 부분 합이 M과 같다면, 카운트합니다
현재 부분 합이 M보다 작다면, end를 1 증가시킵니다
현재 부분 합이 M보다 크거나 같다면, start를 1 증가시킵니다
모든 경우를 확인할 때까지 2번부터 4번까지의 과정을 반복합니다

예제 1) 수들의 합 5 (백준 2018번)

https://www.acmicpc.net/problem/2018

파이썬 코드

import sys
input = sys.stdin.readline

num = int(input())
start = 1
end = 1
count = 1
sumValue = 1

while end != num:

    if sumValue == num:
        count += 1
        end += 1
        sumValue += end

    elif sumValue < num:
        end += 1
        sumValue += end

    else:
        sumValue -= start
        start += 1

print(count)

예제 2) 주몽 (백준 1940번)

https://www.acmicpc.net/problem/1940

파이썬 코드

import sys

input = sys.stdin.readline

n = int(input())
m = int(input())
list1 = list(map(int, input().split()))

list1.sort()

count = 0
front = 0
end = n - 1

while front < end:
    if list1[front] + list1[end] < m:
        front += 1

    elif list1[front] + list1[end] > m:
        end -= 1

    else:
        count += 1
        front += 1
        end -= 1

print(count)

파이썬 자료구조 (1) 구간 합

sm1118sm — Wed, 25 Jun 2025 19:31:29 +0900

구간 합

합 배열 S 정의
- S[ i ] = A [ 0 ] + A [ 1 ] + A [ 2 ] + ... + A [ i - 1 ] + A [ i ]
합 배열 S를 만드는 공식
- S[ i ] = S[ i - 1 ] + A[ i ]
구간 합을 구하는 공식
- S[ j ] - S[ i - 1 ]

예제 1) 구간 합 구하기 4 (백준 11659번)

https://www.acmicpc.net/problem/11659

파이썬 코드

import sys
input = sys.stdin.readline
a, b = map(int, input().split())
num = list(map(int, input().split()))
sumList = [0]

for i in range(a):
sumList.append(num[i] + sumList[i])

for i in range(b):
k, q = map(int, input().split())
print(sumList[q] - sumList[k-1])

예제 2) 구간 합 구하기 5 (백준 11660번)

https://www.acmicpc.net/problem/11660

파이썬 코드

import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a = [[0] * (n+1)]
d = [[0] * (n+1) for _ in range(n+1)]

for i in range(n):
    row = [0] + [int(x) for x in input().split()]
    a.append(row)

for i in range(1, n+1):
    for j in range(1, n+1):
        d[ i ][ j ] = d[ i-1 ][ j ] + d[ i ][ j-1 ] - d[ i-1 ][ j-1 ] + a[ i ][ j ]

for k in range(m):
    x1, y1, x2, y2 = map(int, input().split())

    result = d[ x2 ][ y2 ] - d[ x1-1 ][ y2 ] - d[ x2 ][ y1-1 ] + d[ x1-1 ][ y1-1 ]
    print(result)

합 배열과 구간 합 공식을 적재적소에 활용하면 코딩 테스트에서 시간 복잡도를 줄이는 데 많은 도움이 될 것입니다.

시간복잡도

sm1118sm — Wed, 25 Jun 2025 19:12:03 +0900

시간복잡도 : 주어진 문제를 해결하기 위한 연산 횟수, 일반적으로 파이썬은 2000 만번 ~ 1억 번의 연산을 1초의 수행 시간으로 예측할 수 있습니다.

시간 복잡도 유형
1. 빅-오메가 ( Ω(n) ) : 최선일 때의 연산 횟수를 나타낸 표기법
2. 빅-세타 ( Θ(n) ) : 보통(평균) 일 때의 연산 횟수를 나타낸 표기법
3. 빅-오 ( O(n) ) : 최악일 때의 연산 횟수를 나타낸 표기법 -> 가장 많이 사용함
코딩 테스트에서는 어떤 시간 복잡도 유형을 사용해야 할까?
- -> 코딩 테스트에서는 빅-오 표기법 ( O(n) ) 기준으로 수행 시간을 계산하는 것이 좋습니다.

빅-오 표기법 ( O(n) ) 의 주요 시간 복잡도 종류

O(N) : 5N+3, 2N+10logN, 10N
O(N^2) : N^2+2n+4, 6N^2+12logN
O(NlogN) : NlogN + 30N+ 10, 3NlogN
O(logN) : 3logN, logN+3
O(1): 5, 16, 46

상수 시간	O(1)	입력 크기와 상관없이 항상 일정한 시간 ex) 배열에서 인덱스로 값 찾기
로그 시간	O(log n)	입력이 커질수록 느리게 증가 ex) 이진 탐색
선형 시간	O(n)	입력 크기에 비례 ex) 배열 전체 순회
로그-선형	O(n log n)	정렬 알고리즘에서 자주 등장 ex) 머지 정렬, 퀵 정렬 평균
제곱 시간	O(n²)	중첩 반복문 등 ex) 버블 정렬, 삽입 정렬
지수 시간	O(2^n)	매우 느림. 입력이 조금만 커져도 실행 시간이 급증 ex) 부분집합, 재귀 백트래킹
팩토리얼 시간	O(n!)	극도로 느림. ex) 순열 계산, 완전탐색(브루트포스)