자바의 모듈

1. Java의 모듈

1. 개념

   • Java 9부터 도입된 기능
   • 애플리케이션을 작은 단위로 나누고 관리하여 코드의 구조화와 유지 보수성을 높인다
   • 관련된 코드, 리소스 및 설정을 하나로 묶어서 외부에 공개하거나 숨길 수 있다

2. 특징

1. 모듈정의

- module-info.java 파일을 사용하여 모듈을 정의
- 모듈 이름, 의존 모듈, 내보낼 패키지 등의 정보가 포함된다

2. 명시적 의존관리

- 다른 모듈에 대한 의존성을 명시적으로 선언할 수 있다
- 이를 통해 모듈 간의 의존성을 명확하게 관리 가능

3. 캡슐화

- 자신이 내보내는 패키지 외에는 다른 모듈에서 접근할 수 없다
- 이를 통해 코드의 무결성과 보안을 강화

4. 모듈 경로

- 모듈 경로를 사용하여 애플리케이션 실행 시 필요한 모듈을 지정
- 이는 클래스 경로보다 모듈화된 방식으로 라이브러리와 애플리케이션을 관리할 수 있다

• java.api 사이트 이용
  • https://docs.oracle.com/javase/8/docs/api/
• 클래스 선언부 보기
  • 모든 class는 object class를 상속(object class가 최상위) 받음
• 필드보기
  • SUMMARY Field 링크
• 생성자 보기
  • SUMMARY Constructor 링크
• 메소드 보기
  • SUMMARY Method 링크

패키지	용도	예시
java.lang	자바 언어의 기본 클래스 제공	Object, String, System, Integer, Doblue, Exception, TUntimeExcaption
java.utill	자료 구조와 관련된 컬렉션 클래스를 제공	Scanner, ArrayList, HashMap, Collections
java.time	날짜 및 시간을 조작하거나 연산하는 클래스를 제공	LocalDate, LocalTime, LocalDateTime, Duration, Period
java.io	입출력 스트림 클래스를 제공	File, FileReader, FileWriter, BufferedReader, InputStream, OutputStream
java.net	네트워크 통신과 관련된 클래스를 제공	URL, URLConnection, Socket, ServerSocket, InetAddress

• java.lang 패키지에 포함된 주요 클래스와 용도

• String에 String(문자열 저장 조작)
• StringBuilder(효율적인 문자열 조작)
• java.utill.StringTokenizer(구분자로 연결된 문자열 분리) 존재

2. object 클래스

• 자바의 모든 클래스는 Object의 자식이거나 자손 클래스이다

  메소드	용도
  boolean equals(object obj)	객체의 번지를 비교하고 결과를 리턴
  int hashCode()	객체의 해시코드를 리턴
  String toString	객체 문자 정보를 리턴

객체 동등 비교

• Object의 equals()메소드는 객체의 번지를 비교하고 boolean 값을 리턴

  public boolean equals(Object obj)
  

• equals() 메소드의 매개변수 타입이 Object(최상위 클래스)이므로 자동 타입변환에 의해 모든 객체가 매개값으로 대입될 수 있음

