Bibliothek

※ 『super』

 -  static 으로 선언되지 않은 메소드에서 사용되며 현재 클래스가 상속받은 상위 클래스의 객체를 가리킨다.
 -  super 는 상위 클래스의 생성자를 호출하거나 상위 클래스의 멤버 변수 또는 메소드를 호출할 때 사용할 수 있다.

 - 하위 클래스의 생성자에서 상위 클래스의 생성자를 호출할 때에는
 - 하위 클래스의 생성자 정의 구문에서 맨 처음에만 위치할 수 있다.

※ 생성자와 클래스 상속간의 관계

   하위 클래스는 상위 클래스의 멤버를 상속받지만, 생성자는 상속대상에서 제외된다.
   그리고 하위 클래스의 생성자가 호출될 때 자동으로 상위 클래스의 생성자가 호출된다.
   이 때, 상위 클래스의 생성자는 인수가 없는 생성자(default 생성자 형태)가 호출된다.

   상위 클래스 및 하위 클래스를 설계하는 과정에서 상위 클래스의 생성자를 정의하지(작성하지) 않거나 인수가 없는 생성자만을 정의한(작성한) 경우 명시적으로 하위 클래스에서 상위 클래스의 생성자를 호출하지 않아도 아무런 문제가 발생하지 않지만 상위 클래스에 인자가 있는 생성자만 존재하는 경우에는 주의해야 한다.

   예를 들어 다음에서...

   class A_class
   {
         A_class(int n)
        {
        }
   }

   class B_class extends A_class
   {
         B_class()
         {
              super();
         }
   }

   하위 클래스인 B_class 의 생성자에서 명시적으로 A_class의 생성자를 호출하지 않으면 자동으로 인자 없는 생성자를 호출한다. 하지만, A_class 에는 인자가 있는 생성자만 존재하고 인자가 없는 생성자는 존재하지 않기 때문에 에러 발생한다. 따라서 B_class 생성자의 선두에 다음처럼 명시적으로 상위 클래스의 생성자 호출 구문을 작성해야 한다.

   class A_class
   {
          A_class(int n)
         {
         }
   }

   class B_class extends A_class
   {
          B_class()
         {
               super(10);
               ...
               ...
         }
   }

※ 상속 시 주의할 사항
   
   상위 클래스에서 선언된 멤버 변수의 이름과 하위 클래스에서 선언된 멤버 변수의 이름이 같으면 상위 클래스의 멤버 변수는 일반적인 사용 과정에서 무시된다. 이 때, 상위 클래스의 멤버 변수를 사용하기 위해서는 『super』키워드를 이용할 수 있다. 즉, 『super』 키워드를 활용하여 상위 클래스의 멤버 변수를 사용할 수 있다는 것이다.

동일한 이름의 멤버 변수나 동일한 이름의 메소드가 한 클래스 안에 선언되거나 정의도니는 경우 기본적으로 에러 발생한다. 단, 메소드의 경우에는 매개변수의 갯수나 타입이 다른 경우 에러 발생하지 않고 이들을 서로 다른 메소드로 취급하게 된다.

- Method Overloading
 → 아래에서 정리한 Method Overloading 개념과 구분하여 정리할 것~!!!

// Rect117 클래스와 Circle117 클래스의 부모 클래스
class SuperTest117
{
	protected double area;
	private String title;	// 상속안됨

	public SuperTest117()
	{
		System.out.println("SuperTest117... 인자 없는 생성자");
	}

	public SuperTest117(String title)
	{
		this.title = title;
		System.out.println("SuperTest117... 문자열을 인자로 받는 생성자");
	}

	public void write()
	{
		System.out.println(title + " - " + area);
	}
}

// SuperTest117 클래스를 상속받는 자식 클래스
class Rect117 extends SuperTest117
{
	/*
	protected double area;

	public void write()
	{
		System.out.println(title + " - " + area);
	}
	*/

	private int w, h;
	
