728x90

이것을 사용하는 이유는

강제 타입변환을 하기전에 구현한 객체가 인터페이스타입으로 변환되어 있는지 확인하기 위해서이다.

쉽게 객체의 타입을 확인하기 위해서 사용하는 메소드이다.
확인을 해서 강제 타입 변환이 가능한지 검사하는데 주로 사용하는 메소드이다.

지식인 글을 보고 더 공부하자

 

https://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040201&docId=136479378&qb=7J6Q67CUIGluc3RhbmNlT2Y=&enc=utf8§ion=kin&rank=2&search_sort=0&spq=0

 

자바 InstanceOf 개념 설명좀 해주세요 ㅠㅠ

package classes;class A { void abc(){ System.out.println("Hello"); // ---> 그리고 이값은 왜 출력이 안되는지하구요 ...

kin.naver.com

 


str = baabbaa
System.out.peintln(str.indexOf("aa", 0));

indexOf는 문자열의 첫번째(0번)부터 내가 원하는 단어("aa")를 찾는다.
저 코드를 실행하면 1이 출력된다.
b a a b b a a
0 1 2 3 4 5 6   의 순서이기 때문이다.
근데 우리가 원하는 aa는 1번째 자리 말고도 5번에도 위치하는데 위의 코드는 첫번째를 찾으면 종료해버린다.
그럼 우리는 다시 3번의 위치부터 검색을 해야한다.

str = baabbaabbaa
System.out.peintln(str.indexOf("aa", 0)); //0부터 찾기 시작해서 1출력
System.out.peintln(str.indexOf("aa", 3)); .//다시 3번부터 찾기 시작해서 5출력
System.out.peintln(str.indexOf("aa", 7)); .//다시 7번부터 찾기 시작해서 9출력

b a a b b a a b b a a
0 1 2 3 4 5 6 7 8 9 10
System.out,println(str.indexOf("aa",0));를 실행하면
0번째인 b부터 시작해서 1번째에 있는 a를 해서 찾았고 1을 출력
그리고 우리는 그 뒤에 있는 aa를 찾아야 하기 때문에 3번 부터 다시 검색하게 만들어야 한다.
System.out,println(str.indexOf("aa",3));을 실행하면
3번째인 b부터 시작해서 5번째에 있는 a을 만나 5를 출력
그리고 또다시 뒤를 찾아야하기 때문에 7번부터 다시 검색.
System.out,println(str.indexOf("aa",7));을 실행하면
7번째인 b부터 시작해서 9번째에 있는 a을 만나 9를 출력

System.out,println(str.indexOf("aa",0)); 1 출력
System.out,println(str.indexOf("aa",3)); 5 출력
System.out,println(str.indexOf("aa",7)); 9 출력

그럼 문제를 보자

문제
문자열을 입력하고 바꾸고싶은 문자열과 바꿀 문자열을 입력한 다음 문자를 바꿔주고
몇번 치환했는지 출력하기
[실행결과]
문자열 입력 : aabba
현재 문자열 입력 : aa
바꿀 문자열 입력 : cc
ccbba
1번 치환

문자열 입력 : aAbbA
현재 문자열 입력 : aa
바꿀 문자열 입력 : cc
ccbba
1번 치환

문자열 입력 : aabbaa
현재 문자열 입력 : aa
바꿀 문자열 입력 : cc
ccbbcc
2번 치환

package class_constructor;

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

public class StringTest02_0925 {
	private String input, nowWord, changeWord;
	public StringTest02_0925() throws IOException, NumberFormatException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		System.out.print("문자열 입력: ");
		input = br.readLine().toLowerCase();
		System.out.print("현재 문자열 입력: ");
		nowWord = br.readLine().toLowerCase();
		System.out.print("바꿀 문자열 입력: ");
		changeWord = br.readLine();
		while(nowWord.length()>input.length()) {
			System.out.println("처음 입력한 문자열의 크기보다 큽니다.");
			System.out.print("현재 문자열 입력: ");
			nowWord = br.readLine();
			System.out.print("바꿀 문자열 입력: ");
			changeWord = br.readLine();
		}

	}
	public void disp() {
		//문자열이 몇번째에 있는지 검색
		int index =0;
		int count = 0;
		while((index = input.indexOf(nowWord,index)) != -1) {
			//index는 찾는위치를 뜻하는데 index의 숫자는 계속 변해야 하니까
			//str.indexOf(target, index)를 실행하면 처음에 문자가 있는 숫자가 나온다.
			//그리고 그 숫자(위치)가 index가 되서 그 자리부터 다시 검색을 반복(while)
			index += nowWord.length();
			count++;
		}
		System.out.println(input.replace(nowWord, changeWord));
		System.out.println(count+"번 치환");
		}	
	
	public static void main(String[] args) throws IOException,NumberFormatException{
		while(true) {
			StringTest02_0925 st = new StringTest02_0925();
			st.disp();
		}
	
	}

}

처음에 출력해줄 기본 메소드를 입력한다.
근데 사용자가 대문자를 입력해도 오류가 나지 않도록 toLowerCase()메소드를 통해 
사용자가 입력한 대문자를 소문자로 치환해 input에 저장한다.

그리고 바꿀 문자열 changWord다음에 입력한 문자열 보다 바꿀 문자열이 더 큰 문자열을 인식하지 못하게 범위를 지정해준다.
입력한 문자열(input)보다 현재 문자열(nowWord)가 크면 인식을 할 수 없기 때문에 올바르게 입력할때까지 while문으로감싼다.

 

public class StringTest02_0925 {
	private String input, nowWord, changeWord;
	public StringTest02_0925() throws IOException, NumberFormatException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		System.out.print("문자열 입력: ");
		input = br.readLine().toLowerCase();
		System.out.print("현재 문자열 입력: ");
		nowWord = br.readLine();
		System.out.print("바꿀 문자열 입력: ");
		changeWord = br.readLine();
		while(nowWord.length()>input.length()) {
			System.out.println("처음 입력한 문자열의 크기보다 큽니다.");
			System.out.print("현재 문자열 입력: ");
			nowWord = br.readLine();
			System.out.print("바꿀 문자열 입력: ");
			changeWord = br.readLine();
		}

	}
	

a그다음 이 문제에서 가장 중요한 문자열을 검색해서 치환하는 코드이다.
몇번 치환해 주는지 갯수를 세는 count와 
바꾸고싶은 문자열이 몇번째에 있는지 알아내기 위한 index를 필드로 선언해준다.

문자를 변환하는거는 String클래스에 있는 replace(char oldChar, char newChar) 메소드를 사용하면 쉽다.

public void disp() {
		//문자열이 몇번째에 있는지 검색
		int index =0;
		int count = 0;
		while((index = input.indexOf(nowWord,index)) != -1) {
			//index는 찾는위치를 뜻하는데 index의 숫자는 계속 변해야 하니까
			//str.indexOf(target, index)를 실행하면 처음에 문자가 있는 숫자가 나온다.
			//그리고 그 숫자(위치)가 index가 되서 그 자리부터 다시 검색을 반복(while)
			index += nowWord.length();
			count++;
		}
		System.out.println(input.replace(nowWord, changeWord));
		System.out.println(count+"번 치환");
		}	
	

문제는 몇번 변환을 했는지 카운트를 세는건데 replace를 사용하면 단계고뭐고 한번에 바꿔버려서 count를 셀수가 없다
그럼  입력한 문자열(input)에 바꾸고싶은문자(nowWord)가 몇개 있는지 찾아봐야 한다.
문장의 끝까지 찾아야 하니깐 while문으로 감싸고 조건문을 넣어줘야 한다.
위에서 봤듯이 indexOf를 사용해 문장에서 내가 바꾸고싶은 "aa"를 검색하면 0번째부터 찾아야한다.
b a a b b a a b b a a
0 1 2 3 4 5 6 7 8 9 10

System.out,println(str.indexOf("aa",0));

이 코드를 실행하면 1이 출력된다.
0번 b부터 시작해서 1번째에 있는 a를 찾아내고 끝이 난다. 내가 찾을려고 한건 "aa"인데 왜 1이 나오냐?
baa에서 1,2번째이기 때문에 시작점인 1이 나온다. (만약 ba를 검색하면 0, 4, 8을 출력해낸다.)
암튼 2까지 우리가 찾는 문자열이니깐 3번째부터 다시 검색을 해보자!

System.out,println(str.indexOf("aa",3)); 

이렇게하면 5를 출력한다. 
근데 자동으로 찾아내야지 우리가 일일히 입력할 수는 없다. 공식을 만들어보자.
우리가 처음시작인 0번째에서 찾았고 그다음 3번째에서 검색을 했다.
그럼 저 자리는 계속 변해야 하니까 index라는 변수를 지정해주자.
그럼 input.indexOf(nowWord, index);가 되는데 우리가 바꾸고 싶은 문자열은 1개일수도 있고 여러개일수도 있다. 그럼 length를 써야겠네?

일단 우리문제에서는 난 aa를 찾아내서 바꿀거다.
처음에 1번째 자리가 출력되고 aa를 지난 3번자리에서 다시 검색을 했다. 1과 3은 2가 차이난다.
그다음 3부터 찾았는데 5가 나오고, 난 다시 7번부터 찾아야 된다. 그럼 5 랑 7은 2가 차이난다.
공통으로 변하는건 내가 바꾸고싶은 문자 aa만큼 2개씩 index가 늘어난다.

index 출력 +=nowWord.length()
0 1 2
3 5 2
7 9 2

이렇게 생각할 수 있겠다.
그럼 index = input.indexOf(nowWord, index);{ 
           index += nowWord.length();
}
라고 공식을 만들 수 있다.
근데 조건에 더이상 발견하지못하면 false가되어 빠져나올 수 있도록 

while((index = input.indexOf(nowWord,index)) != -1)를 해준다.
indexOf조건에 맞는게 나오면 위처럼 0,1,5,9 이런게 나와서 -1이 아니면 true
indexOf의 조건에 맞지 앉으면 -1이 출력되는데 그럼 -1이랑 같으니까 !=는 false가 되어 탈출.

public static void main(String[] args) throws IOException,NumberFormatException{
		while(true) {
			StringTest02_0925 st = new StringTest02_0925();
			st.disp();
		}
	
	}

마지막으로 출력하면된다...

728x90

'JAVA' 카테고리의 다른 글

DecimalFormat(숫자 형식 클래스)  (0) 2020.10.01
가변인자 varArgs  (0) 2020.09.29
Import Static  (0) 2020.09.28
배열 연습문제 05  (0) 2020.09.24
상속  (0) 2020.09.24
728x90

 

자주쓰는 메소드를 좀더 편리하게 사용하는 방법이다.
근데 쓸려면 그 메소드가 어디에 있는지 알아야한다.
그래야지 import에 선언해줄 수 있기 때문이다.
static에 관련된 메소드, 클래스에만 사용할 수 있다.

package class_constructor;

import static java.lang.Math.random;
import static java.lang.Math.pow;
import static java.lang.String.format;

public class ImportStatic_0928 {
	
	public static void main(String[] args) {
		
		System.out.println("난수 = "+Math.random());
		System.out.println("난수 = "+random());
		//import로 아예 어디에 있는지 다 선언해놔서 Math.random할 필요없이 random만해도 가능하게 만드는것.
		//import에 static을 무조건 붙여줘야 한다.
		
		System.out.println("제곱승= "+Math.pow(2, 10));
		System.out.println("제곱승= "+pow(2, 10));
		//이것도 import에 pow를 선언해줘야지 가능하다.
		
		System.out.println("소수 이라 2쨰자리= "+format("%.2f", 123.456));
		
		//자주쓰는 메소드를 좀더 편리하게 사용하는 방법이다.
		//근데 쓸려면 그 메소드가 어디에 있는지 알아야한다.
		//그래야지 import에 선언해줄 수 있기 때문이다.
		
		
	} 

}

e더 편한 방법이 있다.

//import static java.lang.Math.random;
//import static java.lang.Math.pow;
import static java.lang.Math.*;

import부분에 *(와일드카드)를 사용하면 Math.밑의 모든 메소드를 사용할 수 있다는 표시이다.

 

package class_constructor;

//import static java.lang.Math.random;
//import static java.lang.Math.pow;
import static java.lang.Math.*;
import static java.lang.String.format;
import static java.lang.System.out;

public class ImportStatic_0928 {
	
	public static void main(String[] args) {
		
		out.println("난수 = "+Math.random());
		out.println("난수 = "+random());
		//import로 아예 어디에 있는지 다 선언해놔서 Math.random할 필요없이 random만해도 가능하게 만드는것.
		//import에 static을 무조건 붙여줘야 한다.
		
		out.println("제곱승= "+Math.pow(2, 10));
		out.println("제곱승= "+pow(2, 10));
		//이것도 import에 pow를 선언해줘야지 가능하다.
		
		out.println("소수 이라 2쨰자리= "+format("%.2f", 123.456));
		
		//자주쓰는 메소드를 좀더 편리하게 사용하는 방법이다.
		//근데 쓸려면 그 메소드가 어디에 있는지 알아야한다.
		//그래야지 import에 선언해줄 수 있기 때문이다.
		
		
	} 

}

import static java.lang.System.out을 해주면
위의 코드처럼 System.out.printld에서 Syste,도 뺄수 있다......

728x90

'JAVA' 카테고리의 다른 글

가변인자 varArgs  (0) 2020.09.29
객체 타입 확인 instanceOf()메소드, indexOf()응용문제  (0) 2020.09.29
배열 연습문제 05  (0) 2020.09.24
상속  (0) 2020.09.24
ArrayList  (0) 2020.09.21
728x90

성적클래스를 만들어 필드와 메소드를 지정하고 문제 1, 2를 풀어라..

문제1,.

클래스명 : SungJuk
필드      : name, kor, eng, math, tot, avg, grade
메소드   : 생성자 
        calc() - 총점, 평균, 학점 계산
        getName()
      getKor()
      getEng()
      getMath()
      getTot()
      getAvg()
      getGrade()
      
[실행결과]
----------------------------------------------------
이름      국어      영어      수학      총점      평균      학점
----------------------------------------------------
홍길동   90      95      100
코난      100      89      75
또치      75      80      48

문제2
문제1에서 생성자로 값을 지정한거랑 달리 입력값을 받아서 출력해라.

SungJuk 클래스 이용하시오
객체 배열

[실행결과]
인원수 입력 : 2

이름 입력 : 홍길동
국어 입력 : 85
영어 입력 : 93
수학 입력 : 100

이름 입력 : 코난
국어 입력 : 75
영어 입력 : 86
수학 입력 : 92

----------------------------------------------------
이름      국어      영어      수학      총점      평균      학점
----------------------------------------------------
홍길동   85      93      100
코난      75      86      92

문제를 풀기위해 필요한 필드와 메소드를 선언한 클래스

package class_constructor;

import java.io.BufferedReader;

public class SungJuk {

	private String name;
	private char gread;
	private int kor, eng, math, sum;
	private double avg;

	public String getName() {
		return name;
	}
	public int getKor() {
		return kor;
	}
	public int getEng() {
		return eng;
	}
	public int getMath() {
		return math;
	}
	public int getSum() {
		return sum;
	}
	public double getAvg() {
		return avg;
	}
	public char getGread() {
		return gread;
	}
		
	public SungJuk(String name, int kor, int eng, int math) {
		this.name = name;
		this.kor = kor;
		this.eng = eng;
		this.math = math;
	}
	
	public void calc() {
		sum = kor + eng + math;
		avg = (double) sum / 3;
		if (avg >= 90) {
			gread = 'A';
		} else if (avg >= 80) {
			gread = 'B';
		} else if (avg >= 70) {
			gread = 'C';
		} else if (avg >= 60) {
			gread = 'D';
		} else {
			gread = 'F';
		}
	}

	
	
}

 

문제1

package class_constructor;

public class SungJukMain {
	public static void main(String[] args) {
	
		SungJuk[] s= new SungJuk[3];
		//SungJuk클래스만 저장할 수 있는 배열 3칸을 만든것
		s[0] = new SungJuk("가", 80, 90, 100);
		s[1] = new SungJuk("나", 95, 88, 75);
		s[2] = new SungJuk("다", 65, 76, 88);
		//3개의 객체는 sunjuk클래스에 파라미터를 받는 값을 저장할 수 있는 메소드를 만들었기 때문에
		//이렇게 저장이 가능하다.
		//입력값으로 받을려면 파라미터가 없는 메소드를 만들어야 한다.
		
		
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균\t학점");
		for(int i=0; i<3; i++) {
			s[i].calc();
			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\t%s\n"
					,s[i].getName(),s[i].getKor(),s[i].getEng(),s[i].getMath(),s[i].getSum(),s[i].getAvg(),s[i].getGread());
		}
	}

}

 

