018. 클래스와 인스턴스 : static(클래스) 변수/메소드

2023.02.17 (금)

클래스와 인스턴스
- static 변수(클래스 변수)와 static 메소드(클래스 메소드)

• static 변수 == 클래스 변수 == 정적 변수
• static 메소드 == 클래스 메소드 == 정적 메소드

※ static 에서 가장 중요한 개념
1) 탄생시점
  - 클래스 변수 또는 클래스 메소드는 클래스 정보가 로딩되는 순간 메모리 할당이 이루어지며
    클래스 이름 또는 객체(인스턴스)를 통해 접근할 수 있다.
    즉,『new』연산자를 통해 메모리를 할당받지 않아도 사용이 가능하다.

2) 공유
 - static 변수의 경우 클래스 내의 "공유 객체" 이다. 
   (공용으로 사용되기 때문에, 해당 객체를 호출하여 사용/변경 하게 되면 그 값이 남아있게 된다) 

---

• Test100
  - static 변수(클래스 변수)와 static 메소드(클래스 메소드)
  - static 변수,메소드 vs 인스턴스 변수,메소드 비교

/*=======================================================
                 ■■■ 클래스와 인스턴스 ■■■
- static 변수(클래스 변수)와 static 메소드(클래스 메소드)
========================================================*/
//	※ 실습 편의상 접근제어 지시자 생략

public class Test100
{
	static int a = 10;		// staitc 변수 (클래스 변수, class 변수, 정적 변수)
	int b = 20;			// non-static 변수 (인스턴스 변수, instance 변수)

	//	※	인스턴스 변수 또는 인스턴스 메소드는
	//		동일한 클래스의 메소드에서는 바로 접근하는 것이 가능하지만
	//		클래스 메소드에서는 접근할 수 없다.

	static void print()		// static 메소드 (클래스 메소드, class 메소드, 정적 메소드)
	{
		//System.out.println("print()");
		System.out.println("클래스   변수 a : " + a);
		//System.out.println("인스턴스 변수 b : " + b);
	}

	void write()			// non-static 메소드 (인스턴스 메소드, instance 메소드)
	{
		//System.out.println("write()");
		System.out.println("클래스   변수 a : " + a);
		System.out.println("인스턴스 변수 b : " + b);
	}

