이번 글에서는 클래스의 객체를 생성한 뒤,
객체의 필드 값을 직접 대입하고 출력해보는 실습을 진행합니다.
이 과정을 통해 객체의 속성(상태)을 설정하고 사용하는 기본적인 방법을 이해할 수 있습니다.

📦 클래스 코드 (Car.java)

package ch06.sec06.exam02;

class Car {
	String company;
	String model;
	String color;
	int maxspeed;
	int speed;
}

📌 실행 코드 (CarExample.java)

package ch06.sec06.exam02;

public class CarExample {
	public static void main(String[] args) {
		Car car = new Car();

		car.company = "현대자동차";
		car.model = "그랜저";
		car.color = "검정";
		car.maxspeed = 350;

		System.out.println("company : " + car.company);
		System.out.println("model : " + car.model);
		System.out.println("color : " + car.color);
		System.out.println("maxspeed : " + car.maxspeed);
		System.out.println("speed : " + car.speed);

		car.speed = 60;
		System.out.println("new speed : " + car.speed);
	}
}

💬 코드 설명

• Car car = new Car();
  → Car 클래스의 인스턴스 생성
• car.필드명 = 값;
  → 필드 값을 직접 대입하여 객체의 상태 설정
• System.out.println(...)
  → 필드 값 확인 출력
• car.speed = 60;
  → 기존 기본값 0이었던 속도를 사용자가 설정한 값(60) 으로 변경

💻 실행 결과

company : 현대자동차
model : 그랜저
color : 검정
maxspeed : 350
speed : 0
new speed : 60

📌 간단 정리

💡 포인트 정리

• 객체를 생성한 후, 필드에 직접 값을 할당할 수 있다
• 필드는 클래스의 속성(데이터) 역할을 하며, 객체의 상태를 나타낸다
• 기본값을 그대로 둘 수도 있고, 후에 변경도 가능
• 객체는 **상태(필드) + 동작(메서드)**로 구성됨 → 이번엔 상태에 집중

이번 글부터는 자바의 객체지향 프로그래밍(OOP)의 핵심 요소인
클래스와 객체 생성을 배우게 됩니다.
클래스를 통해 속성(필드)을 정의하고,
객체를 생성한 뒤 초기 상태의 값을 확인하는 기본 구조를 학습합니다.

📦 클래스 코드 (Car.java)

package ch06.sec06.exam01;

public class Car {
	String model;
	boolean start;
	int speed;
}

📌 실행 코드 (CarExample.java)

package ch06.sec06.exam01;

public class CarExample {
	public static void main(String[] args) {
		Car car = new Car();

		System.out.println("model : " + car.model);
		System.out.println("start : " + car.start);
		System.out.println("speed : " + car.speed);
	}
}

💬 코드 설명

• Car 클래스
  → model, start, speed라는 3개의 필드(멤버 변수) 정의
  → 데이터 타입은 각각 String, boolean, int
• Car car = new Car();
  → Car 클래스의 객체(인스턴스) 생성
• 각 필드 값 출력
  → 초기화하지 않은 경우에도 자바는 기본값을 자동으로 할당

💻 실행 결과

model : null
start : false
speed : 0

📌 필드의 기본값

💡 포인트 정리

• 클래스는 객체의 설계도, 객체는 클래스를 기반으로 생성된 실체
• 필드는 객체가 가지는 데이터(속성)
• 객체를 new로 생성하면 필드들은 자동으로 기본값으로 초기화
• 초기값을 따로 설정하지 않아도 출력 가능하지만, 보통은 생성자나 메서드로 초기화함

✅ 오전 수업 요약

1. 문자열 참조 비교 (== vs .equals())

strArray[0] = "Java";
strArray[2] = new String("Java");

• == : 주소(참조) 비교
• .equals() : 문자열 내용 비교
• 결과:
  • strArray[0] == strArray[1] → true
  • strArray[0] == strArray[2] → false
  • strArray[0].equals(strArray[2]) → true

2. 향상된 for문 (for-each)

int[] x = {95, 71, 84, 93, 87};
for (int y : x) sum += y;

• 배열 전체 반복을 간단하게
• 평균 계산 실습

3. main 메서드의 인자 사용 (args[])

String str1 = args[0];
int num1 = Integer.parseInt(str1);

• 실행 시 인자 2개 필요
• 두 정수의 합 계산 및 출력
• 입력값 없을 경우 종료 처리

✅ 오후 수업 요약 (실습 중심)

1. mission6 - 2차원 배열 구조 확인

static void mission6() {
		int[][] array = { { 95, 86 }, { 83, 92, 96 }, { 78, 83, 93, 87, 88 } };

		System.out.println("배열의 줄 : " + array.length);
		for (int i = 0; i < array.length; i++)
			System.out.println((i + 1) + "번째 배열의 칸 : " + array[i].length);

	}

