본문 바로가기
휴먼 IT 교육 수업 메모

[휴먼IT] 휴먼IT 자바 수업 4일차 메모 (예외처리,클래스와 객체) - 250107

by demianpark127 2025. 1. 7.
SMALL

25.01.07

package array;

import java.util.Scanner;

public class array4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("배열의 크기를 입력하시오 >>");
		int size = sc.nextInt();
		int[] intArr = new int[size];
		
		System.out.println("배열에 값을 저장하시오 >>");
		
		int i=0;
		int value;
		while(i<size) { // 배열의 크기까지만 데이터를 저장반복
			System.out.println("값을 입력 >>");
			value = sc.nextInt();
			intArr[i]=value;
			i++;
			if(i==(size-1)) {
				System.out.println("마지막 하나가 남았습니다.");
			}				
		}
		
		sc.close();
		
		//3.전체검색
		System.out.println("저장된 값들입니다....");
		for(int num:intArr) {
			System.out.println(num);
		}
	}

}
배열의 크기를 입력하시오 >>
3
배열에 값을 저장하시오 >>
값을 입력 >>
2
값을 입력 >>
4
마지막 하나가 남았습니다.
값을 입력 >>
5
저장된 값들입니다....
2
4
5

package array;

import java.util.Scanner;

public class array4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("배열의 크기를 입력하시오 >>");
		int size = sc.nextInt();
		int[] intArr = new int[size];
		
		System.out.println("배열에 값을 저장하시오 >>");
		
		int i=0;
		int value;
		while(i<size) { // 배열의 크기까지만 데이터를 저장반복
			System.out.println("값을 입력 >>");
			value = sc.nextInt();
			intArr[i]=value;
			i++;
			if(i==(size-1)) {
				System.out.println("마지막 하나가 남았습니다.");
			}				
		}
		
		sc.close();
		
		//3.전체검색
		System.out.println("저장된 값들입니다....");
		for(int num:intArr) {
			System.out.println(num);
		}
		
		//4. 입력값의 평균을 출력하시오.
		//   -  일반 for를 사용하고 length를 이용해서 평균을 구한다
		
		//5. 입력값의 최소값과 최대값을 구해서 출력하시오.
		int min=1200000000;
		int max = -1200000000;
		for(int j=0; j<intArr.length;j++) {
			
			if(intArr[j]>max) {
				max=intArr[j];
			}
			if(intArr[j]<min) {
				min=intArr[j];
			}
		
		}
		System.out.println("최대값: "+max);
		System.out.println("최소값: "+min);
		
		//6. 정렬		
		int temp = 0;
		for(int j=0; j<intArr.length;i++) {
			for(int k=j+1; k<intArr.length;k++) {
				if(intArr[j] > intArr[k]) {
					temp=intArr[j];
					intArr[j]=intArr[k];
					intArr[k]=temp;
					
				}
			}
		}
		//결과보기
		for(int num:intArr) {
			System.out.println(num+" ");
		}
	}
}
배열의 크기를 입력하시오 >>
6
배열에 값을 저장하시오 >>
값을 입력 >>
75
값을 입력 >>
34
값을 입력 >>
65
값을 입력 >>
24
값을 입력 >>
100
마지막 하나가 남았습니다.
값을 입력 >>
83
저장된 값들입니다....
75
34
65
24
100
83
최대값: 100
최소값: 24
package array;

public class array5 {
	public static void main(String[] args) {
		/*
		 	미션
		 		- 배열을 이용한 회원관리
		 		1. 회원정원수를 입력받는다
		 		2. 회원을 등록한다 - 반복
		 			. 이름		String[] strName
		 			. 나이		int[]	intAge
		 			. 몸무게		float	floatWeight
		 		3. "회원등록을 계속하시겠습니까? (y/n)"
		 				- y: 회원을 등록합니다
		 				- n: 회원등록을 마칩니다
		 		4. 등록된 회원의 이름, 나이, 몸무게를 출력한다
		 		
		 		5. 특정회원의 나이를 임의값으로 수정하세요
		 		6. 수정된 회원만의 내역을 출력한다.
		 		
		 */
	}

}

 

package array;