• equals()메소드는 비교 연산자인 ==과 동일한 결과 리턴

  Object obj1 = new Object();
  Object obj2 = obj1;
  boolean result = obj1.equls(obj2);
  boolean result = (obj1==obj2); //동일한 결과
  

  class Member{
  	public String id;
  
  	public Member(String id){
  		this.id = id;
  	}
  
  	@Override // object 클래스로부터 상속받은 함수
  	public boolean equals(Object obj){
  		if(obj instanceof Member target){ //obj가 Member 타입인지 검사하고 타입 변환 후 target변수에 대입
  			if(id.equals(target.id)) { //if 문자열이 같은지 비교
  				return true;
  			}
  		}
  		return false;
  	}
  }
  
  public class Test {
  	public static void main(String[] args) {
  
  		Member obj1 = new Member("blue");
  		Member obj2 = new Member("blue"); //new연산자로 객체를 생성했으므로 원래 obj1과 같지 않음
  		Member obj3 = new Member("red");
  
  //1. 문자열 비교 2. 객체 비교
  		if(obj1.equals(obj2)) { //업캐스팅 Object obj = obj2;
  			System.out.println("obj1 obj2 동일"); //동일출력
  		}else {
  			System.out.println("obj1 obj2 다름");
  		}
  
  		if(obj1.equals(obj3)) {
  			System.out.println("obj1 obj3 동일");
  		}else {
  			System.out.println("obj1 obj3 다름"); //다름 풀력
  		}
  
  	}
  }
  

  String str = "java";
  String str2 = "C++";
  
  int r = str.compareTo(str2); //사전순
  
  if(r==0) {
   System.out.println("같다");
  }
  else if(r<0) { //사전에 먼저 나오면 음수 리턴
   System.out.println("java가 C++보다 먼저나온다");
  }
  else { //사전에 나중에 나오면 음수 리턴
   System.out.println("C++이 java보다 먼저나온다"); //출력
  }
  

객체 해시코드

• 객체를 식별하는 정수
• 객체마다 다른 정수값 리턴

public int hashCode()

• 자바는 두 객체가 동등함을 비교할 때 hashCode()와 equals()메소드를 같이 사용하는 경우가 많음

class Student{
	privatr int no;
	privatr String name;

public Student(int no, String name){
  this.no = no;
  this.name = name;
}

public int getNo(){
  return no;
  }

public String getName(){
  return name;
  }

@override //Objct의 hashCode()메소드를 재정의해서 학생 번호와 이름 해시코드를 합한 새로운 해시코드 리
public int hashCode(){ //번호와 이름이 같으면 동일한 해시코드가 됨
  int hashCode = no+name.hashCode();
  return hashCode;
}

@override //Object의 equals()메소드를 재정의해서 Sruddent객체인지 확인
public boolean equals(Object obj) { //obj가 Student 타입인지 확인해서 다운캐스팅
  if(obj instanceof Student target) {

  //obj가 student
  if(no==target.getNo() && name.equals(target.getName()){
    return true;
  }
}
  else
    return false;
  }
}

***

class HashCodeExample {
  public static void main(String[] args) {
    Student s1 = new Student(1, "홍길동");
    Student s2 = new Student(1, "홍길동");

    if(s1.hashCode() == s2.hashCode()){ //해시코드가 동일한지 검사
      if(s1.equals(s2)){ //데이터가 동일한지 검사
        System.out.println("동등");
      }else{
        System.out.println("다름");
      }
    }else{
      System.out.println("다름");
    }
  }
}

• HashSet은 동등 객체를 중복 저장하지 않는다

    class Num{
      int a;
  
      Num(int a){
        this.a = a;
      }
      @Override   //hashCode api사용하는거라 override
      public int hashCode() {
        return a; //1.기준을 정해서 그룹핑(정수값 리턴)
      }
      @Override
      public boolean equals(Object obj) {
        Num num = (Num)obj; //down casting = 강제 타입 변환(object는 최상위로 현재 Num객체 비교해야하므로)
        if(num.a==a) {
          return true;
        }
        else
          return false;
      }
      @Override
      public String toString() { //객체를 문자열로 변환해주는 메서드
        return a+" ";
      }
    }
  
    public class Test {
      public static void main(String[] args) {
  
        HashSet<Num> h = new HashSet<Num>();
        //<>: angle blanket
        h.add(new Num(30)); //HashSet에 Num객체를 넣겠다
        h.add(new Num(60));
        h.add(new Num(40));
        h.add(new Num(60)); //HashSet은 중복될 수 없어 안들어감
  
        Iterator<Num>i = h.iterator();
        while(i.hasNext()) {
          System.out.println(i.next()); //30 60 40
        }
  
      }
    }
    -------------------------------
    40 60 30
  

    import java.utill.HashSet;   //HashSet java.utill 패키지에 있으므로 import
  
