객체지향프로그래밍 정리본

sungsimdangmascot·2026년 4월 7일
정보처리산업기사

1. 클래스, 메서드, 생성자 (기본 뼈대)

  • 클래스: 붕어빵 틀 (설계도)
  • 메서드: 붕어빵 만드는 기능
  • 생성자: new 할 때 딱 한 번 실행되는 초기화 함수 (클래스 이름과 똑같이 생겼고 리턴 타입이 없음)

[암기 공식]
class 클래스명 { ... }
클래스명() { ... } ← 생성자 (이름 똑같음!!)
void 메서드명() { ... } ← 메서드

2. 세터(Setter)와 게터(Getter)

  • 변수를 private으로 숨기고, 안전하게 값을 넣거나(set) 가져올 때(get) 사용합니다.

[암기 공식]
Set: public void set변수명(타입 변수) { this.변수 = 변수; }
Get: public 타입 get변수명() { return 변수; }

3. 상속(Inheritance)

  • 부모의 기능을 자식이 그대로 물려받는 것.

[암기 공식]
class 자식클래스 extends 부모클래스 { ... }

4. 다형성과 타입변환 (Polymorphism)

  • 다형성: 하나의 타입으로 여러 객체를 다루는 것. (부모는 자식을 품을 수 있다!)
  • 업캐스팅 (자동): 부모 타입 변수에 자식 객체 넣기.
  • 다운캐스팅 (강제): 다시 자식 타입으로 바꿀 땐 괄호( ) 사용.

[암기 공식]
부모 p = new 자식(); ← 업캐스팅 (시험에 단골 출제)
자식 c = (자식)p; ← 다운캐스팅 (강제로 깎아서 맞춤)

  1. 다형성과 타입변환 (업캐스팅 / 다운캐스팅)
    '다형성'은 한자로 '모양이 여러 개로 변하는 성질'이야.
    비유하자면 [스마트폰(부모) - 아이폰(자식)] 관계를 생각하면 끝이야.

부모 클래스: 스마트폰

자식 클래스: 아이폰 (스마트폰의 기능을 다 물려받음 + '에어드롭' 같은 자기만의 기능도 있음)

① 업캐스팅 (자동): 당연한 소리 할 때
친구가 "너 폰 뭐 샀어?" 했을 때, 아이폰을 보여주며 "나 스마트폰 샀어"라고 말하는 상황이야.
아이폰은 당연히 스마트폰이니까 누가 태클을 걸지 않지? 그래서 자바에서도 에러 없이 '자동'으로 통과시켜 줘.

코드: 스마트폰 p = new 아이폰();
(아이폰을 만들어서 스마트폰이라는 상자에 넣음. 문제없음!)

② 다운캐스팅 (강제): 억지로 본성을 끌어낼 때
그런데 위에서 p를 '스마트폰'이라고 뭉뚱그려 불렀잖아? 그래서 p.에어드롭()을 쓰려고 하면 컴퓨터가 "어? 스마트폰에는 에어드롭 없는데?" 하고 에러를 내뿜어.
분명히 아이폰을 넣었지만, 겉포장지가 '스마트폰'이라서 자기 기능을 못 쓰는 거야.
이때 겉포장지를 찢고 "야! 얘 사실 아이폰이라고!!" 하고 강제로 도장을 찍어주는 게 다운캐스팅이야.

코드: 아이폰 c = (아이폰) p;
(p 앞에 괄호 치고 (아이폰)이라고 강제로 깎아 맞춰줌. 이제 에어드롭 사용 가능!)

5. 추상클래스 vs 인터페이스

  • 추상클래스: 미완성 설계도 (abstract). "이런 기능은 꼭 있어야 해!"
  • 인터페이스: 규격서 (implements). "이 규칙을 무조건 지켜서 만들어!"

[암기 공식]
추상: abstract class 클래스명 / abstract void 메서드명(); (내용 없음)
인터페이스: interface 이름 / class 클래스명 implements 이름

  1. 추상클래스 vs 인터페이스 (둘 다 잔소리꾼)
    둘 다 본질적인 목적은 똑같아. "내 밑으로 들어올 거면, 이 기능은 무조건 니가 알아서 만들어 놔!!"라고 자식한테 강제(협박)하는 거야. 차이는 '얼마나 도와주느냐'에 있어.

