gwooden_코린이
java_총 복습 본문
728x90
반복문 복습 풀이
| //1+(1+2)+(1+2+3)+(1+2+3+4)+...+(1+2+3+...+10)의 결과를 계산하시오 |
package 총복습;
public class Test01 {
public static void main(String[] args) {
//1+(1+2)+(1+2+3)+(1+2+3+4)+...+(1+2+3+...+10)의 결과를 계산하시오
int i, j;
int sum = 0; //각 구간별 합계
int tot = 0; //전체 총합
/* 1번 =========
for(i = 0; i<=10; i++) {
for(j = 1; j<=i; j++){
sum = sum + j;
}
}
System.out.println("총합 : " + tot);
*/
/* 2번 =========
for(i = 1; i<=10; i++) {
sum = 0; // 중간에 초기화
for(j = 1; j<=i; j++){
sum = sum + j;
}
tot = tot + sum;
}
System.out.println("총합 : " + tot);
*/
//반복문 하나만 써서 결과값 도출
for(i = 1; i<=10; i++) {
sum = sum + i;
tot = tot + sum;
}
System.out.println("총합 : " + tot);
}
}
//1+(-2)+3(-4)+..... 과 같은 식으로 계속 더해나갔을 때 몇까지 더해야 총합이 100 이상 되는지 구하시고
//결과 199package 총복습;
public class Test02 {
public static void main(String[] args) {
//1+(-2)+3(-4)+..... 과 같은 식으로 계속 더해나갔을 때 몇까지 더해야 총합이 100 이상 되는지 구하시고
//결과 199
int i = 0; //숫자(양수, 음수 표현x)
int num = 0; //숫자(양수, 음수 표현 해주는 변수)
int sum = 0; //합계 저장 변수
int s = 1; //스위치 변수(1, -1)
while(true) {
i++; //0부터 시작해서 i값 증가
num = i * s;
//증가된 i값과 s를 곱하면 num값에 저장된다.
//조건이 만족할때 까지 무한반복
sum = sum + num;
//처음에 num 값이 sum에 들어가고
//sum 초기값이 바뀌면서 num값과 sum값을 더한 총합이 sum값으로 들어가고
//무한 반복
s = s * -1;
if(sum >= 100)
break;
}
System.out.println("숫자 : " + num);
System.out.println("합계 : " + sum);
}
}
| //두 개의 주사위를 던졌을 대 눈의 합이 6이 되는 모든 경우의 수를 출력하는 프로그램 작성 // <결과> (1, 5) (2, 4) (3, 3) (4, 2) (5, 1) |
package 총복습;
public class Test03 {
public static void main(String[] args) {
//두 개의 주사위를 던졌을 대 눈의 합이 6이 되는 모든 경우의 수를 출력하는 프로그램 작성
// <결과> (1, 5) (2, 4) (3, 3) (4, 2) (5, 1)
for(int i = 1; i<=6; i++){
for(int j = 1; j <=6; j++){
if(i + j == 6) {
System.out.println("1번 주사위 : " + i + ", " + " 2번 주사위 : "+ j + " = 6");
}
}
}
}
}
| // int타입의 변수 num을 입력받아 각 자리의 합을 더한 결과를 출력하는 코드를 완성하라 // 만일 변수 num의 값이 12345라면 1+2+3+4+5 = ? 의 결과인 15를 출력하라. |
package 총복습;
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
// int타입의 변수 num을 입력받아 각 자리의 합을 더한 결과를 출력하는 코드를 완성하라
// 만일 변수 num의 값이 12345라면 1+2+3+4+5 = ? 의 결과인 15를 출력하라.
int num = 0;
int sum = 0;
Scanner sc = new Scanner(System.in);
System.out.println("숫자 입력 : ");
num = sc.nextInt();
while(num != 0){ //num값이 0이 아닐때 무한반복
sum += num%10; //num을 10으로 나눈 나머지를 sum에 더한다.
num /= 10; //num을 10으로 나눈 값을 다시 num에 저장한다.
}
System.out.print("결과 : " + sum);
/* 잘못된 풀이
int[] num = new int[5];
Scanner sc = new Scanner(System.in);
int sum = 0;
for(int i = 0; i <num.length; i++) {
System.out.println("숫자 입력 : ");
num[i] = sc.nextInt();
}
for(int i = 0; i <num.length; i++){
sum += num[i];
}
System.out.println(sum);
*/
}
}
| /* * 다음은 숫자맞추기 게임을 작성한 것이다. * 1과 사이의 100 값을 반복적으로 입력 해서 컴퓨터가 * 생각한 값을 맞추면 게임이 끝난다 * 사용자가 값을 입력하면 컴퓨터는 자신이 생각한 값과 비교해서 결과를 알려준다 * 사용자가 컴퓨터가 생각한 숫자를 맞추면 게임이 끝나고 * 몇 번 만에 숫자를 맞췄는지 알려준다. * * ex) 컴퓨터가 랜덤으로 1~100숫자를 정함 ->(80이라고 가정) * * 숫자 입력 : 50 * -> 입력한 숫자보다 크다 * 숫자 입력 : 90 * -> 입력한 숫자보다 적다 * 숫자 입력 : 80 * -> 맞췄습니다. * 총 시도 횟수는 3번입니다. */ |
package 총복습;
import java.util.Scanner;
/*
* 다음은 숫자맞추기 게임을 작성한 것이다.
* 1과 사이의 100 값을 반복적으로 입력 해서 컴퓨터가
* 생각한 값을 맞추면 게임이 끝난다
* 사용자가 값을 입력하면 컴퓨터는 자신이 생각한 값과 비교해서 결과를 알려준다
* 사용자가 컴퓨터가 생각한 숫자를 맞추면 게임이 끝나고
* 몇 번 만에 숫자를 맞췄는지 알려준다.
*
* ex) 컴퓨터가 랜덤으로 1~100숫자를 정함 ->(80이라고 가정)
*
* 숫자 입력 : 50
* -> 입력한 숫자보다 크다
* 숫자 입력 : 90
* -> 입력한 숫자보다 적다
* 숫자 입력 : 80
* -> 맞췄습니다.
* 총 시도 횟수는 3번입니다.
*/
public class Test05 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num;
int userNum;
int cnt = 0;
num = (int)(Math.random()*100)+1;
while(true) {
System.out.println("숫자 입력 : ");
userNum = sc.nextInt();
cnt++;
if(userNum > num) {
System.out.println("입력한 숫자보다 크다");
} if(userNum < num) {
System.out.println("입력한 숫자보다 작다");
} else if (userNum == num) {
System.out.println("맞췄습니다");
System.out.println("총 시도 횟수 : " + cnt);
break;
}
}
}
}
| /* * 입력받은 숫자가 회문수인지 출력하는 프로그램을 완성하시오. * 회문수란? 12321, 15751, 131 -> 앞으로 읽어도, 뒤로 읽어도 똑같은걸 회문수 * ★힌트 : 입력받은 숫자를 뒤집어서 저장 ex) 123456 -> 654321 특정 변수에 저장 */ |
package 총복습;
import java.util.Scanner;
public class Test06 {
public static void main(String[] args) {
/*
* 입력받은 숫자가 회문수인지 출력하는 프로그램을 완성하시오.
* 회문수란? 12321, 15751, 131 -> 앞으로 읽어도, 뒤로 읽어도 똑같은걸 회문수
* ★힌트 : 입력받은 숫자를 뒤집어서 저장 ex) 123456 -> 654321 특정 변수에 저장
*/
Scanner sc = new Scanner(System.in);
int num;
int temp;
int result = 0;
System.out.println("숫자 입력 : ");
num = sc.nextInt();
temp = num;
//숫자
while(temp != 0){
result = result * 10 + temp % 10;
temp = temp / 10;
/*
* result temp * 10 + % 10;
* 0 123456 = 0 + 6
* 6 12345 = 60 + 5
* 65 1234 = 650 + 4
* 654 123 = 6540 + 3
* 6543 12 = 65430 + 2
* 65432 1 + 654320 + 1
* 654321 0 = 654321 + 0 <-- 끝내기
*/
}
System.out.println("뒤집어진 숫자 : " + result); //기존 num 값을 temp에 복사해서 넣기
//if문 조건식
if (num == result) {
System.out.println("입력하신 " + result + " 숫자는 회문수 입니다");
} else {
System.out.println("입력하신 " + result + " 숫자는 회문수가 아닙니다.");
}
}
}
배열 복습 풀이
package 총복습배열;
/*
* 다음은 배열에 담긴 데이터를 읽고 각 숫자의 개수를 세어서 개수만큼 *을 찍어서 그래프를 그리는 프로그램이다.
* <실행결과>
* 1 : ***
* 2 : **
* 3 : **
* 4 : ****
*/
public class Test01 {
public static void main(String[] args) {
int[] arr = {1,4,4,3,1,4,4,2,1,3,2};
int[] cnt = new int[4];
int num = 0;
for(int i = 0; i < arr.length; i++) { //
// arr[i] - 1 -> 개수를 저장하는 배열방 번호
cnt[arr[i] - 1]++;
}
for(int i = 0; i < cnt.length; i++) {
System.out.print(i+1 + " : ");
for(int j = 0; j<cnt[i]; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
package 총복습배열;
import java.util.Scanner;
/*
* 거슬러 줄 금액을 입력받아 계산한다
* 보유한 동전의 개수로 거스름돈을 지불할 수 없으면
* 거스름 돈이 부족합니다. 라고 출력하고 종료한다.
*
* 지불할 돈이 충분히 있으면
* 거스름돈을 지불한 만큼 가진 돈에서 빼고
* 남은 동전의 개수를 화면에 출력한다
*
* <출력 결과>
* 거스름 받을 금액을 입력하세요 : 2680
*
* money = 2680
* 500원 : 5
* 100원 : 1
* 50원 : 1
* 10원 : 3
* =남은 동전의 개수=
* 500 : 0
* 100 : 4
* 50 : 4
* 10 : 2
*/
public class Test021 {
public static void main(String[] args) {
int[] coinUnit = {500, 100, 50, 10};//동전 단위 저장 배열
int[] coin = {5, 5, 5, 5}; //동전 개수 저장 배열
int[] passCoin = new int[4]; //동전 개수 임시 보관
int i; //증감식
int money; //입력 받은 돈
//거슬름 받을 금액 입력
Scanner sc = new Scanner(System.in);
System.out.println("거스름 받을 돈을 입력하시오 : ");
money = sc.nextInt();
for(i = 0; i<coin.length; i++) {
passCoin[i] = money / coinUnit[i]; //금액에서 동전단위 나눠서 동전 개수 구함
if(passCoin[i] > coin[i]) { //가지고 있는 동전 개수보다 크냐?
passCoin[i] = coin[i]; // <-- 가지고 있는 동전개수로 지정
coin[i] = 0;
} else {
coin[i] = coin[i] - passCoin[i]; // coinTemp가 5개 보다 적을 경우 뺀 나머지 금액
}
money = money - coinUnit[i] * passCoin[i]; //
}
if(money > 0) {
System.out.println("거슬러줄 잔돈이 부족함");
} else {
System.out.println("=== 거슬러준 동전개수 ===");
for(i = 0; i<coin.length; i++) {
System.out.println(coinUnit[i] + "원: " + passCoin[i] + "개");
}
System.out.println("=== 남은 동전 개수 ===");
for(i = 0; i<coin.length; i++) {
System.out.println(coinUnit[i] + "원: " + coin[i] + "개");
}
}
}
}▼ 정답 보기전에 풀어본 코드
더보기
package 총복습배열;
import java.util.Scanner;
/*
* 거슬러 줄 금액을 입력받아 계산한다
* 보유한 동전의 개수로 거스름돈을 지불할 수 없으면
* 거스름 돈이 부족합니다. 라고 출력하고 종료한다.
*
* 지불할 돈이 충분히 있으면
* 거스름돈을 지불한 만큼 가진 돈에서 빼고
* 남은 동전의 개수를 화면에 출력한다
*
* <출력 결과>
* 거스름 받을 금액을 입력하세요 : 2680
*
* money = 2680
* 500원 : 5
* 100원 : 1
* 50원 : 1
* 10원 : 3
* =남은 동전의 개수=
* 500 : 0
* 100 : 4
* 50 : 4
* 10 : 2
*/
public class Test02 {
public static void main(String[] args) {
int[] coinUnit = {500, 100, 50, 10};//동전 단위 저장 배열
int[] coin = {5, 5, 5, 5}; //동전 개수 저장 배열
// coinUnit[coin[i] * 5];
int i;
int money; //입력 받은 돈
int coinTemp; //동전 개수 임시 보관
int tot = 0;
//거슬름 받을 금액 입력
Scanner sc = new Scanner(System.in);
System.out.println("거스름 받을 돈을 입력하시오 : ");
money = sc.nextInt();
//coin배열과 coinUnit배열을 0번부터 끝번까지 반복시켜 곱한 값을 tot에 대입 누적 시킨다.
for(i = 0; i<coin.length; i++) { //3000
tot += coin[i] * coinUnit[i];
}
//무한루프
if(money < tot) {
//각 배열방에 거스름돈 단위로 총합 저장
for(i = 0; i<coin.length; i++) { //3000
coinTemp = 0; //초기화
coinTemp = money / coinUnit[i]; //금액에서 동전단위 나눠서 동전 개수 구함
if(coinTemp > coin[i]) { //가지고 있는 동전 개수보다 크냐?
coinTemp = coin[i]; // <-- 가지고 있는 동전개수로 지정
coin[i] = 0;
} else {
coin[i] = coin[i] - coinTemp; // coinTemp가 5개 보다 적을 경우 뺀 나머지 금액
}
money = money - coinUnit[i] * coinTemp; //
System.out.println(coinUnit[i] + "원 : " + coinTemp + "개");
}
System.out.println("=== 남은 동전 개수 ===");
for(i = 0; i<coin.length; i++) {
System.out.println(coinUnit[i] + "원: " + coin[i] + "개");
}
} else {
System.out.println("잔액이 부족합니다.");
}
}
}클래스 복습 풀이
package 클래스;
/*
* 다음과 같은 변수를 가지는 Student 클래스를 완성하시오
* 데이터 타입 변수명 설명
* 문자열 name 이름
* 정수 ban 반
* 정수 no 번호
* 정수 kor 국어점수
* 정수 eng 영어점수
* 정수 math 수학점수
*
* 메서드
* 메서드명 : getTotal
* 기능 : 국어, 영어, 수학점수를 다 더해서 반환함
* 리턴타입 : 정수
* 매개변수 없음
*
* 메서드명 : getAverage
* 기능 : 총점을 과목수(3)로 나눈 평균을 반환함
* 리턴타입 : 실수
* 매개변수 없음
*/
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
s.name ="홍길동";
s.ban = 1;
s.no = 2;
s.kor = 100;
s.eng = 60;
s.math = 76;
System.out.println("이름: " + s.name);
System.out.println("총점: " + s.getTotal());
System.out.println("평균: " + s.getAverage());
}
}package 클래스;
public class Student {
String name;
int ban;
int no;
int kor, eng, math;
int getTotal() {
return kor + eng + math;
}
double getAverage(){
return getTotal()/3.0;
}
}
package 클래스;
public class Test02 {
public static void main(String[] args) {
Student s = new Student();
s.name ="홍길동";
s.ban = 1;
s.no = 2;
s.kor = 100;
s.eng = 60;
s.math = 76;
// System.out.println("이름: " + s.name);
// System.out.println("총점: " + s.getTotal());
// System.out.println("평균: " + s.getAverage());
System.out.println("===인포====");
s.info();
}
}package 클래스;
public class Student {
String name;
int ban;
int no;
int kor, eng, math;
public Student() {
}
public Student(String name, int ban, int no, int kor, int eng, int math) {
this.name = name;
this.ban = ban;
this.no = no;
this.kor = kor;
this.eng = eng;
this.math = math;
}
int getTotal() {
return kor + eng + math;
}
double getAverage(){
return getTotal()/3.0;
}
void info() {
System.out.println("이름 : " + name);
System.out.println("반 : " + ban);
System.out.println("번호 : " + no);
System.out.println("국어 : " + kor);
System.out.println("영어 : " + eng);
System.out.println("수학 : " + math);
System.out.println("총점 : " + getTotal());
System.out.println("평균 : " + getAverage());
}
}
- 맞는 것
1. 모든 생성자의 이름은 클래스의 이름과 동일해야 된다. (O)
2. 클래스에는 생성자가 반드시 하나 이상 있어야 한다. (O)
3. 생성자가 없는 클래스는 컴파일러가 기본 생성자를 추가한다 (O)
3-1. 클래스에 생성자가 없을 경우 컴파일러가 기존 생성자를 추가해준다. 2번과 3번을 연결
- 틀린 것
1.생성는 객체를 생성하기 위한 것이다. (X)
객체 생성 -> new 생성자 -> 초기화 목적이 강함
2. 생성자는 오버로딩 할 수 없다 (X)
------------------------
다음 중 오버로딩이 성립하기 위한 조건이 아닌 것을 모두 고르시오. (3, 4)
1. 메서드의 이름이 같아야 한다. (O)
2. 매개변수의 개수나 타입이 달라야 한다. (O)
3. 리턴타입이 달라야 한다. (X)
4. 매개변수 이름이 달라야 한다(X)
2. ex)
public Student(String name, int ban, int no)
public Student(String name, int ban, int no, int kor, int eng, int math)
public Student(String name, int ban, int no, int kor, double eng, int math)
package 클래스;
import java.util.Arrays;
//메서드 이름 xxxx shuffle(xxxx) {
/*
* 메서드명 : shuffle
* 기능 : 배열에 담긴 값의 위치를 바꾸는 작업
* 리턴타입 : 정수형 배열
* 매개변수 : 정수형 배열
*/
public abstract class Test03 {
//메서드 생성 위치
public static int[] shuffle(int[]arr) {
int temp; //임시 저장소
for(int i = 0; i<arr.length; i++) { //배열방
int j = (int)(Math.random()*arr.length); //j 변수안에 랜덤한 숫자가 계속 대입
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
return arr;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9};
int[] result = shuffle(arr);
System.out.println(Arrays.toString(result));
/*
* 결과 예시
* {6,1,3,7,8,2,4,5,9}
*/
}
}
package 문제풀이;
/*
* <실행결과>
* CH:100, VOL:0
* CH:99, VOL:0
* CH:100, VOL:100
*/
public class MyTvTest01 {
public static void main(String[] args) {
MyTv t = new MyTv();
t.channel = 100;
t.volume = 0;
System.out.println("CH:" + t.channel + ", VOL:" + t.volume);
t.channelDown();
t.volumeDown();
System.out.println("CH:" + t.channel + ", VOL:" + t.volume);
t.volume = 100;
t.channelUp();
t.volumeUp();
System.out.println("CH:" + t.channel + ", VOL:" + t.volume);
}
}package 문제풀이;
public class MyTv {
/** 상수 */
boolean isPowerOn;
int channel;
int volume;
final int MAX_VOLUME = 100;
final int MIN_VOLUME = 0 ;
final int MAX_CHANNEL = 100;
final int MIN_CHANNEL = 1;
void turnOnOff() {
/** (1) isPowerOn의 값이 true면 false로, false면 true로 바꾼다.*/
isPowerOn = !isPowerOn;
}
void volumeUp() {
/** (2) volume의 값이 MAX_VOLUME보다 작을 때만 값을 1증가시킨다 */
if(volume < MAX_VOLUME) { //volume = 0 < MAX_VOLUME = 100
volume++; //증가
}
}
void volumeDown() {
/** (3) volume의 값이 MIN_VOLUME보다 클 때만 값을 1감소키니다 */
if(volume > MIN_VOLUME) {
volume--;
}
}
void channelUp() {
/**
* (4) channel의 값을 1증가시킨다
* channel이 MAX_CHANNEL이면, channel의 값을 MIN_CHANNEL로 바꾼다
*/
if(channel == MAX_CHANNEL) { //channel이 MAX_CHANNEL과 같을때 ==
channel = MIN_CHANNEL;
} else {
channel++;
}
}
void channelDown() {
/**
* (5) channel의 값을 1감소시킨다
* channel이 MIN_CHANNEL이면, channel의 값을 MAX_CHANNEL로 바꾼다
*/
if(channel == MIN_CHANNEL) {
channel = MAX_CHANNEL;
} else {
channel--;
}
}
}
다음 중 오버라이딩의 조건으로 옳지 않은 것을 모두 고르시오. (3, 4)
1. 부모의 메서드와 이름이 같아야 한다. (O)
2. 매개변수의 수와 타입이 모두 같아야 한다. (O)
(매개변수의 수와 타입이 달라지면 오버로딩이 되는 것)
3. 접근 제어자는 부모의 메서드보다 좁은 범위로만 변경할 수 있다. (X)
부모 클래스(부모 클래스 -> 상속 -> 자식 클래스(메서드)
4. 부모의 메서드보다 더 많은 수의 예외를 선언할 수 있다. (X)
예외선언 try - catch
이름 같음, 매개변수 같음, 리턴타입 같 = 오버라이딩
public -> protected -> defalut -> private
defalut (같은 패키지에서만 접근 가능)
protected (같은 패키지에서만 접근 가능하지만 상속받은 것 까지도 가능)
동일 클래스에서 오버라딩을 같은 메서드명으로 하고 싶으면 매개변수를 다르게 해서 오버로딩도 같이 이루어져야 된다.
상속받은 클래스에서는 가능 (메인 클래스에서 새로운 객체를 생성을 또 해주기 때문에)
package 문제풀이03;
/**
* MyTv2 클래스의 멤버변수 isPowerOn, Channel, Volume을
* 클래스 외부에서 접근할 수 없도록 제어자를 붙이고
* 대신 이 멤버변수들의 값을 어디서나 읽고 변경할 수 있도록 메서드를 추가하시오
*/
public class MyTvMain02 {
public static void main(String[] args) {
MyTv2 t = new MyTv2();
t.setChannel(10);
System.out.println("CH : " + t.getChannel());
t.setVolume(20);
System.out.println("CH : " + t.getVolume());
}
}package 문제풀이03;
public class MyTv2 {
private boolean isPowerOn;
private int channel;
private int volume;
private final int MAX_VOLUME = 100;
private final int MIN_VOLUME = 0 ;
private final int MAX_CHANNEL = 100;
private final int MIN_CHANNEL = 1;
public boolean isPowerOn() {
return isPowerOn;
}
public void setPowerOn(boolean isPowerOn) {
this.isPowerOn = isPowerOn;
}
public int getChannel() {
return channel;
}
public void setChannel(int channel) {
this.channel = channel;
}
public int getVolume() {
return volume;
}
public void setVolume(int volume) {
this.volume = volume;
}
}
package 문제풀이04;
public class A {
public static void main(String[] args) {
//GroundUnit gu = new GroundUnit();
Unit u = new GroundUnit();
Tank t = new Tank();
AirCraft ac = new AirCraft();
/**
* 클래스가 다음과 같이 정의되어 있을 때 형변환을 올바르게 하지 않을 것을 모두 고르시오.
*/
/** 업캐스팅 */
//업캐스팅이 이루어진 것 만 다운캐스팅이 가능
//다운캐스팅은 그냥은 안됨
/**1번 */ u = (Unit)ac; //형변환 가능
/**2번 */ u = ac; //1번이랑 같은 것 업캐스팅해서 들어간것
/**3번 (o)*/ GroundUnit gu = (GroundUnit)u; //유닛을 그라운드 유닛에 다운캐스팅
//(Unit u = new GroundUnit(); <-- 이게 있기 때문에 가능)
/**4번 */ AirUnit au = ac; //부모의 부모 클래스라 업스캐스팅이여서 가능
/**5번 */ t = (Tank)u; // <-- 다운캐스팅시 바로 아래 단계인 녀석만 가능해서 5번은 불가
/**6번 */ GroundUnit ga = t;
}
}
class Unit {}
class AirUnit extends Unit {}
class GroundUnit extends Unit {}
class Tank extends GroundUnit {}
class AirCraft extends AirUnit {}
package 문제풀이05;
/**
* 세 개의 클래스로부터 공통부분을 뽑아서 Unit 이라는
* 클래스를 만들고 이클래스를 상속받고록
* 코드를 변경하시오.
*/
public class Unit {
int x, y;
void move(int x, int y) {
}
void stop() {
}
}package 문제풀이05;
public class Dropship extends Unit{
void load() {
}
void unload() {
}
}package 문제풀이05;
public class Tank extends Unit {
void changeMode() {
}
}package 문제풀이05;
public class Marine extends Unit {
void stimPack() {
}
}package 연습2;
public class Buyer {
int money = 1000;
Product[] cart = new Product[3]; // 구입한 제품 저장 배열
int i = 0; // cart배열 변수에 사용될 인덱스
void buy(Product p) {
// 1. 가진 돈과 물건의 가격을 비교해서 가진 돈이 적으면 메서드 종료
if(money < p.price) {
System.out.println("잔액이 부족하여 " + p + "를 살수 없습니다.");
return;
}
// 2. 가진 돈이 충분하면 제품의 가격을 가진 돈에서 뺌
money = money - p.price;
// 3. 장바구니에 구입한 물건을 담는다 ( add메서드 호출 )
add(p);
}
void add(Product p) {
// 1. i 값이 장바구니 크기보다 같거나 크면?
if(i >= cart.length) {
// 1-1. 기존 장바구니보다 2배 큰 새로운 배열을 생성
Product[] temp = new Product[cart.length * 2];
// 1-2. 기존 장바구니의 내용을 새로운 배열에 복사
System.arraycopy(cart, 0, temp, 0, cart.length);
// 1-3. 새로운 장바구니와 기존 장바구니를 교체
cart = temp;
}
// 2. 물건을 장바구니(cart)에 저장, 그리고 i 증가
cart[i] = p;
i++;
}
void summary() {
int i;
int sum = 0;
// 1. 장바구니에 담긴 물건의 목록을 만들어 출력
for(i=0; i<cart.length; i++) {
System.out.print(cart[i] + ",");
// 2. 장바구니에 담긴 물건의 가격을 모두 더해서 출력
sum = sum + cart[i].price;
}
System.out.println();
System.out.println("사용한 금액 : " + sum);
// 3. 물건을 사고 남은 금액(돈)을 출력
System.out.println("남은 금액 : " + money);
}
}package 문제풀이07;
public class Sample01 {
public static void main(String[] args) {
Outer ot = new Outer();
Outer.Inner oir = ot.new Inner();
System.out.println(oir.iv);
oir.method();
}
}
class Outer {
int value = 10;
class Inner {
int iv = 100;
int value = 20;
void method() {
int value = 30;
System.out.println(value);
System.out.println(this.value);
System.out.println(Outer.this.value);
}
}
}
package 문제풀이08;
/**
* 숫자가 아닌 값을 입력할 경우 ->
* 다시 입력하세요 -> 다시 진행
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// 1~100 사이의 임의의 값을 얻어서 answer에 저장한다
int answer = (int) (Math.random() * 100) + 1;
int input = 0; // 사용자입력을 저장할 공간
int count = 0; // 시도횟수를 세기 위한 변수
while(true) {
count++;
try {
System.out.print("1과 100사이의 값을 입력하세요 :");
input = new Scanner(System.in).nextInt();
if (answer > input) {
System.out.println("더 큰 수를 입력하세요.");
} else if (answer < input) {
System.out.println("더 작은 수를 입력하세요.");
} else {
System.out.println("맞췄습니다.");
System.out.println("시도횟수는 " + count + "번입니다.");
break;
}
} catch (Exception e) {
System.out.println("다시 입력하세요");
}
}
}
}
▼ continue를 사용 했을때 코드
더보기
package 문제풀이08;
/**
* 숫자가 아닌 값을 입력할 경우 ->
* 다시 입력하세요 -> 다시 진행
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// 1~100 사이의 임의의 값을 얻어서 answer에 저장한다
int answer = (int) (Math.random() * 100) + 1;
int input = 0; // 사용자입력을 저장할 공간
int count = 0; // 시도횟수를 세기 위한 변수
while(true) {
count++;
System.out.print("1과 100사이의 값을 입력하세요 :");
try {
input = new Scanner(System.in).nextInt();
} catch(Exception e) {
System.out.println("숫자 아님 다시 입력");
continue;
}
if (answer > input) {
System.out.println("더 큰 수를 입력하세요.");
} else if (answer < input) {
System.out.println("더 작은 수를 입력하세요.");
} else {
System.out.println("맞췄습니다.");
System.out.println("시도횟수는 " + count + "번입니다.");
break;
}
}
}
}package 문제풀이09;
import java.util.ArrayList;
public class Main01 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
ArrayList<Integer> kyo = new ArrayList<>(); //교집합
ArrayList<Integer> cha = new ArrayList<>(); //차집합
ArrayList<Integer> hap = new ArrayList<>(); //합집합
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
//list1{1,2,3,4}
list2.add(3);
list2.add(4);
list2.add(5);
list2.add(6);
//list2{1,2,3,4}
/**
* kyo : list1과 list2의 교집합을 구하는 코드
* cha : list1과 list2의 차집합을 구하는 코드
* hap : list1과 list2의 합집합을 구하느 코드
*/
kyo.addAll(list1);
kyo.retainAll(list2);
cha.addAll(list1);
cha.removeAll(list2);
hap.addAll(list1);
hap.removeAll(list2);
hap.addAll(list2);
System.out.println("list1 : " + list1);
System.out.println("list2 : " + list2);
System.out.println("kyo : " + kyo);
System.out.println("cha : " + cha);
System.out.println("hap : " + hap);
}
}
package 문제풀이10;
/**
* 클래스를 2개 생성
* Thread1 -> Thread 클래스를 상속
* Thread2 -> Runnable 인터페이스 상속(구현)
*
* 각각 1~100까지를 출력을 구현
*
* 메인 -> 실행
*/
public class Main {
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread t2 = new Thread(new Thread2());
//쓰레드 실행은 .start 메서드로 실행
t1.start();
t2.start();
}
}package 문제풀이10;
public class Thread2 implements Runnable {
public void run() {
for(int i = 0; i<=100; i++) {
System.out.println("스레드2 : " + i);
}
}
}package 문제풀이10;
public class Thread1 extends Thread{
public void run() {
for(int i = 0; i<100; i++) {
System.out.println("스레드1 : " +i);
}
}
}728x90
Comments