이름 국어   영어  수학    총점      평균      학점
가     80    90     100      270     90.00      A
나     95    88      75      258      86.00      B
다     65    76      88      229      76.33      C

문제2

package class_constructor;

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

public class SungJukMain02 {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String name;
		int kor, eng, math, sum;
		double avg;

		System.out.print("인원수 입력 : ");
		int userInput = Integer.parseInt(br.readLine());
		SungJuk[] s = new SungJuk[userInput];
		//sungjuk 클래스를 속성으로 한 객체를 담을 수 있는 배열 생성

		for (int i = 0; i < userInput; i++) {
			System.out.print("이름입력: ");
			name = br.readLine();
			System.out.print("국어점수: ");
			kor = Integer.parseInt(br.readLine());
			System.out.print("영어점수: ");
			eng = Integer.parseInt(br.readLine());
			System.out.print("수학점수: ");
			math = Integer.parseInt(br.readLine());
			System.out.println();
			s[i] = new SungJuk(name, kor, eng, math);
			//성적 클래스에 이 정보를 저장할 수 있는 메소드를 미리 만들어놨기 때문에
			//저장가능.
			s[i].calc();
//s[i]하나가 클래스하나의 정보. 그래서 이름, 국,영,수, 총점, 평균의 값을 다 저장할 수 있음
			//그래서 클래스에 원하는 값을 저장할 수 있는 필드, 메소드를 만들어야 한다.
		}
		System.out.println("-----------------------------------------------------");
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균\t학점");
		System.out.println("----------------------------------------------------");
//		for (int i = 0; i < userInput; i++) {
//			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\t%s\n"
//					,s[i].getName(),s[i].getKor(),s[i].getEng(),s[i].getMath(),s[i].getSum(),s[i].getAvg(),s[i].getGread());
//
//		}

	
	for(SungJuk data : s) {
		System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\t%s\n"
				,data.getName(),data.getKor(),data.getEng(),data.getMath(),data.getSum(),data.getAvg(),data.getGread());

	}
	}
}
인원수 입력 : 2
이름입력: 가
국어점수: 86
영어점수: 75
수학점수: 87