int[][] array = { {95, 86}, {83, 92, 96}, {78, 83, 93, 87, 88} };

• .length로 줄(행) 수와 칸(열) 수 확인
• 출력 예:

배열의 줄 : 3
1번째 배열의 칸 : 2

2. mission7 - 최대값 구하기

static void mission7() {
		int array[] = { 1, 5, 3, 8, 2 }, max = 0;

		for (int num : array)
			if (num > max)
				max = num;

		System.out.println("max num : " + max);
	}

int[] array = {1, 5, 3, 8, 2};

• 향상된 for문 사용
• 조건문으로 최대값 판별

3. mission8 - 2차원 배열 총합 및 평균

static void mission8() {
		int array[][] = { { 95, 86 }, { 83, 92, 96 }, { 78, 83, 93, 87, 88 } }, sum = 0, count = 0;

		for (int i = 0; i < array.length; i++) {
			count += array[i].length;
			for (int j = 0; j < array[i].length; j++)
				sum += array[i][j];
		}

		System.out.println("점수의 전체 합 : " + sum);
		System.out.println("점수 전체의 평균 : " + (double) sum / count);
	}

• 합산 및 요소 수 카운트 → 평균 출력

sum += array[i][j];
count += array[i].length;

4. mission9 - 학생 점수 관리 프로그램