    public class HashSetExample {
      public static void main(String[] args) {
        HashSet hashset = new HashSet();  //HashSet 컬렉션 생성
  
        Student s1 = new Student(1, "홍길동");
        hashSet.add(s1);                      //HashSet에 Student 객체 저장
        System.out.println(hashSet.size()); //출력: 1
  
        Student s2 = new Student(1, "홍길동");
        hashSet.add(s2);                      //HashSet에 Student 객체 저장
        System.out.println(hashSet.size()); //출력: 1
  
        Student s3 = new Student(2, "홍길동");
        hashSet.add(s3);                      //HashSet에 Student 객체 저장
        System.out.println(hashSet.size()); //출력: 2
  
      }
    }
  

객체 문자 정보

• Object의 toString()메소드는 ‘클래스명@16진수해시코드’로 구성된 문자열 리턴
• Object의 toString()메소드를 재정의해서 간결한 정보를 리턴

• String클래스에 저장된 문자열을 리턴하도록 toString()메소드 재정의

  class SmartPhone{
  	private String company;
  	private String os;
  
  	public SmartPhone(String company, String os){
  		this.company = company;
  		this.os = os;
  	}
  
  	@override
  	public String toString(){
  		return company + ", " + os; //Object의 toString() 메소드를 제정의해서 문자열 결합
  	}
  }
  
  public class ToStringExample {
  	public static void main(String[] args) {
  		SmartPhone myPhone = new SmartPhone("삼성전자","안드로이드");
  
  		String strObj = myPhone.toString();
  		System.out.println(strObj);  //toSting() 메소드 호출
  
  		System.out.println(myPhone);  //toSting() 메소드 호출, toString()없이도 호출됨
  	}
  }
  

레코드 선언

• 데이터 전달을 위한 DTO(data Transfer Object)를 작성할 때 반복사용 코드를 줄이기 위해 사용
• DTO vs VO 개념 비교 및 영문명, 개념만 알아두기

롬복(lombok) 사용하기

• 어노테이션(@) 기반으로 코드를 자동완성해주는 라이브러리
• 스프링에서 사용 (@Getter, @Setter 등)
• 롬복 라이브러리를 설치해서 사용

3. System 클래스

정적 멤버(메소드)	용도
exit(int status)	프로세스 종료
currentTimeMillis	현재 시간을 밀리초 단위 long값으로 리턴

• 키보드 입력

    💡 int keyCode = system.in.read();
  

  • read() 메소드는 호출과 동시에 키 코드를 입력하지X
  • Enter키 누르기 전까지 대기 상태, 누르면 입력했던 키들을 읽음

• 시스템 종료

    💡 System.exit(int status)
  

  • exit() 메소드는 int 매개값 필요
  • 정상 종료: 0 , 비정상 종료 1 또는 -1

  public class Test {
  	public static void main(String[] args) {
  		for(int i=0; i<10; i++) {
  			//i값 출력
  			System.out.println(i);
  			if(i==5) { //i가 5가 되면 강제 종료됨
  				//JVM 프로세스 종료
  				System.out.println("프로세스 강제 종료");
  				System.exit(0);
  			}
  		}
  	}
  }
  

4. 문자열 클래스

클래스	설명
String	문자열을 저장하고 조작할 때 사용
StringBuilder	효율적인 문자열 조작 기능이 필요할 때 사용
StringTokenizer	구분자로 연결된 문자열을 분리할 때 사용

✅ String 클래스

• 문자열을 저장, 조작할 때 사용
• byte 배열을 문자열로 변환하는 경우 String으로 객체 생성

  //두가지 경우
  //기본 문자셋으로 byte 배열을 디코딩해서 String 객체로 생성
  String str = new String(byte[] bytes);

  //특정 문자셋으로 byte 배열을 디코딩해서 String 객체로 생성
  String str = new String(byte[] bytes, String charsetName);

  String data ="자바";

  //String → byte 배열(기본: UTF-8 인코딩)
  byte[] arr1 = data.getBytes(); //byte[] arr1 = data.getBytes("UTF-8");
  System.out.println(Arrays.toString(arr1)); //import java.util.Arrays;
  //출력: [-20, -98, -112, -21, -80, -108]