	public static void main(String[] args)
	{
		System.out.println("main() → 클래스 변수 a : " + Test100.a);
		//-- 클래스 변수에 접근하기 위해서는
		//	 『클래스명.변수명』의 형태로
		//	 클래스의 이름을 통해 접근하는 것이 가능하다.
		//--==>> main() → 클래스 변수 a : 10

		System.out.println("main() → 클래스 변수 a : " + a);
		//--==>> main() → 클래스 변수 a : 10
		//-- 같은 클래스 내부에 존재하기 때문에...(같은 멤버)
		//	 클래스의 이름을 생략하는 것이 가능하다.

		Test100.print();
		//--==>> print()
		//--==>> 클래스   변수 a : 10

		print();
		//--==>> 클래스   변수 a : 10
		//-- 클래스 메소드에서 클래스 메소드의 호출은 가능하며
		//	 『클래스명.메소드명()』의 형태로 접근하여 호출하는 것이 가능하다.
		//	 또한, 지금과 같은 상황에서는 동일한 클래스 내부에 존재하기 때문에
		//	 클래스의 이름을 생략하여 호출한 경우에 해당한다.

		//System.out.println("main() → 인스턴스 변수 b : " + b);
		//--==>> 에러 발생(컴파일 에러)
		//System.out.println("main() → 인스턴스 변수 b : " + b);
		//--==>> 에러 발생(컴파일 에러)

		//Test100.write();
		//--==>> 에러 발생(컴파일 에러)
		//write();
		//--==>> 에러 발생(컴파일 에러)

		// Test100 클래스 기반 인스턴스 생성
		Test100 ob = new Test100();
		
		//System.out.println("main() → 인스턴스 변수 b : " + b);
		//--==>> 에러 발생(컴파일 에러)
		//-- 인스턴스 변수에
		//	 생성된 인스턴스를 통해 접근하지 않아서 발생하는 에러

		// 생성된 인스턴스를 통해 인스턴스 변수 접근
		System.out.println("main() → 인스턴스 변수 b : " + ob.b);
		//--==>> main() → 인스턴스 변수 b : 20

		//write();
		//--==>> 에러 발생(컴파일 에러)
		//-- 인스턴스 메소드에
		//	 생성된 메소드에 접근하는 과정에서
		//	 생성된 인스턴스를 통하지 않아서 발생하는 에러

		// 생성된 인스턴스를 통해 인스턴스 메소드 접근(호출)
		ob.write();
		//--==>> 클래스   변수 a : 10
		//		 인스턴스 변수 b : 20
	

		// 생성된 인스턴스를 통해 클래스 변수 접근
		System.out.println("main() → 클래스 변수 a : " + ob.a);
		//--==>> main() → 클래스 변수 a : 10

		// 생성된 인스턴스를 통해 클래스 메소드 접근(호출)
		ob.print();
		//--==>> 클래스   변수 a : 10

		System.out.println("main() → 클래스 변수 a : " + a);
		System.out.println("main() → 클래스 변수 a : " + Test100.a);
		System.out.println("main() → 클래스 변수 a : " + ob.a);
		//--==>> main() → 클래스 변수 a : 10
		//		 main() → 클래스 변수 a : 10
		//		 main() → 클래스 변수 a : 10

		System.out.println(); // 개행

		// Test100 클래스 기반 인턴스 생성
		Test100 ob2 = new Test100();

		ob2.a = 10000;				// 클래스 변수 초기화
		ob2.b = 20000;				// 인스턴스 변수 초기화
	
		System.out.println("ob2 확인 ~~~~~~~~~~~~~~~~~~~~~");
		ob2.write();
		//--==>> 클래스   변수 a : 10000
		//	 	 인스턴스 변수 b : 20000

		System.out.println("ob 확인 ~~~~~~~~~~~~~~~~~~~~~~");
		ob.write();
		//--==>> 클래스   변수 a : 10000				// 공유의 기능
		//		 인스턴스 변수 b : 20
	}
}

// 실행결과

/*
main() → 클래스 변수 a : 10
main() → 클래스 변수 a : 10
클래스   변수 a : 10
클래스   변수 a : 10
main() → 인스턴스 변수 b : 20
클래스   변수 a : 10
인스턴스 변수 b : 20
main() → 클래스 변수 a : 10
클래스   변수 a : 10
main() → 클래스 변수 a : 10
main() → 클래스 변수 a : 10
main() → 클래스 변수 a : 10

ob2 확인 ~~~~~~~~~~~~~~~~~~~~~
클래스   변수 a : 10000
인스턴스 변수 b : 20000
ob 확인 ~~~~~~~~~~~~~~~~~~~~~~
클래스   변수 a : 10000
인스턴스 변수 b : 20
계속하려면 아무 키나 누르십시오 . . .
*/

※ 클래스 변수나 클래스 메소드는
『생성된인스턴스명.변수명』  『생성된인스턴스명.메소드명』 의 형태로도 접근(호출)이 가능하지만
『클래스명.변수명』 『클래스명.메소드명()』 의 형태로 접근(호출) 하는 것이 일반적이다.

---

• Test101, Record, Sungjuk
  - 클래스와 인스턴스 활용
  - 성적, 등수 계산 프로그램 구현하기

// 학생 별로 국어점수, 영어점수, 수학점수를 입력받아 총점, 평균을 계산하는 프로그램을 구현한다.
// 단, 클래스의 개념을 활용하여 작성할 수 있도록 한다.
// 또한, 이 과정에서 배열을 적극적으로 활용할 수 있도록 한다.
// 클래스 설계는 다음의 가이드라인에 따라 진행할 수 있도록 한다.