	// 자식 클래스의 사용자 정의 생성자(default 생성자 형태)
	public Rect117()
	{	
		// 자동으로 삽입
		//super();	→ SuperTest117
	}

	public void calc(int w, int h)
	{
		this.w = w;
		this.h = h;
		area = (double)this.w * this.h;
		write();
	}
	
	@Override			//-- 어노테이션(annotation) → metadata →JDK 1.5부터 지원 , 컴파일과정에서 안사라짐, 보이는 주석 
	public void write()
	{
		System.out.println("w : " + w + ", h : " + h);
		System.out.println("사각형 -" + area);
	}


	// ※ 메소드 오버라이딩(Method Overriding)
	//
	//    상위 클래스를 상속받은 하위 클래스 에서
	//    상위 클래스에 정의된 메소드를 다시 정의하는 것으로(재정의)
	//    객체 지향 프로그래밍의 특징인 다형성을 나타낸다.
	//    재정의(Overriding)는 반드시 상속 관계에 있어야 하며,
	//    메소드의 이름, 리턴 타입, 매개변수의 갯수나 타입이
	//	  완전히 일치해야 한다.
	

}

// SuperTest117 클래스를 상속받는 자식 클래스
class Circle117 extends SuperTest117
{
	/*
	protected double area;
	
	public void write()
	{
		System.out.println(title + " - " + area);
	}
	*/
	
	// 자식 클래스의 사용자 정의 생성자
	public Circle117(String title)
	{
		//super(title);
		super(title);
	}

	public void calc(int r)
	{
		area = r * r * 3.141592;
		write();
	}
}

// main() 메소드를 포함하고 있는 외부의 다른 클래스(동일 패키지)
public class Test117
{
	public static void main(String[] args)
	{
		Rect117 ob1 = new Rect117();
		//--==>> SuperTest117... 인자 없는 생성자

		//Circle117 ob2 = new Circle117();
		//--==>> 에러 발생(컴파일 에러)
		//-- 현재 Circle117 클래스에는
		//   매개변수를 필요로하는 사용자 정의 생성자가 만들어져 있으며
		//   이로 인해 default 생성자가 자동으로 삽이되지 않는 상태

		Circle117 ob2 = new Circle117("원");

		ob1.calc(10,20);
		//--==>> w : 10, h : 20
		//		사각형 - 200.0

		ob2.calc(10);
		//--==>> 원 - 314.1592


	}
}

○ 상속(Inheritance)이란 
   새로 설계(생성)하고자 하는 클래스가 이미 설계되어 있는 다른 클래스의 기능과 중복되는 경우 이미 설계된 클래스의 일부분이나 전체 구조를 공유할 수 있도록 하는 기능을 의미한다. 즉, 상속은 객체를 좀 더 쉽게 만들 수 있는 고수준 재사용성을(reuseability) 확보하고 객체간의 관계를 구성함으로써 객체 지향의 또 다른 큰 특징인 『다형성』의 문법적 토대가 된다.
   상속은 기존 프로그램의 클래스 내용을 공유함으로써 중복된 코드들을 재작성할 필요없이 반복적이고 세부적인 작업을 처리하지 않기 떄문에 프로그램을 작성하는 시간을 절약할 수 있고 유지보수를 편리하게 할 수 있으면, 프로그램 길이도 짧아지게 된다.

  또한, 이미 작성된 프로그램들은 앞서 테스트되었기 때문에 오류를 줄일 수 있어 현재 작성중인 프로그램에만 전념할 수 있다.

※ 물려주는 클래스 → 상속하는 클래스 → 상위 클래스 → 부모(조상) 클래스 → Super Class
   물려받는 클래스 → 상속받는 클래스 → 하위 클래스 → 자식(자손) 클래스 → Sub Class

※ 주의할 점
   자바는 다.중.상.속. 을 지원하지 않기 때문에 두 개 이상의 클래스로부터 상속받을 수 없다.

즉, 자바는 단.일.상.속. 만 허용된다.

