10일차
지역변수와 전역변수(068~069)
// Test069.java 와 비교
// 지역 변수는 초기화 과정을 거치지 않으면 사용할 수 없다.
// (즉, 자바가 자동으로 초기화를 수행해 주거나 하지 않는다.)
public class Test068
{
// 클래스 영역
public static void main(String[] args)
{
// 메소드 영역
// 지역 변수 n
int n;
// 선언 후 초기화 과정을 거치지 않은 상태
// 지역 변수 n 에 접근하여 그 값을 출력하고자 하는 구문
System.out.println("n : " + n);
// 컴파일 에러 variable n might not have been initialized
}
}// Test068.java 와 비교
public class Test069
{
// 클래스의 영역
// 전역 변수 a 선언
int a;
// 자동으로 0으로 초기화 지원
boolean b;
char c;
double d;
public static void main(String[] args)
{
// 메소드의 영역
// System.out.println("a : " + a);
// 컴파일 에러 non-static variable a cannot be referenced from a static context
// Scanner 클래스를 기반으로 인스턴스 생성
Test069 ob = new Test069();
System.out.println("ob.a : " + ob.a); // ob.a : 0
System.out.println("ob.b : " + ob.b); // ob.b : false
System.out.println("ob.c : " + ob.c); // ob.c :
System.out.println("ob.d : " + ob.d); // ob.d : 0.0
}
}직사각형 클래스 설계 실습(070)
/*
직사각형의 넓이와 둘레를 계산하는 객체 -> 클래스로 표현
클래스의 정체성 -> 직사각형의 설계도
클래스의 속성 -> 가로, 세로 (, 넓이, 둘레, 부피, 무게, 재질, 색상, 질량... 등등)
클래스의 기능 -> 넓이 계산, 둘레 계산, 가로 세로 입력, 결과 출력
객체를 구성 -> 속성(상태,데이터) + 기능(동작, 행위)
== 클래스를 설계 -> 변수 + 메소드
class 직사각형
{
// 속성(상태, 데이터) -> 변수 (순서 의미 없음)
가로, 세로
// 기능(동작, 행위) -> 메소드 (순서 의미 없음)
가로 세로 입력()
{
}
넓이 계산()
{
}
둘레 계산()
{
}
결과 출력()
{
}
}
*/
import java.util.Scanner;
class Rect // 직사각형 클래스 설계
{
// 속성(상태, 데이터) -> 변수 (순서 의미 없음)
int w, h; // 가로, 세로
// 기능(동작, 행위) -> 메소드 (순서 의미 없음)
void input() // 가로, 세로 입력
{
Scanner sc = new Scanner(System.in);
System.out.print("가로 입력 : ");
w = sc.nextInt();
System.out.print("세로 입력 : ");
h = sc.nextInt();
}
int calLength() // 둘레 계산 -> (가로 + 세로) * 2
{
return (w + h) * 2;
//int result = (w + h) * 2;
//return result;
}
int calArea() // 넓이 계산 -> 가로 * 세로
{
// 주요 변수 선언
int result;
// 연산 및 처리 -> 선언한 변수들에 값 담아내기
result = w * h;
// 최종 결과 반환
return result;
// return w * h;
}
void print(int a, int b) // 결과 출력 -> 가로 : xx 세로 : yy 넓이 : kk 둘레 : jj
{
// 가로 : 10
// 세로 : 20
// 넓이 : xxx
// 둘레 : xxx
System.out.println("가로 : " + w);
System.out.println("세로 : " + h);
System.out.println("넓이 : " + a);
System.out.println("둘레 : " + b);
}
}
// 하나의 자바 파일에 여러 개의 클래스를 설계할 수 있다.
// 하지만 public class는 이 파일 내에서 하나만 올 수 있다.
// 파일을 저장할 때의 이름은
// 이 public class의 이름으로 지정해야 한다.
// 일반적으로는 하나의 파일에하나의 클래스를 설계한다.
// 또한, 여러 개의 클래스가 설계된 하나의 파일을 컴파일 하게 되면
// 내부에 설계된 클래스의 수 만큼 클래스 파일이 파생된다.
public class Test070
{
public static void main(String[] args)
{
// Rect 클래스 기반의 인스턴스 생성
Rect ob = new Rect();
// new Rect
// Rect();
// 입력 메소드 호출
ob.input();
// 넓이 연산 메소드 호출
int area = ob.calArea();
// 둘레 연산 메소드 호출
int length = ob.calLength();
// 출력 메소드 호출
ob.print(area, length);
// 실행 결과
/*
가로 입력 : 500
세로 입력 : 65
가로 : 500
세로 : 65
넓이 : 32500
둘레 : 1130
*/
}
}클래스와 인스턴스(071)
// CircleTest.java 파일과 한 세트
// BufferedReader나 Input등은 추가해줄 필요가 없다.
import java.io.IOException;
public class Test071
{
public static void main(String[] args) throws IOException
{
/*
CircleTest cr = new CircleTest();
cr.input();
double le = cr.calLength();
double ar = cr.calArea();
cr.print(ar, le);
내 풀이
--------------------------------------
수업
*/
// CircleTest 클래스 기반 인스턴스 생성 == 인스턴스 생성 == 객체 생성
CircleTest ob = new CircleTest();
ob.input(); // 이 메소드 안에 예외 처리를 해주었으면 여기 main 메소드에도 처리해 주어야 한다.
double num1 = ob.calArea();
double num2 = ob.calLength();
ob.print(num1, num2);
}
}/*================================
■■■ 클래스와 인스턴스 ■■■
=================================*/
// Test071.java 파일과 한 세트
// 원의 넓이와 둘레 구하기
// 원의 넓이와 둘레를 구할 수 있는 클래스를 설계한다.
// (클래스명 : CircleTest)
// 입력은 BufferedREader 의 readLine()
// 원의 넓이 = 반지름 * 반지름 * 3.141592
// 원의 둘레 = 반지름 * 2 * 3.141592
// 실행 예)
// 반지름 입력 : xxx
// >> 반지름이 xxx 인 원의
// >> 넓이 : xxxx.xx
// >> 둘레 : xxxx.xx
// 계속하려면 아무 키나 누르세요...
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
/*
class CircleTest
{
int r;
void input() throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("반지름 입력 : ");
r = Integer.parseInt(br.readLine());
}
double calLength()
{
return r * 2.0 * 3.141592;
}
double calArea()
{
return r * r * 3.141592;
}
void print(double a, double b)
{
System.out.printf(">> 반지름이 %d 인 원의\n",r);
System.out.printf(">> 넓이 : %.2f\n", a);
System.out.printf(">> 둘레 : %.2f\n", b);
}
} 내 풀이
--------------------------------------
수업
*/
class CircleTest
{
// 주요 속성(데이터, 상태) -> 멤버 변수
int r;
final double PI = 3.141592;
// 주요 기능(동작, 행위) -> 멤버 메소드
// 반지름 입력 기능
void input() throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // input()에만 필요하기 때문에 input안에 넣는다.
System.out.print("반지름 입력 : ");
r = Integer.parseInt(br.readLine());
}
// 넓이 계산 기능
double calArea()
{
return r * r * PI;
}
// 둘레 계산 기능
double calLength()
{
double result;
result = 2 * PI * r;
return result;
}
// 결과 출력 기능
void print(double a, double l)
{
System.out.printf("\n>> 반지름이 %d 인 원의\n",r);
System.out.printf(">> 넓이 : %.2f\n", a);
System.out.printf(">> 둘레 : %.2f\n", l);
}
}1 부터 입력받은 수 까지의 합을 연산하여 결과값을 출력하는 프로그램을 구현(072)
단, 지금까지처럼 main() 메소드에 모든 기능을 적용하는 것이 아니라
클래스와 인스턴스의 개념을 활용하여 처리할 수 있도록 한다.
(Hap) 클래스 설계
또한, 데이터 입력 처리 과정에서 BufferedReader 의 readLine() 을 사용하며,
입력 데이터가 1보다 작거나 1000보다 큰 경우
다시 입력받을 수 있는 처리를 포함하여 프로그램을 구현할 수 있도록 한다.
실행 예)
임의의 정수 입력(1~1000) : 1200
임의의 정수 입력(1~1000) : -50
임의의 정수 입력(1~1000) : 100
1 ~ 100 까지의 합 : 5050
계속하려면 아무 키나 누르세요...
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
class Hap
{
/* 내 풀이
int n,sum;
void input() throws IOException
{
do
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("임의의 정수 입력(1~1000) : ");
n = Integer.parseInt(br.readLine());
}
while(n < 1 || n > 1000);
}
void calSum()
{
for(int i = 1; i <= n; i++)
{
sum += i;
}
}
void print()
{
System.out.printf(">> 1 ~ %d 까지의 합 : %d\n", n, sum);
}
수업----------------------------------------------*/
// 주요 변수 선언(사용자의 입력값을 담아낼 변수
int su;
// 입력 메소드 정의
void input() throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
do
{
System.out.print("임의의 정수 입력(1~1000) : ");
su = Integer.parseInt(br.readLine());
}
while (su < 1 || su > 1000);
}
// 연산 처리 메소드 정의
int calculate()
{
int result = 0;
for(int i = 1; i <= su; i++)
{
result += i;
}
return result;
}
// 결과 출력 메소드 정의
void print(int sum)
{
System.out.printf("\n>> 1 ~ %d 까지의 합 : %d\n", su, sum);
}
}
public class Test072
{
public static void main(String[] args) throws IOException
{
/* 내 풀이
Hap hp = new Hap();
hp.input();
hp.calSum();
hp.print();
수업 ------------------------------------------------*/
Hap ob = new Hap();
// 생성된 인스턴스를 통해 입력 메소드 호출
// --------------
// 참조변수 활용
ob.input(); // 참조변수 ob 활용 // new Hap().input() 도 가능은 하다
// 생성된 인스턴스를 통해 연산 메소드 호출
int s = ob.calculate();
// 생성된 인스턴스를 통해 출력 메소드 호출
ob.print(s); // == ob.print(ob.calculate();)
/*
임의의 정수 입력(1~1000) : -7
임의의 정수 입력(1~1000) : 10000
임의의 정수 입력(1~1000) : 15
>> 1 ~ 15 까지의 합 : 120
*/
}
}임의의 두 정수와 연산자를 입력받아 해당 연산을 수행하는 프로그램을 구현(073)
`
단, 클래스와 인스턴스의 개념을 활용하여 작성할 수 있도록 한다.
(Calculate 클래스 설계)
실행 예)
임의의 두 정수 입력(공백 구분) : 100 51
임의의 연산자(+ - * /)
100 + 51 = 151
계속하려면 아무 키나 누르세요...
import java.util.Scanner;
import java.io.IOException;
class Calculate
{
int su1, su2;
char op;
void input() throws IOException
{
Scanner sc = new Scanner(System.in);
System.out.print("임의의 두 정수 입력(공백 구분) : ");
su1 = sc.nextInt();
su2 = sc.nextInt();
System.out.print("임의의 연산자(+ - * /) : ");
op = (char)System.in.read();
}
int cal() // 연산 기능 -> 나눗셈 연산도 정수 기반으로 처리
{
int result = -1;
switch(op)
{
case '+': result = su1 + su2; break;
case '-': result = su1 - su2; break;
case '*': result = su1 * su2; break;
case '/': result = su1 / su2; break;
//default : result = -1;
}
return result;
}
void print(int s) // 출력
{
System.out.printf("\n>> %d %c %d = %d\n", su1, op, su2, s);
}
}
/*
{
int a,b,ans; // 입력 받을 두 숫자와 연산 결과
char c;
void input() throws IOException
{
Scanner sc = new Scanner(System.in);
System.out.print("임의의 두 정수 입력(공백 구분) : ");
a = sc.nextInt();
b = sc.nextInt();
System.out.print("임의의 연산자(+ - * /) : ");
c = (char)System.in.read();
}
void cal()
{
if(c == '+')
ans = a + b;
else if(c == '-')
ans = a - b;
else if(c == '*')
ans = a * b;
else
ans = a / b;
}
void print()
{
System.out.printf("\n>> %d %c %d = %d\n", a, c, b, ans);
}
}
*/
public class Test073
{
public static void main(String[] args) throws IOException
{
/* 내 풀이
Calculate cl = new Calculate();
cl.input();
cl.cal();
cl.print();
수업--------------------------------------------------*/
Calculate cal = new Calculate();
cal.input(); // 생성한 인스턴스를 통한 입력 메소드 호출
int r = cal.cal(); // 생성한 인스턴스를 통한 연산 메소드 호출
cal.print(r); // 생성한 인스턴스를 통한 출력 메소드 호출
}
}StringTokenizer를 활용한 풀이
import java.util.Scanner;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;
class Calculate
{
int a,b,ans; // 입력 받을 두 숫자와 연산 결과
char c;
String str;
void input() throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("임의의 두 정수 입력(공백 구분) : ");
str = br.readLine();
StringTokenizer st = new StringTokenizer(str);
a = Integer.parseInt(st.nextToken());
b = Integer.parseInt(st.nextToken());
System.out.print("임의의 연산자(+ - * /) : ");
c = (char)System.in.read();
}
void cal()
{
if(c == '+')
ans = a + b;
else if(c == '-')
ans = a - b;
else if(c == '*')
ans = a * b;
else
ans = a / b;
}
void print()
{
System.out.printf("\n>> %d %c %d = %d\n", a, c, b, ans);
}
}
public class Test73
{
public static void main(String[] args) throws IOException
{
Calculate cl = new Calculate();
cl.input();
cl.cal();
cl.print();
}
}생성자(074)
/*
○ 생성자(Constructor)의 역할
1. 인스턴스 생성 -> 메모리 할당
2. 초기화
○ 생성자(Constructor)의 특징
1. 생성자는 메소드이지만, 일반 메소드처럼 호출될 수 없으며,
반환 자료형을 가질 수 없다.
(void 조차 가질 수 없으며, 값을 반환할 수도 없다.)
2. 생성자는 클래스와 동일한 이름을 가져야 한다.
(대소문자 명확히 구분)
3. 생성자는 객체를 생성하는 과정에서 new 생성자(); 의 형태로 호출된다.
(인스턴스 생성 시 단 한 번만 호출)
-> final 변수(상수화된 변수) 초기화 가능.
*/
class NumberTest
{
int num;
//NumberTest(){} // 디폴트 생성자(비어있음)
// 아래처럼 사용자 정의 생성자를 작성하지 않으면 디폴트 생성자가 자동으로 삽입
NumberTest()
{
num = 1;
System.out.println("사용자 정의 생성자 호출");
}
int getNum()
{
return num;
}
}
public class Test074
{
public static void main(String[] args)
{
// NumberTest 클래스 기반의 인스턴스 생성
NumberTest nt1 = new NumberTest(); // NumberTest() 생성자도 메소드이다.
//== 사용자 정의 생성자 호출
// 인스턴스가 생성되는 시점에서 이와 동시에 선택의 여지 없이
// 생성자 호출이 이루어진다.
// -----------
// NumberTest();
int num = nt1.getNum();
System.out.println(num);
//== 1
nt1.num = 200;
System.out.println(nt1.getNum());
//== 200
// NumberTest 클래스 기반의 인스턴스 생성
NumberTest nt2 = new NumberTest();
//== 사용자 정의 생성자 호출
System.out.println("nt1.num : " + nt1.getNum());
System.out.println("nt2.num : " + nt2.getNum());
// nt1.num : 200
// nt2.num : 1
}
}11일차
생성자와 초기화블럭(076 ~ 078)
public class Test076
{
int x;
// 생성자의 이름은 항상 예외없이 클래스의 이름과 동일해야 하며
// 필요할 경우는 인수를 받아들이는 것도 가능하다.
// 같은 이름의 메소드를 정의하는 중복정의가 가능하지만
// 리턴값(반환값)은 가질 수 없다.
// 생성자는 다른 일반 메소드처럼 호출될 수 없고
// new 연산자를 이용하여 객체를 생성하기 위해 호출되며,
// 각 클래스의 인스턴스인 객체를 생성한 후에
// 생성된 객체의 멤버를 초기화 시키는 작업을 수행하게 된다.
// 생성자
Test076()
{
// 생성자 내부에서 다른 생성자를 호출하는 것은 가능하다. 다른 일반 메소드처럼
// 하지만, 생성자 내부에서 가장 먼저 실행되어야 한다.
this(200);
// 생성자 내부에서 또 다른 생성자를 호출하는 구문
x = 10; // this.x = x라고 해도 됨, x를 매개변수로 받는 것이 아니기 때문에 안해도 문제 없음.
System.out.println("인자 없는 생성자");
System.out.println("Test076이 가지고 있는 x : " + x); // 위와 같이 this.x = x 도 가능
// Test076(200); 가장 먼저 실행되어야 하기 때문에 에러
}
// 생성자
Test076(int x)
{
// x = num;
// x = x; 둘 다 지역변수
// Test076.x = x; 문법적으로 안됨
// this키워드
this.x = x;
// - 논리적인 해석 -> Test076.x = x;
System.out.println("인자가 하나인 생성자");
// this.x = x; 해줬을 때
System.out.println("Test076이 가지고 있는 x : " + this.x); // Test076이 가지고 있는 x : 100
// this.x = x 해주지 않았을 때
System.out.println("Test076이 가지고 있는 x : " + this.x); // Test076이 가지고 있는 x : 0
}
public static void main(String[] args)
{
// Test076 클래스 기반 인스턴스 생성
Test076 ob1 = new Test076();
Test076 ob2 = new Test076(100);
/*
인자 없는 생성자
Test076이 가지고 있는 x : 10
인자가 하나인 생성자
Test076이 가지고 있는 x : 100
*/
System.out.println();
System.out.println("main 에서 ob1.x : " + ob1.x);
System.out.println("main 에서 ob2.x : " + ob2.x);
// main 에서 ob1.x : 10
// main 에서 ob2.x : 100
}
}public class Test077
{
int val1;
double val2;
Test077()
{
val1 = 0;
val2 = 0;
System.out.println("매개변수 없는 생성자...");
}
Test077(int val1)
{
this.val1 = val1;
val2 = 0;
System.out.println("int형 데이터를 넘겨받는 생성자...");
}
Test077(double val2)
{
val1 = 0;
this.val2 = val2;
System.out.println("double형 데이터를 넘겨받는 생성자...");
}
Test077(int val1, double val2)
{
this.val1 = val1;
this.val2 = val2;
System.out.println("int형 데이터와 double형 데이터를 넘겨받는 생성자...");
}
public static void main(String[] args)
{
Test077 ob1 = new Test077();
System.out.println(ob1.val1 + ", " + ob1.val2);
Test077 ob2 = new Test077(4);
System.out.println(ob2.val1 + ", " + ob2.val2);
Test077 ob3 = new Test077(7.0);
System.out.println(ob3.val1 + ", " + ob3.val2);
Test077 ob4 = new Test077(4, 7.0);
System.out.println(ob4.val1 + ", " + ob4.val2);
/*
매개변수 없는 생성자...
0, 0.0
int형 데이터를 넘겨받는 생성자...
4, 0.0
double형 데이터를 넘겨받는 생성자...
0, 7.0
int형 데이터와 double형 데이터를 넘겨받는 생성자...
4, 7.0
*/
}
}public class Test078
{
/* 수행할 수 없음
int n;
int m;
n = 100;
m = 200; 연산은 메소드 내에서 해야함
*/
/*선언과 초기화를 동시에 하면 수행 가능
int n = 100;
int m = 200;
*/
int n;
int m;
// 생성자(Constructor)
Test078()
{
n = 100;
m = 200;
System.out.println("생성자 실행...");
}
// 초기화 블럭(Initialized Block)
{
n = 10;
m = 20;
System.out.println("초기화 블럭 실행...");
}
// 멤버 출력 메소드 정의
void write()
{
System.out.println("n : " + n + ", m : " + m);
}
Test078(int n, int m)
{
this.n = n;
this.m = m;
System.out.println("매개변수 있는 생성자 실행...");
}
public static void main(String[] args)
{
Test078 ob1 = new Test078();
ob1.write();
/*
초기화 블럭 실행...
생성자 실행...
n : 100, m : 200
계속하려면 아무 키나 누르십시오 . ..
*/
Test078 ob2 = new Test078(222,333);
ob2.write();
/* 초기화 블럭 실행...
매개변수 있는 생성자 실행...
n : 222, m : 333
*/
}
}배열의 선언과 초기화(079)
/*
○ 배열의 개요
1. 자바에서의 배열이란 크기와 성격이 같은 일련의 원소들이 모여
공동의 집합 구조를 갖는 자료의 집합체를 의미하는 것으로
동질적인 성격을 가진 자료들에 대해
개별적으로 자료형(Daye Type)을 부여하지 않고
하나의 이름을 가지고 일괄적으로 처리할 목적으로 사용된다.
2. 자바에서의 배열은 다음과 같은 순서에 의해 사용된다.
배열 선언 -> 배열에 메모리 할당 -> 배열 요소 접근(배열 요소의 사용)
○ 형식 및 구조
자료형[] 변수명;
변수명 = new 자료형[요소크기];
변수명[인덱스] = 값;
int[] arr;
arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
*/
public class Test079
{
public static void main(String[] args)
{
// 배열 선언
int[] arr;
// 메모리 할당
arr = new int[10];
// 배열은 다음과 같이 선언과 동시에
// 메모리 할당 및 초기화가 가능하다.
int[] arr2 = new int[10];
int[] arr3 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int arr4[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
// 배열 요소 접근(사용)
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
// 값을 할당하지 않은 나머지 배열 공간은
// 비어있는 것이 아니라 자동으로 초기화 된다. -> 0(int형 배열)
int num = 10;
System.out.println("num : " + num); //== num : 10
System.out.println("arr : " + arr); //== arr : [I@15db9742
// 배열을 출력하기 위해 배열 변수를 일반 변수처럼 사용하여
// 출력하는 구문으로 작성하게 되면
// 배열의 각 방에 들어있는 데이터가 출력되는 것이 아니라
// 우리가 알아볼 수 없는 코드가 출력된다.
// 또한, 출력되는 값은 메모리의 주소값으로 오해하면 안된다.
// (자바는 메모리 주소값에 사용자가 직접 접근하는 것을 허용하지 않기 때문)
System.out.println("arr[0] : " + arr[0]);
System.out.println("arr[1] : " + arr[1]);
System.out.println("arr[2] : " + arr[2]);
// arr[0] : 1
// arr[1] : 2
// arr[2] : 3
System.out.println(arr[0] + " " + arr[1] + " " + arr[2] + " " + arr[3] + " " +
arr[4] + " " + arr[5] + " " + arr[6] + " " + arr[7] + " " +
arr[8] + " " + arr[9]);
//== 1 2 3 0 0 0 0 0 0 0
//System.out.println(arr[10]);
//== ArrayIndexOutOfBoundsException
// 반복문을 활용하여 배열에 담긴 데이터 전체 출력
for(int i = 0; i < 10; i++) // i -> 0 1 2 3 4 5 6 7 8 9
{
// 테스트
//System.out.println("i : " + i);
// 테스트
// System.out.printf("%2d", arr[i]);
System.out.printf("arr 배열의 %d번째 방 : %2d\n", i, arr[i]);
/*
arr 배열의 0번째 방 : 1
arr 배열의 1번째 방 : 2
arr 배열의 2번째 방 : 3
arr 배열의 3번째 방 : 0
arr 배열의 4번째 방 : 0
arr 배열의 5번째 방 : 0
arr 배열의 6번째 방 : 0
arr 배열의 7번째 방 : 0
arr 배열의 8번째 방 : 0
arr 배열의 9번째 방 : 0
*/
}
}
}배열에서 짝수인 요소만 골라서 출력하고, 3의 배수인 요소만 골라서 출력하는 프로그램을 구현(080)
배열을 구성하는 임의의 정수 = 4 7 9 1 3 2 5 6 8
실행 예)
배열 요소 전체 출력
4 7 9 1 3 2 5 6 8
짝수 선택적 출력
4 2 6 8
3의 배수 선택적 출력
9 3 6
계속하려면 아무 키나 누르세요..
public class Test080
{
public static void main(String[] args)
{
/* 내 풀이
int arr[] = {4, 7, 9, 1, 3, 2, 5, 6, 8};
System.out.println("배열 요소 전체 출력");
for(int i = 0; i < 9; i++)
{
System.out.printf("%d ", arr[i]);
}
System.out.println("\n짝수 선택적 출력");
for(int i = 0; i < 9; i++)
{
if(arr[i] % 2 == 0)
System.out.printf("%d ", arr[i]);
}
System.out.println("\n3의 배수 선택적 출력");
for(int i = 0; i < 9; i++)
{
if(arr[i] % 3 == 0)
System.out.printf("%d ", arr[i]);
}
System.out.println();
수업--------------------------------------
*/
// 배열 선언 및 초기화
/* 방법 1
int[] arr = new int[9];
arr[0] = 4;
arr[1] = 7;
arr[2] = 9;
arr[3] = 1;
arr[4] = 3;
arr[5] = 2;
arr[6] = 5;
arr[7] = 6;
arr[8] = 8;
*/ //방법 2
int arr[] = {4, 7, 9, 1, 3, 2, 5, 6, 8};
// System.out.println(arr); == [I@15db9742
// 일반적인 변수에 담긴 내용을 출력하는 형식(방법)으로는
// 배열에 담긴 데이터들을 출력할 수 없다.
System.out.println("배열 요소 전체 출력");
for(int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + " ");
}
System.out.println();
//== 배열 요소 전체 출력
//== 4 7 9 1 3 2 5 6 8
System.out.println("짝수 선택적 출력");
for(int i = 0; i < arr.length; i++)
{
/*
if(i % 2 == 0) // i 가 짝수라면 -> 짝수 번째에 해당하는 요소라면
{
// 출력해 -> 해당 인덱스를
//System.out.print(i + " ");
// 출력해 -> 인덱스에 해당하는 값을
System.out.print(arr[i] + " ");
}
*/
if(arr[i] % 2 == 0) // i 번째 요소의 값이 짝수라면
{
System.out.print(arr[i] + " ");
}
}
System.out.println();
System.out.println("3의 배수 선택적 출력");
for(int i = 0; i < arr.length; i++)
{
if(arr[i] % 3 == 0)
{
System.out.printf("%d ", arr[i]);
}
}
System.out.println();
/*
배열 요소 전체 출력
4 7 9 1 3 2 5 6 8
짝수 선택적 출력
4 2 6 8
3의 배수 선택적 출력
9 3 6
계속하려면 아무 키나 누르십시오 .
*/
}
}배열의 각 방에 알파벳 대문자를 채우고 채워진 그 배열의 전체 요소를 출력하는 프로그램을 구현(081)
단, 채우는 구문과 출력하는 구문은 따로 분리하여 처리할 수 있도록 한다.
실행 예)
A B C D E F G H I J K ... V W X Y Z
계속하려면 아무 키나 누르세요
public class Test081
{
public static void main(String[] args)
{
/*
내 풀이
char al[] = new char[26];
for(int i = 0; i < al.length; i++)
{
al[i] = (char)('A' + i);
}
//for(int i = 0; i < al.length; i++)
//{
// System.out.printf("%c ", al[i]);
//}
for(int i:al)
{
System.out.printf("%c ",i);
}
*/
== A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
// 계속하려면 아무 키나 누르세요
수업-----------------------------------*/
// 방법 1
char[] arr1;
arr1 = new char[26];
arr1[0] = 'A';
arr1[0] = 'B';
// 방법 2
char[] arr2 = {'A', 'B', 'C', 'D', '.', 'Z'};
// 방법 3
char[] arr3 = new char[26];
for(int i = 0, ch = 65; i < arr3.length; i++, ch++)
{
// 테스트
// System.out.println("i: " + i + ", ch: " + ch);
arr3[i] = (char)ch;
}
// 배열 요소 전체 출력
for(int i = 0; i < arr3.length; i++)
{
System.out.print(arr3[i] + " ");
}
System.out.println();
//== A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
// 계속하려면 아무 키나 누르세요
}
}학생 이름과 전화번호를 입력받아 결과 출력(082)
사용자로부터 인원수를 입력받고
입력받은 인원 수 만큼의 학생 이름과 전화번호를 입력받아
이렇게 입력받은 데이터를 이름 배열과 전화번호 배열로 구성하여
결과를 출력할 수 있는 프로그램을 구현한다.
실행 예)
입력 처리할 학생 수 입력(명, 1~10) : 27
입력 처리할 학생 수 입력(명, 1~10) : -5
입력 처리할 학생 수 입력(명, 1~10) : 3
이름 전화번호 입력[1](공백 구분) : 박범구 010-1234-2345
이름 전화번호 입력[1](공백 구분) : 엄재용 010-2345-3456
이름 전화번호 입력[3](공백 구분) : 오수경 010-3456-4567
--------------------
전체 학생 수 : 3
--------------------
이름 전화번호
홍길동 010-1234-2345
홍길동 010-2345-3456
홍길동 010-3456-4567
--------------------
계속하려면 아무 키나 누르세요import java.io.IOException;
import java.util.Scanner;
public class Test082
{
public static void main(String[] args) throws IOException
{
/* 내 풀이
Scanner sc = new Scanner(System.in);
int n = 0;
do
{
System.out.print("입력 처리할 학생 수 입력(명, 1~10) : ");
n = sc.nextInt(); // 학생 수 n
}
while (n < 1 || n > 10);
String[] name = new String[n]; // 이름을 담을 문자열 배열
String[] number = new String[n]; // 번호를 담을 문자열 배열
for(int i = 0; i < n; i++)
{
System.out.printf("이름 전화번호 입력[%d](공백 구분 ) : ", i + 1);
name[i] = sc.next();
number[i] = sc.next();
}
System.out.println();
System.out.println("--------------------");
System.out.printf("전체 학생 수 : %d\n",n);
System.out.println("--------------------");
System.out.println("이름 전화번호");
for(int i = 0; i < n; i++)
{
System.out.print(name[i]+ " ");
System.out.print(number[i] + " \n");
}
System.out.println("--------------------");
수업 ------------------------------------*/
Scanner sc = new Scanner(System.in);
// 사용자가 입력하는 학생 수를 담아낼 변수
int memberCount = 0;
System.out.print("입력 처리할 학생 수 입력(명, 1~10) : ");
memberCount = sc.nextInt();
do
{
System.out.print("입력 처리할 학생 수 입력(명, 1~10) : ");
memberCount = sc.nextInt();
}
while (memberCount < 1 || memberCount > 10);
// 테스트(확인)
// System.out.println("사용자가 입력한 인원 수 : "+ memberCount);
// 사용자가 입력한 인원 수를 토대로
// 이름 배열과 전화번호 배열을 생성해야 한다.
// 인원 수 만큼의 이름 저장 배열 구성
String[] names = new String[memberCount];
// 인원 수 만큼의 전화번호 저장 배열 구성 , 전화번호는 앞에 0이 오기 때문에 -가 없더라도 String으로 해야함
String[] tels = new String[memberCount]; //String[names.length]로 해도 됨
// 이름 전화 번호 입력
// 인원 수 만큼의 안내 메세지 출력 및 입력값 담아내기
// for(nt i = 0; i < names.length; i++)
// for(int i = 0; i < tels.length; i++)
for(int i = 0; i < memberCount; i++)
{
System.out.printf("이름 전화번호 입력[%d](공백 구분) : ", i + 1);
// 박범구 010-1234-2345
// ------
names[i] = sc.next();
// 박범구 010-1234-2345
// -------------
tels[i] = sc.next();
}
// 최종 결과(이름, 전화번호) 출력
System.out.println();
System.out.println("--------------------");
System.out.printf("전체 학생 수 : %d\n", memberCount);
System.out.println("--------------------");
System.out.println("이름 전화번호");
for(int i = 0; i < memberCount; i++)
{
System.out.printf("$3s %14s\n", names[i], tels[i]);
}
System.out.println("--------------------");
}
}import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;
public class Test82
{
public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
int n = 0;
do
{
System.out.print("입력 처리할 학생 수 입력(명, 1~10) : ");
n = Integer.parseInt(br.readLine()); // 학생 수 n
}
while (n < 1 || n > 10);
String[] name = new String[n]; // 이름을 담을 문자열 배열
String[] number = new String[n]; // 번호를 담을 문자열 배열
for(int i = 0; i < n; i++)
{
System.out.printf("이름 전화번호 입력[%d](공백 구분 ) : ", i + 1);
str = br.readLine();
StringTokenizer st = new StringTokenizer(str);
name[i] = st.nextToken();
number[i] = st.nextToken();
}
System.out.println("--------------------");
System.out.printf("전체 학생 수 : %d\n",n);
System.out.println("--------------------");
System.out.println("이름 전화번호");
for(int i = 0; i < n; i++)
{
System.out.print(name[i]+ " ");
System.out.print(number[i] + " \n");
}
System.out.println("--------------------");
}
}입력받은 수 중에 가장 큰 수를 출력하는 프로그램 구현(083)
○ 과제
사용자로부터 임의의 정수를 임의의 갯수만큼 입력받아
입력받은 수 중에서 가장 큰 수를 출력하는 프로그램을 구현한다.\
단, 배열을 활용하여 구현할 수 있도록 한다.
실행 예)
입력할 데이터의 갯수 : 11
데이터 입력(공백 구분) : 45 11 26 35 66 97 50 2 123 10 7
가장 큰 수 -> 123
계속하려면 아무 키나 누르세요...
import java.io.IOException;
import java.util.Scanner;
public class Test083
{
public static void main(String[] args) throws IOException
{
Scanner sc = new Scanner(System.in);
int max = -100000000; // 작은 수로 max값 초기화
System.out.print("입력할 데이터의 갯수 : ");
int n = sc.nextInt(); // 입력할 데이터의 갯수 n
int[] num = new int[n]; // 입력받은 n값으로 배열 만들어 줌
System.out.print("데이터 입력(공백 구분) : ");
for(int i = 0; i < n; i++)
{
num[i] = sc.nextInt(); // 공백으로 구분
if(num[i] > max) // num[i]의 값이 max보다 크면
max = num[i]; // max에 num[i] 대입
}
System.out.printf("\n>> 가장 큰 수 → %d\n",max);
/*
입력할 데이터의 갯수 : 5
데이터 입력(공백 구분) : 75 15 48 75 36
>> 가장 큰 수 → 75
*/
}
}사용자로부터 임의의 학생 수를 입력받고 그만큼의 점수(정수 형태)를 입력받아 전체 학생 점수의 합, 평균, 편차를 구해서 결과를 출력하는 프로그램을 구현(084)
실행 예)
학생 수 입력 : 5
1번 학생의 점수 입력 : 90
2번 학생의 점수 입력 : 82
3번 학생의 점수 입력 : 64
4번 학생의 점수 입력 : 36
5번 학생의 점수 입력 : 98
합 : 370
평균 : 74.0
편차
90 : -16.0
82 : -8.0
64 : 10.0
36 : 38.0
98 : -24.0
계속하려면 아무 키나 누르세요..
*/
import java.io.IOException;
import java.util.Scanner;
public class Test084
{
public static void main(String[] args) throws IOException
{
Scanner sc = new Scanner(System.in);
System.out.print("학생 수 입력 : ");
int n = sc.nextInt(); // 학생수 n 입력 받음
int total = 0; // 합
double avg = 0.0; // 평균
double dev = 0.0; // 편차
int[] score = new int[n]; // 점수를 입력받아 저장할 배열
for(int i = 0; i < n; i++)
{
System.out.printf("%d번 학생의 점수 입력 : ", i + 1);
score[i] = sc.nextInt(); // 점수를 입력받아 배열에 넣어준다.
total += score[i]; // 누적합 계산
}
avg = (double)total / n; // 합과 n 모두 int형이라서 double형으로 강제 형변환 해준다.
System.out.println();
System.out.printf(">> 합 : %d\n", total);
System.out.printf(">> 평균 : %.1f\n", avg);
System.out.println(">> 편차");
for(int i = 0; i < n; i++)
{
System.out.printf("%d : %.1f\n", score[i], avg - score[i]);
}
/*
실행결과
학생 수 입력 : 5
1번 학생의 점수 입력 : 90
2번 학생의 점수 입력 : 82
3번 학생의 점수 입력 : 64
4번 학생의 점수 입력 : 36
5번 학생의 점수 입력 : 98
>> 합 : 370
>> 평균 : 74.0
>> 편차
90 : -16.0
82 : -8.0
64 : 10.0
36 : 38.0
98 : -24.0
*/
}
}배열의 배열(085)
public class Test085
{
public static void main(String[] args)
{
// 배열의 배열 선언과 초기화
// 방법 1
// int [] arr1 = new int[3];
int[][] arr1 = new int[3][3];
// arr1[0] = 1;
arr1[0][0] = 1;
arr1[0][1] = 2;
arr1[0][2] = 3;
arr1[1][0] = 4;
arr1[1][1] = 5;
arr1[1][2] = 6;
arr1[2][0] = 7;
arr1[2][1] = 8;
arr1[2][2] = 9;
// 방법 2
// int[] arr2 = {1, 2, 3};
int[][] arr2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
// 방법 3
int[][] arr3 = new int[3][3];
int n = 1;
for(int i = 0; i < arr3.length; i++) // arr3.length == 3 0 1 2
{
for(int j = 0; j <arr3[i].length; j++) // arr3[i].length == 3 012 012 012
{
// 테스트
// System.out.println("i:"+i + " j:"+j);
arr3[i][j] = n;
n++;
}
}
// 배열의 배열 요소 전체 출력
for(int i = 0; i < arr3.length; i++)
{
for(int j = 0; j < arr3[i].length; j++)
{
System.out.printf("%2d", arr3[i][j]);
}
System.out.println();
}
// 실행 결과
/*
1 2 3
4 5 6
7 8 9
*/
}
}배열의 배열을 활용하여 다음과 같은 데이터를 요소로 취하는 배열(5*5)을 구성하고 그 결과를 출력하는 프로그램을 구현(086~94)
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열(5*5)을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
1 2 3 4 5 00 01 02 03 04
6 7 8 9 10 10 11 12 13 14
11 12 13 14 15 20 21 22 23 24
16 17 18 19 20
21 22 23 24 25 40 41 42 43 44
계속하려면...
*/
public class Test086
{
public static void main(String[] args)
{
/*
int n = 1;
int[][] arr = new int[5][5];
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
arr[i][j] = n;
n++;
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
System.out.printf("%2d ", arr[i][j]);
}
System.out.println();
}
*/
// 배열의 배열 선언 + 메모리 할당
int[][] arr = new int[5][5];
// 변수 선언 및 초기화
int n = 1; // 1 2 3 4 5 6.. 24 25
// 배열의 배열을 반복문의 중첩 구문을 활용하여 구조화
for (int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
arr[i][j] = n;
n++;
}
}
// 담아내기 완료
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
System.out.printf("%3d ", arr[i][j]);
System.out.println();
}
/*
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
*/
}
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9
*/
public class Test087
{
public static void main(String[] args)
{
/*
int[][] arr = new int[5][5];
int n = 1;
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
arr[i][j] = n;
n++;
}
n = i + 2;
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
System.out.printf("%2d ", arr[i][j]);
}
System.out.println();
}
*/ int[][] arr = new int[5][5];
int n;
for(int i = 0; i < arr.length; i++)
{
n = i + 1;
for(int j = 0; j < arr[i].length; j++)
{
// 테스트
//System.out.print(" i:" + i + ", j:" + j);
//System.out.print(" [" + n + "]");
arr[i][j] = n;
n++;
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
System.out.printf("%3d ", arr[i][j]);
System.out.println();
}
}
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
1 2 3 4 5 00 01 02 03 04
5 1 2 3 4 10 11 12 13 14
4 5 1 2 3 20 21 22 23 24
3 4 5 1 2 30 31 32 33 34
2 3 4 5 1 40 41 42 43 44
*/
public class Test088
{
public static void main(String[] args)
{
int[][] arr = new int[5][5];
//int n = 1;
int m = 5;
/*
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
if(n == 6)
n = 1;
arr[i][j] = n;
n++;
}
n--;
}
for(int i = 0; i < arr.length; i++)
{
for(int j = i; j < arr[i].length; j++)
{
arr[i][j] = n;
n++;
}
n = 1;
}
for(int i = arr.length - 1; i > 0; i--)
{
for(int j = i; j > 0; j--)
{
arr[i][m] = m;
m--;
}
}
*/
for(int i = 0; i < arr.length; i++)
{
for(int n = 1, j = i; n <= 5; n++)
{
arr[i][j] = n;
j++;
if(j == 5)
j = 0;
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
System.out.printf("%3d ", arr[i][j]);
System.out.println();
}
}
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
1 8 9 16 17 00 01 02 03 04
2 7 10 15 18 10 11 12 13 14
3 6 11 14 19 20 21 22 23 24
4 5 12 13 20 30 31 32 33 34
*/
// 00 10 20 30 31 21 11 01 02 12
public class Test089
{
public static void main(String[] args)
{
int[][] arr = new int[4][5];
int n = 0;
/* 내 풀이
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 4; j++)
{
if(i % 2 == 0)
{
arr[j][i] = n;
n++;
}
if(i % 2 == 1)
{
arr[3 - j][i] = n;
n++;
}
}
}
수업-------------------------------------------*/
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 4; j++)
{
n++;
if(i % 2 == 0)
arr[j][i] = n;
else
arr[3 - j][i] = n;
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
System.out.printf("%3d ",arr[i][j]);
}
System.out.println();
}
}
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
E J O T Y 69 74 00
D I N S X 68 73 10
C H M R W 67 72 20
B G L Q V 66 71 30
A F K P U 65 70 40
*/
public class Test090
{
public static void main(String[] args)
{
/* 내 풀이
int[][] arr = new int[5][5];
int n = 65;
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
{
arr[4 - j][i] = n;
n++;
}
}
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
{
System.out.printf("%2c", arr[i][j]);
}
System.out.println();
}
-------------수업--------------------------------------------*/
// 배열의 배열 선언 및 메모리 할당
char[][] arr = new char[5][5];
// 배열 구성
char start = 'A'; // 65
for(int i = 0; i < 5; i++)
{
for(int j = 4; j >= 0; j--)
{
arr[j][i] = start++;
}
}
// 전체 요소 출력
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
System.out.printf("%2c", arr[i][j]);
}
System.out.println();
}
}
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
1 2 3 4 10
5 6 7 8 26
9 10 11 12 42
13 14 15 16 58
28 32 36 40 136
*/
public class Test091
{
public static void main(String[] args)
{
int[][] arr = new int[5][5];
/* 내 풀이
int n = 1;
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 4; j++)
{
arr[i][j] = n;
arr[4][j] += arr[i][j];
arr[i][4] += arr[i][j];
arr[4][4] += arr[i][j];
n++;
}
}
수업 ---------------------------------------------*/
int n = 0;
// 테스트 변수
int sum = 0;
// 각 for문 수식2의 -1 -> 반복문의 처리가 필요하지 않은 영역
for (int i = 0; i < arr.length-1; i++)
{
for(int j = 0; j < arr[i].length-1; j++)
{
n++;
arr[i][j] = n;
//sum += arr[i][j];
//System.out.printf("%4d", sum);\
arr[i][arr[i].length-1] += arr[i][j];
arr[arr.length-1][j] += arr[i][j];
arr[arr.length-1][arr[i].length-1] += arr[i][j];
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
System.out.printf("%4d", arr[i][j]);
}
System.out.println();
}
}
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
A B C D E
F G H I J
K L M N O
P Q R S T
U V W X Y
*/
public class Test092
{
public static void main(String[] args)
{
int n = 0;
int[][] arr = new int[5][5]; // 배열 선언
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
arr[i][j] = 'A' + n; // 배열의 값에 'A'부터 시작해서 n씩 증가한 값 넣기
n++; // n값에 1 더해준다.
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[i].length; j++)
{
System.out.printf("%3c", arr[i][j]); // 문자로 출력해야 하므로 %c로 출력해준다.
}
System.out.println();
}
}
/*
실행결과
A B C D E
F G H I J
K L M N O
P Q R S T
U V W X Y
계속하려면 아무 키나 누르십시오 .
*/
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예)
A
B C
D E F
G H I J
K L M N O
*/
public class Test093
{
public static void main(String[] args)
{
int n = 0;
int[][] arr = new int[5][5]; // 배열 선언
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j <= i; j++) // i번째 줄에 i번 출력해야 되기 때문에
{
arr[i][j] = 'A' + n; // 배열의 값에 'A'부터 시작해서 n씩 증가한 값 넣기
n++; // n값에 1 더해준다.
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j <= i; j++)
{
System.out.printf("%2c", arr[i][j]); // 문자로 출력해야 하므로 %c로 출력해준다.
}
System.out.println();
}
}
/* 실행결과
A
B C
D E F
G H I J
K L M N O
계속하려면 아무 키나 누르십시오
*/
}/*=======================
■■■ 배열 ■■■
- 배열의 배열
========================*/
/*
배열의 배열(다차원 배열)을 활용하여
다음과 같은 데이터를 요소로 취하는 배열을 구성하고
그 결과를 출력하는 프로그램을 구현한다.
실행 예) 00 / 11 10 / 20 21 22 / 33 32 31 30
A 00
C B 10 11
D E F 20 21 22
J I H G 30 31 32 33
K L M N O 40 41 42 43 44
*/
public class Test094
{
public static void main(String[] args)
{
int n = 65;
int[][] arr = new int[5][5]; // 배열 선언
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j <= i; j++) // i번째 줄에 i번 출력해야 되기 때문에
{
if(i % 2 == 0) // i가 짝수인 줄에서는
arr[i][j] = n; // 정상적으로 입력
if(i % 2 == 1) // i가 홀수인 줄에서는
arr[i][i-j] = n; // 11 10순으로 가야하므로 [i][i-j]를 해주면 11 10순으로 간다.
n++; // n을 1 더해준다.
}
}
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j <= i; j++)
{
System.out.printf("%2c", arr[i][j]); // 문자로 출력해야 하므로 %c로 출력해준다.
}
System.out.println();
}
}
}13일차
Random 활용(095)
/*======================================
■■■ 배열 ■■■
- 배열과 난수 처리(Random 클래스 활용)
=======================================*/
/*
사용자로부터 임의의 정수를 입력받아
그 수 만큼 난수(1~100)를 발생시켜 배열에 담고
배열에 담겨있는 데이터들 중
가장 큰 값과 가장 작은 값을 선택하여
결과를 출력하는 프로그램을 구현한다.
실행 예)
발생시킬 난수의 갯수 입력 : 10
(50 7 24 81 72 45 61 38 1 99 -> 무작위로 발생한 정수들...)
(int[] arr = {50, 7, 24, 81, 72, 45, 61, 38, 1, 99) -> 배열에 담아내기(배열 구성))
가장 큰 값 : 99, 가장 작은 값 : 1
계속하라면..
*/
import java.util.Scanner;
import java.util.Random;
public class Test095
{
public static void main(String[] args)
{
// Scanner 인스턴스 생성
Scanner sc = new Scanner(System.in);
// 주요 변수 선언
int size; // 사용자의 입력값을 담아낼 변수
// 안내 메세지 출력
System.out.print("발생시킬 난수의 갯수 입력 : ");
size = sc.nextInt();
// 입력받은 size 만큼의 배열방 만들기(배열 길이)
// (배열 선언 및 메모리 할당)
int[] arr = new int[size];
// 무작위 정수(난수)를 발생시키기 위해서는
// 난수 발생 전용 객체가 필요하다.
// -> java.util.Random
Random rd = new Random();
// Random 인스턴스 생성
// Random 클래스의 nextInt() 메소드
// 0 ~ 매개변수로 넘겨받은 정수 n-1 까지의 수 중
// 무작위 정수(난수) 1개를 발생시킨다.
// ex) rd.nextInt(10); // 0 ~ 9 중 난수 1개 발생
// 테스트(확인)
// System.out.println("발생한 난수 : " + rd.nextInt(10));
// 0 ~ 9까지의 범위 내에서 무작위 정수 한 개 발생
// 배열 구성
for(int i = 0; i < size; i++)
{
// rd,nextInt(101); // 0 ~ 100 중 1개
// rd.nextInt(100); // 0 ~ 99 중 1개
arr[i] = rd.nextInt(100) + 1; // 1 ~ 100 중 1개
// ---------------
// 0 ~ 99
// ---------------------
// 1 ~ 100
}
// 테스트 -> 구성된 배열의 전체 요소 출력
for(int i = 0; i < size; i++)
System.out.printf("%4d",arr[i]);
System.out.println();
/*
발생시킬 난수의 갯수 입력 : 10
92 37 53 19 26 82 74 62 29 64
계속하려면 아무 키나 누르십시오 . . .
*/
// ------------------------------------------------- 배열 구성 완료
// 가장 작은 값, 가장 큰 값 출력
/*
int min = arr[0];
int max = arr[0];
for(int i = 0; i < size; i++)
{
if(min > arr[i])
min = arr[i];
if(max < arr[i])
max = arr[i];
}
System.out.printf("가장 큰 값 : %d, 가장 작은 값 : %d\n", max, min);
*/
int max, min;
max = min = arr[0];
for (int = 1; i < arr.length; i++)
{
if(max < arr[i])
max = arr[i];
// else는 안된다. 독립된 if문이 필요함
if(min > arr[i])
min = arr[i];
}
// 결과 출력
System.out.printf("가장 큰 값 : %d, 가장 작은 값 : %d\n", max, min);
}
}배열의 복사(096~097)
/*=======================
■■■ 배열 ■■■
- 배열의 복사
========================*/
/*
Test097.java 파일과 비교
자바에서 배열 변수의 복사에는 데이터 복사, 주소값 복사 두 가지 형태가 존재한다.
주소값 복사 -> 얕은 복사
원본을 수정하면 복사본에 영향을 미치게 되는 복사 방법
(자바의 배열 뿐 아니라 모든 참조형 데이터에 해당하는 복사 방법)
데이터 복사 -> 깊은 복사
실제 요소로 들어있는 값에 대한 복사로
원본을 수정해도 복사본에 영향을 미치지 않는 복사 방법
*/
public class Test096
{
public static void main(String[] args)
{
int[] nums = {10, 20, 30, 40, 50}; // 배열 원본
int[] copys; // 복사본으로 만들 배열
int temp; // 데이터 임시 저장 변수
// (값 타입 확인 -> 배열과 비교)
// check
copys = nums; // 같은 데이터 타입이기 때문에 대입 가능 == 복사
// 배열의 주소값을 copys에 대입하는 것 == 주소를 참조하는 참조변수
temp = nums[0]; // temp에 10이라는 값 대입하겠다는 뜻
// 원본 배열의 데이터 수정
nums[0] = 1000; // nums = {1000, 20, 30, 40, 50}
// copys 배열의 전체 요소 출력
for(int i = 0; i < copys.length; i++)
System.out.printf("%d ",copys[i]); // == 1000 20 30 40 50
System.out.println();
// temp 출력 확인
System.out.println("temp : " + temp); // == temp : 10
}
}/*=======================
■■■ 배열 ■■■
- 배열의 복사
========================*/
/*
Test096.java 파일과 비교
자바에서 배열 변수의 복사에는 데이터 복사, 주소값 복사 두 가지 형태가 존재한다.
주소값 복사 -> 얕은 복사
원본을 수정하면 복사본에 영향을 미치게 되는 복사 방법
(자바의 배열 뿐 아니라 모든 참조형 데이터에 해당하는 복사 방법)
데이터 복사 -> 깊은 복사
실제 요소로 들어있는 값에 대한 복사로
원본을 수정해도 복사본에 영향을 미치지 않는 복사 방법
데이터 복사
- int 형 배열에 대한 깊은 복사를 처리하는
메소드를 정의하는 형태로 실습 진행
*/
public class Test097
{
public static void main(String[] args)
{
int[] nums = {10, 20, 30, 40, 50}; // 배열 원본
int[] copys1 = nums; // 주소값 복사(얕은 복사)
int[] copys2 = copyArray(nums); // 데이터 복사(깊은 복사)
// 사용자 정의 메소드 호출
int[] copys3 = (int[])nums.clone(); // 데이터 복사(깊은 복사)
// 자바 제공 메소드 호출(close), int[] 형으로 형변환
// 원본 배열(nums) 요소의 수정 발생
nums[1] = 2345; // 원본의 값을 변경했다.
// 결과 확인
for(int i = 0; i < nums.length; i++) // 배열 원본
System.out.printf("%5d", nums[i]); //== 10 2345 30 40 50
System.out.println();
for(int i = 0; i < copys1.length; i++) // 주소값 복사(얕은 복사)
System.out.printf("%5d", copys1[i]);//== 10 2345 30 40 50
System.out.println();
for(int i = 0; i < copys2.length; i++) // 데이터 복사(깊은 복사), 사용자 정의 메소드
System.out.printf("%5d", copys2[i]);//== 10 20 30 40 50
System.out.println();
for(int i = 0; i < copys3.length; i++) // 데이터 복사(깊은 복사), 자바 제공 메소드 호출
System.out.printf("%5d", copys3[i]);//== 10 20 30 40 50
System.out.println();
}
/* 매개변수로 int 배열 타입을 넘겨받아
이 배열을 복사한 후
복사한 배열을 반환하는 기능을 가진 메소드 정의
*/
public static int[] copyArray(int[] os) // int배열 타입을 매개변수로 넣어준다, 복사한 배열을 반환하므로 반환형은 int배열형
{
// 매개변수로 넘겨받은 배열(os)
// 즉, 원본 배열만큼의 배열방(메모리 공간)을 확보한
// 복사할 배열 생성
int[] result = new int[os.length]; // 매개변수로 받은 배열의 길이로 배열의 크기 만들어준다.
// 원본 배열(os)에 담겨있는 각각의 요소들을 복사 배열(result)에 담아내기
// result = os; // 데이터 복사가 목적이기 때문에 주소값 복사(참조변수)를 하면 안된다.
for(int i = 0; i < result.length; i++) // os.length도 같다.
{
result[i] = os[i];
}
// 복사한 배열(result) 반환
return result;
}
}접근지시제어자(098)
/*=====================================================================================
■■■ 클래스와 인스턴스 ■■■
- 정보 은닉과 접근제어지시자(접근 지시자, 접근 제어자, 접근 지정자, 접근 제한자, ...)
=====================================================================================*/
/*
*/
import java.util.Scanner;
class CircleTest2
{
// 멤버 변수, 인스턴스 변수, 전역 변수
// int num;
// 정보 은닉(Information Hiding) 을 거치면
private int num; // private이라는 접근제어지시자의 선언은 클래스 내부에서만 접근 및 참조가 가능하게 하겠다는 의미
// int형 전역변수이기 때문에 자동으로 0으로 초기화 된다.
// getter / setter 구성
/*
public int getNum()
{
return num;
}
public setNum(int num)
{
this.num = num;
}
*/
public void input() // 이렇게 public을 붙여줘도 class에 default가 기본으로 있기 때문에
// 다른 패키지의 경우에는 class안으로 못 들어가서 input()에 접근 불가
// public이 붙은 class는 파일에 하나만 있어야 한다. 그래서 분리하는 것
{
Scanner sc = new Scanner(System.in);
System.out.print("반지름 입력 : ");
num = sc.nextInt();
}
public double calArea()
{
return num * num * 3.141592;
}
public void write(double area)
{
System.out.println(">> 반지름 : " + num);
System.out.println(">> 넓이 : " + area);
}
}
public class Test098
{
public static void main(String[] args)
{
// CircleTest2 인스턴스 생성
CircleTest2 ob1 = new CircleTest2();
// ob1.num = 10; 클래스 안에서 private이라서 불가능
// ob1.setNum(10);
// System.out.println("원의 반지름 : " + ob1.num);
// System.out.println("원의 반지름 : " + ob1.getNum);
// 게터세터를 사용하지 않고 하려면 현재 유일하게 num값을 전달할 수 있는 방법
ob1.input(); // 반지름 입력 : 500 -> ob1.num에 500을 대입하라
double result = ob1.calArea();
ob1.write(result);
/*
반지름 입력 : 500
>> 반지름 : 500
>> 넓이 : 785398.0
계속하려면 아무 키나 누르십시오
*/
}
}/*=====================================================================================
■■■ 클래스와 인스턴스 ■■■
- 정보 은닉과 접근제어지시자(접근 지시자, 접근 제어자, 접근 지정자, 접근 제한자, ...)
=====================================================================================*/
/*
*/
import java.util.Scanner;
class CircleTest2
{
// 멤버 변수, 인스턴스 변수, 전역 변수
// int num;
// 정보 은닉(Information Hiding) 을 거치면
private int num; // private이라는 접근제어지시자의 선언은 클래스 내부에서만 접근 및 참조가 가능하게 하겠다는 의미
// int형 전역변수이기 때문에 자동으로 0으로 초기화 된다.
// getter / setter 구성
/*
public int getNum()
{
return num;
}
public setNum(int num)
{
this.num = num;
}
*/
public void input() // 이렇게 public을 붙여줘도 class에 default가 기본으로 있기 때문에
// 다른 패키지의 경우에는 class안으로 못 들어가서 input()에 접근 불가
// public이 붙은 class는 파일에 하나만 있어야 한다. 그래서 분리하는 것
{
Scanner sc = new Scanner(System.in);
System.out.print("반지름 입력 : ");
num = sc.nextInt();
}
public double calArea()
{
return num * num * 3.141592;
}
public void write(double area)
{
System.out.println(">> 반지름 : " + num);
System.out.println(">> 넓이 : " + area);
}
}
public class Test098
{
public static void main(String[] args)
{
// CircleTest2 인스턴스 생성
CircleTest2 ob1 = new CircleTest2();
// ob1.num = 10; 클래스 안에서 private이라서 불가능
// ob1.setNum(10);
// System.out.println("원의 반지름 : " + ob1.num);
// System.out.println("원의 반지름 : " + ob1.getNum);
// 게터세터를 사용하지 않고 하려면 현재 유일하게 num값을 전달할 수 있는 방법
ob1.input(); // 반지름 입력 : 500 -> ob1.num에 500을 대입하라
double result = ob1.calArea();
ob1.write(result);
/*
반지름 입력 : 500
>> 반지름 : 500
>> 넓이 : 785398.0
계속하려면 아무 키나 누르십시오
*/
}
}요일 구하는 프로그램 구현(099)
/*===============================
■■■ 클래스와 인스턴스 ■■■
- 클래스 설계
- 배열의 활용
- 접근제어지시자와 정보은닉
===============================*/
/*
사용자로부터 년, 월, 일을 입력받아
해당 날짜의 요일을 출력하는 프로그램을 구현한다.
단, 달력 클래스(calendar)는 사용하지 않는다.
또한, 클래스의 개념을 활용하여 작성할 수 있도록 한다.
(-> WeekDay 클래스 설계)
그리고, 배열의 개념도 적용시켜 작성할 수 있도록 한다.
접근제어지시자의 개념도 확인하여 작성할 수 있도록 한다.
최종적으로
WeekDay클래스 설계를 통해
Test099 클래스의 main() 메소드가 정상적으로 프로그램 실행될 수 있도록 한다.
실행 예)
년 월 일 입력(공백 구분) : 2023 9 7
>> 2023년 9월 7일 → 목요일
계속하려면...
Hint
- 1년 1월 1일 → "월요일"
- 1년은 365일이 아니다
2월의 마지막 날짜가 29일 -> 윤년
2월의 마지막 날짜가 28일 -> 평년
- 윤년의 판별 조건
년도가 4의 배수이면서 100의 배수가 아니거나,
400의 배수이면 윤년, 그 이외에는 평년
*/
import java.io.IOException;
import java.util.Scanner;
public class Test099
{
public static void main(String[] args) throws IOException
{
Weekday wd = new Weekday();
wd.input(); // 입력창
wd.dayCal(); // 날짜 계산
wd.printDay(); // 결과 출력
}
}
class Weekday
{
int y,m,d; // 년, 월, 일
int daySum; // 입력받은 날짜를 일 기준으로 바꾸어 누적합할 변수
int answer;
String[] dayText = {"일요일", "월요일", "화요일", "수요일", "목요일", "금요일", "토요일"};
void input() throws IOException
{
Scanner sc = new Scanner(System.in);
System.out.print("년 월 일 입력(공백 구분) : ");
y = sc.nextInt(); // 년 월 일 입력 받기
m = sc.nextInt();
d = sc.nextInt();
}
void yearCal()
{
int[] yearDay = new int[y];
for(int i = 1; i < y; i++)
{
if((i % 4 == 0 && i % 100 != 0) || i % 400 == 0) // 윤년이면 366 더해주고
daySum += 366;
else // 평년이면 365 더해줌
daySum += 365;
}
}
void monthCal()
{
int[] monthDay = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 평년
int[] monthDay4 = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 윤년
if((y % 4 == 0 && y % 100 != 0) || y % 400 == 0) // 윤년이면 윤년 배열에서 계산
{
for(int i = 1; i < m; i++)
daySum += monthDay4[i - 1];
}
else
{
for(int i = 1; i < m; i++) // 평년이면 평년 배열에서 계산
daySum += monthDay[i - 1];
}
}
void dayCal()
{
yearCal(); // 년도 계산
monthCal(); // 월 계산
daySum += d;
answer = daySum % 7;
//System.out.println(answer);
//System.out.printf(">> %d년 %d월 %d일 → %s", y, m, d, dayText[answer]);
}
void printDay()
{
System.out.printf(">> %d년 %d월 %d일 → %s\n", y, m, d, dayText[answer]);
}
}/*===============================
■■■ 클래스와 인스턴스 ■■■
- 클래스 설계
- 배열의 활용
- 접근제어지시자와 정보은닉
===============================*/
/*
사용자로부터 년, 월, 일을 입력받아
해당 날짜의 요일을 출력하는 프로그램을 구현한다.
단, 달력 클래스(calendar)는 사용하지 않는다.
또한, 클래스의 개념을 활용하여 작성할 수 있도록 한다.
(-> WeekDay 클래스 설계)
그리고, 배열의 개념도 적용시켜 작성할 수 있도록 한다.
접근제어지시자의 개념도 확인하여 작성할 수 있도록 한다.
최종적으로
WeekDay클래스 설계를 통해
Test099 클래스의 main() 메소드가 정상적으로 프로그램 실행될 수 있도록 한다.
실행 예)
년 월 일 입력(공백 구분) : 2023 9 7
>> 2023년 9월 7일 → 목요일
계속하려면...
Hint
- 1년 1월 1일 → "월요일"
- 1년은 365일이 아니다
2월의 마지막 날짜가 29일 -> 윤년
2월의 마지막 날짜가 28일 -> 평년
- 윤년의 판별 조건
년도가 4의 배수이면서 100의 배수가 아니거나,
400의 배수이면 윤년, 그 이외에는 평년
*/
import java.io.IOException;
import java.util.Scanner;
public class Test099
{
public static void main(String[] args) throws IOException
{
// WeekDay 클래스 기반 인스턴스 생성
Weekday wd = new Weekday();
// 입력 메소드 호출
wd.input();
// 요일 산출 메소드 호출
String result = wd.week();
// 최종 결과 출력 메소드 호출
wd.print(result);
}
}
// 실행결과
/*
년 월 일 입력(공백 구분) : 2024 3 19
>> 2024년 3월 19일 → 화요일
계속하려면 아무 키나 누르십시오
*/
// 하나의 파일이 아니고 다른 파일에 따로 class를 만든다고 가정
class Weekday
{
private int y,m,d; // 년, 월, 일 담아낼 변수
// 메소드 정의 년, 월, 일 입력 받기
public void input() throws IOException
{
Scanner sc = new Scanner(System.in);
System.out.print("년 월 일 입력(공백 구분) : "); // 2024 3 19
y = sc.nextInt(); // 2024
m = sc.nextInt(); // 3
d = sc.nextInt(); // 19
}
// 메소드 정의 -> 기능 : 요일 산출하기
public String week()
{
// 각 월의 마지막 날짜(각 월의 최대값)을 배열 형태로 구성
int[] months = {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
// 확인
// System.out.println(months.length);
// 날 수를 종합할 변수
int nalsu;
// 요일 확인 변수
int w;
// 요일 타이틀을 배열 형태로 구성
String[] weekNames = {"일", "월", "화", "수", "목", "금", "토"};
// 윤년에 따른 2월의 날 수 계산
// 입력 년도가 윤년이라면.. 2월의 마지막 날짜를 29일로 설정
// 입력 년도가 평년이라면.. 2월의 마지막 날짜를 28일로 설정
if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0) // 윤년
{
months[1] = 29;
}
else // 평년
{
months[1] = 28;
}
// 1. 1년 1월 1일 부터 입력받은 년도의 이전년도 12월 31일 까지의 날 수 계산
// ex) 2024 3 19 -> 1.1.1 ~ 2023.12.31
nalsu = (y-1) * 365 + (y-1) / 4 - (y-1) / 100 + (y-1) / 400;
// 1년 기본주기
// 4년마다+1
// 100년마다 +1 하지마
// 400년마다 + 1
// 확인
// System.out.println("날수 : " + nalsu);
// 날수 : 738885
// 1년 1월 1일 ~ 2023년 12월 31일 까지의 날 수
// 2. 입력받은 월의 이전 월 까지의 날 수 계산 후
// 이 결과를 1번의 결과에 더하는 연산
// ex) 2024 3 19 -> 2024.1.1 ~ 2024.2.29
for(int i = 0; i < (m - 1); i++)
nalsu += months[i];
// 확인
// System.out.println("날수 : " + nalsu);
//== 날수 : 738945
// 738885 + 31 + 29 = 738945
// 1년 1월 1일 부터 ~ 2024년 2월 29일 까지의 날 수
// 3. 입력받은 일의 날짜만큼 날 수 계산 후
// 이 결과를 2번의 결과에 더하는 연산
// ex) 2024 3 19 -> + 19
nalsu += d; // nalsu를 d 만큼 증가
// 확인
// System.out.println("날수 : " + nalsu);
// 날수 : 738964
// 738945 + 19 = 738964
// -- 1.1.1 ~ 2024.3.19 총 날짜 수
// --------------------------------------- 날 수 연산 끝
// 무슨 요일인지 확인하기 위한 연산
w = nalsu % 7; // 전체 날 수 % 7 == 0 일요일
// 1 월요일
// 2 화요일
// 3 수요일
// 테스트(확인)
// System.out.println("w : " + w);
// w : 2
// 전체 날 수 % 7 == 2 -> 화요일
// return w;
return weekNames[w];
}
// 메소드 정의 -> 기능 : 결과 출력하기
public void print(String day)
{
System.out.printf(">> %d년 %d월 %d일 → %s요일\n", y, m, d, day);
}
}14일차
static (100)
/*========================================================
■■■ 클래스와 인스턴스 ■■■
- static 변수(클래스 변수)와 static 메소드(클래스 메소드)
=========================================================*/
/*
탄생 시점
공유
*/
public class Test100
{
// 클래스 변수 또는 클래스 메소드는
// 클래스 정보가 로딩되는 순간 메모리 할당이 이루어지며
// 클래스 이름 또는 객체(인스턴스)를 통해 접근할 수 있다.
// 즉, new 연산자를 통해 메모리를 할당받지 않아도
// 사용이 가능하다는 것이다.
static int a = 10; // static 변수(클래스 변수, class 변수, 정적 변수)
int b = 20; // non-static 변수(인스턴스 변수, instance 변수)
// 인스턴스 변수 또는 인스턴스 메소드는
// 동일한 클래스의 메소드에서는 바로 접근하는 것이 가능하지만
// 클래스 메소드에서는 접근할 수 없다.
void write() // non-static 메소드(인스턴스 메소드)
{
System.out.println("인스턴스 메소드 -> 클래스 변수 a : " + a); // write가 생성될 때 static int a는 생성이 되어 있다.
System.out.println("인스턴스 메소드 -> 인스턴스 변수 b : " + b);
}
static void print() // static 메소드(클래스 메소드, 정적 메소드)
{
System.out.println("클래스 메소드 -> 클래스 변수 a : " + a);
//System.out.println("클래스 메소드 -> 인스턴스 변수 b : " + b); 컴파일 에러 static void print() 가 생성될 때 int b 는 생성 x
}
public static void main(String[] args)
{
System.out.println("main() 메소드 -> 클래스 변수 a : " + Test100.a); // 인스턴스명이 아닌 클래스명을 통해 접근(a가 static변수이므로)
// 클래스 변수에 접근하기 위해서는
// 클래스명.변수명 의 형태로 클래스의 이름을 통해
// 접근하는 것이 가능하다.
// == main() 메소드 -> 클래스 변수 a : 10
System.out.println("main() 메소드 -> 클래스 변수 a : " + a); // 같은 클래스 내부에 있는 경우 클래스 이름 생략 가능
//== main() 메소드 -> 클래스 변수 a : 10
Test100.print();
//== 클래스 메소드 -> 클래스 변수 a : 10
print(); // main도 스태틱이고 print도 스태틱이고 같은 클래스에 있으므로 클래스 생략 가능
//== 클래스 메소드 -> 클래스 변수 a : 10
// 클래스 메소드에서 클래스 메소드의 호출은 가능하며,
// 클래스명.메소드명() 의 형태로 접근하여 호출하는 것이 가능하다.
// 또한, 지금은 같은 클래스 내부에 존재하기 때문에
// 클래스의 이름을 생략한 경우에 해당한다.
// System.out.println("main() 메소드 -> 인스턴스 변수 b : " + b); static이 아닌 int b를 바로 꺼내오는건 불가능 == 컴파일 에러
// System.out.println("main() 메소드 -> 인스턴수 변수 b : " + b);
//== non-static variable b cannot be referenced from a static context 스태틱이 아니어서 가져올수 없다는 오류메시지
// Test100.write();
// write();
// 컴파일 에러
// Test100 클래스 기반 인스턴스 생성
Test100 ob = new Test100();
// System.out.println("main() 메소드 -> 인스턴스 변수 b : " + b); 인스턴스 통해서 접근해야한다 == 컴파일 에러
// System.out.println("main() 메소드 -> 인스턴스 변수 b : " + Test100.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 = 10000; // 인스턴스 변수
System.out.println("ob2 확인 --------------------------");
ob2.write();
//== ob2 확인 --------------------------
// 인스턴스 메소드 -> 클래스 변수 a : 10000 공유 스테이플러 심을 10000으로 채운것
// 인스턴스 메소드 -> 인스턴스 변수 b : 10000 개인 딱풀을 10000으로 심은것
System.out.println("ob 확인 --------------------------");
ob.write();
//== ob 확인 --------------------------
// 인스턴스 메소드 -> 클래스 변수 a : 10000
// 인스턴스 메소드 -> 인스턴스 변수 b : 20
}
}클래스 인스턴스 활용(101)
/*===============================
■■■ 클래스와 인스턴스 ■■■
- 클래스와 인스턴스 활용
================================*/
/*
학생별로 이름, 국어점수, 영어점수, 수학점수를 입력받아
총점, 평균을 계산하는 프로그램을 구현한다.
단, 클래스의 개념을 활용하여 작성할 수 있도록 한다.
또한, 이 과정에서 배열을 적극적으로 활용할 수 있또록 한다.
클래스 설계는 다음의 가이드라인에 따라 진행할 수 있어야 한다.
[가이드라인]
프로그램을 구성하는 클래스
1. Record 클래스 // 속성 = 이름, 국어점수, 영어점수, 수학점수 학생1명
- 속성만 존재하는 클래스로 설계할 것
2. Sungjuk 클래스
- 인원 수를 입력받아,
입력받은 인원 수 만큼 이름, 국어점수, 영어점수, 수학점수를 입력받고
총점과 평균을 산출하는 클래스로 설계할 것
속성 : 인원수, Record 타입의 배열 record[] arr = {ob1,ob20} 학생들
기능 : 인원수 입력, 상세 데이터 입력, 총점 및 평균 연산, 결과 출력
3. Test101 클래스
- main() 메소드가 존재하는 외부 클래스로 설계할 것
실행 예)
인원 수 입력(1~100) : 102
인원 수 입력(1~100) : -10
인원 수 입력(1~100) : 3
1번째 학생의 이름 입력 : 강혜성
국어 점수 : 90
영어 점수 : 80
수학 점수 : 70
2번째 학생의 이름 입력 : 길현욱
국어 점수 : 92
영어 점수 : 82
수학 점수 : 72
2번째 학생의 이름 입력 : 김경태
국어 점수 : 82
영어 점수 : 72
수학 점수 : 62
강혜성 90 80 70 240 xx.xx 2
길현욱 92 82 72 xxx xx.xx 1
김경태 82 72 62 xxx xx.xx 3
계속하려면...
*/
import java.io.IOException;
public class Test101
{
public static void main(String[] args) throws IOException
{
Sungjuk sj = new Sungjuk();
//sj.input();
//sj.cal(sj.input());
sj.output(sj.cal(sj.input()));
}
}/*
2. Sungjuk 클래스
- 인원 수를 입력받아,
입력받은 인원 수 만큼 이름, 국어점수, 영어점수, 수학점수를 입력받고
총점과 평균을 산출하는 클래스로 설계할 것
속성 : 인원수, Record 타입의 배열
기능 : 인원수 입력, 상세 데이터 입력, 총점 및 평균 연산, 결과 출력
*/
import java.util.Scanner;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Sungjuk
{
int n; // 인원 수
//Record rc = new Record(); // Record에 속성 값 넣어줘야 하므로 Record 인스턴스 생성
// 필요없구나..
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Record[] input() throws IOException
{
do
{
System.out.print("인원 수 입력(1~100) : ");
n = Integer.parseInt(br.readLine());
}
while (n < 1 || n > 100);
Record[] arr = new Record[n];
for(int i = 0; i < n; i++)
{
arr[i] = new Record();
System.out.printf("%d번째 학생의 이름 입력 : ", i + 1);
arr[i].name = br.readLine();
System.out.printf("국어 점수 : ");
arr[i].score[0] = Integer.parseInt(br.readLine());
System.out.printf("영어 점수 : ");
arr[i].score[1] = Integer.parseInt(br.readLine());
System.out.printf("수학 점수 : ");
arr[i].score[2] = Integer.parseInt(br.readLine());
//arr[i].total = arr[i].score[0] + arr[i].score[1] + arr[i].score[2];
//arr[i].avg = arr[i].total / 3.0;
}
return arr;
}
Record[] cal(Record[] arr)
{
for(int i = 0; i < n; i++)
{
arr[i].total = arr[i].score[0] + arr[i].score[1] + arr[i].score[2];
arr[i].avg = arr[i].total / 3.0;
}
return arr;
}
void output(Record[] arr)
{
for(int i = 0; i < n; i++)
{
System.out.printf("%s %d %d %d %d %.2f", arr[i].name, arr[i].score[0], arr[i].score[1], arr[i].score[2], arr[i].total, arr[i].avg);
System.out.println();
}
}
int rank(Record[] arr)
{
arr[i].
}
}
/*
record[] recarr = new record[5];
recarr[0] = 1 // 불가능!!!! record 타입이어야 함
int[] arr = new int[3] -> arr[0] = 3 처럼 자료형이 맞아야함
즉 recarr[i] = new record(); -> 인스턴스 변수가 바뀔때마다 새롭게 Record 인스턴스를 생성해야 한다.
---------
새로운 인스턴스 변수 = 새로운 객체
*/import java.io.IOException;
public class Test101
{
public static void main(String[] args) throws IOException
{
Sungjuk sj = new Sungjuk();
sj.input();
sj.cal();
sj.output();
}
}/*
2. Sungjuk 클래스
- 인원 수를 입력받아,
입력받은 인원 수 만큼 이름, 국어점수, 영어점수, 수학점수를 입력받고
총점과 평균을 산출하는 클래스로 설계할 것
속성 : 인원수, Record 타입의 배열
기능 : 인원수 입력, 상세 데이터 입력, 총점 및 평균 연산, 결과 출력
*/
import java.util.Scanner;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Sungjuk
{
int n; // 인원 수
Record rc = new Record(); // Record에 속성 값 넣어줘야 하므로 Record 인스턴스 생성
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Record[] arr;
void input() throws IOException
{
do
{
System.out.print("인원 수 입력(1~100) : ");
n = Integer.parseInt(br.readLine());
}
while (n < 1 || n > 100);
arr = new Record[n];
for(int i = 0; i < n; i++)
{
arr[i] = new Record();
System.out.printf("%d번째 학생의 이름 입력 : ", i + 1);
arr[i].name = br.readLine();
System.out.printf("국어 점수 : ");
arr[i].score[0] = Integer.parseInt(br.readLine());
System.out.printf("영어 점수 : ");
arr[i].score[1] = Integer.parseInt(br.readLine());
System.out.printf("수학 점수 : ");
arr[i].score[2] = Integer.parseInt(br.readLine());
//arr[i].total = arr[i].score[0] + arr[i].score[1] + arr[i].score[2];
//arr[i].avg = arr[i].total / 3.0;
}
}
void cal()
{
for(int i = 0; i < n; i++)
{
arr[i].total = arr[i].score[0] + arr[i].score[1] + arr[i].score[2];
arr[i].avg = (double)arr[i].total / n;
}
}
void output()
{
for(int i = 0; i < n; i++)
{
System.out.printf("%s %d %d %d %d %.2f", arr[i].name, arr[i].score[0], arr[i].score[1], arr[i].score[2], arr[i].total, arr[i].avg);
System.out.println();
}
}
//void rank(Record[] arr)
//{
// Record copy = (Record[])arr.clone();
//}
}
/*
record[] recarr = new record[5];
recarr[0] = 1 // 불가능!!!! record 타입이어야 함
int[] arr = new int[3] -> arr[0] = 3 처럼 자료형이 맞아야함
즉 recarr[i] = new record(); -> 인스턴스 변수가 바뀔때마다 새롭게 Record 인스턴스를 생성해야 한다.
---------
새로운 인스턴스 변수 = 새로운 객체
*//*===============================
■■■ 클래스와 인스턴스 ■■■
- 클래스와 인스턴스 활용
================================*/
/*
학생별로 이름, 국어점수, 영어점수, 수학점수를 입력받아
총점, 평균을 계산하는 프로그램을 구현한다.
단, 클래스의 개념을 활용하여 작성할 수 있도록 한다.
또한, 이 과정에서 배열을 적극적으로 활용할 수 있또록 한다.
클래스 설계는 다음의 가이드라인에 따라 진행할 수 있어야 한다.
[가이드라인]
프로그램을 구성하는 클래스
1. Record 클래스 // 속성 = 이름, 국어점수, 영어점수, 수학점수 학생1명
- 속성만 존재하는 클래스로 설계할 것
2. Sungjuk 클래스
- 인원 수를 입력받아,
입력받은 인원 수 만큼 이름, 국어점수, 영어점수, 수학점수를 입력받고
총점과 평균을 산출하는 클래스로 설계할 것
속성 : 인원수, Record 타입의 배열 record[] arr = {ob1,ob20} 학생들
기능 : 인원수 입력, 상세 데이터 입력, 총점 및 평균 연산, 결과 출력
3. Test101 클래스
- main() 메소드가 존재하는 외부 클래스로 설계할 것
실행 예)
인원 수 입력(1~100) : 102
인원 수 입력(1~100) : -10
인원 수 입력(1~100) : 3
1번째 학생의 이름 입력 : aaa
국어 점수 : 90
영어 점수 : 80
수학 점수 : 70
2번째 학생의 이름 입력 : bbb
국어 점수 : 92
영어 점수 : 82
수학 점수 : 72
2번째 학생의 이름 입력 : ccc
국어 점수 : 82
영어 점수 : 72
수학 점수 : 62
강혜성 90 80 70 240 xx.xx 2
길현욱 92 82 72 xxx xx.xx 1
김경태 82 72 62 xxx xx.xx 3
계속하려면...
*/
import java.io.IOException;
public class Test101
{
public static void main(String[] args) throws IOException
{
Sungjuk sj = new Sungjuk();
sj.set();
sj.input();
sj.print();
}
}
/* 실행 결과
인원수 입력(1~100) : 3
1번째 학생의 이름 입력 : aaa
국어 점수 : 90
영어 점수 : 80
수학 점수 : 70
2번째 학생의 이름 입력 : bbb
국어 점수 : 92
영어 점수 : 82
수학 점수 : 72
3번째 학생의 이름 입력 : ccc
국어 점수 : 82
영어 점수 : 72
수학 점수 : 62
aaa 90 80 70 240 80.00 2
bbb 92 82 72 246 82.00 1
ccc 82 72 62 216 72.00 3
*/
//Record 클래스
// - 속성만 존재하는 클래스로 설계할 것 속성 = 이름, 국어점수, 영어점수, 수학점수 학생1명
public class Record
{
String name;
//int kor,eng,mat;
int[] score = new int[3];
int tot;
double avg;
int rank;
}
/*
2. Sungjuk 클래스
- 인원 수를 입력받아,
입력받은 인원 수 만큼 이름, 국어점수, 영어점수, 수학점수를 입력받고
총점과 평균을 산출하는 클래스로 설계할 것
속성 : 인원수, Record 타입의 배열
기능 : 인원수 입력, 상세 데이터 입력, 총점 및 평균 연산, 결과 출력
*/
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Sungjuk
{
// 주요 속성 구성
int inwon; // 인원수
Record[] rec; // Record 타입의 배열(학생 한 명 당 Record 배열 방 한개 활용)
// Record 를 기반으로 생성된 객체만 담아낼 수 있는 배열
// 주요 기능 구성
// 1. 인원 수 입력
public void set() // 외부에서 써야하기 때문에 public
{
Scanner sc = new Scanner(System.in);
do
{
System.out.print("인원수 입력(1~100) : ");
inwon = sc.nextInt();
}
while (inwon < 1 || inwon > 100);
// check
// Record 클래스를 기반으로 생성된 객체(인스턴스)를 담을 수 있는
// 배열방을 inwon 만큼 생성한 것일 뿐
// Record 클래스의 인스턴스를 생성한 것은 아니다
rec = new Record[inwon];
}
// 2. 상세 데이터 입력 + 3. 총점 및 평균 연산
public void input()
{
Scanner sc = new Scanner(System.in);
String[] subTitle = {"국어 점수 : ", "영어 점수 : ", "수학 점수 : "};
// 인원 수 만큼 반복 -> 인원 수에 기반하여 만들어진 배열의 길이만큼 반복
//for(int i = 0; i < inwon; i++)
for(int i = 0; i < rec.length; i++)
{
// Record 클래스 기반의 인스턴스 생성
//Record ob = new Record(); // new Record()가 인스턴스 생성 구문 Record ob 는 int n과 똑같다.
rec[i] = new Record();
System.out.printf("%d번째 학생의 이름 입력 : ", i + 1);
rec[i].name = sc.next();
for(int j = 0; j < subTitle.length; j++)
{
// 안내 메시지 출력
System.out.print(subTitle[j]);
rec[i].score[j] = sc.nextInt();
// 국어, 영어, 수학 점수 데이터를 반복적으로 입력받는 동안
// 총점에 대한 누적 산출
rec[i].tot += rec[i].score[j];
// 평균값은 반복문에 넣어서 반복하면서 계산할 필요가 없다
}
// 평균 산출하기
rec[i].avg = rec[i].tot / 3.0;
}//end outer for
}//end input()
// 4. 결과 출력
//강혜성 90 80 70 240 xx.xx 2
//길현욱 92 82 72 xxx xx.xx 1
//김경태 82 72 62 xxx xx.xx 3
public void print()
{
// 내부 석차 메소드 호출
ranking();
// 개행
System.out.println();
// 학생 한 명 당 반복 출력 구문 구성
// for(int i = 0; i < inwon; i++)
for(int i = 0; i < rec.length; 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);
// 석차 출력
// ranking();
System.out.printf("%4d", rec[i].rank);
// 개행
System.out.println();
}
}
// 5. 석차 산출
// - 산출 과정에서 연산에 필요한 데이터가 이미 존재하는 상황 -> 매개변수 넘겨줄 필요 없음
// - Record 배열의 rank 속성에 연산결과 대입 기능 수행 -> 반환 자료형 void
// - 클래스 내부에서 활용할 메소드로 정의 -> 접근제어 지시자 private
private void ranking()
{
// 모든 학생들의 등수(석차, rank)를 1로 초기화
for(int i = 0; i < inwon; i++)
rec[i].rank = 1;
// 등수 산출 -> 입력 인원이 5명이라 가정하면
for(int i = 0; i < inwon - 1; i++) // 비교기준 -> 0 1 2 3 까지 4는 아니다
{
for(int j = i + 1; j < inwon; j++) // 비교대상 -> 1234 234 34 4
{
if(rec[i].avg > rec[j].avg) // 비교기준의 평균이 비교대상의 평균보다 크다면
{
// 비교대상의 rank를 1만큼 증가
rec[j].rank++;
}
else if(rec[i].avg < rec[j].avg) // 비교대상의 평균이 비교기준의 평균보다 크다면
{
// 비교기준의 rank를 1만큼 증가
rec[i].rank++;
}
}
}
}
/* 내 풀이 ----------------- 두 가지 방법
public void ranking()
{
for(int i = 0; i < rec.length; i++)
rec[i].rank = 1;
for(int i = 0; i < rec.length; i++)
{
//for(int j = i; j < rec.length; j++)
//{
// if(rec[i].avg < rec[j].avg)
// rec[i].rank += 1;
// else if(rec[j].avg < rec[i].avg)
// rec[j].rank += 1;
//}
for(int j = 0; j < rec.length; j++)
{
if(rec[i].avg > rec[j].avg)
rec[j].rank += 1;
}
}
}
*/
}