패키지에 있는 크기가 자동으로 조절되는 배열 기반 리스트이다. ArrayList는 요소를 추가 시 자동으로 크기를 늘린다.

ArrayList<Movie> movies = new ArrayLisr<>();
// Movie 객체를 여러개 담아두는 리스트

값 넣기 add()

값 꺼내기 get()

개수 확인 size()

삭제 remove()

예외가 발생했을 때 프로그램을 멈추지 않고 안전하게 다음 코드를 실행하도록 처리하는 핵심 문법

"이 코드를 실행하고(try), 문제가 생기면 이렇게 처리해(catch)."

try {
    // 오류가 발생할 수 있는 코드
} catch (예외타입 변수) {
    // 오류가 발생했을 때 실행할 코드
}

try {
    int num = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("숫자를 입력해주세요.");
}

NumberFormatException e

숫자로 바꾸려고 했는데 숫자로 바꿀 수 없을 때 발생하는 오류

ex. Integer.parseInt("123"); // 정상 Integer.parseInt("abc"); // NumberFormatException ( 오류

e는 발생할 오류를 저장하는 변수 이름이다 : 발생한 예외정보가 포함된다.

상속(Inheritance)은 기존 클래스의 필드와 메서드를 물려받아 새로운 클래스를 만드는 것이다.

기존 클래스의 기능을 그대로 재사용할 수 있기 때문에 코드의 중복을 줄이고 유지보수를 쉽게 할 수 있다.

상속에서 물려받는 것

• 필드(Field) → 클래스의 특성이나 상태를 나타냄
• 메서드(Method) → 클래스의 동작이나 기능을 나타냄

즉,

기존 클래스의 필드와 메서드를 물려받아 새로운 클래스를 만드는 것

이라고 이해하면 된다.

부모 클래스와 자식 클래스

상속 관계에서는 두 클래스를 다음과 같이 부른다.

• 부모 클래스(Super Class) → 상속을 해주는 클래스
• 자식 클래스(Sub Class) → 부모 클래스를 상속받는 클래스

Java에서는 extends 키워드를 사용하여 상속받을 수 있다.

class Animal {
    String name;

    void eat() {
        System.out.println("먹습니다.");
    }
}

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

Dog 클래스는 Animal 클래스를 상속받았기 때문에 Animal의 name 필드와 eat() 메서드를 사용할 수 있다.

또한 Dog만의 새로운 메서드인 bark()도 추가할 수 있다.

상속의 특징

상속을 사용하면 부모 클래스의 기능을 재사용할 수 있다.

class Animal {
    void eat() {
        System.out.println("먹습니다.");
    }
}

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

Dog dog = new Dog();

dog.eat();   // 부모 클래스에서 상속받은 메서드
dog.bark();  // 자식 클래스에서 추가한 메서드

실행 결과:

먹습니다.
멍멍!

이처럼 자식 클래스는 부모 클래스의 기능을 사용할 수 있고, 필요한 기능을 추가할 수도 있다.

상속을 사용하는 이유

1. 코드 재사용

이미 만들어진 부모 클래스의 필드와 메서드를 다시 작성하지 않고 사용할 수 있다.

2. 코드 중복 감소

여러 클래스에서 공통적으로 사용하는 기능을 부모 클래스에 작성하면 중복 코드를 줄일 수 있다.

3. 유지보수 편리

공통 기능을 부모 클래스에서 관리하기 때문에 수정이 필요한 경우 부모 클래스의 코드를 수정하면 된다.

StringBuilder는 문자열을 변경하거나 추가할 때 사용하는 클래스이다.

String은 한 번 생성된 문자열을 직접 변경할 수 없는 불변(immutable) 객체이기 때문에 문자열을 자주 수정해야 한다면 StringBuilder를 사용하는 것이 효율적이다.

특히 문자열을 반복해서 연결하거나 수정할 때 새로운 String 객체를 계속 생성하는 것보다 메모리와 성능 측면에서 유리하다.

StringBuilder의 버퍼(Buffer)

StringBuilder는 문자열을 저장하기 위해 버퍼(Buffer)라는 공간을 사용한다.

기본 생성자

StringBuilder sb = new StringBuilder();

기본 버퍼 크기는 16개의 문자를 저장할 수 있다.

StringBuilder sb = new StringBuilder();

System.out.println(sb.capacity());

실행 결과:

16

버퍼의 공간이 부족해지면 StringBuilder가 자동으로 버퍼 크기를 늘린다.

StringBuilder(int capacity)

원하는 크기의 버퍼를 미리 지정할 수도 있다.

StringBuilder sb = new StringBuilder(50);

위 코드는 50개의 문자를 저장할 수 있는 버퍼를 생성한다.

System.out.println(sb.capacity());

실행 결과:

50

버퍼 크기를 미리 지정하면 문자열의 크기를 어느 정도 예상할 수 있는 경우 불필요한 버퍼 확장을 줄일 수 있다.

StringBuilder(String str)

문자열을 초기값으로 지정할 수도 있다.

StringBuilder sb = new StringBuilder("Hello");

"Hello"가 버퍼의 초기 문자열로 저장된다.

System.out.println(sb);

실행 결과:

Hello

이때 기본 버퍼 크기인 16에 문자열의 길이가 더해져 초기 용량은 21이 된다.

StringBuilder와 스레드

StringBuilder를 이해하기 위해서는 스레드(Thread)의 개념도 알아야 한다.