  //byte 배열 → String(기본: UTF-8 디코딩)
  String str1 = new String(arr1); //String arr1 = new String(arr1, "UTF-8");
  System.out.println(str1);
  //출력: 자바

  //String → byte 배열(기본: EUC-KR 인코딩)
  byte[] arr2 = data.getBytes("EUC-KR");
  System.out.println(Arrays.toString(arr2));
  //출력: [-64, -38, -71, -39]

  //byte 배열 → String(기본: UTF-8 디코딩)
  String str2 = new String(arr2,"EUC-KR");
  System.out.println(str2);
  //출력: 자바

• UTF-8 vs EUC-KR 차이점 : UTF-8로 인코딩하면 3바이트, EUC-KR로 인코딩하면 2바이트가 됨

✅ StringBuilder클래스

• String은 내부 문자열 수정 불가
• StringBuilder는 내부 버퍼(데이터를 저장하는 메모리)에 문자열을 저장해두고 그 안에서 추가, 수정, 작업을 하도록 설계됨

• 잦은 수정이 있는 경우 사용

  리턴타입	메소드(매개변수)	설명
  StringBuilder	append(기본값	문자열)	문자열을 끝에 추가
  StringBuilder	insert(위치,기본값	문자열)	문자열을 지정 위치에 추가
  StringBuilder	delete(시작위치,끝위치)	문자열 일부를 삭제
  StringBuilder	replace(시작위치, 끝위치,문자열)	문자열 일부를 대체
  String	toString()	완성된 문자열을 리턴

• StringBuffer 예제

  //StringBuffer
  //문자의 개수에 따라 버퍼 크기를 자동으로 조절할 수 있다
  //문자열이 길거나 문자열 작업이 많은 경우
  StringBuffer sb = new StringBuffer("java");
  
  sb.append("is very good");
  //맨 끝에 추가
  sb.insert(0, "A ");
  sb.replace(2, 6, "html ");
  System.out.println(sb);      //html is very good
  

✅ StringTokenizer 클래스

• String을 더 자주 씀
• 문자열이 구분자로 연결되어 있을 경우, 구분자를 기준으로 문자열을 분리할 때 사용
  (String의 split() 또는 StringTokenizer)

• 또는 여러 종류가 아닌 한 종류가 아닌 한 종류의 구분자만 있을 때 사용

  리턴 타입	메소드(매개변수)	설명
  int	countTokens()	분리할 수 있는 문자열의 총 수
  boolean	hasMoreTokens()	남아 있는 문자열이 있는지 여부
  String	nextToken()	문자열을 하나씩 가져옴

  String str = "id=123#name=gildong#daar=seoul";
  //#을 기준으로 문자열 나누기
  
  StringTokenizer s = new StringTokenizer(str, "#");
  int n = s.countTokens();
  System.out.println(n);
  
  while(s.hasMoreTokens()) {
  	String a = s.nextToken();
  	System.out.println(a);
  }
  
  출력:
  3
  id=123
  name=gildong
  daar=seoul
  

5. Wrapper 클래스

• 자바는 기본 타입의 값을 갖는 객체를 생성할 수 있음 → 이런 객체를 포장(wrapper)객체라고 함
• 포장 객체를 생성하기 위한 클래스는 java.lang 패키지에 포함됨

기본 타입	포장 클래스
byte	Byte
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

---

박싱과 언박싱

• 박싱: 기본 타입의 값을 포장 객체로 만드는 과정

• 언박싱: 포장 객체에서 기본 타입의 값을 얻어내는 과정

  Interger obj = 100; //(자동)박싱
  int value = obj; //(자동)언박싱
  

  526
  //Boxing
  Integer obj = 100;
  System.out.println(obj.intValue()); //100
  //intValue() 메소드는 Integer 객체 내부의 int 값을 리턴
  
  //Unboxing
  int value = obj;
  System.out.println(value); //100
  
  //연산 시 Unboxing
  int result = obj + 100;
  System.out.println(result); //200
  

• 예제