/*============================
  ■■■ 클래스 고급 ■■■
  - 상속(Inheritance)
==============================*/

// 부모 클래스
class SuperTest116
{
	// 『protected』 : 상속받는 클래스, 동일한 패키지, 클래스 내부에서 접근 가능
	protected double area;
	
	// 생성자
	// 『default』 : 동일한 패키지, 클래스 내부에서 접근 가능
	// 부모 클래스의 생성자
	SuperTest116()
	{
		System.out.println("Super Class...");
	}
	// 『default』 : 동일한 패키지, 클래스 내부에서 접근 가능	
	void write(String title)
	{
		System.out.println(title + " - " + area);
	}
}



// 자식 클래스(동일한 패키지에 존재하는 자식 클래스)
public class Test116 extends SuperTest116//, SuperTest117, SuperTest118	// 우리 부모님이 SuperTest116 이다~!!!
{
	// 부모 클래스로부터 상속받은 내용
	/*
	protected double area;

	void write(String title)		// 동일한 패키지에 존재하기 때문에 상속 가능
	{
		System.out.println(title + " - " + area);
	}
	*/
	
	double area = 10.1234;
	
	// 자식 클래스의 생성자
	Test116()
	{
		// 부모 클래스의 생성자 호출
		//SuperTest116();	//→ super();

		//Test116();		//→ this();

		System.out.println("Sub Class...");

		//super();		// 생성자 내부에서 다른 생성자 호출가능하지만 가장먼저 수행되어야 한다는 규칙에 위배
		//--==>> 에러 발생(컴파일 에러)
	}

	public void circle()
	{
		int r = 10;
		super.area = r * r * 3.141592;
		write("원");
	}

	public void rect()
	{
		int w = 20, h = 5;
		super.area = w * h;
		write("사각형");
	}

	public static void main(String[] args)
	{
		// Test116 클래스(자식 클래스) 기반 인스턴스 생성
		Test116 ob = new Test116();
		//--==>> Super Class...
		//		 Sub Class...

		ob.circle();
		//--==>> 원 - 314.1592
		ob.rect();
		//--==>> 사각형 - 100.0


	}

}

※ 사용자로부터 여러 학생의 성적 데이터를 입력받아
 점수가 높은 순으로 등수를 부여하여 결과를 출력하는 프로그램을 구현한다.
 단, 배열과 정렬 알고리즘을 활용하여 작성할 수 있도록 한다.

 실행 예)
 인원 수 입력 : 5
 이름 점수 입력(1) : 조인경 90
 이름 점수 입력(2) : 박다빈 80
 이름 점수 입력(3) : 허수민 85
 이름 점수 입력(4) : 박해진 75
 이름 점수 입력(5) : 강정우 95

---------------
1등 강정우 95
2등 조인경 90
3등 허수민 85
4등 박다빈 80
5등 박해진 75
---------------
계속하려면 아무 키나 누르세요...

 2등이 두명이면 그다음은 3등처리

 입력받은 수 만큼 객체 배열 생성 → 이름과 점수 입력받음 → 점수기준 객체 정렬 →

정렬된 객체 배열에서 인접한 인덱스끼리 동점 체크하며 순위 구하기 → 인덱스 순으로 출력

/*==================================
  ■■■ 정렬(Sort) 알고리즘 ■■■
====================================*/

import java.util.Scanner;

class Student
{
	String name;
	int score;
	int rank=1;
}