import java.util.Scanner;

public class ArrayMemberManagement {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 1. 회원 정원 입력
        System.out.print("회원 정원수를 입력하세요: ");
        int capacity = sc.nextInt();
        sc.nextLine(); // 버퍼 비우기

        String[] strName = new String[capacity];
        int[] intAge = new int[capacity];
        float[] floatWeight = new float[capacity];

        int count = 0; // 현재 등록된 회원 수

        // 2. 회원 등록
        while (true) {
            if (count >= capacity) {
                System.out.println("회원 정원이 꽉 찼습니다!");
                break;
            }

            System.out.print("회원 이름: ");
            strName[count] = sc.nextLine();

            System.out.print("회원 나이: ");
            intAge[count] = sc.nextInt();

            System.out.print("회원 몸무게: ");
            floatWeight[count] = sc.nextFloat();
            sc.nextLine(); // 버퍼 비우기

            count++;

            System.out.print("회원등록을 계속하시겠습니까? (y/n): ");
            String choice = sc.nextLine();
            if (choice.equalsIgnoreCase("n")) {
                break;
            }
        }

        // 3. 회원 정보 출력
        System.out.println("\n--- 등록된 회원 목록 ---");
        for (int i = 0; i < count; i++) {
            System.out.println("회원 " + (i + 1) + ": 이름=" + strName[i] + ", 나이=" + intAge[i] + ", 몸무게=" + floatWeight[i]);
        }

        // 4. 특정 회원 나이 수정
        System.out.print("\n나이를 수정할 회원 번호를 입력하세요 (1 ~ " + count + "): ");
        int memberIndex = sc.nextInt() - 1;

        if (memberIndex >= 0 && memberIndex < count) {
            System.out.print("새로운 나이를 입력하세요: ");
            int newAge = sc.nextInt();
            intAge[memberIndex] = newAge;

            System.out.println("\n--- 수정된 회원 정보 ---");
            System.out.println("이름=" + strName[memberIndex] + ", 나이=" + intAge[memberIndex] + ", 몸무게=" + floatWeight[memberIndex]);
        } else {
            System.out.println("잘못된 회원 번호입니다.");
        }

        sc.close();
    }
}
회원 정원수를 입력하세요: 3
회원 이름: Alice
회원 나이: 25
회원 몸무게: 55.5
회원등록을 계속하시겠습니까? (y/n): y
회원 이름: Bob
회원 나이: 30
회원 몸무게: 75.2
회원등록을 계속하시겠습니까? (y/n): n

--- 등록된 회원 목록 ---
회원 1: 이름=Alice, 나이=25, 몸무게=55.5
회원 2: 이름=Bob, 나이=30, 몸무게=75.2

나이를 수정할 회원 번호를 입력하세요 (1 ~ 2): 2
새로운 나이를 입력하세요: 35

--- 수정된 회원 정보 ---
이름=Bob, 나이=35, 몸무게=75.2
package array;

public class array6 {
	public static void main(String[] args) {
	/*
	 	[0][0]
	 	
		[0,0][0,1][0,2][0,3][0,4]
		[1,0][1,1][1,2][1,3][1,4]
		[2,0][2,1][2,2][2,3][2,4]
	*/
		
		//생성
		int[][] intArr = new int[3][5];
		
		//값등록
		intArr[0][0] = 1;
		intArr[0][1] = 2;
		intArr[0][2] = 3;
		intArr[0][3] = 4;
		intArr[0][4] = 5;
		intArr[1][0] = 6;
		intArr[1][1] = 7;
		intArr[1][2] = 8;
		intArr[1][3] = 9;
		intArr[1][4] = 10;
		intArr[2][0] = 11;
		intArr[2][1] = 12;
		intArr[2][2] = 13;
		intArr[2][3] = 14;
		intArr[2][4] = 15;
		
		//읽기
		System.out.println(intArr[2][2]);
		//값수정
		intArr[1][4]=100;
		System.out.println(intArr[1][4]);
		
		//이중배열에서 전체읽기
		for(int i=0;i<intArr.length;i++) {			//행
			for(int j=0;j<intArr[i].length;j++) {	//열
				System.out.println(intArr[i][j]+" ");
			}
			System.out.println();
		}
		
		//확장for
		for(int[] i :intArr) {
			for(int j :i) {
				
			}			
		}
	}

}
package array;