싱글스레드

싱글스레드(Single Thread)는 하나의 프로세스에서 하나의 스레드가 작업을 수행하는 방식이다.

프로세스
   ↓
스레드 1
   ↓
작업 수행

하나의 작업 흐름으로 프로그램이 실행된다.

멀티스레드

멀티스레드(Multi Thread)는 하나의 프로세스에서 둘 이상의 스레드가 작업을 수행하는 방식이다.

프로세스
 ├─ 스레드 1
 ├─ 스레드 2
 └─ 스레드 3

여러 스레드가 동시에 작업하거나 실행 흐름을 나누어 작업할 수 있다.

StringBuilder vs StringBuffer

StringBuilder와 비슷한 클래스로 StringBuffer가 있다.

두 클래스 모두 문자열을 변경할 수 있는 가변(Mutable) 문자열 클래스이다.

StringBuffer는 동기화(Synchronization)를 지원하기 때문에 여러 스레드가 동시에 접근하는 상황에서도 안전하게 사용할 수 있다.

반면 StringBuilder는 동기화를 지원하지 않는 대신 동기화에 따른 오버헤드가 없어 싱글스레드 환경에서 더 빠르게 사용할 수 있다.

정리

싱글스레드 → StringBuilder 멀티스레드 → StringBuffer

다만 실제 프로그램에서는 멀티스레드 환경이라고 해서 무조건 StringBuffer를 사용하는 것은 아니며, 공유 문자열에 대한 동시 접근이 필요한지 등을 고려해야 한다.

Object 클래스는 최상위 조상 클래스이다. 선언 시 extend 키워드로 다른 클래스를 상속하지 않으면 묵시적으로 java.lang.Object 클래스를 강제 상속하게 된다.

주요 메소드

1) clone() 메소드

객체 자신을 복제하는 메소드로 반환 타입은 Object 타입으로 선언되어 있다. 따라서 타입에 맞게 사용하려면 형변환 연산이 필요하다. 복제 가능 클래스와 불가능 클래스가 있는데 Cloneable 인터페이스로 구현한 클래스는 바로 복제할 수 있다.

package pack01;
import java.util.GregorianCalendar;

public class ObjectCloneEx {
    public static void main(String[] args) {
        GregorianCalendar cal1 = new GregorianCalendar(2024, 07,07);
        GregorianCalendar cal2 = (GregorianCalendar)cal1.clone();
        System.out.printf("%tF %n", cal1);
        System.out.printf("%tF %n", cal2);
        }
    }

2)boolean equals(Object obj) 메소드

비교하는 메소드로 두 객체가 같으면 true 다르면 false를 반환한다.

package pack01;

class School {
    private String name;
    public School(String name) {
        this.name = name;
}
@Override
public boolean equals(Object obj) {
    if (obj instanceof School) {
        School school = (School) obj;
        return this.name == school.name;
    } else {
        return false;
        }
    }
}
public class EqualsEx1 {
    public static void main(String[] args) {
        School sch1 = new School("해피마이스터고");
        School sch2 = new School("해피마이스터고");
        System.out.println("sch1==sch2 : "+(sch1==sch2));
        System.out.println("sch1.equals(sch2): "+sch1.
        equals(sch2));
    }
}

3)getClass() 메소드

참조하고 있는 클래스 정보를 얻기 위해 사용되는 메소드이다.

package pack01;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Rectangle {
    private int width, height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public String toString() {
        return "Rectangle [width=" + width + ", height=" + height + "]";
    }

    public int getArea() {
        return width * height;
    }
}

public class getClassEx {
    public static void main(String[] args) {
        Rectangle p = new Rectangle(2, 3);

        Class clss = p.getClass();

        System.out.println(clss.getName());
        System.out.println(clss.getSuperclass());

        Field field[] = clss.getDeclaredFields();

        System.out.println(
            "field[0] : " + field[0] + "\n" +
            "field[1] : " + field[1]
        );

        Method method[] = clss.getDeclaredMethods();

        System.out.println(
            "method[0] : " + method[0] + "\n" +
            "method[1] : " + method[1]
        );

        System.out.println(p.hashCode());
        System.out.println(p.toString());
        System.out.println(p);
    }
}

Java에서 패키지(Package)는 관련 있는 클래스와 인터페이스를 하나로 묶어 관리하는 공간이다.

쉽게 생각하면 패키지 = 폴더라고 생각하면 이해하기 쉽다.

프로젝트가 커지면 클래스 파일이 많아지기 때문에 패키지를 이용하면 파일을 목적에 따라 나누어 관리할 수 있다.

참고: Java API Documentation

1. 패키지의 기본 구조

패키지에 속한 클래스나 인터페이스는 패키지 이름과 동일한 디렉터리에 저장된다.

예를 들어 다음과 같은 패키지가 있다고 하자.

package com.example.student;

그러면 일반적으로 디렉터리 구조는 다음과 같이 구성된다.

src
└── com
    └── example
        └── student
            ├── Student.java
            └── Score.java

즉

com.example.student

이라는 패키지는 실제 디렉터리에서는

com/example/student

형태로 표현된다.

2. 디렉터리 계층 구조

Java 패키지는 다른 패키지를 포함하는 계층적인 구조로 만들 수 있다.

이때 패키지의 계층은 점(.)으로 구분한다.

예를 들어,

com.example
com.example.student
com.example.teacher

와 같이 사용할 수 있다.