public class Test115
{
	public static void main(String[] args)
	{
		// Scanner 인스턴스 생성 
		Scanner sc = new Scanner(System.in);
		System.out.print("인원 수 입력 : ");
		int n = sc.nextInt();

		// Student 인스턴스 배열로 선언
		Student[] st = new Student[n];
		// Student 인스턴스 배열 각 원소 생성
		for (int i = 0; i < st.length; i++)
			st[i] = new Student();
		
		// 정렬시 임시 저장 용도로 쓰일 Student 인스턴스 생성
		Student stTmp = new Student();

		// ① 이름, 점수 입력받기
		for (int i = 0; i < n; i++)
		{
			System.out.printf("이름 점수 입력(%d) : ", i+1);
			st[i].name = sc.next();
			st[i].score = sc.nextInt();
		}
		
		// ② 점수별로 내림차순으로 객체 정렬(향상된 버블정렬 이용)
		boolean flag = true;
		for (int i = 1; i < n && flag; i++)
		{
			flag = false;
			for (int j = 0; j < n - i; j++)
			{	
				if (st[j].score < st[j + 1].score)
				{	
					stTmp = st[j+1];
					st[j+1] = st[j];
					st[j]=stTmp;
					flag = true;
				}
			}
		}
		
		int rank = 1;
		// ③ 순위 구하기 (인접한 인덱스끼리 동점 체크)
		for (int i = 1; i < n; i++)
		{

			// 인접한 점수가 동점인 경우
			if (st[i].score == st[i-1].score)
			{
				st[i].rank = st[i-1].rank;
			}
			else 
				st[i].rank = st[i-1].rank + 1;

		}

		// ④ 결과 출력
		System.out.println("---------------");
		for (int i = 0; i < n; i++)
		{
			System.out.println(st[i].rank + "등 " + st[i].name + "  " + st[i].score);
		}
		System.out.println("---------------");

	}

}


// 실행 결과

/*
인원 수 입력 : 5 
이름 점수 입력(1) : 조인경 90
이름 점수 입력(2) : 박다빈 80
이름 점수 입력(3) : 허수민 85
이름 점수 입력(4) : 박해진 85
이름 점수 입력(5) : 강정우 95
---------------
1등 강정우  95
2등 조인경  90
3등 허수민  85
3등 박해진  85
4등 박다빈  80
---------------
계속하려면 아무 키나 누르십시오 . . .
*/

   ○ 정렬
      : 데이터를 특정한 규칙(기준)에 맞게 순서대로 나열(오름차순, 내림차순)

   ○ 정렬의 목적
      : 데이터 처리 과정의 편의성이나 가독성을 높이기 위함
    → 보기 좋게... 검색하기 위함

   ○ 정렬의 종류
      : 선택 정렬, 버블 정렬, 삽입 정렬, 힙 정렬, 퀵 정렬, 쉘 정렬, ...


 실행 예)
 Source Data : 52 42 12 62 60
 Sorted Data : 12 42 52 60 62
 계속하려면 아무 키나 누르세요...

① 삽입 정렬

삽입 정렬은 자료 배열의 모든 요소를 앞에서부터 차례대로 이미 정렬된 배열 부분과 비교하여, 자신의 위치를 찾아 삽입함으로써 정렬을 완성하는 알고리즘이다. k번째 반복 후의 결과 배열은, 앞쪽 k + 1 항목이 정렬된 상태이다.

public class Test110
{
	public static void main(String[] args)
	{
		int[] a = {52, 42, 12, 62, 60};
		int i, j;
		// 정렬 전 데이터
		System.out.print("Source Data : ");
		for (int n: a)
			System.out.print(n + " ");
		System.out.println();
		//--==>> Source Data : 52 42 12 62 60
		
		// Selection Sort 구현
		for (i = 0; i < a.length - 1; i++)		// 비교 기준 데이터(0    1   2  3)
		{											//					|    |   |  |
			for (j = i + 1; j < a.length; j++)  // 비교 대상 데이터(1234 234 34 4)
			{	
				/*
				if(비교기준이 비교대상보다 크다면)
				{
					자리바꿔라
				}
				*/
		
				// if(a[i] < a[j])		// 내림차순 정렬
				if (a[i] > a[j])		// 오름차순 정렬
				{
					a[i]=a[j]^a[i];
					a[j]=a[i]^a[j];
					a[i]=a[j]^a[i];
				}
			}
		}

		System.out.print("Sorted Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();	
	}
}

// 실행 결과
/*
Source Data : 52 42 12 62 60
Sorted Data : 12 42 52 60 62
계속하려면 아무 키나 누르십시오 . . .
*/

② 버블 정렬

버블 정렬은 첫 번째 자료와 두 번째 자료를, 두 번째 자료와 세 번째 자료를, 세 번째와 네 번째를, … 이런 식으로 (마지막-1)번째 자료와 마지막 자료를 비교하여 교환하면서 자료를 정렬한다. 

1회전을 수행하고 나면 가장 큰 자료가 맨 뒤로 이동하므로 2회전에서는 맨 끝에 있는 자료는 정렬에서 제외되고, 2회전을 수행하고 나면 끝에서 두 번째 자료까지는 정렬에서 제외된다. 이렇게 정렬을 1회전 수행할 때마다 정렬에서 제외되는 데이터가 하나씩 늘어난다. 