public class array7 {
	public static void main(String[] args) {
		// 생성방법2
		int[][] intArr = new int[3][]; //행까지만생성
		
		//0번행
		intArr[0] = new int[1];
		//1번행
		intArr[1] = new int[3];
		//2번행
		intArr[2] = new int[2];
		
		System.out.println(intArr.length);
		System.out.println(intArr[0].length);
		System.out.println(intArr[1].length);
		System.out.println(intArr[2].length);
	}
}

 

예외처리

ArithmeticExceptopn : 0으로 나눌때

package exception;

import java.util.Scanner;

public class Exception1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("분자를 입력하시오>>");
		int a = sc.nextInt();
		System.out.println("분모를 입력하시오>>");
		int b = sc.nextInt();		
		sc.close();
		
		try {
			System.out.println("결과값: " + (a/b));
			
		} catch (ArithmeticException e) {
			System.out.println("0으로 나눌 수 없습니다.");
		}
	}
}
분자를 입력하시오>>
5
분모를 입력하시오>>
0
0으로 나눌 수 없습니다.
package exception;

public class Exception2 {
	public static void main(String[] args) {
		
		//ArrayIndexOutOfBoundsException : 배열의 크기의 범위를 벗어났을 때
		
		//5개크기의 배열생성
		//String[] strArr = new String[5];
		
		try {
			String[] strArr = new String[5];
			strArr[3] = "100";
			strArr[5] = "2500"; // 오류발생 
			strArr[1] = "100"; // 실행하지 않음
		}catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("배열의 범위를 초과하였습니다.");
		}finally {
			System.out.println("끝났습니다");
		}
	}
}
배열의 범위를 초과하였습니다.
끝났습니다
package exception;

public class exception3 {
	public static void main(String[] args) {
		String[] strNumber = {"23","12","998","3.14"};
		
		try {
			for(int i=0; i<strNumber.length; i++) {
				int j =Integer.parseInt(strNumber[i]);
				System.out.println("숫자로 변환된 값은 : " +j);
			}
			
			int a = 100;
			int b = 0;
			int result = a/b; //ArithmeticException
			
		}catch (NumberFormatException e) {
			System.out.println("정수로 변환할 수 없는 데이터가 존재합니다");
		}catch (ArithmeticException e) {
			System.out.println("0으로 나눌 수 없습니다.");				
		}catch (Exception e) {
			System.out.println("예외가 발생되었습니다.");
		}
		System.out.println("끝났습니다.");
	}
}
package exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class exeption4 {
	
	//예외를 떠넘긴 메소드를 사용하는 쪽에서 try~catch처리
	public void method1() {		
		try {
			method2();
		}catch (Exception e) {
			
		}		
	}
	
	//예외를 떠넘긴 메소드
	public void method2() throws ClassNotFoundException {		
		Class clazz = Class.forName("java.lang.String");
	}
	
	//main메소드	
	public static void main(String[] args) {
		
		try {
			FileInputStream fis = new FileInputStream("./file/A.txt");
			System.out.println("파일을 찾았습니다.");
			
			int c;
			while((c=fis.read()) != -1) {
				System.out.print((char)c);
			}
			fis.close();
		}catch (FileNotFoundException e) {
			System.out.println("파일이 존재하지 않습니다");
		}catch (IOException e) {
			System.out.println("파일을 읽을때 입출력오류가 발생되었습니다.");
		}
				
	}
}

package Class;

class 동물 {
	
	//변수, 멤버변수, 필드
	String str;
	//생성자 - 클래스이름과 동일한 메소드
	동물(String s){
		str = s;
	}
	
	//메소드
	void speaker(String s) {
		System.out.println(s);
	}
}