  //Integer i = new Integer(10); //정수 10을 i객체로 만듬(boxing)
  
  Integer i = 10; //auto boxing
  int i1 = i.intValue(); //unboxing
  int a = i+10; //i가 객체가 아닌 정수로 자동 언박싱됨
  System.out.println(a);  //출력: 20
  
  Character c = new Character('a'); //new할 필요 없이 a라고만 적어도 됨
  char c1 = c.charValue();
  
  Boolean b = new Boolean(true);
  boolean b1 = b.booleanValue();
  --------------------------------------------------
  //정수5를 객체로 만들기
  //Integer i = new Integer(5); 박싱
  Integer i = 5; //자동 박싱
  
  //객체를 다시 정수 5로 만들기
  //int n = i.intValue(); 언박싱
  int n = i; //자동 언박싱
  

---

문자열을 기본 값으로 변환

• 포장 클래스는 문자열을 기본 타입 값으로 변환할 때도 사용
• 대부분 포장 클래스에는 ‘parse+기본타입’ 명으로 되어있는 정적 메소드 존재

//문자열을 기본타입으로 변환
int i2=Integer.*parseInt*("123");
boolean b2=Boolean.*parseBoolean*("true");
double d2 = Double.*parseDouble*("3.14");
//parse~ 반환형이 기본 자료형

✅ Value of

• 문자열, 정수 등을 기본타입으로 바꿔줌

• Value of: 반환형이 객체 vs parse~: 반환형이 기본자료형

  int i3 = Integer.valueOf(123); //기본타입을 정수로 바꾸는 자동언박싱
  int i4 = Integer.valueOf("10")+Integer.valueOf("20");//문자를 정수로 바꾸는 언박싱
  
  System.out.println(i4);
  //valueOf는 반환형이 객체
  
  String a = Integer.toString(123);
  //정수형 객체 123을 분자열로 변환
  System.out.println(a);  //출력: 123
  
  Integer i11=100; //auto boxing
  int n1 = i11+100;
  System.out.println(n1); //출력: 200
  

포장 값 비교

• 포장 객체는 내부 값 비교를 위해 == 와 !=연산자 사용 불가

  //-128~127 초과값일 경우
  Integer obj1 = 300;
  Integer obj2 = 300;
  System.out.println(obj1==obj2); //false. int 범위 초과
  System.out.println(obj1.equals(obj2)); //true
  

• equals 사용: String, Object, Boxing(객체)

6. 수학 클래스

• 모두 정적 메소드로 Math 클래스로 바로 사용 가능

  구분	코드(Math.)	비고
  절대값	abs(n);
  올림값	cell(n);	소수점 올림
  버림값	floor(n);	소수점 버림
  최대값	max(n);
  최소값	min(n);
  랜덤값	random();	0이상 1미만
  반올림값	round(n.n);	long으로 반환

• 종자값(seed) (난수를 만드는 알고리즘에 사용되는 값)이 같이면 같은 난수를 얻음

  리턴값	메소드(매개변수)	설명
  boolean	nextBoolean()	boolean 타입의 난수 리턴
  double	nextDouble()	double 타입의 난수를 리턴(0.0≤ ~ <1.0)
  int	nextInt()	int 타입의 난수를 리턴(-2²³ ≤ ~ ≤ 2²³-1);
  int	nextInt(int n)	int타입의 난수를 리턴(0≤ ~ < n)

  import java.util.Arrays;
  import java.util.Random;
  