이를 디렉터리 구조로 표현하면 다음과 같다.

com
└── example
    ├── student
    └── teacher

따라서 패키지 이름의 .은 디렉터리의 /와 대응된다고 생각하면 된다.

com.example.student
        ↓
com/example/student

3. package 문

클래스를 특정 패키지에 포함시키려면 클래스 파일의 가장 위쪽에 package를 작성한다.

package com.example.student;

public class Student {

}

이렇게 작성하면 Student 클래스는

com.example.student

패키지에 속하게 된다.

package 선언은 일반적으로 Java 파일의 가장 위쪽에 작성한다.

4. import란?

다른 패키지에 있는 클래스를 사용하려면 import 문을 사용할 수 있다.

import를 사용하면 클래스의 전체 패키지 경로를 매번 작성하지 않고 클래스 이름만으로 사용할 수 있다.

예를 들어 Java에서 자주 사용하는 Scanner 클래스는

java.util.Scanner

패키지에 포함되어 있다.

import를 사용하면 다음과 같이 작성할 수 있다.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
    }
}

import가 없다면 다음처럼 전체 이름을 작성해야 한다.

java.util.Scanner scanner =
    new java.util.Scanner(System.in);

따라서 import를 사용하면 코드가 훨씬 간결해진다.

5. import 사용 방법

import 문은 클래스 선언보다 먼저 작성한다.

기본적인 형태는 다음과 같다.

import 패키지이름.클래스이름;

또는

import 패키지이름.*;

두 가지 방법이 있다.

① 특정 클래스만 import

특정 패키지에서 하나의 클래스만 사용하고 싶다면 클래스 이름까지 작성한다.

import java.util.Scanner;

이제 Scanner를 사용할 때

Scanner scanner = new Scanner(System.in);

처럼 클래스 이름만 작성할 수 있다.

형식

import 패키지이름.클래스이름;

예시

import java.util.ArrayList;

java.util 패키지의 ArrayList만 가져오는 것이다.

② 패키지의 모든 클래스를 import

특정 패키지에 있는 모든 클래스를 클래스 이름만으로 사용하고 싶다면 *을 사용할 수 있다.

import java.util.*;

이렇게 하면 java.util 패키지에 있는 여러 클래스를 사용할 수 있다.

예를 들어,

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
    }
}

위 코드에서는 Scanner와 ArrayList를 모두 클래스 이름만으로 사용할 수 있다.

형식

import 패키지이름.*;

6. import 정리

예를 들어,

import java.util.Scanner;

→ Scanner만 사용

import java.util.*;

→ java.util 패키지의 여러 클래스를 사용할 수 있음

💡 핵심 정리

패키지는 Java에서 클래스와 인터페이스를 묶어서 관리하는 공간이다.

쉽게 말하면,

패키지 = 클래스들을 정리해 놓은 폴더

라고 생각하면 된다.

그리고 다른 패키지의 클래스를 사용할 때는 import를 사용한다.

package
  ↓
클래스들을 그룹으로 관리

import
  ↓
다른 패키지의 클래스를 간편하게 사용

한 줄 정리

package는 클래스를 묶어 관리하기 위한 공간이고, import는 다른 패키지의 클래스를 쉽게 사용하기 위한 문법이다.

final은 한 번 정해진 값을 변경할 수 없도록 만드는 키워드이다.

필드에 final을 붙이면 한 번 값이 할당된 이후에는 다시 값을 변경할 수 없는 상수 필드가 된다.

final 선언

final 필드는 다음과 같은 방법으로 초기화할 수 있다.

• 선언과 동시에 초기화
• 생성자에서 초기화

final int number = 10;

또는 생성자에서 값을 지정할 수도 있다.

class Person {
    final String name;

    Person(String name) {
        this.name = name;
    }
}

final 필드는 한 번 초기화한 후에는 다른 값으로 변경할 수 없다.

number = 20;  // ❌ 컴파일 오류

즉, final은 값이 변경되지 않도록 제한할 때 사용하는 키워드이다.

메소드에 전달되는 인자의 개수가 정해져 있지 않을 때 사용하는 기능이다.

가변인자를 사용하면 같은 타입의 여러 인자를 개수에 상관없이 전달할 수 있다. 선언할 때는 자료형 뒤에 점 세 개(...)를 붙여 사용한다.

void print(int... numbers) {
    // ...
}

가변인자는 메소드 내부에서 배열처럼 사용할 수 있다.

void print(int... numbers) {
    for (int number : numbers) {
        System.out.println(number);
    }
}

따라서 다음과 같이 인자의 개수를 다르게 전달할 수 있다.

print(1);
print(1, 2, 3);
print(1, 2, 3, 4, 5);

단, 하나의 메소드에서는 가변인자를 하나만 사용할 수 있으며, 가변인자는 반드시 매개변수의 가장 마지막에 위치해야 한다.

접근 제어자는 클래스, 변수, 메서드 등에 접근할 수 있는 범위를 제한하는 기능이다. 누가 사용할 수 있는지 권한을 정하는 역할이라고 생각하면 된다. 예를 들어, 게시글을 모든 사람이 볼 수 있게 할지, 작성자만 볼 수 있게 할지 설정하는 것과 비슷한 개념이다.

자바의 접근제어자

접근 범위

public
   ↓
protected
   ↓
default
   ↓
private

위로 갈수록 접근 범위가 넓고, 아래로 갈수록 접근 범위가 좁아진다.