//실행클래스
public class C1_동물ex {
	public static void main(String[] args) {
		
		//1.객체생성 - 생성자를 이용해서 생성한다
		// 클래스 변수 = new 생성자() ;
		동물 animal = new 동물("야옹이"); // animal
		
		//2. 객체의 멤버변수 읽어오기
		String st = animal.str;
		//3. 객체의 메소드를 가져오기
		animal.speaker("야옹");
		
		C2_붕어빵 파란붕어빵 = new C2_붕어빵("노랑");
			파란붕어빵.앙꼬 = "파란"; //변경
		System.out.println(파란붕어빵.앙꼬);
	}

}

 

package Class;

public class C2_붕어빵 {
	//멤버변수 /필드
	String 앙꼬;
	String 색상;
	
	//생성자
	C2_붕어빵(){} //기본생성자 - 생략가능
	C2_붕어빵(String 앙꼬) {
		this.앙꼬 = 앙꼬;
		System.out.println(this.앙꼬+"붕어빵 입니다");
	}
	
	C2_붕어빵(String 앙꼬, String 색상){
		this.앙꼬 = 앙꼬;
		this.색상 = 색상;		
	}
}
야옹
노랑붕어빵 입니다
파란

📝 자바 객체지향 프로그래밍(OOP: Object-Oriented Programming)

**객체지향 프로그래밍(Object-Oriented Programming, OOP)**은 **객체(Object)**를 중심으로 설계 및 개발하는 프로그래밍 패러다임입니다. 자바는 대표적인 객체지향 프로그래밍 언어로, 현실 세계의 사물과 개념을 객체로 모델링하여 소프트웨어를 개발합니다.

📚 1. 객체지향 프로그래밍의 핵심 개념

🔹 1.1 클래스(Class)

  • 설명: 클래스는 객체를 생성하기 위한 설계도입니다.
  • 예시: Car, Person, Animal
  • 구성 요소:
    • 필드(Field): 객체의 상태를 나타내는 변수
    • 메서드(Method): 객체의 동작을 정의
    • 생성자(Constructor): 객체를 초기화

예시:

class Car {
    String model;
    int speed;

    void accelerate() {
        speed += 10;
    }
}

🔹 1.2 객체(Object)

  • 설명: 객체는 클래스로부터 생성된 **인스턴스(Instance)**입니다.
  • 특징:
    • 상태(State): 객체가 가지고 있는 데이터 (예: 색상, 속도)
    • 행동(Behavior): 객체가 할 수 있는 동작 (예: 가속, 감속)
  • 예시: 
Car car1 = new Car();
car1.model = "Tesla";
car1.accelerate();

🔹 1.3 캡슐화(Encapsulation)

  • 설명: 객체의 속성과 행위를 하나로 묶고, 데이터의 접근을 제한하는 기술입니다.
  • 목적: 데이터 보호 및 객체의 무결성 유지
  • 방법: private 접근 제어자 사용, getter와 setter 메서드 제공

예시:

class Person {
    private String name;

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

    public String getName() {
        return name;
    }
}

🔹 1.4 상속(Inheritance)

  • 설명: 기존 클래스(부모 클래스)의 특성을 새로운 클래스(자식 클래스)가 상속받아 사용할 수 있게 하는 기능입니다.
  • 목적: 코드 재사용성 증가, 유지보수 용이
  • 키워드: extends

예시: 

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

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

🔹 1.5 다형성(Polymorphism)

  • 설명: 하나의 인터페이스나 부모 클래스를 통해 여러 형태의 객체를 다룰 수 있는 기능입니다.
  • 목적: 유연한 코드 작성, 유지보수 편의성
  • 종류:
    • 오버로딩(Overloading): 같은 이름의 메서드를 매개변수로 구분
    • 오버라이딩(Overriding): 부모 클래스의 메서드를 자식 클래스에서 재정의

예시:

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

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound();  // "Woof"
    }
}

🔹 1.6 추상화(Abstraction)

  • 설명: 불필요한 부분은 숨기고 중요한 부분만 보여주는 기법입니다.
  • 방법:
    • 추상 클래스(Abstract Class): abstract 키워드 사용
    • 인터페이스(Interface): interface 키워드 사용

예시: 

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

📚 2. 객체지향 프로그래밍의 4대 특징

 