이름입력: 나
국어점수: 88
영어점수: 98
수학점수: 97

-----------------------------------------------------
이름 국어 영어 수학 총점 평균 학점
----------------------------------------------------
가 86 75 87 248 82.67 B
나 88 98 97 283 94.33 A

일단 입력받을 값을 저장해줄 이름,국어,영어등 필요한 필드를 만들어준다.
입력할 인원수 만큼 배열을 만들면되기 때문에 입력받는 변수 userInput을 배열의 크기로 설정한다.
배열을 생성한 후 for문을 이용해 입력값을 받고
마지막에 s[i] =~ 를 통해 배열을 저장한다.

배열은 같은 타입의 값들이 모인 것인데 지금은 이름,점수등 다양한 타입을 한번에 저장해야 한다.
그래서 타입을 가진 값이 아닌 클래스를 하나의 배열값으로 저장하는 방법을 사용한다.
먼저 필요한 필드와 메서드를 선언한 SungJuk클래스를만든 후 
SungJuk[] s = new SungJuk[]; 이란 코드를 통해
SungJuk의 속성을 같는 s을 생성했다. 이 클래스에는 다양한 타입의 값을 받을 수 있도록 필드와 메서드를 선언했기 때문에 클래스자체를 배열로 저장할 수 있게 된다.