접근 제어자를 사용하는 이유

접근 제어자를 사용하면 외부에서 중요한 데이터를 함부로 수정하는 것을 막을 수 있다. 예를 들어 학생의 점수는 0~100 사이만 저장되어야 한다고 가정해 보자. 접근 제어자가 없다면 외부에서 다음과 같이 잘못된 값을 넣을 수도 있다.

student.score = -10;
student.score = 1000;

이렇게 되면 프로그램의 데이터가 잘못될 수 있다.

반면 private으로 변수를 숨기고 setter 메서드를 통해 값을 변경하면 조건을 검사할 수 있다.

public class Student {

    private int score;   // 외부에서 직접 접근 불가능

    public void setScore(int score) {
        if (score >= 0 && score <= 100) {
            this.score = score;
        }
    }

    public int getScore() {
        return score;
    }
}

이처럼 잘못된 값이 저장되는 것을 방지할 수 있다.

접근 제어자를 사용하지 않았을 때의 문제점

• 외부에서 변수 값을 마음대로 변경할 수 있다.
• 잘못된 데이터가 저장될 수 있다.
• 프로그램의 안정성이 떨어진다.
• 변수에 직접 접근하여 검증(방어) 로직이 무력화된다.

클래스(Class)는 객체를 만들기 위한 설계도(틀)이다.
하나의 클래스로 여러 개의 객체를 생성하여 효율적으로 관리할 수 있다.

클래스 이름 작성 규칙

• 클래스 이름의 첫 글자는 대문자로 작성한다.
• 여러 단어로 이루어진 경우 파스칼 표기법(PascalCase)을 사용한다.

Student
MemberInfo
BankAccount

객체(Object) 생성

객체는 new 키워드를 사용하여 생성한다.

클래스명 객체명 = new 클래스명();

예시

Student st = new Student();

같은 클래스로 여러 개의 객체를 만들 수 있으며, 객체 이름만 다르게 작성하면 된다.

인스턴스 변수(필드)

인스턴스 변수(필드)는 객체가 가지는 고유한 데이터를 저장하는 변수이다.

class Student {
    String name;
    int age;
}

name과 age가 인스턴스 변수(필드)이다.

main 메서드

main() 메서드는 프로그램이 처음 실행되는 시작 메서드이다.

public static void main(String[] args) {

}

main() 메서드 안에서 객체를 생성하고 프로그램을 실행한다.

this 키워드

메서드 안에서 인스턴스 변수를 명확하게 지정할 때 사용

    public class BlackBox{
    String name;
    int price;
    String color;
    void appendname(String name){
        this.name = this.name + name;

    }
}

this.name : 객체가 가지고 있는 인스턴스 변수 (ex.까망이) name : 메서드를 호출할 때 전달받은 매개변수(ex.최신형)

기본 생성자

생성자는 new 키워드를 사용해 객체를 생성할 때 단 한 번 자동으로 실행되는 메서드 초기화 작업을 담당

생성자 생성 규칙

• 생성자의 이름은 클래스 이름과 같아야한다.
• 반환형을 적지 않으며, void도 쓰지 않는다.

사용자 정의 생성자

객체를 생성할 때 값을 함께 넣는다.

생성자간 역할 분리: this()

같은 클래스에 만들어둔 다른 생성자를 호출하는 코드

반드시 생성자의 첫 번째 줄에 위치해야함.

게터와 세터

게터

인스턴스 변수의 값을 가져올 때 사용하는 메서드이다.

세터

인스턴스 변수의 값을 설정할 때 사용하는 메서드이다.

    void setPrice(int price){
        if(price < 100000){
            this.price = 100000;
        }else {
            this.price = price;
        }
}

this 객체의 price에 전달받은 price를 저장해라.

b2.setPrice (-5000)

작성해도 세터가 감지해 최소 가격인 10,000으로 자동 보정

메서드란?

메서드(Method)는 특정 작업을 수행하는 코드의 묶음이다.

프로그램을 기능별로 나누어 작성할 수 있으며, 필요할 때마다 호출하여 재사용할 수 있다.

메서드의 장점

• 코드의 재사용이 가능하다.
• 중복 코드를 줄일 수 있다.
• 프로그램을 더 간결하고 체계적으로 작성할 수 있다.
• 유지보수가 쉬워진다.

메서드 정의하기

메서드는 다음과 같은 형태로 정의한다.

접근제한자 반환형 메서드명() {
    실행할 코드
}

예시

public class Method {

    public static void say() {
        System.out.println("안녕하세요");
    }

    public static void main(String[] args) {

    }
}

코드 설명

• public : 어디서든 접근 가능
• static : 객체를 생성하지 않고 사용할 수 있음
• void : 반환값이 없음
• say() : 메서드 이름

메서드 이름 짓기 규칙

• 소문자로 시작한다.
• 카멜 표기법(Camel Case)을 사용한다.
• 메서드의 기능을 알 수 있는 이름을 사용한다.

예시

printName()
sumNumber()
getScore()

메서드 호출하기

정의한 메서드는 메서드 이름을 이용하여 호출할 수 있다.

public class Method {

    public static void say() {
        System.out.println("안녕하세요");
    }

    public static void main(String[] args) {

        System.out.println("메서드 호출 전");

        say();

        System.out.println("메서드 호출 후");
    }
}

실행 결과

메서드 호출 전
안녕하세요
메서드 호출 후