특징 설명 키워드
캡슐화 데이터 보호 및 무결성 유지 private, getter/setter
상속 코드 재사용성 증가 및 확장성 제공 extends
다형성 하나의 인터페이스로 다양한 객체 사용 Overriding, Overloading
추상화 핵심 기능만 노출, 복잡성 감소 abstract, interface

 

📚 3. 객체지향 프로그래밍의 장점

  1. 재사용성 (Reusability)
    • 이미 작성된 코드를 재사용할 수 있습니다.
  2. 유지보수성 (Maintainability)
    • 수정 및 관리가 용이합니다.
  3. 확장성 (Scalability)
    • 새로운 기능을 쉽게 추가할 수 있습니다.
  4. 보안성 (Security)
    • 데이터 은닉과 접근 제어로 보안을 강화합니다.
  5. 유연성 (Flexibility)
    • 다형성으로 다양한 객체를 유연하게 사용할 수 있습니다.

📚 4. 객체지향 설계 원칙 (SOLID)

  1. S - 단일 책임 원칙 (Single Responsibility Principle)
  2. O - 개방-폐쇄 원칙 (Open/Closed Principle)
  3. L - 리스코프 치환 원칙 (Liskov Substitution Principle)
  4. I - 인터페이스 분리 원칙 (Interface Segregation Principle)
  5. D - 의존관계 역전 원칙 (Dependency Inversion Principle

📚 5. 객체지향 프로그래밍 예제

class Person {
    private String name;

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

    public void introduce() {
        System.out.println("Hello, my name is " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        p1.introduce();
    }
}
Hello, my name is Alice

1. 객체와 클래스에 대한 설명으로 틀린 것은 무엇입니까?

  1. 클래스는 객체를 생성하기 위한 설계도(청사진)와 같은 것이다.
  2. new 연산자로 클래스의 생성자를 호출함으로써 객체가 생성된다.
  3. 하나의 클래스로 하나의 객체만 생성할 수 있다.
  4. 객체는 클래스의 인스턴스이다.

정답: ③
해설: 하나의 클래스로 여러 개의 객체를 생성할 수 있습니다. 따라서 '하나의 클래스로 하나의 객체만 생성할 수 있다'는 설명은 잘못되었습니다.

2. 클래스의 구성 멤버가 아닌 것은 무엇입니까?

  1. 필드 (field)
  2. 생성자 (constructor)
  3. 메소드 (method)
  4. 로컬 변수 (local variable)

정답: ④
해설: 로컬 변수는 메소드 내부에서 선언되고 사용되며, 클래스의 멤버가 아닙니다.

3. 필드, 생성자, 메소드에 대한 설명으로 틀린 것은 무엇입니까?

  1. 필드는 객체의 데이터를 저장한다.
  2. 생성자는 객체의 초기화를 담당한다.
  3. 메소드는 객체의 동작 부분으로, 실행 코드를 가지고 있는 블록이다.
  4. 클래스는 반드시 필드와 메소드를 가져야 한다.

정답: ④
해설: 클래스는 필드와 메소드를 반드시 가져야 하는 것은 아닙니다. 비어 있는 클래스도 존재할 수 있습니다.

4. 필드에 대한 설명으로 틀린 것은 무엇입니까?

  1. 필드는 메소드에서 사용할 수 있다.
  2. 인스턴스 필드 초기화는 생성자에서 할 수 있다.
  3. 필드는 반드시 생성자 선언 전에 선언되어야 한다.
  4. 필드는 초기값을 주지 않더라도 기본값으로 자동 초기화된다.

정답: ①
해설: 필드는 메소드 내에서 선언되거나 사용할 수 없습니다. 필드는 클래스 수준에서 선언됩니다.

5. 생성자에 대한 설명으로 틀린 것은 무엇입니까?

  1. 객체를 생성하려면 생성자 호출이 반드시 필요한 것은 아니다.
  2. 생성자는 다른 생성자를 호출하기 위해 this()를 사용할 수 있다.
  3. 생성자가 선언되지 않으면 컴파일러가 기본 생성자를 추가한다.
  4. 외부에서 객체를 생성할 수 없도록 생성자에 private 접근 제한자를 붙일 수 있다.

정답: ④
해설: private 접근 제한자를 사용하면 외부에서 객체를 직접 생성할 수 없지만, 이는 싱글톤 패턴과 같은 특정 디자인 패턴에서 사용됩니다. 그러나 객체 생성 자체가 불가능한 것은 아닙니다.

 

6. 메소드에 대한 설명으로 틀린 것은 무엇입니까?

  1. 리턴값이 없는 메소드는 리턴 타입을 void로 해야 한다.
  2. 리턴 타입이 있는 메소드는 리턴값을 지정하기 위해 반드시 return 문이 있어야 한다.
  3. 매개값의 수를 모를 경우 ...를 이용해서 매개변수를 선언할 수 있다.
  4. 메소드의 이름은 중복해서 선언할 수 없다.

정답: ④
해설: 메서드의 이름은 오버로딩을 통해 중복해서 선언할 수 있습니다. 단, 매개변수의 타입, 수, 순서가 달라야 합니다.

7. 메소드 오버로딩에 대한 설명으로 틀린 것은 무엇입니까?

  1. 동일한 이름의 메소드를 여러 개 선언하는 것을 말한다.
  2. 반드시 리턴 타입이 달라야 한다.
  3. 매개변수의 타입, 수, 순서를 다르게 선언해야 한다.
  4. 매개값의 타입 및 수에 따라 호출될 메소드가 선택된다.

정답: ②
해설: 오버로딩에서는 리턴 타입은 고려 대상이 아닙니다. 매개변수의 타입, 수, 순서만 다르면 같은 이름의 메서드를 여러 개 선언할 수 있습니다.

8. 인스턴스 멤버와 정적 멤버에 대한 설명으로 틀린 것은 무엇입니까?

  1. 정적 멤버는 static으로 선언된 필드와 메소드를 말한다.
  2. 인스턴스 필드는 생성자 및 정적 블록에서 초기화될 수 있다.
  3. 정적 필드와 정적 메소드는 객체 생성 없이 클래스를 통해 접근할 수 있다.
  4. 인스턴스 필드와 메소드는 객체를 생성하고 사용해야 한다.

정답: ②
해설: 인스턴스 필드는 생성자에서만 초기화될 수 있습니다. 정적 블록에서 인스턴스 필드를 초기화할 수 없습니다.

9. final 필드와 상수(static final)에 대한 설명으로 틀린 것은 무엇입니까?

  1. final 필드와 상수는 초기값이 지정되면 값을 변경할 수 없다.
  2. final 필드와 상수는 생성자에서 초기화될 수 있다.
  3. 상수의 이름은 대문자로 작성하는 것이 관례이다.
  4. 상수는 객체 생성 없이 클래스를 통해 사용할 수 없다.

정답: ④
해설: static final로 선언된 상수는 객체 생성 없이 클래스 이름을 통해 접근할 수 있습니다.

10. 패키지에 대한 설명으로 틀린 것은 무엇입니까?

  1. 패키지는 클래스를 그룹화시키는 기능을 한다.
  2. 클래스가 패키지에 속하려면 패키지 선언을 반드시 해야 한다.
  3. import 문은 다른 패키지의 클래스를 사용할 때 필요하다.
  4. com.mycom 패키지에 속한 클래스는 com.yourcom에 옮겨 놓아도 동작한다.

정답: ④
해설: 클래스가 속한 패키지는 코드 내 package 선언에 따라 결정되므로 물리적으로 파일 위치를 옮긴다고 패키지가 변경되지 않습니다. 그러나 참조하는 위치와 클래스 경로가 일치해야 합니다.

LIST

'휴먼 IT 교육 수업 메모' 카테고리의 다른 글

[휴먼IT] 휴먼IT 자바 수업 6일차 메모 (상속) 250109  (1) 2025.01.09
[휴먼IT] 휴먼IT JAVA 5일차 수업 메모 (상속) -250108  (0) 2025.01.08
[휴먼IT] 자바 수업 3일차 메모 (반복문,배열)  (0) 2025.01.06
[휴먼IT] JAVA 수업 2일차 메모 (250103)  (0) 2025.01.03
[휴먼IT] 자바 수업 1일차 메모 (250102)  (0) 2025.01.02

관련글

티스토리툴바