① 추상클래스 (abstract) = 프랜차이즈 식당 물려주기
본사(부모)가 가맹점(자식)한테 가게를 내주는데, 기본적 인테리어나 포스기 쓰는 법(일반 기능)은 다 세팅해서 넘겨줘.
그런데 "비법 소스(추상 메서드)는 동네 입맛에 맞게 니가 알아서 연구해서 만들어!" 하고 빈칸을 남겨두는 거야.

특징: 기본 틀은 제공함. 일부만 "니가 완성해!" (abstract 키워드 사용)

② 인터페이스 (interface) = 백종원의 골목식당 규격서
도와주는 거 1도 없음. 오직 지켜야 할 '규칙 목록'만 종이에 적어서 던져줘.
"식당 할 거면 1. 주차장 만들어, 2. 위생 철저히 해, 3. 메뉴판 3개로 줄여."
이걸 어떻게 할지는 100% 자식(가맹점)이 바닥부터 다 짜야 해.

특징: 껍데기(이름)만 던져줌. 내용물은 100% 자식이 알아서 만들어야 함. (implements 키워드 사용)

6. 예외처리 (Exception)

  • 에러가 나도 프로그램이 멈추지 않게 방어막을 치는 것.

[암기 공식]
try { 에러 날 것 같은 코드 }
catch (예외클래스 e) { 에러 나면 할 일 }
finally { 에러 나든 안 나든 무조건 실행 }

7. 제너릭 (Generic)

  • 데이터 타입을 미리 정하지 않고, 쓸 때 정하는 것. (<T>나 <E>를 사용)

[암기 공식]
ArrayList<String> list = new ArrayList<>();
(안에 들어갈 타입을 < > 안에 적어준다!)

8. 내부 클래스 (Inner Class)

  • 클래스 안에 또 클래스가 있는 것. 바깥 클래스의 기능을 편하게 쓰려고 사용합니다.

[암기 공식]
class Outer { class Inner { ... } }

9. 다형성의 꽃: 오버라이딩 (Overriding)

  • 부모가 준 메서드를 자식이 맘대로 고쳐 쓰는 것.

[암기 공식]
@Override 스티커 붙이기! (부모 메서드와 이름, 매개변수가 똑같아야 함)

암기해야할 틀

1번: 클래스, 생성자, 게터/세터의 정석

  • 용도: "회원(또는 상품) 클래스를 설계하고 캡슐화하시오"라는 문제가 나올 때 쓰는 가장 기본 뼈대.

변수 숨기기: 클래스 안에 만드는 모든 변수(데이터) 앞에 무조건 private을 붙인다.

창구 만들기: 그 숨겨진 변수를 밖에서 안전하게 읽고 쓸 수 있도록, public으로 Getter와 Setter 메서드를 만들어 준다.

class Person {
    // 1. 변수는 private으로 숨김 (캡슐화)
    private String name; 

    // 2. 생성자 (클래스 이름과 똑같고 void 안 씀!)
    public Person(String name) {
        this.name = name; // 넘어온 값을 내 변수(this)에 넣음
    }

    // 3. Getter (값 가져오기, return 필수)
    public String getName() {
        return name;
    }

    // 4. Setter (값 집어넣기, void 사용)
    public void setName(String name) {
        this.name = name;
    }
}

2번: 상속, 다형성, 오버라이딩

  • 용도: "부모 클래스를 상속받아 자식 클래스에서 기능을 재정의하시오"라는 문제가 나올 때 쓰는 공식. 다형성(업캐스팅/다운캐스팅)은 무조건 출제.
// 1. 부모 클래스
class Animal {
    void sound() {
        System.out.println("동물 소리");
    }
}

// 2. 자식 클래스 (extends로 부모 기능 물려받음)
class Dog extends Animal {
    
    // 3. 오버라이딩 (부모 메서드 덮어쓰기)
    @Override 
    void sound() {
        System.out.println("멍멍");
    }
}