실행 순서

1. "메서드 호출 전" 출력
2. say() 호출
3. "안녕하세요" 출력
4. main()으로 돌아옴
5. "메서드 호출 후" 출력

메서드의 가장 큰 장점

메서드는 재사용할 수 있다는 것이 가장 큰 장점이다.

예를 들어 같은 문장을 여러 번 출력해야 한다면,

say();
say();
say();

처럼 메서드를 여러 번 호출하면 된다.

같은 코드를 반복해서 작성하지 않아도 되므로 코드가 훨씬 깔끔해진다.

반환값(Return Value)이 있는 메서드

메서드는 작업을 수행한 후 결과를 호출한 곳으로 돌려줄 수 있다.

이때 사용하는 키워드가 return이다.

문법

접근제한자 반환형 메서드명() {
    return 반환값;
}

void와 return

void

void는 반환할 값이 없다는 의미이다.

public static void say() {
    System.out.println("안녕하세요");
}

위 메서드는 화면에 출력만 하고 아무 값도 돌려주지 않는다.

return

return은 메서드의 실행 결과를 호출한 곳으로 반환하는 키워드이다.

public static int add() {
    return 10 + 20;
}

return을 만나면 메서드가 종료되고, 결과값이 호출한 곳으로 전달된다.

반환값이 있는 메서드 예제

public class Method {

    public static int add() {
        return 10 + 20;
    }

    public static void main(String[] args) {

        int result = add();

        System.out.println(result);
    }
}

실행 결과

30

add()가 반환한 값 30이 result에 저장된다.

반환값 활용하기

반환된 값은 변수에 저장하거나 계산에 사용할 수 있다.

int result = add();

System.out.println(result);

System.out.println(add() + 10);

출력 결과

30
40

즉, 반환된 값은 다른 계산에 자유롭게 사용할 수 있다.

Java 메서드 오버로딩(Overloading)

메서드 오버로딩이란?

메서드 이름은 같지만, 매개변수(전달값)의 자료형이나 개수가 다른 메서드를 여러 개 만드는 것을 말한다.

즉, 같은 기능을 수행하지만 전달받는 값이 다를 때 하나의 이름으로 여러 메서드를 정의할 수 있다.

오버로딩 규칙

Math.random()은 0.0 이상 1.0 미만의 실수(double)를 반환한다.

double rand = Math.random();

반환 범위

0.0 <= Math.random() < 1.0

1~6까지의 랜덤 값 만들기

int dice = (int)(Math.random() * 6) + 1;

동작 과정

예를 들어 Math.random()이 0.73을 반환했다고 가정하면,

1. 0.73 × 6 = 4.38
2. (int)로 형변환하면 소수점이 버려져 4
3. +1을 하면 5

즉, 결과는 1~6 사이의 정수가 된다.

범위 변화

10~20까지의 랜덤 값 만들기

공식은 다음과 같다.

int num = (int)(Math.random() * (20 - 10 + 1)) + 10;

일반 공식

(int)(Math.random() * (최대값 - 최소값 + 1)) + 최소값

동작 과정

예를 들어 Math.random()이 0.81을 반환했다고 가정하면,

1. 20 - 10 + 1 = 11
2. 0.81 × 11 = 8.91
3. (int) 형변환 → 8
4. 8 + 10 = 18

따라서 10~20 사이의 정수가 반환된다.

범위 변화

랜덤 범위 공식

(int)(Math.random() * (최대값 - 최소값 + 1)) + 최소값

예시

// 1~100
int num = (int)(Math.random() * 100) + 1;

// 50~100
int num = (int)(Math.random() * (100 - 50 + 1)) + 50;

// 10~20
int num = (int)(Math.random() * (20 - 10 + 1)) + 10;

핵심 포인트

• Math.random()은 0.0 이상 1.0 미만의 실수를 반환한다.
• * (최대값 - 최소값 + 1)로 원하는 범위의 개수를 만든다.
• (int)를 사용하면 소수점이 버려져 정수가 된다.
• 마지막에 + 최소값을 해 원하는 시작 값으로 이동시킨다.

Random 클래스

Random 클래스는 java.util 패키지에 포함되어 있으며, 객체를 생성한 후 랜덤 값을 생성하는 방식이다.

Math.random()과 달리 형변환(casting)이 필요 없고, 원하는 자료형의 값을 바로 얻을 수 있다는 장점이 있다.

import java.util.Random;

Random random = new Random();

1~6까지의 랜덤 값 만들기

int dice = random.nextInt(6) + 1;

동작 과정

nextInt(6)은 0 이상 6 미만의 정수를 반환한다.

즉,

0, 1, 2, 3, 4, 5

여기에 +1을 하면

1, 2, 3, 4, 5, 6

즉, 1~6 사이의 정수가 생성된다.

범위 변화

10~20까지의 랜덤 값 만들기

int num = random.nextInt(11) + 10;

동작 과정

1. 20 - 10 + 1 = 11
2. nextInt(11) → 0 ~ 10
3. +10 → 10 ~ 20

범위 변화

일반 공식

random.nextInt(최대값 - 최소값 + 1) + 최소값

예시

// 1~100
int num = random.nextInt(100) + 1;

// 50~100
int num = random.nextInt(100 - 50 + 1) + 50;

// 10~20
int num = random.nextInt(20 - 10 + 1) + 10;

ThreadLocalRandom