		// 정렬 전 데이터
		int[] a = {52, 42, 12, 62, 60};
		int i, j;
		System.out.print("Source Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();
        
      	  	// Bubble Sort 구현
		for (i = 1; i < a.length; i++)			
		{
			for (j = 0; j < a.length-i; j++)	
			{
				// 테스트(확인)
				//System.out.print("[" + j + "," + (j + 1) + "]");
				//--==>> [0,1][1,2][2,3][3,4][0,1][1,2][2,3][0,1][1,2][0,1]
				
				if (a[j] > a[j+1])	// 오름차순 정렬
				{
					a[j] = a[j]^a[j+1];
					a[j+1] = a[j]^a[j+1];
					a[j] = a[j]^a[j+1];
				}
			}
		}

		// 결과 출력
		System.out.print("Sorted Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();

	}
}

// 실행 결과

/*
Source Data : 5 4 3 2 1
Sorted Data : 1 2 3 4 5
계속하려면 아무 키나 누르십시오 . . .
*/

③ 삽입 정렬

삽입 정렬은 자료 배열의 모든 요소를 앞에서부터 차례대로 이미 정렬된 배열 부분과 비교하여, 자신의 위치를 찾아 삽입함으로써 정렬을 완성하는 알고리즘이다. k번째 반복 후의 결과 배열은, 앞쪽 k + 1 항목이 정렬된 상태이다.

		int[] a = {52, 42, 12, 62, 60};
		//int[] a = {5,4,3,2,1};
		int i, j;
		