public class Main {
    public static void main(String[] args) {
        // 4. 다형성 (업캐스팅): 부모 타입에 자식 객체 넣기
        Animal a = new Dog(); 
        a.sound(); // 자식이 덮어쓴 "멍멍"이 출력됨

        // 5. 다운캐스팅: 다시 자식 타입으로 깎아서 맞춤
        Dog d = (Dog) a; 
    }
}

3번: 인터페이스, 예외처리, 제네릭

  • 용도: "규격에 맞춰 구현하시오(인터페이스)", "에러를 처리하시오(try-catch)", "리스트를 만드시오(제네릭)" 문제가 섞여 나올 때 쓰는 종합 세트.
// 1. 인터페이스 (규격서 - 내용물 없이 선언만)
interface Flyable {
    void fly(); 
}

// 2. 인터페이스 구현 (implements 사용, 무조건 오버라이딩 필수)
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("새가 납니다");
    }
}

import java.util.ArrayList; // 리스트 쓰려면 임포트 필수

public class Main {
    public static void main(String[] args) {
        // 3. 제네릭 (ArrayList 꺾쇠 < > 안에 타입 넣기)
        ArrayList<String> list = new ArrayList<>();
        list.add("합격");

        // 4. 예외처리 (에러 방어막)
        try {
            int result = 10 / 0; // 에러 터지는 코드
        } catch (Exception e) {
            System.out.println("에러 발생!"); // 에러 나면 여기 실행
        } finally {
            System.out.println("무조건 실행됨"); // 무조건 마지막에 실행
        }
    }
}

📝 필사 4번: 추상클래스와 내부클래스

  • 용도: "추상클래스를 구현하시오", "내부클래스를 사용하시오"라는 조건이 붙었을 때 쓰는 공식.
// 1. 추상클래스 (abstract: 미완성 설계도)
abstract class Shape {
    // 내용물 {} 이 없는 미완성 메서드
    abstract void draw(); 
}

// 2. 자식 클래스 (추상클래스는 무조건 자식이 완성해줘야 함!)
class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("동그라미 그리기");
    }
}

// 3. 내부클래스 (클래스 안의 클래스)
class Outer {
    int outVar = 10;
    
    // 껍데기 안에 들어있는 이너 클래스
    class Inner { 
        void print() {
            System.out.println("바깥 변수 사용: " + outVar);
        }
    }
}

📝 필사 5번: (시험 단골 추가) 배열과 반복문

  • 용도: "여러 개의 데이터를 받아서 출력하시오", "점수의 평균을 구하시오" 같은 문제에서 무조건 100% 나오는 구조.
public class Main {
    public static void main(String[] args) {
        
        // 1. 배열 만들기 (데이터를 기차 칸처럼 여러 개 담는 통)
        int[] scores = {80, 90, 100}; 
        int sum = 0; // 합계를 담을 빈 바구니

        // 2. 반복문 (배열 크기만큼 빙글빙글 돌기)
        // i는 0부터 시작해서 배열의 길이(scores.length) 전까지 증가(i++)
        for (int i = 0; i < scores.length; i++) {
            sum = sum + scores[i]; // 바구니에 점수를 계속 누적해서 더함
            System.out.println(scores[i] + "점 출력!");
        }

        // 3. 결과 출력
        System.out.println("총합은: " + sum);
    }
}

📝 필사 6번: 제네릭 (Generic) 전용

  • 용도: "자료형을 미리 정하지 않고, 객체를 생성할 때 정하도록 설계하시오"라는 말이 나오면 무조건 <T>를 쓴다.
// 1. 제네릭 클래스 설계 (<T>는 '타입은 나중에 정할게!'라는 빈칸입니다)
class Box<T> {
    private T item; // 타입이 T인 변수

    // Setter
    public void setItem(T item) { 
        this.item = item; 
    }
    
    // Getter
    public T getItem() { 
        return item; 
    }
}

public class Main {
    public static void main(String[] args) {
        // 2. 객체 만들 때 < > 안에 진짜 타입(String, Integer 등)을 넣어줌
        Box<String> stringBox = new Box<>(); 
        stringBox.setItem("문자열 합격!");

        Box<Integer> intBox = new Box<>();
        intBox.setItem(100); // 숫자 100
    }
}