static void mission9() {
		Scanner sc = new Scanner(System.in);
		String str;
		int count = 0, scores[] = null, sum = 0;

		while (true) {
			System.out.println("-".repeat(40));
			System.out.println("1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료");
			System.out.println("-".repeat(40));
			System.out.print("선택> ");
			str = sc.nextLine();

			if (str.equals("1")) {
				System.out.print("학생수> ");
				str = sc.nextLine();
				count = Integer.parseInt(str);
				scores = new int[count];
			} else if (str.equals("2")) {
				if (scores == null) {
					System.out.println("현재 정해진 학생 수가 없습니다.");
					continue;
				}

				for (int i = 0; i < scores.length; i++) {
					System.out.print("scores[" + i + "]>");
					str = sc.nextLine();
					count = Integer.parseInt(str);
					scores[i] = count;
				}
			} else if (str.equals("3")) {
				for (int i = 0; i < scores.length; i++)
					System.out.println("scores[" + i + "] : " + scores[i]);
			} else if (str.equals("4")) {
				for (int i : scores) {
					if (i > count)
						count = i;
					sum += i;
				}

				System.out.println("최고 점수 : " + count);
				System.out.println("평균 점수 : " + (double) sum / scores.length);
			} else if (str.equals("5"))
				break;
		}

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

• 메뉴 기능 구성:
  1. 학생 수 설정
  2. 점수 입력
  3. 점수 출력
  4. 최고 점수 및 평균 분석
  5. 종료
• 입력/출력 및 예외 처리 포함

🧠 9일차 핵심 요약표

이번 글에서는 자바 애플리케이션 실행 시 외부에서 값을 입력받는 방식인
main 메서드의 매개변수 String[] args를 사용해 명령행 인자를 처리하는 방법을 학습합니다.
실행 시 입력값을 활용하여 유연한 프로그램을 만드는 기초가 됩니다.

📌 예제 코드

public class MainStringArrayArgument {
	public static void main(String[] args) {
		if (args.length != 2) {
			System.out.println("프로그램 입력값 부족");
			System.exit(0);
		}

		String str1 = args[0], str2 = args[1];

		int num1 = Integer.parseInt(str1), num2 = Integer.parseInt(str2);
		int sum = num1 + num2;
		System.out.println(num1 + " + " + num2 + " = " + sum);
	}
}

💬 코드 설명

• String[] args
  → 프로그램 실행 시 외부에서 전달되는 문자열 배열
  → 입력값이 없으면 args.length == 0
• args.length != 2
  → 인자가 2개가 아닐 경우 오류 메시지 출력 후 프로그램 종료
• args[0], args[1]
  → 입력값 2개를 문자열로 받아서 각각 저장
• Integer.parseInt()
  → 문자열을 정수로 변환
• System.exit(0)
  → 프로그램 즉시 종료

💻 실행 예시 (명령행 입력)

> java MainStringArrayArgument 10 20
10 + 20 = 30

→ 인자가 2개이므로 정상 실행됨

> java MainStringArrayArgument 10
프로그램 입력값 부족

→ 인자가 1개이므로 종료됨

📌 간단 정리

💡 포인트 정리

• main(String[] args)는 외부에서 실행 시 데이터를 입력받을 수 있도록 설계된 구조
• args.length를 활용해 입력값 유무를 검증해야 함
• 숫자 입력은 반드시 parseInt() 등으로 형변환 필요
• System.exit(0)은 정상 종료, System.exit(1)은 오류 종료로 사용 가능

이번 글에서는 문자열을 배열로 선언한 후,
==(참조 비교) 와 .equals()(내용 비교) 의 차이를 직접 확인합니다.
특히 new String() 으로 생성된 문자열과 리터럴로 초기화된 문자열은 메모리 구조에서 차이가 나므로
비교 연산자 사용 시 주의가 필요합니다.

📌 예제 코드

public class ArrayReferenceObjectExample {
	public static void main(String[] args) {
		String[] strArray = new String[3];
		strArray[0] = "Java";
		strArray[1] = "Java";
		strArray[2] = new String("Java");

		System.out.println(strArray[0] == strArray[1]);
		System.out.println(strArray[0] == strArray[2]);
		System.out.println(strArray[0].equals(strArray[2]));
	}
}

💬 코드 설명

• strArray[0] = "Java";
  → 문자열 리터럴 "Java"를 저장 (상수 풀에 등록됨)
• strArray[1] = "Java";
  → 동일한 리터럴이므로 strArray[0]과 같은 객체를 참조
• strArray[2] = new String("Java");
  → "Java"와 같은 내용을 가지지만, 새로운 객체를 생성함
• ==
  → 참조가 같은지 비교 (메모리 주소 비교)
• .equals()
  → 문자열의 실제 내용이 같은지 비교

💻 실행 결과

true
false
true

📌 간단 정리

💡 포인트 정리

• "문자열" 리터럴은 상수 풀에 저장, 동일 리터럴은 같은 참조를 공유
• new String("문자열")은 항상 새로운 객체를 생성
• ==는 참조 비교 (주소 비교)
  → 객체가 같은 메모리를 참조하는가
• .equals()는 내용 비교
  → 문자열 값 자체가 같은가

🕘 오전 수업 요약

✅ 배열 생성과 기본값 확인

• new 키워드를 사용해 int[], double[], String[] 배열 생성
• 기본값:
  • int → 0
  • double → 0.0
  • String → null

✅ 배열 값 할당 및 출력

• 인덱스를 이용해 값 저장 및 출력

arr1[0] = 10; arr2[1] = 0.2; array[2] = "3월";

✅ 배열의 길이 활용 (.length)

• 반복문에 배열 길이 활용 (for (int i = 0; i < arr.length; i++))
• 총합과 평균 계산 실습

🕐 오후 수업 요약

✅ 1. 2차원 배열 생성과 값 출력 (MulltidimensionalArrayByValueListExample)

• 중첩 배열 사용: int[][] scores = { {80,90}, {76,88}, ... }
• 반별 점수 출력과 평균 계산
• 전체 학생 수 집계와 전체 평균 계산

System.out.println("scores[" + i + "][" + j + "] : " + scores[i][j]);

✅ 2. 고정형 2차원 배열 (MultidimensionalArrayByNewExample)

• new int[2][3] → 2행 3열 배열 생성
• 모든 요소 출력 후 값 입력, 평균 계산

✅ 3. 가변형 2차원 배열

• 행마다 열 개수가 다른 배열 구조

int[][] eng = new int[2][];
eng[0] = new int[2];
eng[1] = new int[3];

• 각각의 행에 점수 대입 후 전체 평균 계산

📌 8일차 핵심 요약

이번 글에서는 new 키워드를 사용하여 2차원 배열을 생성하는 방법을 익히고,
고정형 2차원 배열과 가변형 2차원 배열의 차이를 비교합니다.
또한 수학과 영어 점수를 배열로 관리하며, 전체 평균을 계산해보는 예제를 작성합니다.

📌 예제 코드

public class MultidimensionalArrayByNewExample {
	public static void main(String[] args) {
		int[][] math = new int[2][3];
		for (int i = 0; i < math.length; i++)
			for (int j = 0; j < math[i].length; j++)
				System.out.println("math[" + i + "][" + j + "] : " + math[i][j]);

		math[0][0] = 80; math[0][1] = 83; math[0][2] = 85;
		math[1][0] = 86; math[1][1] = 90; math[1][2] = 92;

		int stu = 0, sum = 0;
		for (int i = 0; i < math.length; i++) {
			stu += math[i].length;
			for (int j = 0; j < math[i].length; j++)
				sum += math[i][j];
		}
		System.out.println("전체 학생의 수학 평균 점수 : " + (double) sum / stu + "\n");

		int[][] eng = new int[2][];
		eng[0] = new int[2];
		eng[1] = new int[3];

		for (int i = 0; i < eng.length; i++)
			for (int j = 0; j < eng[i].length; j++)
				System.out.println("eng[" + i + "][" + j + "] : " + eng[i][j]);

		eng[0][0] = 90; eng[0][1] = 91;
		eng[1][0] = 92; eng[1][1] = 93; eng[1][2] = 94;

		stu = sum = 0;
		for (int i = 0; i < eng.length; i++) {
			stu += eng[i].length;
			for (int j = 0; j < eng[i].length; j++)
				sum += eng[i][j];
		}
		System.out.println("전체 학생의 영어 평균 점수 : " + (double) sum / stu + "\n");	
	}
}

💬 코드 설명

🟢 수학(math) 배열 – 고정형

• int[][] math = new int[2][3];
  → 2행 3열의 고정형 2차원 배열 생성
• 모든 요소는 초기값 0으로 채워짐
• 각 인덱스에 점수를 수동 입력한 후 평균 계산

🔵 영어(eng) 배열 – 가변형

• int[][] eng = new int[2][];
  → 2행만 생성한 뒤, 각 행에 다른 열 길이를 개별 설정
  • eng[0] = new int[2]; → 2열
  • eng[1] = new int[3]; → 3열
• 가변 구조이므로 행마다 학생 수가 달라도 가능

💻 실행 결과 (요약)

math[0][0] : 0
math[0][1] : 0
math[0][2] : 0
...
전체 학생의 수학 평균 점수 : 84.33333333333333

eng[0][0] : 0
eng[0][1] : 0
...
전체 학생의 영어 평균 점수 : 92.0

📌 간단 정리

💡 포인트 정리

• new int[행][열] → 고정형 2차원 배열
• new int[행][] → 가변형 2차원 배열
• 배열의 길이는 .length로 확인 (각 행도 .length 사용 가능)
• 평균 계산 시 학생 수(stu) 누적 후 (double) sum / stu로 계산
• 초기값은 기본형: 0, 참조형: null

이번 강의에서는 2차원 배열을 값 목록으로 초기화하고,
각 반별 평균과 전체 평균을 계산하는 프로그램을 작성해봅니다.
2차원 배열은 행과 열 구조로 구성되며,
각 배열의 길이는 .length 속성으로 확인할 수 있습니다.

📌 예제 코드

public class MulltidimensionalArrayByValueListExample {
	public static void main(String[] args) {
		int scores[][] = {
			{ 80, 90, 96 },
			{ 76, 88 },
			{ 80, 90, 55 },
			{ 50, 60, 70, 80 }
		};

		System.out.println("1차원 배열 길이(전체 반의 수) : " + scores.length);
		for (int i = 0; i < scores.length; i++) {
			System.out.println("2차원 배열 길이( " + (i + 1) + "번째 반의 학생 수) : " + scores[i].length);
			for (int j = 0; j < scores[i].length; j++)
				System.out.println("scores[" + (i + 1) + "][" + (j + 1) + "] : " + scores[i][j]);
		}

		int sum = 0, allSum = 0, pCount = 0;
		for (int i = 0; i < scores.length; i++) {
			for (int j = 0; j < scores[i].length; j++, pCount++)
				sum += scores[i][j];
			System.out.println((i + 1) + "반의 평균 점수 : " + (double) sum / scores[i].length);
			allSum += sum;
			sum = 0;
		}
		System.out.println("전체 학생의 평균 : " + (double) allSum / pCount);
	}
}

💬 코드 설명

• int[][] scores = { ... };
  → 2차원 배열 선언과 값 목록으로 초기화
  → 각 반마다 학생 수가 다름 → 가변 배열
• scores.length
  → 반의 개수 (1차원 배열 길이)
• scores[i].length
  → 해당 반의 학생 수 (2차원 배열의 각 행 길이)
• sum += scores[i][j]
  → 한 반의 점수 합계 계산
• (double) sum / scores[i].length
  → 각 반의 평균 계산
• allSum, pCount
  → 전체 점수 합과 전체 학생 수를 누적 → 마지막에 전체 평균 계산

💻 실행 결과 (예시)

1차원 배열 길이(전체 반의 수) : 4
2차원 배열 길이( 1번째 반의 학생 수) : 3
scores[1][1] : 80
scores[1][2] : 90
scores[1][3] : 96
2차원 배열 길이( 2번째 반의 학생 수) : 2
scores[2][1] : 76
scores[2][2] : 88
...

1반의 평균 점수 : 88.66666666666667
2반의 평균 점수 : 82.0
3반의 평균 점수 : 75.0
4반의 평균 점수 : 65.0
전체 학생의 평균 : 77.875

📌 간단 정리

💡 포인트 정리

• 2차원 배열은 [행][열] 구조, 각 행의 길이는 서로 다를 수 있음
• 배열.length는 1차원 배열(반 수)
  배열[i].length는 각 행의 길이(학생 수)
• 반복문 중첩 시 반복 기준을 .length로 설정하면 유지보수에 유리
• 전체 평균 = 총합 ÷ 총 학생 수 → 따로 누적 변수 필요