그래서 s[i]에는 이름, 국어,영어,수학 점수, 총점, 평균, 학점의 정보가 들어가있다.
그리고 s[i].clac() 라는 코드를 통해 총점과 평균을 구할 수 있따.

728x90

'JAVA' 카테고리의 다른 글

객체 타입 확인 instanceOf()메소드, indexOf()응용문제  (0) 2020.09.29
Import Static  (0) 2020.09.28
상속  (0) 2020.09.24
ArrayList  (0) 2020.09.21
set, get 메소드를 사용하는 이유  (0) 2020.09.17
728x90

super는 부모, sub는 자식을 뜻한다.
상속을 사용하는 이유는 이미 만들어진 클래스에서 좀더 업그레이드를 시키기위해 기존의 메소드와 필드를 업혀서 기능들을 더 추가하기위한 방법이다.

상속의 장점!

1. 코드를 재활용함으로써 클래스 구조가 간결해진다
2. 상속을 하면 부모클래스안의 메소드만 확인하면 나머지도 잘 되는 거니깐 정확성이 높아진다.
3. 부모클래스에 몇개가 모여져 있으니까 수정/추가에 대한 유연성 및 확장성이 증가한다.

 

부모클래스는 자기 껏만 사용할 수 있는데 
부모클래스를 상속받는 자식클래스는 자기것만 아니라 부모것도 자동으로 사용할 수있다.

하나의 부모가 여러 자식에게 상속 가능 자식이 여러 부모의 상속불가능

private는 그 클래스 안에서만 접근이 가능한데
protected는 상속받는 자식 클래스까지 접근이 가능하다.

package inheritance;

public class SuperTest {

protected double weight;
protected double height;

public SuperTest(double w, double h) {
   this.weight = w;
   this.height = h;
}
public void disp() {
   System.out.println("몸무게= "+weight);
   System.out.println("키= "+height);
}

package inheritance;

public class SubTest extends SuperTest{
  
   public static void main(String[] args) {
     }
}
   

부모클래스에 weight와 height를 필드로 선언하고 
파라미터값을 받는 생성자를 만들고
출력하는 disp()를 만들었다.  
근데 이렇게 하면 자식클래스에 밑줄친것 처럼 오류가 나타난다.

왜냐하면 부모클래스에서 '기본생성자'를 만들지 않았기 때문이다.
부모클래스는 문제없는데 자식클래스는 자기꺼+부모꺼 까지 생성자를 구분한다.
자바는 생성자를 만들지 않으면 자동으로 '기본생성자'를 생성한다.(우리눈에 안보여도 생성된다)
근데 다른 생성자를 만들면 '기본생성자'를 만들어주지않는다. 우리가 직접 선언을 해줘야 한다.

그래서 오류가 나는 이유는
부모클래스에서 파라미터값을 받는 생성자(public SuperTest(double w, double h))를 만들었기 때문에
'기본생성자'가 자동으로 생성되지 않았다. 그래서 SubTest클래스에선 자기는 기본생성자가 자동으로 생성되었는데 부모인SuperTest에는 기본생성자가 없네? 하면서 오류가 나는 것이다.
아래 처럼 부모클래스에도 기본 생성자를 만들면 오류는 해결된다.

package inheritance; 

public class SuperTest { 

protected double weight; 
protected double height;

public SuperTest() {
   System.out.println("SuperTest 기본 생성자");
}
public SuperTest(double w, double h) {
   this.weight = w;
this.height = h;
}
public void disp() {
   System.out.println("SuperTest클래스의 disp()");
   System.out.println("몸무게= "+weight);
   System.out.println("키= "+height);
}
package inheritance; 

public class SubTest extends SuperTest{ 

   public static void main(String[] args) { 
      }
}
     

package inheritance; 

public class SuperTest { 

protected double weight; 
protected double height;

public SuperTest() {
   System.out.println("SuperTest 기본 생성자");
}
public SuperTest(double w, double h) {
   this.weight = w;
this.height = h;
}
public void disp() {
   System.out.println("SuperTest클래스의 disp()");
   System.out.println("몸무게= "+weight);
   System.out.println("키= "+height);
}
package inheritance; 

public class SubTest extends SuperTest{ 

 public SubTest() { 
          System.out.println("SubTest 기본 생성자")
     }

   public static void main(String[] args) { 
      SuperTest aa = new SuperTest();
//부모클래스를 그냥 사용사능
     System.out.println();
     SubTest bb = new SubTest(); 

     }

자식(SubTest)클래스에 노란색처럼 기본생성자를 넣어주고
new생성자를 이용하면 각 클래스의 기본생성자가 출력이 된다.

SuperTest 기본 생성자

SuperTest 기본 생성자
SubTest 기본 생성자

자식클래스에 선언한 SuperTest aa = new SuperTest(); 때문에 부모클래스의 기본 생성자가 나오고
SuperTest aa = new SuperTest(); 자기를 생성자로 만들면 
자식은 부모것도 자기것이기 때문에 부모클래스와 자식 클래스의 기본생성자 두개가 출력된다. 
자식은 별다른명령어 없이도 부모클래스의 필드나 메서드를 마음대로 호출할 수 있다.

 


package inheritance; 

public class SuperTest { 

protected double weight; 
protected double height;

public SuperTest() {
   System.out.println("SuperTest 기본 생성자");
}
public SuperTest(double w, double h) {
   this.weight = w;
this.height = h;
}
public void disp() {
   System.out.println("SuperTest클래스의 disp()");
   System.out.println("몸무게= "+weight);
   System.out.println("키= "+height);
}
package inheritance; 

public class SubTest extends SuperTest{ 