		System.out.print("Source Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();
		
		
		// 삽입 정렬
		for (i = 1; i < a.length; i++)		// i = 1
		{
			int tmp = a[i];			//tmp = 42
			j = i-1;			//j = 0

			while((j >= 0) && (a[j] > tmp))	// true && true
			{
				a[j+1] = a[j];		//a[1] = 52		→ 52 52 12 62 60
				j--;			// j = -1
			}
			a[j+1] = tmp;			//a[0] = 42		→ 42 52 12 62 60

		}

		// 결과 출력
		System.out.print("Sorted Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();


// 실행 결과

/*
Source Data : 52 42 12 62 60
Sorted Data : 12 42 52 60 62
계속하려면 아무 키나 누르십시오 . . .
*/

④ 향상된 버블 정렬

 앞에서 확인해 본 Selection Sort(Test110) 나 Bubble Sort(Test111)의 성능은 같다.
   (→ 반복의 횟수로 추정)
   하지만, 향상된 Bubble Sort 는 대상 데이터의 구조에 따라
   일반 Bubble Sort 나 Selection Sort 보다 성능이 좋게 나타날 수 있다.

원본 데이터 : 61 15 20 22 30
  15 20 22 30 61 - 1회전 (스왑 발생 → true) → 다음 회전 진행 ○
  15 20 22 30 61 - 2회전 (스왑 발생 → false)   → 다음 회전 진행 Ⅹ 

==> 1회전 수행... 2회전 수행... 을 해보았더니
       2회전에서 스왑(자리바꿈)이 전혀 일어나지 않았기 때문에
       불필요한 추가 연산(더 이상의 회전)은 무의미한 것으로 판단하여
       수행하지 않는다.

		int[] a = {10, 50, 22, 31, 43};
		//int i, j;
		int cnt = 0;
		boolean swap = true;
		
		boolean flag;
		int pass = 0;

		System.out.print("Source Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();
		
		//향상된 버블 정렬(Bubble Sort)
		do
		{
			// 테스트 확인
			//System.out.println("반복문 수행");		//-- 2회전 확인


			flag = false;	//-- 자리바꿈이 발생할 경우 true 로 설정
			pass++;

			for (int i = 0; i < a.length-pass; i++)	// 0 1 2 3 / 0 1 2 / 0 1 / 0
			{
				//System.out.println(쑝);

				if (a[i] > a[i+1])		// 01 12 23 34
				{						// 01 12 23
					//자리바꾸기		// 01 12
					a[i]=a[i]^a[i+1];   // 01
					a[i+1]=a[i+1]^a[i];
					a[i]=a[i]^a[i+1];
					flag =true;
					//-- 단 한 번이라도 스왑(자리바꿈)이 발생하게 되면
					//   flag 변수를 true 로 변경하여
					//   다음 회전을 추가로 진행할 수 있도록 처리
				}				   
			}
		}
		while (flag);
		//-- flag 변수가 false 라는 것은
		//   회전이 구분적으로 발생하는 동안 스왑이 일어나지 않은 경우
		//   더 이상의 반복문 수행은 무의미한 것으로 판단 가능~!!!

		// 결과 출력
		System.out.print("Sorted Data : ");
		for(int n : a)
			System.out.print(n + " ");
		System.out.println();

○ 주민등록번호 검증 공식
   
   ① 마지막 자리를 제외한 앞자리 수를 규칙에 맞게 곱한다
  
  123456-123456(7) (주민번호)
 ----------------------------------- 각 자릿수에 곱하기
  234567 892345  (각 자리에 곱해질 수)
   
   
   ② 규칙에 맞게 곱셈 연산을 수행한 결과를 모두 더한다.

   ex) 7 5 0 6 1 5 - 1 8 6 2 1 3 3
         * * * * * *      * * * * * * 
        2 3 4 5 6 7     8 9 2 3 4 5
   ----------------------------------
   → 14 + 15 + 0 + 30 + 6 + 35 + 8 + 72 + 12 + 6 + 4 + 15

  == 217

   ③ 더해진 결과값을 11로 나누어 『나머지』를 취한다.
 

          19
       --------
    11| 217
        11
      ---------
        107
         99
      ---------
  8 → 나머지

④ 11에서 나머지(8)을 뺀 결과값을 구한다.

   11 - 8 → 3

   ※ ③의 처리 과정에서 나머지가 0인 경우 → 11 - 0 → 11 → 1
      1인 경우 → 11 - 1 → 10 → 0
   이를 다시 10으로 나누어 나머지를 취한다.

⑤ ④의 연산 결과가 주민번호를 구성하는 마지막 숫자와
   일치하는지의 여부를 확인한다.

   일치   → 유효한 주민번호
   불일치 → 잘못된 주민번호



 실행 예)
 주민번호 입력(xxxxxx-xxxxxxx) : 123456-12345678 → 입력 갯수 초과
 >> 입력 오류
 계속하려면 아무 키나 누르세요...

 주민번호 입력(xxxxxx-xxxxxxx) : 123456-123456 → 입력 갯수 미달
 >> 입력 오류
 계속하려면 아무 키나 누르세요...

 주민번호 입력(xxxxxx-xxxxxxx) : 750615-1252085 → 유효한 주민번호
 >> 정확한 주민번호~!!!
 계속하려면 아무 키나 누르세요...

 주민번호 입력(xxxxxx-xxxxxxx) : 750615-1252084 → 유효한 주민번호
 >> 잘못된 주민번호~!!!
 계속하려면 아무 키나 누르세요...


 추가 팁~!!!

 배열.length → 배열의 길이(배열방의 갯수) 반환
 문자열.length() → 문자열의 길이 반환
 문자열.substring() → 문자열 추출

/*=======================================  
  ■■■ 주민등록번호 유효성 검사 ■■■     
========================================*/

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test109
{
	public static void main(String[] args) throws IOException
	{
		// BufferedReader 인스턴스 생성
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// 입력받는 주민번호(문자열 형태)
		String str;

		// 주민번호의 각 자릿수에 고바게 될 수 → 배열 형태로 구성
		//			 7 5 0 6 1 5  -  1 8 6 2 1 3 3 
		//			 *  *  *  *  *  *     * * * * * *
		int[] chk = {2,3,4,5,6,7, 0 ,8,9,2,3,4,5};
		//							  ---
		//							check~!!!

		// 곱셈 연산 후 누적합 (각 곱셈 결과를 더해 나가라...
		int tot = 0;

		System.out.print("주민번호 입력(xxxxxx-xxxxxxx) : ");
		//str = Integer.parseInt(br.readLine());
		str = br.readLine();

		if (str.length() != 14)
		{
			System.out.println(">> 입력 오류~!!!");
			return;	//-- 메소드종료 → main() 메소드 종료 → 프로그램 종료
		}

		// 테스트
		//System.out.println(">> 자릿수 적합");
		
		// ex) 750615-1252085
		for (int i = 0; i < 13; i++)
		{
			if(i == 6)
				continue;	//-- 뒷부분 무시하고... 계속해라...
							//   ------
							//   line 162

			//chk[i] * Integer.parseInt(주민번호 특정 자릿수 추출);
			tot += chk[i] * Integer.parseInt(str.substring(i, i + 1));
			                        
		}

		//------------ 여기까지 수행하면 ①과 ②를 모두 끝낸 상황이며
		//			   규칙에 맞게 곱셈 연산을 수행한 결과를 모두 더한 값은
		//			   변수 tot 에 담겨있는 상황이 된다.

		// ③ ④ 관련 연산 수행
		int su = 11 - tot % 11;

		// 테스트(확인)
		//System.out.print(su);
		
		// 최종 결과 출력 이전에... 추가 연산 필요~!!!
		// su에 대한 연산 결과가 두 자리로 나올 경우
		// 주민번호 마지막 자리의 숫자와 비교할 수 없는 상황
		su = su % 10;		// su % 10

		if (su == Integer.parseInt(str.substring(13)))
		{
			System.out.println(">> 정확한 주민번호~!!!");
		}
		else
		{
			System.out.println(">> 잘못된 주민번호~!!!");
		}

	}
}
// 실행 결과
/*
주민번호 입력(xxxxxx-xxxxxxx) : 940603-*******
>> 정확한 주민번호~!!!
계속하려면 아무 키나 누르십시오 . . .
*/

※
실행 예 )
연도를 입력하세요 : 2021
월을 입력하세요 : 1