  public class Test {
  	public static void main(String[] args) {
  		//선택번호
  		int[] selectNumber = new int[6]; //선택번호 6개 저장 배열
  		Random random = new Random(3);  //선택번호를 얻음
  
      System.out.println("선택번호: ");
  
      for(int i=0;i<6;i++) { //선택번호 6개를 얻어 배열 저장
  			selectNumber[i] = random.nextInt(45)+1; //0부터 44+1까지
  			System.out.print(selectNumber[i]+" ");
  		}
  
      System.out.println();
  
  		//당첨번호
  		int[] winningNumber = new int[6];
  		random = new Random(5);
  
      System.out.println("당첨번호: ");
  
      for(int i=0;i<6;i++) {
  			winningNumber[i] = random.nextInt(45)+1;
  			System.out.print(winningNumber[i]+" ");
  		}
  
      System.out.println();
  
  		//당첨여부
  		Arrays.sort(selectNumber); //배열 정렬
  		Arrays.sort(winningNumber);
  		boolean result = Arrays.equals(selectNumber, winningNumber); //배열항목 비교
  
      System.out.println("당첨여부: ");
  
      if(result) {
  			System.out.println("1등");
  		}else {
  			System.out.println("당첨안됨");
  		}
  	}
  }
  

7. 날짜와 시간/형식/정규 표현식 클래스

✅ 날짜와 시간 클래스

• Date, Calendar 클래스

  • 현재 날짜를 문자열로 얻고 싶으면 toString() 메소드 사용 가능(영문으로 나옴)
  • SimpleDateFormat 클래스로 원하는 문자열 얻을 수 있음

  클래스	설명
  Date	날짜 정보를 전달하기 위해 사용
  Calendar	다양한 시간대별로 날짜와 시간을 얻을 때 사용
  LocalDataTime	날짜와 시간을 조작할 때 사용

  import java.text.*;
  import java.util.*;
  
  public class Test {
    public static void main(String[] args) {
  
      Date now = new Date();
      String strNow1 = now.toString();
      System.out.println(strNow1);
  
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy.mm.dd HH:mm:ss");
      String strNow2 = sdf.format(now);
      System.out.println(strNow2);
  
    }
  }
  ------------------------------------------------------
  Tue Mar 05 18:08:47 KST 2024
  2024.00.5 18:08:47
  

✅ Calendar 클래스

• getInstance() 메소드
  컴퓨터에 설정된 시간대 객체 얻을 수 있음

  Calendar now = Calendar.getInstance();
  
  int year = now.get(Calendar.YEAR);        //년도를 리턴
  int month = now.get(Calendar.MONTH)+1;    //월을 리턴
  int day = now.get(Calendar.DAY_OF_MONTH); //일을 리턴
  int week = now.get(Calendar.DAY_OF_WEEK); //요일을 리턴
  int amPm = now.get(Calendar.AM_PM);       //오전/오후 리턴
  int hour = now.get(Calendar.HOUR);        //시 리턴
  int minute = now.get(Calendar.MINUTE);    //분 리턴
  int second = now.get(Calendar.SECOND);    //초 리턴
  
  System.out.println(year+"년 "+month+"월 "+day+"일 "+week+"요일"); //  2024년 3월 5일 3요일
  System.out.println(amPm+" "+hour+"시 "+minute+"분 "+second+"초"); // 1 7시 7분 53초
  

  Calendar now = Calendar.getInstance();
  
  int year = now.get(Calendar.YEAR);        //년도를 리턴
  int month = now.get(Calendar.MONTH)+1;    //월을 리턴
  int day = now.get(Calendar.DAY_OF_MONTH); //일을 리턴
  int week = now.get(Calendar.DAY_OF_WEEK); //요일을 리턴
  String strWeek = null;
  switch(week) {
  	case Calendar.MONDAY:     strWeek = "월"; break;
  	case Calendar.TUESDAY:   strWeek = "화"; break;
  	case Calendar.WEDNESDAY:  strWeek = "수"; break;
  	case Calendar.THURSDAY:   strWeek = "목"; break;
  	case Calendar.FRIDAY:     strWeek = "금"; break;
  	case Calendar.SATURDAY:   strWeek = "토"; break;
  	default:                  strWeek = "일"; break;
  }
  int amPm = now.get(Calendar.AM_PM);       //오전/오후 리턴
  	String strAmPm = null;
  	if(amPm == Calendar.AM) {
  		strAmPm = "오전";
  	}else {
  		strAmPm = "오후";
  	}
  