   protected String name;
   protected int age;

 public SubTest() { 
          System.out.println("SubTest 기본 생성자")
     }

   public static void main(String[] args) { 
     SuperTest aa = new SuperTest();
//부모클래스를 그냥 사용사능
     System.out.println();
     SubTest bb = new SubTest(); 
     }

위에 노란색처럼 필드를 추가해주자
그럼 부모클래스의 필드는 weight, height 2개인데
자식클래스의 필드는 부모의 필드를 받고 지것도 해서 weight, height, name, age 총 4개가 된다.


package inheritance; 

public class SuperTest { 

protected double weight; 
protected double height;

public SuperTest() {
   System.out.println("SuperTest 기본 생성자");
}
public SuperTest(double w, double h) {
   this.weight = w;
this.height = h;
}
public void disp() {
   System.out.println("SuperTest클래스의 disp()");
   System.out.println("몸무게= "+weight);
   System.out.println("키= "+height);
}
package inheritance; 

public class SubTest extends SuperTest{ 

   protected String name;
   protected int age;

 public SubTest() { 
          System.out.println("SubTest 기본 생성자")
     }
   public SubTest(double weight, double height, String              name, int age) {
          System.out.println("SubTest 생성자");
          super.weight = weight;
          this.height = height;
          this.name = name;
          this.age = age;
    }
   public void output() {
          System.out.println("몸무게: "+weight);
          System.out.println("키: "+height);
          System.out.println("이름: "+name);
          System.out.println("나이: "+age);

   }

   public static void main(String[] args) { 
     SuperTest aa = new SuperTest();
//부모클래스를 그냥 사용사능
     System.out.println();
     SubTest bb = new SubTest(); 
     }

노란색부분은 파라미터를 받는 생성자를 추가하고 
주황색부분은 출력하는 메소드를 만들었다.

노란색부분에서 super와 this를 썼는데 super는 부모를 뜻하고 this는 자기(자식클래스)를 뜻한다.
근데 weight는 부모클래스에 있는 필드니까 super.를 사용했는데 height는 this를 썼다? 
자식은 부모껀 내껀데? 하는 느낌이라서 부모클래스의 필드도 지께되서 this를 사용해도 상관이 없다.....
그러나 알아보기 편하게 부모껀 super로 하자.

주황색부분도 마찬가지이다. 출력하는데 다른거 같으면 weight나 height에 super나 다른클래스를 불러오는 뭔가를 해줘야 하는데 자식은 부모것을 다 쓸수있으니깐 그냥 써도 자동으로 인식이되어 오류가 나지 않는다. 
super.weight를 써도 된다.


package inheritance; 

public class SuperTest { 

protected double weight; 
protected double height;

public SuperTest() {
   System.out.println("SuperTest 기본 생성자");
}
public SuperTest(double w, double h) {
   this.weight = w;
this.height = h;
}
public void disp() {
   System.out.println("SuperTest클래스의 disp()");
   System.out.println("몸무게= "+weight);
   System.out.println("키= "+height);
}
package inheritance; 

public class SubTest extends SuperTest{ 

   protected String name;
   protected int age;

 public SubTest() { 
          System.out.println("SubTest 기본 생성자")
     }
   public SubTest(double weight, double height, String              name, int age) {
          System.out.println("SubTest 생성자");
          super.weight = weight;
          this.height = height;
          this.name = name;
          this.age = age;
    }
   public void output() {
          System.out.println("몸무게: "+weight);
          System.out.println("키: "+height);
          System.out.println("이름: "+name);
          System.out.println("나이: "+age);

   }

   public static void main(String[] args) { 
     SuperTest aa = new SuperTest();
//부모클래스를 그냥 사용사능
     System.out.println();
    SubTest bb = new SubTest(75.3, 185.5, "홍길동",25); 
    //파라미터 값을 넣고
bb.output(); 
//먼저 SubTest클래스에서 찾고 없으면 SuperTest클래스로 넘어간다.
System.out.println();
bb.disp();
//먼저 SubTest클래스에서 찾고 없으면 SuperTest클래스로 넘어간다.


     }
}

SuperTest 기본 생성자

SuperTest 기본 생성자
SubTest 생성자
몸무게: 75.3
키: 185.5
이름: 홍길동
나이: 25

SuperTest클래스의 disp()
몸무게= 75.3
키= 185.5

자식클래스에 있는 output()를 사용해 정보를 출력하고
bb.disp();를 하면 SubTest bb = new SubTest(75.3, 185.5, "홍길동",25); 에 있는 파라미터 값들이 
부모클래스에 있는 disp()를 찾아가 weight와 height를 출력하게 된다.

 


this()나 super()는 static영역에서는 사용할 수 없다. 그래서 지금까지 공부한 것을 보면 메인영역에는 this나 super를 사용하지 않았다.
메인영역 밖에서도 클래스 영역중에 ststic를 사용하지 않은 곳에만 this, super를 사용할 수  있다. 그래서 자식클래스의 메인 메소드안에서 바로 super.부모클래스의 메서드를 할 수없다.

 

그리고 메소드를 오버라이드하면 부모의 메소드는 무시하고 무.조.건. 오버라이드된 자식클래스내의 메소드에서 작동한다.
메소드명만 같고 파라이터가 다르면 오버로드
메소드명이 같고 파라미터도 같으면 오버라이드



내가 알아보기 쉽게 정리!

부모(Super)클래스

package com.zoo;

public class A {
	protected int a = 1;
	protected String oh = "A클래스의 oh";
	
	public void play() {
		System.out.println("클래스A의 play");
	}

}

자식(Sub)클래스

ckage com.zoo;

public class B extends A{
	
		int a1 = 2;
		String oh1 = "B클래스의 oh";
		