ThreadLocalRandom은 java.util.concurrent 패키지에 포함된 클래스로, 멀티스레드 환경에서 성능이 좋은 랜덤 클래스이다.

객체를 직접 생성하지 않고 current() 메서드를 통해 사용할 수 있다.

import java.util.concurrent.ThreadLocalRandom;

1~6까지의 랜덤 값 만들기

int dice = ThreadLocalRandom.current().nextInt(1, 7);

nextInt(시작값, 끝값)에서 끝값은 포함되지 않는다.

따라서

nextInt(1, 7)

은 1 이상 7 미만, 즉 1~6의 정수를 반환한다.

범위

실수 랜덤 값 만들기

double randDouble = ThreadLocalRandom.current().nextDouble();

반환 범위

0.0 <= 값 < 1.0

즉, Math.random()과 동일하게 0.0 이상 1.0 미만의 실수를 반환한다.

원하는 범위의 정수 만들기

// 10~20
int num = ThreadLocalRandom.current().nextInt(10, 21);

nextInt(10, 21)은

• 시작값(10)은 포함
• 끝값(21)은 포함하지 않으므로

결과는 10~20이 된다.

정리

핵심 포인트

• Random은 nextInt(범위) + 최소값 형태를 사용한다.
• ThreadLocalRandom은 nextInt(최소값, 최대값 + 1) 형태를 사용한다.
• ThreadLocalRandom의 끝값은 포함되지 않는다.

연산자는 데이터를 계산하거나 비교, 논리 판단 등을 수행하기 위해 사용하는 기호이다.

산술 연산자

산술 연산자는 숫자 값을 계산할 때 사용한다.

int a = 10;
int b = 3;

System.out.println(a + b); // 13
System.out.println(a - b); // 7
System.out.println(a * b); // 30
System.out.println(a / b); // 3
System.out.println(a % b); // 1

관계(비교) 연산자

두 값을 비교하여 true 또는 false를 반환한다.

int a = 10;
int b = 20;

System.out.println(a < b);   // true
System.out.println(a == b);  // false
System.out.println(a != b);  // true

논리 연산자

여러 조건을 함께 비교할 때 사용한다.

AND (&&)

두 조건이 모두 true일 때만 true

System.out.println(10 > 5 && 5 > 3); // true

OR (||)

둘 중 하나만 true여도 true

System.out.println(10 > 5 || 5 < 3); // true

NOT (!)

논리값을 반대로 바꾼다.

boolean check = true;

System.out.println(!check); // false

참고

• &&, || : 논리 연산자(주로 사용)
• &, | : 비트 연산자이면서 boolean에서도 사용 가능하지만, 모든 조건을 끝까지 검사한다.

증감 연산자

변수의 값을 1 증가 또는 감소시킨다.

int num = 10;

num++;
System.out.println(num); // 11

num--;
System.out.println(num); // 10

전위형과 후위형

int a = 10;

System.out.println(++a); // 11 (먼저 증가)
System.out.println(a++); // 11 (출력 후 증가)
System.out.println(a);   // 12

비트 연산자

비트를 기준으로 계산하는 연산자이다.

예시

System.out.println(5 & 3); // 1
System.out.println(5 | 3); // 7

대입 연산자

변수에 값을 저장하거나 계산한 결과를 다시 저장한다.

int num = 10;

num += 5; // 15
num -= 3; // 12
num *= 2; // 24

조건(삼항) 연산자

조건에 따라 두 가지 결과 중 하나를 선택한다.

문법

조건 ? 처리1 : 처리2

• 조건이 참(true)이면 처리1
• 조건이 거짓(false)이면 처리2

int score = 80;

String result = score >= 60 ? "합격" : "불합격";

System.out.println(result); // 합격

연산자 우선순위

시험에서 꼭 기억할 핵심

• 산술 연산자는 계산에 사용한다.
• 비교 연산자의 결과는 true 또는 false이다.
• &&는 둘 다 참, ||는 하나만 참이면 참이다.
• !는 논리값을 반대로 바꾼다.
• ++와 --는 값을 1씩 증가·감소시킨다.
• 삼항 연산자는 조건 ? 참 : 거짓 형태이다.
• 연산자 우선순위가 헷갈리면 괄호 ()를 사용하는 것이 가장 안전하다.

2차원 배열이란?

2차원 배열은 행(Row)과 열(Column)로 이루어진 데이터를 저장하는 배열이다.

엑셀의 표나 행렬(Matrix)처럼 데이터를 테이블 형식으로 저장할 수 있는 구조이다.

예를 들어 다음과 같은 표를 2차원 배열로 표현할 수 있다.

배열 선언

2차원 배열은 다음과 같이 선언할 수 있다.

데이터형[][] 배열명;

또는

데이터형 배열명[][];

또는

데이터형[] 배열명[];

세 가지 모두 같은 의미이며, 가장 많이 사용하는 형태는 다음과 같다.

int[][] arr;

배열 생성

배열의 크기를 지정하여 생성한다.

데이터형[][] 배열명 = new 데이터형[행의 개수][열의 개수];

예시

int[][] arr = new int[3][4];

위 코드는

• 행(Row) : 3개
• 열(Column) : 4개

인 2차원 배열을 생성한다.

배열 초기화

배열을 생성하면서 값을 바로 저장할 수도 있다.

int[][] numbers = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

배열의 모습

배열 요소 접근

2차원 배열은

배열명[행][열]

형태로 접근한다.

예시