  int hour = now.get(Calendar.HOUR);        //시 리턴
  int minute = now.get(Calendar.MINUTE);    //분 리턴
  int second = now.get(Calendar.SECOND);    //초 리턴
  
  System.out.println(year+"년 "+month+"월 "+day+"일 "+strWeek+"요일");  //  2024년 3월 5일 화요일
  System.out.println(strAmPm+" "+hour+"시 "+minute+"분 "+second+"초");  // 오후 7시 15분 26초
  

---

8. 형식 클래스

• Format(형식) 클래스
  • 숫자 또는 날짜를 원하는 형태의 문자열로 변환
• DecimalFormat
  • 숫자를 형식화 된 문자열로 변환
• SimpleFateFormat
  • 날짜를 형식화 된 문자열로 변환

9. 정규 표현식 클래스

• java.util.regex 패키지의 두 클래스를 사용
• 문자열이 정해져 있는 형식으로 구성되어 있는 경우 올바르게 구성되어 있는지 검증하는데 사용

✅ Pattern

• 정규표현식을 컴파일해서 Pattern 객체로 만든다
• 정규식 자체를 표현하는 클래스
• 정적 메서드 Pattern.compile(String regex)를 통해 객체를 생성한다

Pattern pattern = Pattern.compile("\\d+"); // 숫자 하나 이상

✅ Matcher

• Pattern 객체를 사용해서 특정 문자열에 대해 매칭 작업을 수행하는 클래스
• matcher() 메서드를 통해 생성된다

Matcher matcher = pattern.matcher("123abc");

주요 메서드

메서드명	설명
matches()	전체 문자열이 정규식과 일치하는지 확인
find()	문자열 내에서 정규식과 일치하는 부분이 있는지 확인
group()	찾은 일치 부분 반환
replaceAll(String replacement)	정규식과 일치하는 부분을 치환

• 예시

import java.util.regex.*;

public class RegexExample {
    public static void main(String[] args) {
        String input = "나는 2025년에 졸업할 거야.";
        Pattern pattern = Pattern.compile("\\d{4}");
        Matcher matcher = pattern.matcher(input);

        if (matcher.find()) {
            System.out.println("매칭된 연도: " + matcher.group());
        }
    }
}
--------------------------
매칭된 연도: 2025

10. 리플렉션, 어노테이션

• 자바는 클래스와 인터페이스의 메타 정보를 Class 객체로 관리한다
• 메타정보: 패키지 정보, 타입 정보, 멤버(생성자,필드,메소드) 정도 등

리플렉션 (Reflection)

• 런타임에 클래스, 메서드, 필드, 생성자 등의 정보를 조사하거나 조작할 수 있는 기능이다
• java.lang.reflect 또는 java.lang.Class

주요 클래스

• Class<?> : 클래스 정보를 담는 클래스
• Field : 필드(멤버 변수) 정보
• Method : 메서드 정보

• Constructor : 생성자 정보

  ① Class clazz = 클래스.class;   //클래스로부터 얻음
  ② Class clazz = Class.forName("패키지..클래스이름");  //클래스로부터 얻음
  ③ Class clazz = 객체참조변수.getClass();   //객체로부터 얻음
  

• 패키지와 타입 정보 얻을 수 있음

  메소드	용도
  Package getPackage()	패키지 정보 읽기
  String getSimpleName()	패키지를 제외한 타입 이름
  String getName()	패키지를 포함한 전체 타입 이름

  import java.lang.reflect.*;
  
  class User {
      private String name = "홍길동";
  
      public void sayHello() {
          System.out.println("안녕하세요!");
      }
  }
  
  public class ReflectionExample {
      public static void main(String[] args) throws Exception {
          Class<?> clazz = Class.forName("User");
          Object obj = clazz.getDeclaredConstructor().newInstance();
  
          Field field = clazz.getDeclaredField("name");
          field.setAccessible(true); // private 접근 허용
          System.out.println("name 필드 값: " + field.get(obj));
  
          Method method = clazz.getDeclaredMethod("sayHello");
          method.invoke(obj); // 메서드 실행
      }
  }
  

어노테이션 (Annotation)

• 메타데이터를 코드에 추가하는 방법
• 코드에서 @으로 작성

• 클래스 또는 인터페이스를 컴파일하거나 실행할 때 어떻게 처리해야 할 것인 지 알려주는 정보