		public void play() {
			System.out.println("클래스B의 play");
		}
	

}

메인클래스

package com.zoo;
//상속 완전 정리
public class C {
	public static void main(String[] args) {
		System.out.println("A aClass = new A(); 일때");
		A aClass = new A();
		System.out.println("Super클래스인 A클래스의 변수a : "+aClass.a);
		System.out.println("Super클래스인 A클래스의 변수oh : "+aClass.oh);
		aClass.play();
		System.out.println();
		
		System.out.println("B bClass = new B(); 일때");
		B bClass = new B();
		System.out.println("Super클래스인 A클래스의 변수a : "+bClass.a);
		System.out.println("Sub클래스인 B클래스의 변수a : "+bClass.a1);
		System.out.println("Super클래스인 A클래스의 변수oh : "+bClass.oh);
		System.out.println("Sub클래스인 B클래스의 변수oh : "+bClass.oh1);
		bClass.play();
		System.out.println();
		
		System.out.println("A aClass = new B(); 일때");
		A abClass = new B();
		System.out.println("Super클래스인 A클래스의 변수a : "+abClass.a);
		System.out.println("Super클래스인 A클래스의 변수oh : "+abClass.oh);
		abClass.play();
		
		
		
		
	}

}

결과

A aClass = new A(); 일때
Super클래스인 A클래스의 변수a : 1
Super클래스인 A클래스의 변수oh : A클래스의 oh
클래스A의 play

B bClass = new B(); 일때
Super클래스인 A클래스의 변수a : 1
Sub클래스인 B클래스의 변수a : 2
Super클래스인 A클래스의 변수oh : A클래스의 oh
Sub클래스인 B클래스의 변수oh : B클래스의 oh
클래스B의 play

A aClass = new B(); 일때
Super클래스인 A클래스의 변수a : 1
Super클래스인 A클래스의 변수oh : A클래스의 oh
클래스B의 play

ㅇ필드는 각자의 꺼를 사용하지만 메소드는 오버라이딩이 되어 부모와 자식의 메소드중에 자식의 메소드를 우선 적용한다.

 

728x90

'JAVA' 카테고리의 다른 글

Import Static  (0) 2020.09.28
배열 연습문제 05  (0) 2020.09.24
ArrayList  (0) 2020.09.21
set, get 메소드를 사용하는 이유  (0) 2020.09.17
[메소드]toString()메소드  (0) 2020.09.16
728x90

ArrayList는 배열과 리스트의 특징을 둘다 가지고 있는 클래스이다.
원래의 배열은 크기를 지정해주고 값을 넣어주기 때문에 새로운 값을 넣으면 크기가 초과되어 오류가 난다.

하지만 ArrayList는 처음부터 크기를 정해주는 방식이 아니라
넣는 데이터의 갯수에 따라 크기가 가변적으로 바뀌기 때문에 배열의 한계를 해결해주는 편리한 클래스이다.

 

ArrayList 라는 자바에서 만들어준 클래스를 사용하는 방법은

ArrayList list = new Arraylist();

라고 선언해 주고 

list.add();
list.get();

이렇게 사용하면 된다.

그리고 필드와 메소드를 담아놓은 클래스를 상속? 받아 ArrayList를 사용할 때에는

ArrayList<클래스이름> list = new ArrayList<>(); 


이런 양식으로 선언을 해 주어야 한다.

일단 필요한 필드와 메소드를 선언한 Car 클래스를 만들고

package day0916;
//설계도인 이 클래스 안에서 필드의 초기값은 없다.

import java.text.DecimalFormat;

public class Car {
		
	//필드
	//차량번호
	private String number, color, type;
	//차량 종류
	//private String type;
	//연식
	private int year, price;
	//가격
	//private int price;
	//색깔
	//private String color;
	
	
	//파라미터가 있는 생성자
	public Car(String number, String type, int year, int price, String color) {
		//number = number; 
		//이렇게 하면 number는 윗줄에 있는 파라미터 = 파라미터가 되서 입력?이 안된다
		//우리가 원하는건 Car 클래스 안의 필드 number에 파라미터 값을 입력하고 싶은거니까 
		//클래스안의 필드를 가리키는this를 해줘야 한다.
		this.number = number;
		this.type = type;
		this.year = year;
		this.price = price;
		this.color = color;
	}
	
	//필드에 대한 캡슐화
	public void setNumber(String number) {
		this.number = number;
	}
	public String getNumber() {
		return number;
	}
	
	public void setType(String type) {
		this.type = type;
	}
	public String getType() {
		return type;
	}
	
