자바 향상된 for문, 객체지향
04_array
ArrayEx2 향상 for문// ----------------------------------------------------------
/* [향상된 for문 (forEach) ]
*
* - 0번 인덱스 부터 마지막 인덱스까지 1씩 증가하며
* iterable 성격을 띄는 객체의 요소를
* 하나씩 순서대로 반환하는 for문
*
* * iterable : 반복 가능한
* ex) 배열, List, Set, Map 등
*
*
* [작성법]
*
* for(배열 요소 자료형의 변수 : 배열명){
*
* }
*
* ex)
* int[] arr = new int[3];
*
* for(int num : arr){
* // num은
* // for문이 반복 될 때마다
* // arr[0], arr[1], arr[2] 인덱스 값이
* // 순차 적으로 대입됨
* }
*/
public void method3() {
int[] arr = {10, 20, 30, 40};
// 향상된 for문
for(int num : arr) {
System.out.println(num);
}
// 일반 for문
System.out.println("-----------------");
for(int i=0 ; i<arr.length ; i++) {
System.out.println(arr[i]);
}
}
/**
* 향상된 for문을 이용한
* 배열 요소 순차 접근(==반복 접근)
*/
public void method4() {
char[] arr = {'백', '동', '현'};
for(char ch : arr) { // 향상된 for문
System.out.printf("%c의 유니코드 : %d \n", ch, (int)ch );
}
}
// ----------------------------------------------------
/** 2차원 배열
*
* - 1차원 배열을 묶음으로 다루는 것
* -> 1차원 배열을 참조하는
* 참조형 변수의 묶음
*
* [작성법]
* ( [] : 1차원 배열 )
*
*
* 자료형[][] 배열명 = new 자료형[크기][크기];
*/
public void method5() {
// 2차원 배열 선언/할당
int[][] arr = new int[2][3];
// 2차원 배열 초기화
arr[0][0] = 10;
arr[0][1] = 20;
arr[0][2] = 30;
arr[1][0] = 40;
arr[1][1] = 50;
arr[1][2] = 60;
// 출력
System.out.println(arr[0]); // 1차원 배열의 해시코드(주소)
System.out.println(arr[1]); // 1차원 배열의 해시코드(주소)
// arr[0]가 참조하는 객체/배열이 int[] 자료형인가?
// js로따지면 type of 같은것
System.out.println(arr[0] instanceof int[]); // true
System.out.println("------------------------------");
// for문으로 모든 요소 출력하기 1 (일반 for문)
// arr.length
// - arr 이 참조하고 있는
// 1차원 배열 참조 변수의 묶음의 길이
for(int row = 0 ; row < arr.length ; row++) { // 행 제어
for(int col = 0 ; col < arr[row].length; col++) { // 열 제어
System.out.print(arr[row][col] + " ");
}
System.out.println(); // 줄바꿈
}
System.out.println("-------------------------------");
// for문으로 모든 요소 출력하기 2 (향상된 for문)
for(int[] row : arr) { // 행을 하나씩 순차 접근
for(int col : row ) { // 각 행의 열을 하나씩 순차접근
System.out.print(col + " ");
}
System.out.println();
}
}
}
Array run.java
package run;
//import ex.ArrayEx1;
import ex.ArrayEx2;
public class ArrayRun {
public static void main(String[] args) {
// ArrayEx1 ex1 = new ArrayEx1();
// ex1.method1();
// ex1.method2();
// ex1.method3();
// ex1.method4();
ArrayEx2 ex2 = new ArrayEx2();
// ex2.method1();
// ex2.method2();
// ex2.method3();
// ex2.method4();
ex2.method5();
}
}
ArrayPractice.java
package practice;
import java.util.Scanner;
public class ArrayPractice {
Scanner sc = new Scanner(System.in);
/* [실습 문제 1]
* 길이가 9인 배열을 선언 및 할당하고,
1부터 9까지의 값을 반복문을 이용하여
순서대로 배열의 각 인덱스 요소에 대입하고 출력한 후
짝수 번째 인덱스 값의 합을 출력하세요.
(0 번째 인덱스는 짝수로 취급)
*/
public void practice1() {
int[] arr = new int[9]; // 배열 선언, 할당
// 배열 요소 초기화
for(int i=0 ; i<arr.length; i++) {
arr[i] = i + 1;
}
// 출력 및 합계
int sum = 0;
for(int i = 0; i<arr.length; i++) {
System.out.print(arr[i] + " ");
if(i % 2 == 0) { // 짝수번째 인덱스 요소 합
sum += arr[i];
}
}
// \n : 줄바꿈 (개행) 문자
System.out.println("\n짝수 번째 인덱스 합 : " + sum);
}
/* [실습 문제 2]
메소드 명 : public void practice2(){}
길이가 9인 배열을 선언 및 할당하고,
9부터 1까지의 값을 반복문을 이용하여
순서대로 배열의 각 인덱스 요소에 대입하고 출력한 후
홀수 번째 인덱스 값의 합을 출력하세요.
(0 번째 인덱스는 짝수로 취급)
*/
public void practice2() {
// 정방향(0 -> 8)
int[] arr = new int[9];
// i : 0 1 2 3 4 5 6 7 8
// arr.length : 9 9 9 9 9 9 9 9 9
// arr.legnth - i : 9 8 7 6 5 4 3 2 1
// arr[i] : 9 8 7 6 5 4 3 2 1
int sum = 0;
for(int i = 0; i <arr.length; i++) {
arr[i] = arr.length -i;
System.out.print(arr[i] + " ");
if( i % 2 == 1) sum += arr[i];
}
System.out.println("\n홀수 번째 인덱스 합 : " + sum);
System.out.println("--------------------------");
// 역방향(8 -> 0)
int[] arr2 = new int[9];
int sum2 = 0;
// arr.length : 9 9 9 9 9 9 9 9 9
// i : 8 7 6 5 4 3 2 1 0
// arr.length - i : 1 2 3 4 5 6 7 8 9
// arr[i] : 1 2 3 4 5 6 7 8 9
// 대입은 역방향
for(int i = arr2.length - 1 ; i >= 0 ; i--) {
arr2[i] = arr2.length - i;
if(i % 2 == 1) sum2 += arr2[i];
}
// 출력은 정방향
for(int num : arr2) {
System.out.print(num + " ");
}
System.out.println("\n홀수 번째 인덱스 합 : " + sum2);
}
// int[] arr = new int[9];
//
// for(int i = 9; i > 0 ; i--) {
//
// // 9 9 > 9 9 --
// }
//
// int sum = 0;
//
// for(int i = 9; i > 0 ; i--) {
// System.out.print(i + " ");
//
// if(i % 2 == 0) {
// sum += i;
// }
//
// }
// System.out.println("\n홀수 번째 인덱스 합 : " + sum);
// }
//
/* [실습 문제 3]
* 메소드 명 : public void practice3(){}
* 사용자에게 입력 받은 양의 정수만큼 배열 크기를 할당하고
* 1부터 입력 받은 값까지 배열에 초기화한 후 출력하세요.
*/
public void practice3() {
System.out.print("양의 정수 : ");
int c = sc.nextInt();
int[] arr = new int[c]; // 입력 받은 크기 만큼의 배열 할당
for(int i=0 ; i < arr.length; i++ ) {
arr[i] = i + 1; // 배열 요소에 1부터 값 대입
System.out.print( arr[i] + " ");
}
}
/* [실습 문제 4]
메소드 명 : public void practice4(){}
정수 5개를 입력 받아 배열을 초기화 하고
검색할 정수를 하나 입력 받아
배열에서 같은 수가 있는 인덱스를 찾아 출력.
배열에 같은 수가 없을 경우
“일치하는 값이 존재하지 않습니다“ 출력
*/
public void practice4() {
int[] arr = new int[5];
for(int i = 0; i<arr.length; i++) {
System.out.printf("입력 %d :", i);
arr[i] = sc.nextInt(); // 요소 마다 입력 값 대입
}
System.out.print("검색할 값 : ");
int search = sc.nextInt();
// 검색 값이 존재하면 true
// 없으면 false
boolean flag = false;
for(int i=0; i<arr.length; i++) { // 검색
// i번째 요소에 저장된 값과 검색할 값이 같은 경우
if(arr[i] == search) {
System.out.println("인덱스 : " + i);
flag = true; // 같은 값이 있으니 true로 변경
}
}
if(!flag) { // flag == false
System.out.println("일치하는 값이 존재하지 않습니다");
}
}
/* [실습 문제 5]
사용자가 배열의 길이를 직접 입력하여 그 값만큼
정수형 배열을 선언 및 할당하고
배열의 크기만큼 사용자가 직접 값을 입력하여
각각의 인덱스에 값을 초기화 하세요.
그리고 배열 전체 값을 나열하고
각 인덱스에 저장된 값들의 합을 출력하세요.
*/
public void practice5() {
System.out.print("정수 : ");
int num = sc.nextInt();
int[] arr = new int[num];
int sum = 0;
for(int i = 0 ; i < arr.length ; i++) {
System.out.printf("배열 %d번째 인덱스에 넣을 값 : ", i);
arr[i] = sc.nextInt();
sum += arr[i]; // 합계 누적
}
// 한 줄 출력
for(int value : arr) System.out.print(value + " ");
// 합계 출력
System.out.println("\n총 합 : " + sum);
}
/* [실습 문제 6]
주민등록번호를 입력 받아 char 배열에 저장한 후 출력하세요.
단, char 배열 저장 시
성별을 나타내는 숫자 이후부터 *로 저장하세요.
문자열.length() : 문자열의 길이
문자열.charAt(index) : 문자열 중 index번째 문자(char) 반환
*/
public void practice6() {
// 991122-1234567
// char[] arr = new char["991122-1234567".length()];
char[] arr = new char[14];
System.out.print("주민등록번호(-포함) : ");
String str = sc.next();
// 주민등록번호를 char 배열 요소로 하나씩 대입
for(int i = 0 ; i < str.length() ; i++) {
if(i <= 7) arr[i] = str.charAt(i); // 성별 까지
else arr[i] = '*'; // 성별 이후
System.out.print(arr[i]); // 출력
}
}
}
PracticeRun.java
package run;
import practice.ArrayPractice;
public class PracticeRun {
public static void main(String[] args) {
// ArrayPractice 객체 생성
ArrayPractice pr = new ArrayPractice();
// pr.practice1();
// pr.practice2();
// pr.practice3();
// pr.practice4();
// pr.practice5();
pr.practice6();
}
}
05_oop 객체지향
Nation.java
package basic;
// 클래스(class)
// - 객체가 가져야 할 속성(값), 기능(메서드)를
// 글(코드)로 작성해둔 문서
// -> 객체를 정의한 문서
// - 클래스는 객체를 만들 때 설계도로 사용된다!!
/**
*
* 국민 객체를 정의한 클래스
* == 국민이라는 객체를 만들기 위한 설계도
*/
public class Nation {
/* 속성 */
// - 국민이라면 모두 가지고 있을 공통적인 속성만 작성
// == 추상화
String name; // 이름
int age; // 나이
char gender; // 성별
String JuminNumber; // 주민번호
String tel; // 전화 번호
String address; // 주소
/* 기능 */
public void speakKorean() {
System.out.println("한국어 가능");
}
public void 납세의의무() {
// 19세 이상만 세부 남부 대상자
if(age >= 19) {
System.out.printf("%s 님은 세금 납부 대상자 입니다.", name);
} else {
System.out.printf("%s 님은 미성년자로 세금 납부 대상자 아닙니다.", name);
}
}
//자기 소개
public void introduce() {
System.out.printf("이름은 %s이고, %d세 %c성 입니다\n",
name, age, gender);
}
}
BasicRun.java
package basic;
// 같은 패키지의 클래스는 import X
public class BasicRun {
public static void main(String[] args) {
// 국민 객체 생성
// == 국민(Nation) 클래스에 작성된 내용대로
// heap 메모리 영역에 할당(생성) 하는 것
Nation n1 = new Nation(); // 국민 객체 생성됨!!!
// 국민 객체에 값(속성) 대입
n1.name = "홍길동";
n1.age = 20;
n1.gender = '남';
// 국민 객체가 공통적으로 가진 기능(메서드) 수행
n1.introduce();
// 국민 객체 생성
Nation n2 = new Nation();
n2.name = "신짱구";
n2.age = 5;
n2.gender = '남';
// n2.tel =
// 세금 납부 여부 확인
System.out.println("----------------");
n1.납세의의무();
System.out.println();
n2.납세의의무();
}
}
Account.java
package basic;
/** 계좌 클래스
* (class == 객체의 속성, 기능을 정의한 문서(설계도))
*/
public class Account{
/* [캡슐화]
*
* 1) 객체의 속성, 기능을 하나로 묶음
*
* 2) 외부로부터의 직접 접근을 제한
* - 내부가 보이지 않음
* -> 정보 은닉 효과 발생
*
* [ 직접 접근을 제한하는 방법 ]
* - 접근을 제한 할 속성에 private 키워드 추가
* (private : 개인적인, 사적인)
* -> 현재 객체만 접근 가능한 (현재 객체 ; 개인적인것)
*
* **************************************************
* ** 기본적으로 모든 클래스의 속성은 **
* ** private를 적용하는 것이 원칙!!! **
* **************************************************
*/
// 속성 ( 값 == 변수)
private String name; // 이름(계좌주)
private String accountNumber; // 계좌 번호
private long balance; // 잔액
private String password; // 비밀번호
// private이 붙은 변수는
// 만들어진 객체에서만 사용/접근 가능!!!
// 기능 ( 메서드 )
/** 입금 기능
*
* 매개 변수(Parameter) : 메서드 호출 시 전달 받은 값을 저장하는 변수
*
* @param amount : 전달 받은 금액
*/
public void deposit(long amount) {
balance += amount; // 전달 받은 금액을 잔액에 누적
// 현재 잔액 얼마인지 출력
System.out.printf("%s님의 %s 계좌의 현재 잔액 : %d \n",
name, accountNumber, balance);
}
/**
* 출금 기능
* @param pw : 전달 받은 비밀번호
* @param amount: 전달 받은 출금 금액
*/
public void withdraw(String pw, long amount) {
// 자바에서
// - 기본 자료형 값 비교는 A == B
// - 참조형(객체) 값 비교는 A.equals(B)
if(!password.equals(pw)) { // 비밀번호가 일치하지 않을 때
System.out.println("비밀번호가 일치하지 않습니다");
return; // 메서드 종료
}
// 출금 금액이 잔액보다 큰 경우
if(amount > balance) {
System.out.println("잔액이 부족합니다");
return;
}
// 잔액 - 출금 금액
balance -= amount;
System.out.println(amount + "원이 출금 되었습니다");
System.out.printf("%s님의 %s 계좌의 현재 잔액 : %d \n",
name, accountNumber, balance);
}
// getName()을 호출하면 String 자료형을 반환할거야
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAccountNumber() {
return accountNumber;
}
public void setAccountNumber(String accountNumber) {
this.accountNumber = accountNumber;
}
public long getBalance() {
return balance;
}
public void setBalance(long balance) {
this.balance = balance;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
/* 변수(필드) 간접 접근 기능
*
* 1. setter : 변수에 값을 세팅(대입)하는 기능
*
* public void set필드명(자료형 변수명){
* this.필드명 = 변수명;
* }
*
*
* 2. getter : 변수의 값을 얻어가게 하는 기능
* public 반환형 get필드명 (){
* return 필드명;
* }
* */
}
AccountRun.java
package basic;
public class AccountRun {
public static void main(String[] args) {
// Account 객체 생성
Account a1 = new Account();
// The field Account.name is not visible
// -> 캡슐화(private)로 인해 변수가 보이지 않아서 오류가 발생!
// a1.name = "홍길동";
// a1.accountNumber = "6167020122";
// a1.balance = 10000;
// a1.password = "1q2w3e4r";
// 간접 접근 기능을 이용해서 세팅
a1.setName("홍길동");
a1.setAccountNumber("1234567890");
a1.setBalance(10000);
a1.setPassword("1q2w3e4r");
// a1 계좌의 잔액, 비밀번호 바꾸기
// System.out.println("a1 잔액 :" + a1.balance);
//
// a1.balance = 0; // 잔액을 0원으로 바꿔버림
// a1.password = "asdf1234";
// 간접 기능을 이용해 값 얻어오기
String name1 = a1.getName();
String accountNumber1 = a1.getAccountNumber();
long balance1 = a1.getBalance();
String password1 = a1.getPassword();
System.out.printf("%s / %s / %d / %s \n",
name1, accountNumber1, balance1, password1);
// 입금 기능 호출
a1.deposit(5000); // a1이 참조하는 계좌의 잔액을 5000 추가
String a = "ABCD";
String b = new String("ABCD");
// System.out.println(a.equals(a1.getName()));
System.out.println(a); // ABCD
System.out.println(b); // ABCD
System.out.println(a == b); // false (동일비교)
System.out.println(a.equals(b)); // true (동등비교)
System.out.println("---------------------------");
System.out.println("[출금 기능]");
a1.withdraw("zxcvasdf", 2000000); // 비밀번호 불일치
a1.withdraw("1q2w3e4r", 2000000); // 잔액 부족
a1.withdraw("1q2w3e4r", 7000); // 출금 성공
a1.withdraw("1q2w3e4r", 8000); // 모두 출금
}
}