int num1 = numbers[0][1];

• 첫 번째 행
• 두 번째 열

값은 2이다.

int num2 = numbers[2][3];

• 세 번째 행
• 네 번째 열

값은 12이다.

배열 요소 변경

배열의 특정 값을 다른 값으로 변경할 수 있다.

numbers[1][2] = 10;

변경 전

5  6  7  8

변경 후

5  6 10  8

또 다른 예시

numbers[2][3] = 200;

변경 전

9 10 11 12

변경 후

9 10 11 200

배열의 길이

1. 행(Row)의 개수

int rows = array.length;

예시

int[][] arr = new int[3][4];

System.out.println(arr.length);

출력

3

즉, 행의 개수를 반환한다.

2. 열(Column)의 개수

int cols = array[0].length;

예시

int[][] arr = new int[3][4];

System.out.println(arr[0].length);

출력

4

즉, 첫 번째 행의 열 개수를 반환한다.

2차원 배열 전체 출력

2차원 배열은 보통 중첩 for문을 사용하여 출력한다.

int[][] numbers = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

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

출력 결과

1 2 3
4 5 6
7 8 9

static이란?

static은 클래스(Class)에 속하는 변수나 메서드를 의미한다.

일반 변수(인스턴스 변수)는 객체마다 각각 생성되지만, static 변수는 클래스에 하나만 생성되어 모든 객체가 함께 공유한다.

특징

• 클래스가 메모리에 로딩될 때 한 번만 생성된다.
• 모든 객체(인스턴스)가 하나의 값을 공유한다.
• 객체를 생성하지 않아도 클래스 이름으로 접근할 수 있다.
• 공통으로 사용하는 값을 저장할 때 사용한다.

static 필드 정의

예를 들어 사람(Person) 객체가 생성될 때마다 생성된 사람 수를 세고 싶다면 static 변수를 사용할 수 있다.

public class PersonWithStatic {

    public static int count = 0;
    private String name;

    public PersonWithStatic(String name) {
        this.name = name;
        count++;
    }
}

코드 설명

• count는 static 변수이므로 객체가 아닌 클래스에 하나만 존재한다.
• 객체가 생성될 때마다 생성자에서 count++가 실행된다.
• 따라서 생성된 객체의 개수를 쉽게 확인할 수 있다.

static 필드 접근

public class PersonWithStaticDemo {

    public static void main(String[] args) {

        System.out.println("객체 생성 이전 : " + PersonWithStatic.count);

        PersonWithStatic p1 = new PersonWithStatic("철수");
        PersonWithStatic p2 = new PersonWithStatic("영희");

        System.out.println("객체 생성 이후 : " + PersonWithStatic.count);

        System.out.println(PersonWithStatic.count);
    }
}

실행 결과

객체 생성 이전 : 0
객체 생성 이후 : 2
2

객체로 접근할 수도 있을까?

가능은 하지만 권장되지 않는다.

System.out.println(p1.count);

위 코드는 실행은 되지만 다음과 같은 경고가 발생한다.

"static 필드는 클래스 이름으로 접근하세요."

권장하는 방법은 다음과 같다.

System.out.println(PersonWithStatic.count);

즉, static은 객체가 아니라 클래스의 변수이므로 클래스 이름으로 접근하는 것이 올바른 방법이다.

static을 사용하는 이유

예를 들어 학생 객체를 100개 생성했다고 가정해 보자.

Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();

학생 수를 세는 변수(count)가 일반 변수라면 객체마다 따로 생성된다.

s1.count = 1
s2.count = 1
s3.count = 1

이렇게 되면 전체 학생 수를 알 수 없다.

하지만 static을 사용하면 하나의 변수를 모든 객체가 공유하므로,

Student.count = 3

처럼 전체 객체의 개수를 쉽게 관리할 수 있다.

일반 변수와 static 변수 비교

한 줄 정리

static 필드는 클래스에 하나만 생성되어 모든 객체가 공유하는 변수이다. 객체를 생성하지 않아도 클래스 이름으로 접근할 수 있으며, 공통으로 사용하는 데이터를 저장할 때 사용한다.

• 화면
• 기능
• 데이터

필수 페이지 기능

• 메인 화면
• 입력 화면
• 결과 화면
• 관리자 화면

• 사용자 정보
• 게시글 / 내용
• 점수 / 결과
• 시간 정보
• 이미지

실습 기록

교내 공모전 팀 찾기 프로젝트

클라이언트 단일 파일 / 클라우드 연동 / AI통합 플랫폼

🔬 실습 기록

아스트랄 타로 앱 : https://gemini.google.com/share/79c5d150a2d9?skid=0e595ae4-2f01-4f16-b8f3-5511488ca4d8

깃허브 개발 일지 작성 앱 : https://share.gemini.google/3FDJ4V4sOpw2

공공 데이터를 활용한 자료 시각화 수업 :

💡 입력한 프롬프트

⭐️ 기능 우선 순위 정하기

너는 웹앱 기획을 도와주는 AI야.

나는 HTML 하나의 파일만 사용해서 간단한 웹앱을 만들려고 해.

다음 순서대로 진행해줘.

1. 내 생활이나 관심사에 대해 질문하기

2. 해결하고 싶은 불편함을 함께 찾기

3. 만들 수 있는 웹앱 아이디어를 3개 제안하기

4. 각 아이디어의 장단점을 설명하기

5. 내가 하나를 선택하면 필요한 기능을 우선순위대로 정리하기