   [2021년 1월]

일   월   화   수   목   금   토
=======================
                                1    2
  3    4    5    6    7    8    9
10  11  12  13  14  15  16
17  18  19  20  21  22  23
24  25  26  27  28  29  30
31
========================


문제 인식 및 분석
-서기 1년 1월 1일 : 월요일

-연도가 4의 배수이면서 100의 배수가 아니거나
400의 배수이면 2월은 29일까지 있는 (윤년),
나머지 2월은 28일까지 있는 (평년)

-만약 2020년 8월 달력을 그린다고 가정하면
1. 1. 1. ~ 2019.7.31 까지의 날 수를 구한다
----------------------------------------- 
 (1. 1. 1. ~ 2019.12.31) + (2020.1.1 ~ 2020.7.31)

- 위의 내용과 같이 구해진 날 수에 +1 연산을 수행하면
(2020년 8월 1일의 요일 확인)
--------------------------여기까지 수행하면 달력을 그려낼 준비 끝

- 요일 = 전체 날 수 %7
  요일 = 0 --> 일요일
  요일 = 1 --> 월요일
  요일 = 2 --> 화요일
            :

/*==========================
  ■■■만년달력■■■
============================*/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;


public class Test108
{
	public static void main(String[] args) throws IOException
	{

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// 배열 선언 및 초기화
		//-- 각 달이 담고있는 마지막 날짜(매 월의 최대 날짜)

		int[] days = {31,28,31,30,31,30,31,31,30,31,30,31};

		// 테스트(확인)
		//System.out.println(days.length);
		//--==>> 12

		// 주요 변수 선언
		int nalsu, y, w;
		int m; //-- 날 수, 년, 월, 요일
		
		do
		{
			System.out.print("『연도』를 입력하세요 : ");
			y = Integer.parseInt(br.readLine());
		}
		while (y<1);

		do
		{
			System.out.print("『월』를 입력하세요 : ");
			m = Integer.parseInt(br.readLine());
		}
		while (m<1 || m>12);

		// 입력받은 월이 1보다 작거나 12보다 클 경우... 다시 입력받을 수 있도록 처리

		//---------------------------- 여기까지 수행하면 유효한 년, 월을 입력한 상태~!!!

		// 입력받은 년도에 해당하는 2월의 마지막 날 계산
		if (y%4==0 && y%100!= 0 || y%400 == 0) //-- 윤년이라면
			days[1] = 29;
		//-- else 구문은 현재 days 배열의 1번째 요소(2월)가 28로 구성되어 있는
		//   상태이기 때문에 생략 가능한 구문이 된다.

		// 1년 1월 1일 ~ 입력받은 년도 이전년도의 12월 31일까지의
		// 날 수 계산

		nalsu = (y-1)*365 + (y-1)/4 - (y-1)/100 + (y-1)/400;

		// 입력받은 년도(해당년도)의 1월 1일 ~ 입력한 월의 이전 월 까지의
		// 날 수 누적 연산

		for (int i=0; i<(m-1); i++)
			nalsu += days[i];
		
		//------------------- 여기까지 수행하면 입력년 입력월의 하루 전 날 수까지 누적


		// 입력받은 월의 1일을 날 수 누적 연산

		nalsu += 1; // ++nalsu;

		//------------------- 여기까지 수행하면 모든 날 수에 대한 종합 완료~!!!

		// 요일 산출
		// : 입력받은 월의 1일이 무슨 요일인지 확인하기 위한 연산
		//   이 연산을 수행해야 달력에서 1일을 어느 위치부터 그리기 시작해야 하는지
		//   알 수 있게 되는 상황.
		w = nalsu % 7; // 0: 일요일, 1:월요일, 2:화요일, ...

		// 테스트(확인)
		//System.out.println(w);

		// 출력(달력 그리기)
		System.out.println();
		System.out.printf("\t[ %d년 %d월 ]\n", y, m);
		System.out.println("  일  월  화  수  목  금  토");
		System.out.println("============================");

		// 특정 요일부터 1일이 출발할 수 있도록 공백 발생(지정)
		for (int i=1; i<=w; i++)
		{
			System.out.print("    "); // 공백 4칸 발생
		}

		// 테스트(확인)
		//System.out.printf("%4d", 1);

		// 해당 월(입력한 월)의 날짜만 출력될 수 있도록 반복문 구성
		for (int i=1; i<=days[m-1]; i++)
		{
			System.out.printf("%4d",i);	// 1 2 3  4 5 6 ... 31
			w++;						// 7 8 9 10 ...
			

			if (w%7==0) // 일요일에 해당하는 날짜일 경우
			{
				System.out.println();	// 개행
			}
		}

		// 달의 마지막 날짜가 출력 형식을 모두 채웠을 경우
		// 이미 일요일 개행이 이루어졌기 때문에
		// 이 경우에는 추가 개행을 하지 않도록 처리
		//System.out.println();
		
		if(w%7!=0)
			System.out.println();

		System.out.println("============================");



	}
}