	public void setYear(int year) {
		this.year = year;
	}
	public int getYear() {
		return year;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
	public int getPrice(){
		return price;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	public String getColor() {
		return color;
	}
	public String toString() { 
		//이게 없으면 다른 클래스에서 클래스명[i]로 출력하면 원하는 값이 아니라 주소값이 출력된다. 
		//Car의 객체가 들어있는 이 클래스안에 toString을 선언해 줘야 우리가 원하는 값이 출력.
		
		return "차량번호: " +number+
				", 차량종류: "+type+
				", 차량가격: "+price+"원"+
				", 차량연식: "+year+"년"+
				", 차량색상: "+color;
	}
	
	
	
	
}

 메인메소드에서 이렇게 사용하면 된다.

package day0918;

import java.util.ArrayList;

import day0916.Car;

public class Ex01ArrayList {

	public static void main(String[] args) {
		//어레이리스트 선언하기
		ArrayList<Car> carList = new ArrayList<>();
		//어레이리스트가 어디를 참조해야 하는지 정해주는 코드
		Car c1 = new Car("a", "typeA", 2000, 100000, "a");
		Car c2 = new Car("b", "typeB", 2001, 200000, "b");
		Car c3 = new Car("c", "typeC", 2002, 300000, "c");
		Car c4 = new Car("d", "typeD", 2003, 400000, "d");
		Car c5 = new Car("e", "typeE", 2004, 500000, "e");
		
		// 1. 배열의 현재크기를 알아볼때는 size()를 이용하면 된다.
	      System.out.println("carList.size(): "+carList.size());
	      System.out.println("객체는 만들고 add 하기전");
	      System.out.println();
	    //2. 어레이리스트에 새로운 객체를 추가할 때에는 add()르 이용하면 된다.
	      carList.add(c1);
	      System.out.println("carList.size(): "+carList.size());
	      carList.add(c2);
	      System.out.println("carList.size(): "+carList.size());
	      carList.add(c3);
	      System.out.println("carList.size(): "+carList.size());
	      carList.add(c4);
	      System.out.println("carList.size(): "+carList.size());
	      carList.add(c5);
	      System.out.println("carList.size(): "+carList.size());
	      System.out.println();

	      //3. 어레이 리스트에서 해당 위치에 있는 객체를 호출할 떄엔 get()메소드를 사용하면 된다.
	      System.out.println("carList.get(1): "+carList.get(1));
	      //get으로 호출한 객체는 '배열의 몇번째 칸에 있는 객체다'처럼 우리가 그 객체의 메소드를 실행해 줄 수 있다.
	      System.out.println("carList.get(0).getType(): "+carList.get(0).getType());
	      
	      //4. 어레이 리스트에서 객체를 제거할 때에는 2가지 방법이 가능하다.
	      //A) 인덱스로 삭제하기
	      //	인덱스로 삭제할 때에는 remove(inmdex)를 하면 된다.
	      System.out.println("carList.get(0): "+carList.get(0));
	      carList.remove(0);
	      System.out.println("carList.get(0): "+carList.get(0));
	      	
	      //B) 객체로 삭제하기
	      //	객체로 삭제할 때에는 해당 객체와 equals()가 true가 나오는 객체를 넣어주면된다.
	      Car c44 = new Car("d","typeD",2003,400000,"d");
	      Car c55 = new Car("e","typeE",2004,500000,"e");
		
	      System.out.println("c4.equals(c44): "+c4.equals(c44));
	      System.out.println("carList.size(): "+carList.size());
	      carList.remove(c44);
	      System.out.println("car.List.size(): "+carList.size());
	      carList.remove(c55);
	      System.out.println("car.List.size(): "+carList.size());
	      
	}
}

 

이렇게 결과가 나온다.

728x90

'JAVA' 카테고리의 다른 글

배열 연습문제 05  (0) 2020.09.24
상속  (0) 2020.09.24
set, get 메소드를 사용하는 이유  (0) 2020.09.17
[메소드]toString()메소드  (0) 2020.09.16
배열 연습문제04  (0) 2020.09.12
728x90

클래스를 나눠서 만들다보면 필드를 만들고 다른 클래스에서 값을 마음대로 수정할 수 없도록 정보보호?를 위해 private을 붙여주게 된다. 이것을 캡슐화라고 한다.

Car클래스에서 필드에 private를 해주지 않으면 CarPlay클래스에서 값을 마음대로 수정할 수 있다.
하지만 private를 지정해주면 사진처럼 오류가 나오고 값을 수정할 수 없다.

이렇게 설계도 격인 Car클래스의 정보들은 외부에서 수정할 수 없도록 private를 선언해 주어야 한다.

private를 지정한 후 CarPlay클래스에서 값을 지정하는 방법은 
set, get메소드를 통해 가능하다.

 

package day0916;
//설계도인 이 클래스 안에서 필드의 초기값은 없다.
public class Car {
		
	//필드
	//차량번호
	private String number;
	//차량 종류
	private String type;
	//연식
	private int year;
	//가격
	private int price;
	//색깔
	private String color;
	
	
	//메소드
	//차량 출력정보
	public void printInfo() {
		System.out.printf("차량번호 : %s 차량종류: %s\n",number, type);
		System.out.printf("연식 : %d 가격: %d원\n",year, price);
		System.out.printf("색상 : %s\n", color);
	}
	
	//파라미터가 없는 생성자
	public Car() {//파라미터가 없으니까 초기화를 해줘야함
		//지금 String은 null, int는 0으로 초기화 되어있는데 아래처럼 초기화를 안한상태에서 
		//정보를 불러오면 null포인트 오류가 난다. 그래서 오류를 없애기 위해 초기화를 해서 정리?를 해주는것이다.
		number = new String();
		type = new String();
		year =0;
		price =0;
		color = new String();
	}
	
	//파라미터가 있는 생성자
	public Car(String number, String type, int year, int price, String color) {
		//number = number; 
		//이렇게 하면 number는 윗줄에 있는 파라미터 = 파라미터가 되서 입력?이 안된다
		//우리가 원하는건 Car 클래스 안의 필드 number에 파라미터 값을 입력하고 싶은거니까 
		//클래스안의 필드를 가리키는this를 해줘야 한다.
		this.number = number;
		this.type = type;
		this.year = year;
		this.price = price;
		this.color = color;
	}
	
	//필드에 대한 캡슐화
	public void setNumber(String number) {
		this.number = number;
	}
	public String getNumber() {
		return number;
	}
	
	public void setType(String type) {
		this.type = type;
	}
	public String getType() {
		return type;
	}
	
	public void setYear(int year) {
		this.year = year;
	}
	public int getYear() {
		return year;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
	public int gerPrice()
	{
		return price;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	public String getColor() {
		return color;
	}
	

이렇게 set과 gaet메소드를 정의 해주면 된다.
set은 메인클래스에서 값을 입력만 받고 출력해주지 않기 때문에 public void를 선언하고 파라미터로 입력해야 하는 타입과 파라미터명을 정해준다(아무렇게나 해도 상관없지만 알아보기 쉬운 단어로 해야한다).

get은 set메소드를 통해 입력받은 값을 메인클래스에 출력할 것이기 때문에 입력받은 타입을 지정해준다. 그리고 return 파라미터값 을 설정해준다.

그리고 값을 출력해줄 printInfo()메소드도 만들어준다.

package day0916;

public class CarPlay {
	public static void main(String[] args) {
		Car c = new Car();
		c.setNumber("01가1234");
		c.setType("모닝");
	    c.setYear(2020);
	    c.setColor("빨간색");
	    
	    c.printInfo();
	    
	}

}
차량번호 : 01가1234 차량종류: 모닝
연식 : 2020 가격: 0원
색상 : 빨간색

메인 메소드에서 위의 코드처럼 new 연산자를 통해 객체 c를 만들고
c.set~()을 통해 각 값을 넣어주면 객체c에 입력한 값들이 저장된다.

그후 printInfo()를 통해 값을 출력해주면 입력한 값들이 나온다.

728x90

'JAVA' 카테고리의 다른 글

상속  (0) 2020.09.24
ArrayList  (0) 2020.09.21
[메소드]toString()메소드  (0) 2020.09.16
배열 연습문제04  (0) 2020.09.12
배열, 2차원 배열 정리  (0) 2020.09.12
728x90

toString()메소드는 객체가 가지고 있는 정보나 값들을 문자열로 만들어 리턴하는 메소드이다.

객체를 그냥 출력하면 우리가 저장한 값이 아니라 해시태그 값을 나타낸다.

package day0916;
public class Car {	
	//필드
	//차량번호
	private String number;
	//차량 종류
	private String type;
	//연식
	private int year;
	//가격
	private int price;
	//색깔
	private String color;
	
	
	//파라미터가 없는 생성자
	public Car() {//파라미터가 없으니까 초기화를 해줘야함
		number = new String();
		type = new String();
		year =0;
		price =0;
		color = new String();
	}

	
}
package day0916;

public class Play {
	public static void main(String[] args) {
		Car c1 = new Car();
		
		c1.setNumber("00가 0000");
		c1.setType("모닝");
		c1.setYear(2019);
		c1.setPrice(500000);
		c1.setColor("빨간색");
		
		System.out.println(c1);
		System.out.println(c1.toString());//두개가 같다
	}

}

 

day0916.Car@15db9742

day0916.Car@15db9742

저렇게 출력하면 내가 저장한 값이 아니라 해시태그 값이 나온다. 형식은 저렇게 해도 똑같이 나온다.

이때 toString()메소드를 이용해 문자열로 변환해서 내가 원하는 값을 보일 수 있다.

package day0916;
public class Car {	
	//필드
	//차량번호
	private String number;
	//차량 종류
	private String type;
	//연식
	private int year;
	//가격
	private int price;
	//색깔
	private String color;
	
	
	//파라미터가 없는 생성자
	public Car() {//파라미터가 없으니까 초기화를 해줘야함
		number = new String();
		type = new String();
		year =0;
		price =0;
		color = new String();
	}

	public String toString() { 
		return "차량번호: " +number+
				", 차량종류: "+type+
				", 차량가격: "+price+"원"+
				", 차량연식: "+year+"년"+
				", 차량색상: "+color;
	}
	
}

a메소드를 정의한 클래스에서 toString()메소드를 위와 같이 선언을 해주면

차량번호: 00가 0000, 차량종류: 모닝, 차량가격: 500000원, 차량연식: 2019년, 차량색상: 빨간색

이렇게 원하는 값을 나타낼 수 있다.

728x90

'JAVA' 카테고리의 다른 글

ArrayList  (0) 2020.09.21
set, get 메소드를 사용하는 이유  (0) 2020.09.17
배열 연습문제04  (0) 2020.09.12
배열, 2차원 배열 정리  (0) 2020.09.12
for 연습05  (0) 2020.09.09
728x90

순서대로 학생 5명의 이름과 국어, 영어, 수학 점수를 입력받고
저장된 1~5번 학생의 이름과 총점을 호출해보자. -1을 입력하면 종료

[결과]
 보고싶은 학생 : 3
3번 학생의 총점 : 

보고싶은학생  : 4  
4번 학생의 총점  :

보고싶은학생 : 99
잘못입력하셨습니다.

package day0911;

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

public class Ex01Array_1 {
	// 2개의 배열을 동시에 사용해서
	// 이름과 총점을 동시에 관리하자
	final static int SIZE = 5;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 이름을 담당할 배열
		String[] nameArray = new String[SIZE];
		// 총점을 담당하는 배열
		int[] sumArray = new int[SIZE];

		// 차례대로 입력을 해보자
		for (int i = 0; i < SIZE; i++) {
			System.out.print((i + 1) + "번 학생의 이름 : ");
			nameArray[i] = br.readLine();
			// 국어점수
			System.out.print(nameArray[i] + "학생의 국어점수 : ");
			int korean = Integer.parseInt(br.readLine());
			while (korean < 0 || korean > 100) {
				System.out.println("잘못입력하셨습니다.");
				System.out.print(nameArray[i] + "학생의 국어점수 : ");
				korean = Integer.parseInt(br.readLine());
			}
			// 영어점수
			System.out.print(nameArray[i] + "학생의 영어점수 : ");
			int english = Integer.parseInt(br.readLine());
			while (english < 0 || english > 100) {
				System.out.println("잘못입력하셨습니다.");
				System.out.print(nameArray[i] + "학생의 영어점수 : ");
				english = Integer.parseInt(br.readLine());
			}
			// 수학점수
			System.out.print(nameArray[i] + "학생의 수학점수 : ");
			int math = Integer.parseInt(br.readLine());
			while (math < 0 || math > 100) {
				System.out.println("잘못입력하셨습니다.");
				System.out.print(nameArray[i] + "학생의 수학점수 : ");
				math = Integer.parseInt(br.readLine());
			}
			sumArray[i] = korean + english + math;

		}
		System.out.println();

		// 보고싶은 학생의 번호를 입력하면 그 학생의 정보를 출력하게 만들어보자
		// System.out.print("보고싶은 학생의 번호를 입력하세요(1~5) : ");
		// int userChoice = Integer.parseInt(br.readLine())-1;

		// System.out.println(nameArray[userChoice]+"학생의 총점 : "+sumArray[userChoice]);

		while (true) {
			System.out.println("보고싶은 학생의 번호를 입력하세요(1~5, -1은 종료) : ");
			System.out.print("> ");
			int userChoice = Integer.parseInt(br.readLine());
			if (userChoice == -1) {
				// 사용자가 종료를 선택했을때
				System.out.println("사용해주셔서 감사합니다.");
				break;
			} else if (userChoice >= 1 && userChoice <= 5) {
				// 학생번호가 유효할때
				int index = userChoice - 1;
				// 첫번째 학생을 본다치면 user는 1을 치지만 배열의 첫번째는 0이다.
				// 그래서 입력되는 값에서 -1을 하면 배열의 i와 일치한다.
				System.out.println(nameArray[index] + "학생의 총점: " + sumArray[index]);
			} else {
				// 잘못입력했을때
				System.out.println("잘못입력하셨습니다.");
			}

		}
	}
}
1번 학생의 이름 : 1
1학생의 국어점수 : 1
1학생의 영어점수 : 1
11학생의 수학점수 : 
2번 학생의 이름 : 2
2학생의 국어점수 : 2
2학생의 영어점수 : 2
2학생의 수학점수 : 2
3번 학생의 이름 : 3
3학생의 국어점수 : 3
3학생의 영어점수 : 3
3학생의 수학점수 : 3
4번 학생의 이름 : 4
4학생의 국어점수 : 4
4학생의 영어점수 : 4
4학생의 수학점수 : 4
5번 학생의 이름 : 5
5학생의 국어점수 : 5
5학생의 영어점수 : 5
5학생의 수학점수 : 5

보고싶은 학생의 번호를 입력하세요(1~5, -1은 종료) : 
> 6
잘못입력하셨습니다.
보고싶은 학생의 번호를 입력하세요(1~5, -1은 종료) : 
> 1
1학생의 총점: 3
보고싶은 학생의 번호를 입력하세요(1~5, -1은 종료) : 
> -1
사용해주셔서 감사합니다.
728x90

+ Recent posts