// [※ 가이드라인]
// 프로그램을 구성하는 클래스
// 1. Record 클래스
// - 속성만 존재하는 클래스로 설계할 것
// 2. Sungjuk 클래스
// - 인원 수를 입력받아, 입력받은 인원 수 만큼 이름, 국어점수, 영어점수, 수학점수를 입력받고
// 총점과 평균을 산출하는 클래스로 설계할 것
// ·속성 : 인원수, Record 타입의 배열(check)
// ·기능 : 인원수입력, 상세데이터입력, 총점및평균연산, 결과출력
// 3. Test101 클래스
// - main() 메소드가 존재하는 외부 클래스로 설계할 것

실행 예)

// 인원 수 입력 (1~100) : 102
// 인원 수 입력 (1~100) : 2
// 1번째 학생의 이름 입력 : 이창섭
// 국어 점수 : 90
// 영어 점수 : 80

// 수학 점수 : 70
// 2번째 학생의 이름 입력 : 한영범
// 국어 점수 : 92
// 영어 점수 : 82
// 수학 점수 : 72
// 이창섭 90 80 70 240 xx.xx 2
// 한영범 92 82 72 xxx xx.xx 1 

풀이)

public class Record
{
	String name;
	int[] score = new int[3];	//int k, e, m;
							//    0  1  2
	int tot;
	double avg;
	
	// 추가
	int rank;
}​

import java.util.Scanner;

public class Sungjuk
{
	int n;	// 입력받을 인원 수
	Record[] rec;

	public void input()
	{
		Scanner sc = new Scanner(System.in);
		do
		{
			System.out.print("인원 수 입력 (1~100) : ");
			n = sc.nextInt();
		}
		while (n<1 || n>100);

		rec = new Record[n];	// 방 갯수 생성
	}

	public void cal()
	{
		Scanner sc = new Scanner(System.in);
		
		String[] title = {"국어 점수 : ", "영어 점수 : ", "수학 점수 : "};

		for (int i=0; i<rec.length; i++)
		{
			//Record 기반의 인스턴스 생성
			//Record[] rec2 = new Record();
			//rec[i] = rec2;
			rec[i] = new Record();

			System.out.printf("%d번째 학생의 이름 입력 : ", i+1);
			rec[i].name = sc.next();
			
			for (int j=0; j<title.length; j++)
			{		
				System.out.print(title[j]);				// 0국어 1영어 2수학
				rec[i].score[j] = sc.nextInt();
				rec[i].tot += rec[i].score[j];			// 총점 누적
			}
			rec[i].avg = rec[i].tot /3.0;
		}
		
	}

	public void print()
	{
		ranking();
		System.out.println();

		for (int i=0; i<n; i++)
		{
			System.out.printf("%5s",rec[i].name);
			for (int j=0; j<3; j++)
			{
				System.out.printf("%4d",rec[i].score[j]);
			}
			System.out.printf("%5d",rec[i].tot);
			System.out.printf("%8.2f",rec[i].avg);

			System.out.printf("%4d",rec[i].rank);

			System.out.println();
		}
	}

	private void ranking()
	{
		for (int i=0; i<n; i++)
			rec[i].rank = 1;

		for (int i=0; i<n-1; i++)	//  비교 기준
		{
			for (int j=i+1; j<n; j++)	//	비교 대상
			{
				if (rec[i].avg > rec[j].avg)
				{
					rec[j].rank++;
				}
				else if (rec[i].avg < rec[j].avg)
				{
					rec[i].rank++;
				}
			}
		}
	}
	
}​

public class Test101
{
	public static void main(String[] args)
	{
		Sungjuk sj = new Sungjuk();

		sj.input();
		sj.cal();
		sj.print();
	}
}

 

// 개인적 감상

여태껏 main() 메소드 안에서 모든 것을 구현 하는 방법으로 배우다가,
클래스(객체) 단위로 나누어서 기능을 만들어 실행해보니 신기하기도 하고
하나의 프로그램을 만들기 위해서 여러 클래스를 기준에 맞게 잘 설계해야한다는 것을 알 수 있었다,