아직 코드는 작성하지 말고, 기획 단계까지만 도와줘.

통계 자료 데이터 모음

통계 놀이터: https://padlet.com/2022141037/0713-15-ai-bit-ly-7-bbondytidsazmaf7/wish/pRxDZ4MyxeB3W183

공공데이터포털: https://www.data.go.kr/

국가통계포털: https://kosis.kr/index/index.do

동일한 매소드를 여러 개 선언하는 것

int add(int a, int b){
}

double add(double a, double b){
}

특징

• 메소드 이름은 같음
• 매개변수의 개수 또는 자료형이 달라야 함
• 반환 타입만 다르게 하는 것은 불가능

생성자와 생성자 오버로딩

객체가 생성될 때 호출되는 특별한 메소드

Scanner sc = new Scanner(System.in);

new 클래스이름() 을 사용할 때 생성자가 호출된다.

() <= 매개변수 . (초기화작업)

- 반환 타입 없음 - 단 한 번만 호출 - 메소드 이름은 클래스 이름과 동일

class Person{

    Person(){
        System.out.println("생성자 호출");
    }

}

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

        Person p = new Person();

    }
}

사용하는 이유

객체를 다양한 방법으로 생성하기 위해 사용한다.

객체 지향 프로그래밍 언어에서 클래스의 필드(Field)에 접근하거나 값을 설정하는 데 사용하는 메서드이다.

메서드 이름 규칙

게터(Getter) : get + 파스칼 케이스(PascalCase)로 변환한 필드 이름 세터(Setter) : set + 파스칼 케이스(PascalCase)로 변환한 필드 이름

파스칼 케이스(PascalCase)란?

여러 단어를 이어 붙여 이름을 만들 때 모든 단어의 첫 글자를 대문자로 표기하는 명명 규칙이다.

예시

UserName
PhoneNumber
StudentScore

게터, 세터 이름 짓기 예시

hello

//게터 메서드
getHello()

//세터 메서드
setHello()

예제 코드

package chap2;

class Car {

    String brand;
    String model;
    int year;

    // 게터 메서드 (값을 반환)
    String getBrand() {
        return brand;
    }

    // 세터 메서드 (값을 설정)
    void setBrand(String value) {
        brand = value;
    }
}

설명 getBrand()

brand의 값을 가져온다. return을 사용해 값을 반환한다.

setBrand(String value)

매개변수 value로 전달받은 값을 brand에 저장한다.

예시

Car car = new Car();

car.setBrand("Hyundai");

System.out.println(car.getBrand());

패키지(Package)

패키지는 관련된 클래스들을 묶어서 관리하는 폴더 같은 개념이다.

장점 같은 이름의 클래스 충돌을 방지할 수 있다.

예시

package animal;
class Cat {}

package robot;
class Cat {}

한줄 정리

패키지는 클래스들을 그룹으로 묶어 관리하고, 이름 충돌을 방지하기 위해 사용한다.

동일한 데이터형의 여러 데이터를 하나의 변수에 순서대로 저장하는 선형 데이터 구조이다. 여러 개의 변수를 따로 만들지 않고 하나의 배열 변수로 관리할 수 있다.

1. 배열 선언

배열을 사용하겠다고 미리 선언하는 단계이다.

형식

데이터형[] 배열변수명;
데이터형 배열변수명[];

예시

int[] numbers;

String[] names;

double scores[];

2. 배열 생성

배열이 실제로 저장될 공간(메모리)을 생성하는 단계이다.

new 연산자를 사용한다. new 연산자 : 객체가 저장될 공간을 생성한다.

형식

배열변수명 = new 데이터형[배열의 길이];

예시

int[] numbers;

numbers = new int[5];

→ 정수 5개를 저장할 공간이 생성된다.

초기상태

[0, 0, 0, 0, 0]

3. 배열 초기화

배열을 생성하면서 원하는 값을 바로 넣는 방법이다.

형식

데이터형[] 배열변수명 = {초기값 나열};

예시

int[] numbers = {1, 2, 3, 4, 5};

String[] fruits = {"사과", "바나나", "딸기"};

4. 배열 요소 접근 및 변경

배열은 인덱스(Index) 를 사용하여 각 요소에 접근한다. 배열의 인덱스는 0부터 시작한다.

예시

int[] num = {1, 2, 3, 4, 5};

// 첫 번째 요소 접근
int firstNum = num[0];

// 두 번째 요소 값 변경
num[1] = 100;

결과

{1, 100, 3, 4, 5}

5. 배열의 길이(length)

배열의 길이는 배열 객체의 멤버 변수인 length를 사용한다.

형식

배열변수명.length

예시

int[] numbers = {1, 2, 3, 4, 5};

int length = numbers.length;

결과

length = 5

배열 전체 예제

public class ArrayExample {

    public static void main(String[] args) {

        // 배열 초기화
        int[] numbers = {1, 2, 3, 4, 5};

        // 요소 접근
        int firstNum = numbers[0];

        // 값 변경
        numbers[1] = 100;

        // 배열 길이
        int length = numbers.length;

        System.out.println(firstNum); // 1
        System.out.println(numbers[1]); // 100
        System.out.println(length); // 5
    }
}

한줄정리

배열(Array)은 같은 자료형의 여러 데이터를 하나의 변수에 순서대로 저장하고, 인덱스를 이용해 접근하는 데이터 구조이다.