📝 필사 7번: 다형성과 타입 변환 (업/다운캐스팅) 전용

  • 용도: 과정형 평가에서 "부모 타입으로 자식을 다루시오" 혹은 "다시 자식 타입으로 변환하여 메서드를 호출하시오" 할 때 쓰는 핵심 공식.
class Parent {
    void show() { 
        System.out.println("부모 기능"); 
    }
}

class Child extends Parent {
    @Override
    void show() { 
        System.out.println("자식이 덮어쓴 기능"); 
    }
    
    void onlyChild() { 
        System.out.println("자식한테만 있는 특별한 기능"); 
    }
}

public class Main {
    public static void main(String[] args) {
        
        // [공식 1] 자동 타입 변환 (업캐스팅)
        // 자식 객체를 만들어서 부모 변수(p)에 담음
        Parent p = new Child(); 
        p.show(); // "자식이 덮어쓴 기능" 출력됨

        // [공식 2] 강제 타입 변환 (다운캐스팅)
        // p.onlyChild(); // 에러 발생! 부모 껍데기라 자식 전용 버튼이 안 보임
        
        // 다시 자식 타입으로 (Child)라고 써서 강제로 깎아줌!
        Child c = (Child) p; 
        c.onlyChild(); // 이제 자식 전용 기능 실행 가능!
    }
}

이모티콘을 모두 제거하고, 복습이나 블로그(Velog) 포스팅에 바로 활용하실 수 있도록 깔끔한 평서문(-한다 체) 형식으로 다시 정리해 드립니다.

[Java] 문자열(String) 주요 내장 함수 요약

자바에서 문자열을 다룰 때 빈번하게 사용되는 필수 내장 함수들을 목적별로 정리한다. 코딩 테스트나 실기 시험에서 코드의 빈칸 채우기 또는 출력 결과 예측 문제로 자주 출제되므로 각 함수의 역할을 정확히 숙지해야 한다.

1. 문자열 길이 확인 및 문자 추출

  • length(): 문자열의 총 길이를 정수(int)로 반환한다.
    • 예시: "Java".length() 실행 시 4 반환
  • charAt(int index): 지정한 인덱스 번호에 위치한 문자(char) 하나를 반환한다. 자바의 인덱스는 0부터 시작한다.
    • 예시: "Java".charAt(1) 실행 시 'a' 반환

2. 문자열 자르기 및 쪼개기

  • substring(int beginIndex, int endIndex): 문자열의 특정 구간을 잘라서 반환한다. 시작 인덱스부터 끝 인덱스 '직전'까지만 잘라낸다는 점에 주의해야 한다.
  • split(String regex): 특정 기호나 문자를 기준으로 문자열을 쪼개어 String 배열 형태로 반환한다.
    • 예시: "010-1234-5678".split("-") 실행 시 배열 ["010", "1234", "5678"] 반환

3. 문자열 검색 및 치환

  • indexOf(String str): 특정 단어나 문자가 시작되는 첫 번째 위치의 인덱스 번호를 반환한다.
  • replace(CharSequence target, CharSequence replacement): 특정 문자열을 찾아 다른 새로운 문자열로 모두 교체한다.
    • 참고: 정규표현식을 적용해 교체할 때는 replaceAll(), 처음 발견된 패턴 하나만 교체할 때는 replaceFirst()를 사용한다.
  • trim(): 문자열의 양 끝에 있는 공백을 모두 제거한다. (문자열 중간에 포함된 띄어쓰기는 제거하지 않음)

4. 문자열 비교 및 포함 여부 확인 (boolean 반환)

  • equals(Object anObject): 두 문자열의 값이 완전히 동일한지 비교하여 참/거짓을 반환한다. 자바에서는 문자열의 값을 비교할 때 == 연산자를 사용하면 주소값을 비교하게 되므로, 반드시 equals() 메서드를 사용해야 한다.
  • contains(CharSequence s): 문자열 안에 특정 단어나 문자가 포함되어 있는지 확인한다.
  • startsWith(String prefix): 문자열이 특정 문자로 시작하는지 확인한다.
  • endsWith(String suffix): 문자열이 특정 문자로 끝나는지 확인한다.
profile
sungsimdangmascot
성심당마스코트
이전 포스트

(조건문 - 배열) 오답노트

다음 포스트

20260407TUE (9일차)

0개의 댓글