  ① 컴파일 시 사용하는 정보 전달
  ② 빌드 툴이 코드를 자동으로 생성할 때 사용하는 정보 전달
  ③ 실행 시 특정 기능을 처리할 때 사용하는 정보 전달
  

• 자주 쓰는 어노테이션
  • @Override : 메서드가 부모 클래스의 메서드를 오버라이드하는지 확인
  • @Deprecated : 사용하지 말아야 할 API 표시
  • @SuppressWarnings("unchecked") : 경고 억제

// 커스텀 어노테이션
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

• @Retention(RetentionPolicy.RUNTIME) : 런타임에도 유지되게
• @Target(ElementType.METHOD) : 메서드에만 적용 가능

---

문제

1. main()를 보고 클래스를 작성해라

main(){
Point p = new Point(3,4);
System.out.println(p); //3, 4출력
}

class Point{
  int a,b;

  public Point(int a, int b){
    this.a = a;
    this.b = b;
  } //→ 여기까지만 하면 해시코드가 나온다

  @Override
  public String toString() {
    return a+", "+b;
  } //→ 문자열로 바꿔주는 작업 필요
}

---

2. equals(두 원의 면적이 같은지 비교), toString메소드를 사용하여 완성시켜라.(반지름: 30)

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

		Circle a=new Circle(30);
		Circle b=new Circle(30);

		System.out.println("반지름"+a);
		System.out.println("반지름"+b);

		if(a.equals(b)) {
		System.out.println("같은 원"); }
		else {
		System.out.println("다른 원");}
	}
}

class Circle{

	int r;

	public Circle(int r) {
		this.r = r;
	}

	@Override
	public String toString() {
		return r+"";
	}

	@Override
	public boolean equals(Object obj) { //객체동등비교. 안하면 객체로 비교되서 다른값으로 인식
		if(obj instanceof Circle target) {
			Circle c = (Circle) obj;
			return this.r == c.r;
			}
			return false;
		}
}
----------------------------------------------------
또는
class Circle{

	int r;

	public Circle(int r) {
		this.r = r;
	}

	@Override
	public String toString() {
		return r+"";
	}

	@Override
	public boolean equals(Object obj) {
		if(this.r == ((Circle)obj).r ) {
		// ↑자기 자신    ↑obj(부모)를 Circle(자식)으로 강제 형변환 후 r에 접근
			return true;
		}
		return false;
	}
}

3. 실수 9.5를 객체화(박싱) 해라

3-1) 객체화 시킨 9.5를 문자열로 변경하기

3-2) 문자열로 변경한 9.5를 기본형 값으로 언박싱하기

    //4. 실수 9.5를 객체화(박싱)
    Double d = 9.5;
    double d2=Double.valueOf("9.5"); //두개 다 가능

    //4.1) 객체화 시킨 9.5를 문자열로 변경
    String s = d.toString(); //문자열 반환은 toString만 됨!

    //4.2) 문자열로 변경한 9.5를 기본형값으로 언박싱
    double d3 = Double.parseDouble(s); //valueOf하면 기본형으로 자동 언박싱 되니까 사용가능

4. 문자열 “1+2+3+4+5”를 “+”로 구분해서 총합 15를 출력해라 (StringTokenizer,parseInt 다 사용)

String str= "1+2+3+4+5";
int sum = 0;

StringTokenizer s = new StringTokenizer(str,"+");

while(s.hasMoreTokens()) {
	String a = s.nextToken();
	int b = Integer.parseInt(a);
	sum += b;
}
System.out.println(sum);
----------------------------------------
//더 간단하게
String str= "1+2+3+4+5";
int sum = 0;

StringTokenizer s = new StringTokenizer(str,"+");

while(s.hasMoreTokens()) {
	sum += Integer.parseInt(s.nextToken());
}

System.out.println(sum);