001. 자바프로그래밍 기초

📍 24.03.26(화) ~ 24.03.29(금) : 자바/이클립스 설치, 환경 변수 설정, 환경 변수 설정, 이클립스 단축키, 자료형, 연산자, 형변환, Scanner, 제어문 조건문/반복문

📍 24.04.01(월) ~ 24.04.05(금) : 반복문/중첩 반복문, fomat, 이스케이프 문자, do~while 문, for문, 중첩 반복문, 메서드 정의와 호출, 객체지향-class와 객체, 재귀호출, 변수종류(지역변수/인스턴스변수/멤버변수), setter/getter, this참조변수, 생성자, 배열(1차원 배열/2차원 배열)

📍 24.04.08(월) ~ 24.04.11(목) : 2차원 배열, 객체 배열, 배열의 값 수정, String 의 문자열 비교(.equals()), toString(), parameter, wrapper class

 

📍 24.03.26(화) 1일차

1. 시작 전 다운로드

오라클 다운로드 : https://www.oracle.com/java/technologies/downloads/

이클립스 다운로드 : https://www.eclipse.org/downloads/

Eclipse Downloads | The Eclipse Foundation

Download the Latest Java LTS Free

 

x 친곳에서 다운 받으면 에러생길수 있음

 

이클립스 폴더와 jdk 파일 2개 = 3

2-1. 환경 변수 설정해주기

# 환경변수할 때 사용자 변수에 하면 안됨

JAVA_HOME -> C:\Program Files\Java\jdk-11
path -> %JAVA_HOME%\bin

 

 

2-1. C 드라이버 -> D 드라이버

깃은 별도로 내가 설치함 / study_JAVA 깃 저장소 

# 폴더 설명
fullstack
    ㄴbackend
        ㄴworkspace
            # 프로젝트명은 소문자로파일명은 대문자로 (모두 x)
            ㄴ.metadata # 이클립스 오류 생길 때 .metadata 폴더 지우면 대부분 해결된다고 함
            ㄴexample
            ㄴp240326 # 하루에 한 번 프로젝트 생성할 예정
    ㄴprogram

 

.metadata : 데이터에 관한 구조화된 데이터로, 다른 데이터를 설명해주는 데이터 / 이클립스 설정이 보관되는 폴더

참고 블로그

https://devsyw.tistory.com/4

[Java] Eclipse Workspace 프로젝트 생성 시 .metadata의 정체

 

1. 자바프로그래밍 기초
- 자료형 : 데이터 종류, 메모리 크기, 데이터의 표현 범위
	기본 자료형(기본형) - primitive type
        정수 자료형(정수형) 
            byte - char - short - int(기본) - long
            1      2      2       4     	  8byte
        실수 자료형(실수형)
            float - double(기본)
            4       8byte
            소수 6자리 / 소수 15자리까지 표현
            # 16번째부터는 정확x 
        논리 자료형(논리형)
            boolean
            1byte
	참조 자료형(참조형) - reference type
	
- 변수 선언과 초기화

- 연산자
	대입 연산자
	산술 연산자
	복합 대입 연산자
	관계 연산자
	논리 연산자 
	증가/감소 연산자
	조건 연산자(삼항 연산자)
    
- 형변환
	자동 형변환(묵시적 형변환)
	강제 형변환(명시적 형변환)
    
- Scanner

- 제어문 : 조건문, 반복문

- 메소드 정의 및 호출

 

자료형 - char (문자) - 유니코드(음수코드 x)

자료향 - int (기본)

실수 자료형의 변환법 따로 공부하기

 

윈도우 명령어&단축키

탐색기 : 윈도우 + e

정의

CLI : 명령줄 인터페이스
IDE : 통합 개발 환경
.dll : 확장자

파일 가져갈 때

1. 프로젝트 : import
2. 자바 파일 : 프로젝트 생성후 src 추가

---

📍 24.03.27(수) 2일차

이클립스 자바 버전 차이로 에러 발생

다음날 와보니 ... 이클립스 실행 에러남 ㅠ

https://print-blue.tistory.com/108

 

이클립스 실행시 에러날 때 해결방안

 

 

프로젝트 생성 -> 파일 추가

프로젝트 생성 후 java project 클릭 후 이름 지정 후 모듈 체크 해제

위에 17 선택 어플라이 > 어플라이 크로즈 선택

이클립스 실행시 에러 떴는데 버전이 안맞았던 이유가 디폴트값 때문임

에러 피하기 위해서 다 알아야겠농 ㅠ

 

 

scr 폴더에 ~~!  파일 생성하기

꿀팁

알트 누르고 저 v 누르면 체크 됨

 

 

이클립스 단축키&폰트

 

라인 삭제 : ctrl + d

실행 : ctrl + F11

선언한 변수 다시 쓸 때 : ctrl + 스페이스바

화이트 라인 (위) : ctrl  + shift  + 엔터

다음줄 넘어가기  :  shift  + 엔터

스크롤 이동 : ctrl + 활살표 위/아래

열린 파일 닫기 : ctrl  + window

열린 파일 모두 닫기 : ctrl + shift + w

이전에 작업했던 파일 열기 : 알트 + 왼쪽 화살표

다른 파일로 가기 : 알트 + 활살표

화면 분할 : 탭 선택 후 원하는 곳으로 드래그

화면 확대 : ctrl  + m

자동 import : ctrl  + shift + o\

이전 작업 : 컨트롤 + F7

같은 이름의 변수명 한번에 바꾸기 : 바꾸고자 하는 변수명 클릭 + 알트 + 쉬프드 + R

메소드 문서 보기 : 보려고 하는 메소드에 컨트롤 꾹 누르기

파일 탐색기 : 알트 + 쉬프트 + W + x

setter/getter : 알트 + 쉬프트 + s

오버라이딩 단축키 : 클래스명 클릭 + 컨트롤 + 1

 

https://phantom.tistory.com/16

[Eclipse]이클립스 단축키 모음(Eclipse Shortcut Keys)

 

 

문자와 문자열

public class TypeEx01 {
	public static void main(String[] args) {
		
        // 문자 : 'a' (문자 하나) - 작은 따옴표
        // 문자열 : "adsd" (문자 조합) - 큰 따옴표 구분 해조야함
        // char = 2byte , 컴파일이 되면(정수) 메모리엔 97이 넣게 됨, a = x
        char ch1 = 'a'; 
        System.out.println("ch1 : " + ch1); # 쉼표 안됨, + 해야함

        // 타입이 char, 65-> A 라서 그대로 출력, 보기 편하기 위해 A 라고 하는게 나음
        // char ch2 = 65;
        char ch2 = 'A'; 
        System.out.println("ch2 : " + ch2); 

        // 더하기 가능함 왜냐 ? 정수
        char ch3 = 'A' + 1; 
        System.out.println("ch3 : " + ch3);
	}
}

# 출력
ch1 : a
ch2 : A
ch3 : B

 

 

a가 97인 이유 : 자바 유니코드 확인 (https://needjarvis.tistory.com/643)

[Java] 자바 아스키코드및 유니코드로 문자 변환

 

 

클린 코드 / white Line (빈라인)

책 읽는 거 추천, 1~2개만 줌

 

Literal (리터럴) / constant (상수)

Literal(중요함)

- 그 자체로의 값의 의미

- 이름없음(메모리에 이름 x)

- 접미사 L,F (대문자로 써야잘보임 약속)

- 정수형 리터럴 : int // L

- 실수형 리터럴 : float// F

- 논리형 리터럴 : boolean (접미사 x)

- 문자형 리터럴 : int (접미사 x)

- 문자열 리터럴 : String (접미사 x)

 

constant

- 이름이 있는 값

- 변수와 마찬가지로 값을 저정할 수 있는 공간

- 초기화한 값으로 고정 -> 변경 불가능

- 선언 방법은 변수와 동일 

- 변수 타입 앞에 final 만 붙여줌

- 변수는 무조건 대문자

ex ) final int age = 10;

final int one = 1;
int two = 2;

one = 100; ==> int : 100
two = 200; ==> 에러 발생

 

 

 

ex ) 위에 사진을 보면 

Ram 에서 numOne (이름) + 4바이트 + 빈공간 / 이름 x  + 4바이트(기본형) + 100

cpu가 이름 없는 100을 복사해서 numOne 에 100을 붙여놓음, 그리고 이름 없는 100은 삭제

이런 개념으로 100은 리터럴이 됨

 

 

논리형 리터럴의 예약어는 메모리에 어떻게 저장되는가 ?

// 논리형 리터럴(true)
// true = 예약어
boolean bo = true;
System.out.println("논리값 : " + bo);

 

정수(10진수) -> 논리값 // 컴파일러 할 때

1 - true

0 - false

 

논리값 -> 2진수

true - 1

false - 0

 

즉, 메모리 들어올 때 true가 아니라 1로 들어옴

 

 실수형의 정밀도

public class TypeEX03 {

	public static void main(String[] args) {
		
        // [ 정밀도 ] =========================
        // float : 6자리
        float num1 = 3.123456789123456789F;
        System.out.println("num1 : " + num1);

        // double : 15자리
        double num2 = 3.123456789123456789;
        System.out.println("num2 : " + num2);	
	}
}

# 실행값
num1 : 3.1234567 # float -> 6자리까지 나오고 7자리부터 정확x
num2 : 3.123456789123457 -> 반올림됐음

 

 

산술 연산자

 

public class OperatorEx01 {

	public static void main(String[] args) {
		
        // 산술 연산자
        // int num1 = 5;
        // int num2 = 3;

        int num1 = 5, num2 = 3;

        // 덧셈
        System.out.println("덧셈 : " + num1 + num2);
        System.out.println("덧셈 : " + (num1 + num2));
        System.out.println(num1 + num2 + " --> 덧셈 끝");

        // 뺄셈은 안됨(메소드가 x)
        //		System.out.println("덧셈 : " + num1 - num2);
        System.out.println("뺄셈 : " + (num1 - num2));
        System.out.println(num1 - num2 + " --> 뺄셈 끝");

        // 안해도 되지만 직관성 높이기 위해 괄호 사용
        System.out.println("곱셈 : " + (num1 * num2)); 
        System.out.println("몫 : " + (num1 / num2)); 

        // 나머지 : 짝수/홀수 나눌 때, ~배수 찾을 때
        System.out.println("나머지 : " + (num1 % num2)); 

	}
}

# 실행결과
덧셈 : 53
덧셈 : 8
8 --> 덧셈 끝
뺄셈 : 2
2 --> 뺄셈 끝
곱셈 : 15
몫 : 1
나머지 : 2

 

복합 연산자

public class OperatieEx02 {

	public static void main(String[] args) {
		
        // 변수 선언 , 자료향 변수형
        int n1 = 5, n2 = 3;
        System.out.println("n1 : " + n1);
        n1 = n1 + n2;
        System.out.println("n1 : " + n1);
        System.out.println("n2 : " + n2);

        n1 += n2;
        System.out.println("n1 : " + n1);
        System.out.println("n2 : " + n2);
		
	}
}

# 실행결과
n1 : 5
n1 : 8
n2 : 3
n1 : 8
n2 : 3

 

관계 연산자

public class operatorEx03 {

	public static void main(String[] args) {
		
        int n1 = 5;
        int n2 = 3;

        System.out.println("크니 ? : " + (n1 > n2));

        // 변수에 집어넣기
        boolean result = n1 > n2;
        System.out.println("result ==> " + result);

        System.out.println("다르냐 ? " + (n1 != n2));
        System.out.println("같냐 ? " + (n1 == n2));
		
	}
}

# 실행결과
크니 ? : true
result ==> true
다르냐 ? true
같냐 ? false

 

 

논리 연산자

&& : 교집합 // 깐깐

|| : 합집합 // 유연함

! : 여집합 / 부정 연산자 // 

차집합 x

true = t

false = f

# 이항 연산자

t && t ==> t

t && f ==> f

f && f ==> f

 

t || t ==> t

t || f ==> t # 왼쪽부터 실행이 되는데 ture면 뒤에 피연산자는 계산 안해도 됨

f || f ==> f

 

# 단항 연산자

! t ==> f

! f ==> t

public class OperatorEx04 {

	public static void main(String[] args) {
		
        int n1 = 5;
        int n2 = 3;
        boolean result = n1 > 4 || n2 > 4;
        boolean result = (n1 > 4) || (n2 > 4); # 괄호 안해도 되지만 직관성을 위해 

        System.out.println("결과값 : " + result);
		
	}

}

증가/감소 연산자

1증가 1감소

public class OperatorEx05 {

	public static void main(String[] args) {

        int num = 5;
        System.out.println("num : " + num);

        // [ 1 증가식 }
        //		num = num + 1;
        //		System.out.println("1 증가식 num ==> " + num);

        // [ 복합 대입 연산자 ]
        //		num += 1;
        //		System.out.println("복합 대입 연산자 num ==> " + num);

        // [ 1증가 연산자 ]
        num++;
        System.out.println("1증가 연산자 num ==> " + num);
		
	}

}

# 실행 결과
num : 5
1증가 연산자 num ==> 6

 

num = 5;

num++; -> 됨

5++; -> 안됨

 

public class OperatorEx06 {

	public static void main(String[] args) {
		
        int num = 5;
        int result = num++; // 후증가 연산자

        System.out.println("result : " + result);
        System.out.println("num : " + num);

        # 실행 결과
        result : 5
        num : 6
        # result 변수에 num 값 5가 대입이 되고, 그 다음 num이 ++ 돼서 6이 됨
        쉽게 설명
        int result = num++; 이 코드가

        int result = num;
        num = num + 1; 랑 같다는 것

        int num = 5;
        int result = ++num; // 선증가 연산자 
        System.out.println("result : " + result);
        System.out.println("num : " + num);

        # 실행 결과
        result : 6
        num : 6
        # result 변수가 만들어지고 ++가 먼저 와 num 값 5가 6이 돼서 저장되며
        result값이 6이 되고, num 값이 6이 됨
        
	}

}

 

 

삼항 연산자

삼항 연산자 결과값을 무조건 변수 선언해야함

public class OperatorEx07 {

	public static void main(String[] args) {
		
        // [ 삼항 연산자(조간 연산자) ]
        // (조건) ? true : false ;
        // 조건 = n1 > 10

        int n1 = 25;
        String result = (n1 > 10) ? "10보다 크다" : "작거나 같다"; # 직관성을 위해 괄호
        System.out.println("result : " +  result);

	}

}

# 실행 결과
result : 10보다 크다

 

 

퀴즈

[ 문제 1] 조건 연산자 
 num의 값이 양수이면, 2 증가한 값을 result에 저장하고,
 num의 값이 음수이면, 5 감소한 값을 result에 저장하시오.
 

public class Quiz01 {

	public static void main(String[] args) {
		
        int num = 5; 
        // 1차 시도 : 너무 .. 생각을 많이 함
        //		boolean cheak = (num > 0) ? true : false;
        //		int result = (cheak == true) ? num + 2 : num - 5;

        // 2차 시도 : 간결하게 함	
        int result = (num > 0) ? num + 2 : num -5;
        System.out.println("result : " + result);

	}

}

# num = 0;
실행 결과 : result : -5

fulse 일 경우 0도 포함

 

 

형변환

강제 형변환

자동 형변환

 

- 캐스팅 일순위 괄호 일순위

- 변수에 변수를 집어넣을 땐 타입이 맞아야함

- 강제 형변환한다고 잘못된 값을 저장하지는 않음

- 접미사 L, F도 강제 형변환에 포함됨

 

public class CastingEx01 {

	public static void main(String[] args) {
		
        // [ 형변환 ] --> 타입 변환
        // 강제 형변환, 명시적 형변환	
        // 자동 형변환, 묵시적 형변환

        int n1 = 9;
        int n2 = 2;
        System.out.println("n1/n2 => " + n1/n2);
        System.out.println("n1/(float)n2 => " + n1/(float)n2);		
        System.out.println("(float)n1/n2 => " + (float)n1/n2);
        System.out.println("(float)(n1/n2) => " + (float)(n1/n2));
		
	}

# 실행 결과
n1/n2 => 4
n1/(float)n2 => 4.5
(float)n1/n2 => 4.5
(float)(n1/n2) => 4.0


}


public class CastingEx02 {

	public static void main(String[] args) {
		
        /*
         * <--------- 정수 ---------> <---  실수 ---->
         * byte - short - int - long - float - double
         * char 는 뺏음
         * 
         * 강제 형변환한다고 잘못된 값을 저장하지는 않음
         */

        int num = 100;

        // 강제 형변환 : 큰 크기 -> 작은 크기
        short sh = (short)num; 
        System.out.println("short : " + sh);
        byte by = (byte)num; 
        System.out.println("byte : " + by);
        float fo2 = 2.34F;
        System.out.println("float : " + fo2);

        // 자동 형변환 : 작은 크기 -> 큰 크기 
        long lo = num; 
        System.out.println("long : " + lo);
        float fo = num;
        System.out.println("float : " + fo);
		
	}
}

# 실행 결과
short : 100
byte : 100
float : 2.34
long : 100
float : 100.0

 

---

📍 24.03.28(목) 3일차

이클립스 테마 변경

이클립스 실행 => 메뉴 탭 중 window => Preferences => General => Apperance => 테마 선택

비주얼스튜디오보다 구리군

 

Scanner

입력 버퍼 / 출력 버퍼

https://terianp.tistory.com/19

Java 입출력(I/O), 스트림(Stream), 버퍼(Buffer) 개념 및 사용법

 

Java 입출력(I/O), 스트림(Stream), 버퍼(Buffer) 개념 및 사용법

python input 이랑 비슷함

하지만 type이 다르면 nextInt() 사용할 때 nextInt("정수 입력하세요") 가 안됨 

보통 변수를 scanner 를 사용한다 함

Scanner 선언 후 계속 갔다 쓸 수 있음

import java.util.Scanner;

public class ScannerEx01 {

	public static void main(String[] args) {
		
        // 변수 선언
        // int 자료형으로 선언된 변수 num
        int num = 5;
        System.out.println("num에 저장된 값 => " + num);

        // Scanner 객체 생성
        // Scanner 자료형으로 선언된 변수 input
        Scanner input = new Scanner(System.in);

        System.out.println("정수 1개 입력하세요 ... ");

        // 정수 입력
        // nextInt() : Int 를 입력받을 때
        num = input.nextInt();
        System.out.println("입력 받은 값 => " + num);
		
	}

}

# 실행 결과
num에 저장된 값 => 5
정수 1개 입력하세요 ... 
10 # 콘솔창에서 입력한 값 / 따로 입력창이 구분되어 있지 않아서 구분하기 힘듦
입력 받은 값 => 10

 

import java.util.Scanner;

public class ScannerEx02 {

	public static void main(String[] args) {
		
        // 1. Scanner 객체 생성
        Scanner input = new Scanner(System.in);

        //2. 문자열 입력
        System.out.println("문자열 입력하세요 . . .");
        String str = input.nextLine();

        //3. 출력
        System.out.println("입력받은 문자열 : " + str);
        input.close();
		
	}

}

Scanner String : next() 와 nextLine()의 차이

str2는 '공백' + 'ㅎㅇ'까지 출력되는 것

같은 타입인 경우에는 또 다시 작성안해도 됨

flush => 버퍼를 비우는 메소드

import java.util.Scanner;

public class ScannerSring {

	public static void main(String[] args) {
		
        // 1. Scanner 객체 생성
        Scanner input = new Scanner(System.in);

        // 2-1. 문자열 입력 : next() - 첫 번째 공백 전까지만 입력
        System.out.print("문자열 입력하세요 . . . ");
        String str1 = input.next();

        // 2-2. 문자열 입력 : nextLine() - 엔터까지 입력
        // Enter : CRLF = \r\n
        // CR : Carriage Return -> \r
        // LF : Line Feed -> \n
        System.out.print("문자열 입력하세요 . . . ");
        String str2 = input.nextLine();

        System.out.println("str1 >>" + str1);
        System.out.println("str2 >>" + str2);
		
	}
}

# 실행결과
문자열 입력하세요 . . . 홍길동 ㅎㅇ
문자열 입력하세요 . . . str1 >>홍길동
str2 >> ㅎㅇ

 

java.util 참고 : https://jammdev.tistory.com/136

[JAVA] java.util 패키지

scanner 메소드 정리 : https://velog.io/@cse_pebb/Java-Scanner-%EB%A9%94%EC%84%9C%EB%93%9C-%EC%B4%9D%EC%A0%95%EB%A6%AC

[Java] Scanner() 메서드 총정리

 

println 와 print 차이

println 이 line 이라는 뜻인데 출력이 끝나면 다음 라인으로 넘어가게 됨

# println 사용했을 때

num에 저장된 값 => 5
정수 1개 입력하세요 ... 
3
입력 받은 값 => 3


# print 사용할 때

num에 저장된 값 => 5
정수 1개 입력하세요 ... 3
입력 받은 값 => 3

 

퀴즈

 [ 문제 ]

정수 2개를 입력받은 후, 덧셈 결과를 출력하시오.

출력 문구는 : 정수 2개 입력하세요...

 

import java.util.Scanner;

public class ScannerQuiz01 {

	public static void main(String[] args) {

        // 1. Scanner 객체 생성
        Scanner input = new Scanner(System.in);

        // 2. 출력 문구 출력
        System.out.println("정수 2개 입력하세요...");

        // 3. 정수 2개 입력 받고, 변수에 저장
        int num1 = input.nextInt();
        int num2 = input.nextInt();

        //4. 정수 2개 값을 받은 변수를 더해 덧셈 결과 출력
        System.out.println("덧셈 결과 : " + (num1 + num2));

        //5. Scanner 닫기 
        input.close();
	}

}

 

 

절차지향 언어 : C 언어
객체지향 언어 : Java

자바는 객체 지향 언어라서 미리 선언하지 않아도 됨

int num1, num2;

num1 = input.nextInt();
num2 = input.nextInt();

int num1 = input.nextInt();
int num2 = input.nextInt();

 

 

제어문 : 조건문 / 반복문

조건문 : if / swith

swith -> if 바꿀 수 o / if -> swith 바꿀 수 x

 

if 문

조건식 넣을 때 확률적으로 많은 게 앞에다 둠

[ 조건문 ] if문 ========================
 * 
 * << 조건 1개일 경우 >>
 * if(조건식) {
 * 	조건이 true일 때, 실행되는 영역;
 *  명령어;
 * }
 * 
 * << 조건 2개일 경우 >>
 * if(조건식) {
 * 	조건이 true일 때, 실행되는 영역;
 *  명령어;
 * } else {
 * 	조건이 false일때, 실행되는 영역;
 * 	명령어;
 * }
 * 
 * << 조건 3개일 경우 >>
 * if(조건식) {
 * 	조건이 true 일 때, 실행되는 영역;
 *  명령어;
 * } else if (조건식2) {
 * 	조건식2이 true 일때, 실행되는 영역;
 * 	명령어;
 * } else {
 * 	조건이 false 일 때, 실행되는 영역;
 * 	명령어;
 }

# 조건 1개일 경우
public class IfEx01 {

	public static void main(String[] args) {
		
        int num = 50;

        if(num >= 10) { // 조건이 1개일 경우는 중괄호 생략해도 코드 실행 가능, 하지만 2개부터 x
            num++; // 후 증가
            System.out.println("true일 때, 실행되는 영역 ");
        }

        System.out.println("num : " + num);
	}
}

# 조건 2개일 경우
public class IfEx2 {

	public static void main(String[] args) {
		
        int num = 5;

        if(num >= 10) {
            num++; // 후 증가
            System.out.println("true일 때, 실행되는 영역 ");
        } else {
            System.out.println("false일 때, 실행되는 영역 ");	
        }

        System.out.println("num : " + num);
	}
}

# 조건 3개일 경우
public class IfEx3 {

	public static void main(String[] args) {
		
        int num = 5;

        if(num > 0) {
            System.out.println("양수 입니다.");
        } else if(num < 0) {
            System.out.println("음수 입니다.");
        } else {
            System.out.println("0 입니다.");
        }

        System.out.println("프로그램 종료 !");
		
	}
}

 

 

중천 if문

public class IfEx04 {

	public static void main(String[] args) {
		
        int num = 100;

        if (num < 0) {
            System.out.println("0 미만");
        } else {
            if (num < 100) {
                System.out.println("100 미만");
            } else {
                System.out.println("100 이상");				
            }
        }
    }
}

 

퀴즈

import java.util.Scanner;

public class IfQuiz01 {

	public static void main(String[] args) {
		
        /*
         * 정수 1개를 입력받은 후, 0인지 아닌지를 출력
         * 
         * - 입력 문구 : 정수 하나 입력하세요 ...
         * - 출력 문구 : 입력한 숫자는 0입니다.
         * 				 입력한 숫자는 0이 아닙니다.
         */

        // 1. 사용자에게 입력 받을 scanner 객체 생성
        Scanner input = new Scanner(System.in);

        // 2. 입력 문구 출력 후, int 타입의 변수 num 입력 받기
        System.out.print("정수 하나 입력하세요 ... ");
        int num = input.nextInt();

        if (num == 0) {
            System.out.println("입력한 숫자는 0입니다.");
        } else {
            System.out.println("입력한 숫자는 0이 아닙니다.");
        }

        input.close();
	}

}

 

[ 조건문 ]Switch

case(라벨) ; (세미콜론) x

float 타입 사용 x

case 는 리터럴 값 변수가 올 수 없음 / 상수만 올 수 있음(변하지 않는 것들)

switch(정수값) { // 간단한 식, 정수
case 값 1: 
    명령어;
    명령어;
case 값 2:
    명령어;
    명령어;
default : 
    명령어;
    명령어;
}

public class SwitchEx01 {

	public static void main(String[] args) {
		
        int num = 1;

        switch(num) {
        case 1:
            System.out.println("1 이다.");
        case 2: 
            System.out.println("2 이다.");
        case 3: 
            System.out.println("3 이다.");
        default:
            System.out.println("나머지이다.");
        }

        System.out.println("<< 실행 완료 >>");
			
	}
}

# 실행 결과
1 이다.
2 이다.
3 이다.
나머지이다.
<< 실행 완료 >>

 

만약 int num = 3; 이면 ? 

# 실행 결과

3 이다.
나머지이다.
<< 실행 완료 >>

 

이걸로 switch문은 모든 걸 다 실행이 되는데 멈추고 싶으면 break; 사용하기

그렇다고 필수는 아님, << 선택 사항 >>

 

public class SwitchEx02 {

	public static void main(String[] args) {
		
        String fruit = "사과";

        switch(fruit) {
        case "딸기":
            System.out.println("딸기 입니다.");
            break;
        case "사과":
            System.out.println("사과 입니다.");
            break;
        case "배":
            System.out.println("배 입니다.");
            break;
        }

        System.out.println("<< 실행 완료 >>");
		
	}

}

public class SwitchEx03 {

	public static void main(String[] args) {
		
        char ch = 'A';

        switch(ch) {
        case 'A':
            System.out.println("A 입니다.");
            break;
        case 'B':
            System.out.println("B 입니다.");
            break;
        default:
            System.out.println("나머지 모두 !");
            break;
		}
	}

}


# 실행 결과 
A 입니다.

빈 문자열 선언 후 초기화 하기

import java.util.Scanner;

public class SwitchQuiz01Refactoring {

	public static void main(String[] args) {
		
		// 1. 사용자에게 월을 입력받기 위해 scanner 객체 생성
		Scanner input = new Scanner(System.in);
		
		// 2. 사용자에게 숫자 입력 받기
		System.out.print("숫자로 월을 입력하세요.");
		int month = input.nextInt();
		String season;
		
		// 3. switch 를 사용해 조건에 맞게 출력하기
		switch (month) {
		case 12: case 1: case 2:
			season = "겨울";
			break;
		case 3: case 4: case 5:
			season = "봄";
			break;
		case 6: case 7: case 8:
			season = "여름";
			break;
		case 9: case 10: case 11:
			season = "가을";
			break;
		default: 
			System.out.println(month + "월 이라니!");
			System.out.print("1 ~ 12 중에 입력해주세요.");
			break;
		}
		
		System.out.print("계절은 " + season + "입니다.");
		
		input.close();
	}

}

# 이런 경우 season 부분에 The local variable season may not have been initialized 에러가 뜨는데
String season; 에서 String season = "";으로 바꿔주기 (빈 문자열)

---

📍 24.03.29(금) 4일차

https://print-blue.tistory.com/109

JAVA 프로그래밍 기초 연습 문제 - Scanner 사용자에게 정수 2개 입력 받아 큰 값 출력 받기 (삼항연

https://print-blue.tistory.com/110

JAVA 프로그래밍 기초 연습 문제 - Scanner 사용자에게 정수와 문자열 입력 받고, 타입에 따라 출력

https://print-blue.tistory.com/114

JAVA 프로그래밍 기초 연습 문제 - 조건문 if문을 활용해 숫자로 입력 받아 조건에 따라 출력하기

https://print-blue.tistory.com/115

JAVA 프로그래밍 기초 연습 문제 - Scanner를 활용해 입력 받고, 입력 받은 값을 구분하여 출력하기

https://print-blue.tistory.com/116

JAVA 프로그래밍 기초 연습 문제 - 조건문 if문을 활용해 학점 계산기 만들기

https://print-blue.tistory.com/117

 

https://print-blue.tistory.com/118

JAVA 프로그래밍 기초 연습 문제 - 조건문 if 문을 switch 문으로 바꾸기

 

 

제어문 - 반복문 : while / do~while / for

while (조건식)

1. 무한 루프(loop)

- while (true)

- 좋다, 나쁘다의  개념x

- 반복문 내에 break 명시

 

2. break

- 반복문 내에서 조건문과 함께 사용

- 의미 : 반복문 탈출

 

3, continue

- 반복문 내에서 조건문과 함께 사용

- 의미 : 특정 명령어 (continue 아래에 있는 명령어) 를 실행에서 제외

[반복문] while문

초기값 설정;

while (조건식) { // 조건이 true일 동안 반복 -> 처음으로 false 가 되는 순간 탈출
	명령어;
    증감식;
}

public class WhileEx02 {

	public static void main(String[] args) {
		
        int idx = 1;

        // 무한 반복문 구현
        while (true) {
            System.out.println("idx --> " + idx);

            if (idx == 3) { // 반복문 탈출 조건
                break;
            }	
            idx++;
        }
        
        // 위 [무한 반복문]을 [조건식 있는 while 문]으로 변경
        while (idx <= 3) {
            System.out.println("idx --> " + idx);
            idx++;
        }

        System.out.println("프로그램 종료 !");

	}
}

# 실행 결과
idx --> 1
idx --> 2
idx --> 3
프로그램 종료 !

public class WhileBreak {

	public static void main(String[] args) {

		int idx = 0;
		
		while (idx < 10) {
			
            idx++;

            if (idx % 2 == 1) {
                break;
            }

            System.out.print("idx --> " + idx);
        }

        System.out.println("반복문 실행 후 idx --> " + idx);
        System.out.println("프로그램 종료 !");
		
		
	}

}

/*
 * [ continue ]
 * 
 * 반복문 내에서 조건문과 함께 사용
 * 의미 : 특정 명령어(continue 아래에 있는 명령어)를 실행에서 제외  
 * 
 */

public class WhileContinue {

	public static void main(String[] args) {

        int idx = 0;

//		while (idx < 10) {
//			idx++;
//			
//			if (idx % 2 == 0) {
//				continue;
//			}
//
//			System.out.println("idx --> " + idx);
//		}

        // 위 코드를 continue 를 사용하지 않은 형태로 변경
        while (idx < 10) {
            idx++;

            if (idx % 2 == 1) {
                System.out.println("idx --> " + idx); // 1,3,5,7,9
            }
        }

        System.out.println("반복문 실행 후 idx --> " + idx);
        System.out.println("프로그램 종료 !");
		
	}

}

/*
 * [ 지역 변수 ] local variable
 * - 영역 내 선언된 변수
 * - 영역 내에서만 사용(접근) 가능
 * - 영역 밖에서는 사용(접근) 불가능
 */

public class WhileEx03 {

	public static void main(String[] args) {
		
		int idx = 1; // 값 설정
		
		while (idx <= 10) { // 조건식
			int num = 100; // 지역 변수
			System.out.println("while 문 내 선언된 변수 num : " + num);
			
			idx++; // 증감식
			num++;
		}
		
		System.out.println("idx : " + idx);
//		System.out.println("while 문 밖 선언된 변수 num : " + num);
		
	}
}

---

📍 24.04.01(월) 5일차

https://print-blue.tistory.com/120

JAVA 프로그래밍 기초 연습 문제 - 학점 계산기

https://print-blue.tistory.com/121

JAVA 프로그래밍 기초 연습 문제 - Switch 문을 활용해 숫자로 입력 받아 조건에 맞게 출력하기 (리

https://print-blue.tistory.com/122

JAVA 프로그래밍 기초 연습 문제 - Switch 문을 활용해 정수 2개와 사칙연산 기호 받은 후 식과 계산

https://print-blue.tistory.com/123

JAVA 프로그래밍 기초 연습 문제 - Switch문을 활용해 컴퓨터랑 가위, 바위, 보 시스템 만들기

 

제어문 - 반복문 : while / do~while / for / 중첩 반복문

printf => fomat

모든 데이터는 문자열로 바꿀 수 있음 (500 확인)

System.out.printf("정수 : %d\n", 100);
System.out.printf("실수 : %f\n", 100.34);
System.out.printf("문자 : %c\n", '문');
System.out.printf("문자열 : %s\n", "문자열");
System.out.printf("500 출력 ==> %s\n", 500);

# 실행결과
정수 : 100
실수 : 100.340000
문자 : 문
문자열 : 문자열
500 출력 ==> 500

<형태>
System.out.printf("문자열", 값, 값);

// [서식문자]
형태 : % + 문자
%d : 정수
%f : 실수
%c : 문자
%s : 문자열
System.out.printf("학점은 %c%c입니다.", 값, 값);

 

이스케이프 문자 (\ + 문자)

• \n : 아래로 줄 바꿈 할 때 사용합니다.
• \t : 수평으로 탭 간격을 줄 때 사용합니다.
• \ \ : 문자열 상에서 백 슬래쉬( \ ) 를 표시할 때 사용합니다.
• \' : 문자열 상에서 작은따옴표( ' ) 를 표시할 때 사용합니다.
• \" : 문자열 상에서 큰따옴표( " ) 를 표시할 때 사용합니다.

개행 문자(텍스트의 한 줄이 끝남을 표시하는 문자 또는 문자열) : \n

https://wikidocs.net/192095

01. 이스케이프 문자

 

do~while

[ 반복문 ] do ~ while 문

조건에 상관없이, 반복문 처음 한 번은 꼭 실행하고자 할 때

do {
    명령어;
    명령어;
    명령어;
} while (조건식);

 

일단 한 번 실행하고 조건식 실행 하는 것

# 기존 while 문
public class DoWhileEx01 {

	public static void main(String[] args) {
		
        int idx = 10; // 초기값

        // [while 문]		
        while (idx < 10) { // 조건식
            System.out.println("idx >> " + idx);
            idx++; // 증감식
        }

		System.out.println("반복문 실행 후 idx >> " + idx);
	}
}

# 실행 결과 
반복문 실행 후 idx >> 10

public class DoWhileEx01 {

	public static void main(String[] args) {
		
        int idx = 10; // 초기값

        // [do ~ while]
        do { // 조건식
            System.out.println("idx >> " + idx);
            idx++; // 증감식
        } while (idx < 10); 

        System.out.println("반복문 실행 후 idx >> " + idx)
	}
}

# 실행 결과
idx >> 10
반복문 실행 후 idx >> 11

for

[ 반복문 ] for문

for (초기값; 조건식; 증감식) {
    명령어;
    명령어;
}

public class ForEx02 {

	public static void main(String[] args) {
		
        int idx = 1;

        for (;;) { // 조건식이 없어서 무한루프
            System.out.println("idx >> " + idx);

            if (idx == 2) {
                break;
            }
            idx++;
        }
		
        // while 문의 무한 루프
        while (true) {
            명령어;
        }

        System.out.println("반복문 실행 후 idx >> " + idx);
	}
}

중첩 반복문

public class NestedLoopEx01 {

	public static void main(String[] args) {

        // int i, j;

        for (int i=0; i<3; i++) {
            System.out.println("*** 바깥쪽 for문 " + (i+1) + "차 회전 ***");

            for (int j=0; j<3; j++) {
                System.out.println("안쪽 for문 " + (j+1) + "차 회전");
            }
        }

        System.out.println();
	}
}

# 실행 결과
*** 바깥쪽 for문 1차 회전 ***
안쪽 for문 1차 회전
안쪽 for문 2차 회전
안쪽 for문 3차 회전
*** 바깥쪽 for문 2차 회전 ***
안쪽 for문 1차 회전
안쪽 for문 2차 회전
안쪽 for문 3차 회전
*** 바깥쪽 for문 3차 회전 ***
안쪽 for문 1차 회전
안쪽 for문 2차 회전
안쪽 for문 3차 회전

public class ForEx02 {

	public static void main(String[] args) {
		
		int idx = 1;
		
        for (;;) { // 조건식이 없어서 무한루프
            System.out.println("idx >> " + idx);

            if (idx == 2) {
                break;
            }
            idx++;
        }
		
        // while 문의 무한 루프 (정확하게 명시해둠 true)
        // while (true) {
        //    명령어;
        // }
		
//		System.out.println("반복문 실행 후 idx >> " + idx);
	}
}

	while문	for문
반복 횟수 결정 여부	x	o

레이블/라벨 : outer ==> 반복문 탈출

public class NestedLoopEx02 {

	public static void main(String[] args) {

        outer:
        for (int i=0; i<3; i++) {
            System.out.println("*** 바깥쪽 for문 " + (i+1) + "차 회전 ***");

            for (int j=0; j<3; j++) {
                System.out.println("안쪽 for문 " + (j+1) + "차 회전");

                if (j%2 == 0) 
                    break outer;
            }

            System.out.println();
		}
	}
}

# 실행 결과
*** 바깥쪽 for문 1차 회전 ***
안쪽 for문 1차 회전

*** 바깥쪽 for문 2차 회전 ***
안쪽 for문 1차 회전

*** 바깥쪽 for문 3차 회전 ***
안쪽 for문 1차 회전

---

📍 24.04.02(화) 6일차

https://print-blue.tistory.com/124

JAVA 프로그래밍 기초 연습 문제 - Switch 문을 활용해 정수 2개와 사칙연산 기호 받은 후 식과 계산

https://print-blue.tistory.com/125

JAVA 프로그래밍 기초 연습 문제 - while문을 활용하여 가로로 출력하기

https://print-blue.tistory.com/126

JAVA 프로그래밍 기초 연습 문제 - while문을 활용하여 구구단 2단 출력

https://print-blue.tistory.com/127

JAVA 프로그래밍 기초 연습 문제 - while 문을 활용하여 1 ~ 10 까지 누적합 구하기

https://print-blue.tistory.com/128

JAVA 프로그래밍 기초 연습 문제 - 사용자에게 입력 받고, 랜덤값 생성하여 입력 받은 값 맞추기

https://print-blue.tistory.com/129

JAVA 프로그래밍 기초 연습 문제 - 사용자에게 원하는 만큼 입력 받고 누적합 출력하기

https://print-blue.tistory.com/130

JAVA 프로그래밍 기초 연습 문제 - for문을 활용하여 구구단 2단 출력하기

https://print-blue.tistory.com/131

JAVA 프로그래밍 기초 연습 문제 - 중첩 for문을 활용하여 구구단 2 ~ 9단 출력하기

https://print-blue.tistory.com/132

JAVA 프로그래밍 기초 연습 문제 - 중첩 while문을 활용하여 구구단 2 ~ 9단 출력하기

https://print-blue.tistory.com/133

JAVA 프로그래밍 기초 연습 문제 - 중첩 for문을 활용하여 안쪽 for문에서 출력하기

if문 조건식에서 문자열 사용할 때

문자열을 가지고 비교를 할 때(==) 주소가 불일치한 경우가 있어서 메소드 만들어서 사용하는게 좋음

if (userSymbol == "+" || userSymbol == "-" || userSymbol == "*" || userSymbol == "/") {
    System.out.printf("%d %s %d = %d", userValue1, userSymbol, userValue2, result);
}

if (userSymbol.equals("+") || userSymbol.equals("-") || userSymbol.equals("*") || userSymbol.equals("/")) {
    System.out.printf("%d %s %d = %d", userValue1, userSymbol, userValue2, result);
}

 

https://print-blue.tistory.com/124

JAVA 프로그래밍 기초 연습 문제 - Switch 문을 활용해 정수 2개와 사칙연산 기호 받은 후 식과 계산

 

메서드 정의와 호출

[ 메소드 정의 형태 ] => 선언했다고 말 안함
반환형/리턴형/자료형 메서드명(자료형 변수명/매개변수) {
	명령어;
	명령어;
	return 값; => 있어도 없어도 됨
}

void : 반환형 // 반환이 되는 데이터 자료형 // return // 없다라는 의미 // 생략 안됨

main : 메서드명

args : 매개변수 / prameter(파라미터) // 지역변수

void main (String[] arge) : 사람 머리 // 선언부

그 이후 괄호 : 몸통 // body

argument(아구먼트) : 인수

// 호출 되는 값들이 "인수(argument)"
System.out.println(5);   	// 정수
System.out.println(5.1); 	// 실수
System.out.println('A'); 	// 문자
System.out.println("ㅎㅇ"); // 문자열
System.out.println(true);   // 논리

 

- 여러번 호출 가능

- 매개변수의 타입은 절대 생략할 수 없음 ex) (int n1, n2) x / (int n1, int n2) o

- 자료형 변수명과 return 이 있어도 없어도 됨 이러한 형태가 4가지가 있음

 

public class MethodEx01 {
	
	// main 메소드 정의
     public static void main(String[] args) {
        System.out.println("== 1. main method 시작==");

        // 메소드 호출
        increment(3);
        System.out.println("== 2. main method 종료==");
    }
	
    // 메소드 정의 형태
    // [ 형태 ] 1) 매개변수 있고, 리턴 없음
    // 기능 : 인수로 받은 값을 1증가 후, 출력
    public static void increment(int num) {
        System.out.println("== 3. increment method 시작 ==");
        num++;
        System.out.println("1 증가된 값 >> " + num);
        System.out.println("== 4. increment method 종료 ==");
    }
}

# 실행 결과
== 1. main method 시작==
== 3. increment method 시작 ==
1 증가된 값 >> 4
== 4. increment method 종료 ==
== 2. main method 종료==

실행 순서 / 타입에 따라 넣어야함

 

public class MethodEx02 {

	// [ main method ] ================
	public static void main(String[] args) {
		System.out.println("** main method 시작 **");
		
		int sumResult = sum(2, 5);
		System.out.println("sum(2,5) 호출 결과 >> " + sumResult);
		
		System.out.println("** main method 종료 **");
	}
	
	// [ method 정의 ] ================
	// [ 형태 2 ] 매개변수 있고, 리턴 있음
	// 기능 : 인수로 정수 2개 받은 후, 덧셈 결과 리턴
	// 메소드명 : sum, 매개변수 : 2개
	public static int sum(int num1, int num2) {
		int result = num1 + num2;
		return result;
		// System.err.println("sum 메소드 실행 종료"); return 이 끝났으므로 실행 x
	}
}

 

MethodEx01 의 increment 는 return 이 없기 때문에

int result = increment(3); 이 안됨 

System.out.println( increment(3)); 또한 안됨

 

public class MethodEx03 {
	
	// [ main method ] ================
	public static void main(String[] args) {

		showString();
		
	}
	
	// [ method 정의 ] ================
	// [ 형태 3 ] 매개변수 없고, 리턴 없음
	// 기능 : 호출하면 문자열 출력
	// 메소드명 : showString, 매개변수 : x
	// 반환할 것이 없어서 void 
	
	public static void showString() {
		
		System.out.println("--------------------------");
		System.out.println("showString() 메소드 실행됨");
		System.out.println("--------------------------");
	
	}
	
}

# 실행 결과
--------------------------
showString() 메소드 실행됨
--------------------------

 

public class MethodEx04 {

	// [ main method ] ================
	public static void main(String[] args) {

		// 방법 1. 변수 저장
		String str = returnString();
		System.out.println("변수 저장 : returnString() 호출 결과 >> " + str);
		
		// 방법 2. 바로 사용
		System.out.println("바로 사용 : returnString() 호출 결과 >> " + returnString());

	}
	
	// [ method 정의 ] ================
	// [ 형태 4 ] 매개변수 없고, 리턴 있음
	// 기능 : 호출하면 문자열 리턴
	// 메소드명 : returnString, 매개변수 : x
	
	public static String returnString() {
		
		return "안녕";
	}

}

return 의미

- 메소드 실행 끝

- 리턴값을 호출한 쪽으로 넘겨줌

- 결과값은 하나만 가능

 

메소드 실행 끝의 이미

- return

- method의 body 의 닫힌 중괄호 ( } )

 

지역 변수 local variable

stack

https://velog.io/@iamjinseo/Java-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B5%AC%EC%A1%B0-Static-Stack-Heap

[Java] 메모리 구조 - Static, Stack, Heap

---

📍 24.04.03(수) 7일차

https://print-blue.tistory.com/134

JAVA 프로그래밍 기초 연습 문제 - 사용자에게 입력 받은 후 짝수 단과 홀수 단 출력하기

https://print-blue.tistory.com/135

JAVA 프로그래밍 기초 연습 문제 - 매개 변수가 있고, return 이 있을 때와 없는 경우

https://print-blue.tistory.com/137

JAVA 프로그래밍 기초 연습 문제 - 메소드 정의 후 호출하여 정수 2개를 받아 누적합 출력

https://print-blue.tistory.com/138

JAVA 프로그래밍 기초 연습 문제 - 메소드 정의 후 호출하여 정수 1개를 받아 제곱값 출력

https://print-blue.tistory.com/139

JAVA 프로그래밍 기초 연습 문제 - 메소드 정의 후 호출하여 정수 1개를 받아 패토리얼 값 출력

Method

기본 구조 / 메소드 안에 또 다른 메소드가 들어올 수 없음

 

 

아래 코드를 볼 땐 num 을 one 으로 바꿔서 보세용

public class MethodEx01 { // MethodEx01 클래스

    // [ increment method ] =====================
    public static void increment(int num) {
        int var = 100;
        num++;
        System.out.println("1 증가 >> " + num);
    }

    // [ main method ] =====================
    public static void main(String[] args) {
        int one = 1;
        increment(one); // 인수(변수)
        System.out.println("one >> " + one);
    }
}

# 실행 결과
1 증가 >> 2
one >> 1 // increment 메소드와 main 메소드의 one 매개변수는 다른 영역이기 때문에 다른 변수로 인식이 됨

다른 변수로 인식

메소드 오버로딩 (method overloading)

- 같은 이름의 메소드를 여러 개 정의

- 단, 매개 변수의 정보가 달라야함

- 반환형(리턴형)과는 다름

 

타입이 맞는 메소드로 찾아감 !

다른 타입의 sum 메소드

이름은 같지만 다른 sum, println 도 같아보이지만 다 다름

public class MethodEx02 {

    public static void main(String[] args) {

        // method 호출
        sum(2,3);
        sum(2.1, 3.3); 

    }
	
    // [ method 정의 ] ==============================
    public static void sum(int n1, int n2) {
        int result = n1 + n2;
        System.out.println("덧셈 결과 >> " + result);
    } 

    public static void sum(double n1, double n2) {
        double result = n1 + n2;
        System.out.println("덧셈 결과 >> " + result);
    } 

    // ==============================================
}
 # 실행 결과 
덧셈 결과 >> 5
덧셈 결과 >> 5.4

 

 

컴파일러가 동일한 메소드로 인식을 해서 에러 뜸

이런 경우에는 자리가 다르기 때문에 오버로딩이 맞음

`

public static void sum(int n1, double n2) {

} 

public static void sum(double n1, int n2) {

}



public static void sum(int n2, double n1) {

} 

public static void sum(double n1, int n2) {

}

공식 문서로 확인해보기

 

메소드 문서 보기 : 보려고 하는 메소드에 컨트롤 꾹 누르기

 

https://print-blue.tistory.com/136

JAVA 공식 문서 보는 방법

 

 

 

반복문

/*
 * [ 반복문 ] ====================================
 * 특정 코드가 연속적으로 반복 ==> 반복문으로 구현
 * 
 * [ 메서드 정의 ] ===============================
 * 특정 코드가 불연속적으로 반복 ==> 메서드 정의
 * - < 모듈화 >라고 함
 */

// 모듈화 만들기

import java.util.Scanner;

public class MethodEx03Refactoring01 {

    public static void increment(int ar) {
        ar++;
        System.out.println("1 증가 >> " + ar);

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

        int num = 5;

    //		num++;
    //		System.out.println("1 증가 >> " + num);
        increment(num);

        Scanner input = new Scanner(System.in);
        System.out.print("정수 1개 입력 >> ");
        int userNumber = input.nextInt();
        input.close();

    //		userNumber++;
    //		System.out.println("1 증가 >> " + userNumber);
        increment(userNumber);

        int var = 10;

    //		var++;
    //		System.out.println("1 증가 >> " + var);
        increment(var);

    }
}\

# 실행 결과
1 증가 >> 6
정수 1개 입력 >> 100
1 증가 >> 101
1 증가 >> 11

 

이클립스 자동 리팩토링

단축키 : 컨트롤 + 쉬프트 + T 

 

 

 

도구 모음에 초록색 재생아이콘 에 검은색 화살표 클릭했을 때

import java.util.Arrays;

public class MethodEx04 {

	public static void main(String[] args) {
		
		System.out.println(args);
		System.out.println(Arrays.toString(args));
		
	}
}

# 실행 결과
[Ljava.lang.String;@372f7a8d
[안녕, 반가워]

 

객체 지향 프로그래밍

1) 클래스와 객체

자바는 모든 객체를, 생성되는 인스턴스는 heap 에 저장

초기값을 설정을 안해도 자바에서 초기값 0으로 설정해줌

 * [ 클래스 ] class ========================================
 * - 클래스는 '자료형'
 * - 사용자(개발자) 정의 자료형
 * - 참조형(reference type)
 * 		cf) 기본형(primitive type) : int, float, double, ...
 * - 클래스명 : 대문자로 시작
 * - 클래스 내 멤버 : 변수, 메소드 
 * 
 * - 참조(reference) 변수 선언 형태
 * 	클래스명 변수명;
 * 	
 * 	cf) int num;
 * =========================================================

// [ class 정의 ]
class Student{
	
    // 멤버 : 변수
    int age;
    String name;


    // 멤버 : 메소드
    /* 반환형 메소드명(매개변수) {
     *  	명령어;
     *  	return 값;
     *  }
     */
    void study() {
        System.out.println("열심히 공부 중 !");
    }
}


public class InstanceEx01 {

	public static void main(String[] args) {
        // [ 변수 선언 ] ===================
        // [ 기본형 ] 
        // 자료형 변수명;
        int num = 1; // 초기값 설정안하면 error !
        System.out.println("num >> " + num); 

        // [ 자료형 ] 
        // 참조 변수 선언
        // 클래스 변수명;
        // Student jin; 은 쓰레기값 // stack 영역에 저장
        Student jin = ull; // 0도 되는데 그럼 에러가 나서 null 를 씀, 찾아갈 곳이 없다는 뜻, 아스키코드표 
        
        // 객체 생성
        // new 클래스명(); // new => RAM 에 heap 에 할당함
        new Student();
        
        // 멤버 접근 
        // 여기서 . 은 접근 연산자
		System.out.println("멤버 변수 age 초기값 >> " + jin.age);
		System.out.println("멤버 변수 age 초기값 >> " + jin.name);

        // 멤버 변수에 값 설정
        jin.age = 20;
        System.out.println("멤버 변수 age >> " + jin.age);
        jin.name = "진따라";
        System.out.println("멤버 변수 name >> " + jin.name);

        // 멤버 메서드 study() 호출
        jin.study();
        
        // 참조 변수 선언과 동시에 초기화
        Student jung = new Student();
        System.out.println("정띠리 나이 >> " + jung.age);
        
        // new Student(); // 에러는 발생 안함, 객체 생성은 했지만 주소가 없어서 찾아갈 방법 x, 
        
        // 일회용으로 생성된 객체
        new Student().study();
	}
}

# 실행 결과 
num >> 1
멤버 변수 age 초기값 >> 0
멤버 변수 name 초기값 >> null
멤버 변수 age >> 20
멤버 변수 name >> 진따라
열심히 공부 중 !
정띠리 나이 >> 0
정띠리 이름 >> null
열심히 공부 중 !

 

 

class Person { // 실체화가 됐다 => 멤버 메서드가 할당 됐다는 뜻
	
    // 멤버 변수 
    int age;

    // 멤버 메서드
    void showInfo() {
    	System.out.println("<< 정보 >>");
	}
}

public class InstanceEx02 {

	public static void main(String[] args) {
		
        // 1. 객체 생성
        Person p1 = new Person(); // 참조 변수

        // 2. 객체 멤버에 접근
        System.out.println("멤버 변수 age >> " + p1.age); // 주소.age

        // 3. 참조 변수 p1 의 저장된 주소
        System.out.println("참조 변수 p1 의 저장된 주소 >> " +p1);
		
        // 참조 변수가 무조건 지역 변수가 되는 것이 아님
        // Person p2; // error !
        Person p2 = p1;

        // 주소 복사 : p1 에 저장된 주소를 p2에 복사
        // 같은 객체를 가리킨다(접근)
        Person p2 = p1;
        System.out.println("p2에 저장된 주소 >> " + p2);
	}
}

# 실행 결과
멤버 변수 age >> 0
참조 변수 p1 의 저장된 주소 >> Person@66048bfd
p2에 저장된 주소 >> Person@66048bfd

 

---

📍 24.04.04(목) 8일차

객체 지향 프로그래밍

재귀 호출

잘못 호출할 경우 

https://print-blue.tistory.com/139

JAVA 프로그래밍 기초 연습 문제 - 메소드 정의 후 호출하여 정수 1개를 받아 패토리얼 값 출력

2) 변수 종류

2-1. 지역 변수
2-2. 멤버 변수 - 인스턴스(객체) 변수

/* 
 * [ 클래스 ] class
 * - 자료형
 * - 사용자 정의 자료형
 * - 객체 아님
 * 
 * [ 객체 ] object, instance ========================================
 * - 클래스로 생성된 구체화(실체화)된 대상
 * - java 는 모든 객체를 heap 영역에 생성 --> 멤버도 heap 영역에 할당
 * - 객체가 heap 영역에 생성되면, 할당된 주소를 리턴(반환)
 * - 생성된 객체는 반드시 주소를 통해 접근(간접 접근) / 바로 접근 x
 * - 객체는 원래 이름이 없음
 * [ 객체 생성 문법 ] ===============================================
 * new 클래스명();
 * new : heap 영역에 할당해라 
 * 
 * [ 참조 변수 선언 문법 ] ==========================================
 * 클래스명 변수명;
 * 
 */

class Student {
	
    // 멤버 변수
    int age;
    String name;

    // 멤버 메소드
    void study() {
    	System.out.println("열심히 . . 오늘도 . . 공부를 .. 하네 . . .");
    }
}


public class InstanceEx01 {

	public static void main(String[] args) {
		
        // 참조 변수 선언
        // Student class 로 생성된 객체가 저장'될' 참조 변수 선언
        Student jin;

        // 객체 생성
        // heap 영역에 Student class 로 객체 생성
        jin = new Student();

        // 멤버 접근
        // 멤버 변수는 외부 접근을 권장하지 않음
        System.out.println("나이 : " + jin.age);
        jin.age = 35;
        System.out.println("나이 : " + jin.age);
		
        // 멤버 메소드
        jin.study();
    
    }	
}

setter(세터) / getter(게터) method

참조 변수 : this.멤버변수 / this.멤버메서드()

this. 참조 변수 ==> 내가 나를 가리키는 것 !

class 에서 setter 메소드에서 지역 변수를 만들 때 지역 변수와 멤버 변수가 같다 보니 접근을 하지 못해서 가려지는데

이때 참조 변수를 만들고, this 연산자를 사용 !

/*
 * setter method : 멤버 변수의 값을 설정하는 메소드
 * - 메소드명 규칙 - set멤버변수명;
 * 
 * void 메서드명() { 
 * 
 * }
 */

    /* 
 * getter method : 멤버 변수의 값을 리턴하는 메소드
 * - 메서드명 규칙 - get멤버변수명;
 * 
 * 반환형 메서드명(); { 
 * 		return 값;
 * }
 */

 

↓ ↓  이거 그림 그리기 .......

class Fruit {
    int count;
    String sort;
	
    // setter method 
//  void setCount (int num) { // heap 영역에 만들어지는게 아니라 stack 영역에 만들어졌다가 사용되면 사라짐
//      count = num; 
//  }
	
    // stack 영역보다 heap 영역에 있는 멤버 변수에 값이 저장됨(지역 변수는 메소드 기준 가까이 있는 거 갖다 씀)
    void setCount (int count) { // 보통 매개 변수는 멤버 변수명으로 맞춰줌
        // count = count; // 지역변수와 멤버변수가 같다 보니 접근을 하지 못해서 가려짐 --> 그래서 참조 변수를 만듦 (this 연산자)
        // count(멤버) = count(매개); 가 되어야함 
        this.count = count;
        // 여기엔 System.out.print(); 가 일반적으로 안들어옴
        System.out.println("this 에 저장된 주소 >> " + this); // 확인을 위해 작성한 것
    }
    
    
    // getter method 
    int getCount() {
    	return count;
    }
}


public class InstanceEx02 {

	public static void main(String[] args) {

        // 객체 생성
        Fruit fruit = new Fruit();
        System.out.println("참조 변수 fruit >> " + fruit);

        // 멤버 메소드 호출
        // System.out.println("멤버 변수 count >> " + fruit.count()); // 앞으로 이렇게는 x, 감출 것
        System.out.println("전) 멤버 변수 count >> " + fruit.getCount());

        fruit.setCount(10);
		
        System.out.println("멤버 변수 count >> " + fruit.getCount());
		
	}
}

# 실행 결과
참조 변수 fruit >> Fruit@483bf400
전) 멤버 변수 count >> 0
this 에 저장된 주소 >> Fruit@483bf400
참조 변수 fruit >> Fruit@483bf400
후) 멤버 변수 count >> 10

 

class 와 객체와 인스턴스

https://gmlwjd9405.github.io/2018/09/17/class-object-instance.html

[Java] 클래스, 객체, 인스턴스의 차이 - Heee's Development Blog

// Dog class 정의
class Dog {
	int age;
	
    void showInfo() {
        System.out.println("this >> " + this);
    }
	
}

public class InstanceEx03 {

	public static void main(String[] args) {
		
        // Dog class 로 생성된 jaho 객체(인스턴스)
        Dog jaho = new Dog();
        System.out.println("참조 변수 jaho 에 저장된 주소 >> " + jaho);
        jaho.showInfo();
     	
        // Dog class 로 생성된 jason 객체(인스턴스)
        Dog jason = new Dog(); 
        System.out.println("참조 변수 jason 에 저장된 주소 >> " + jason);
        jason.showInfo();
	}

}

# 실행 결과
참조 변수 jaho 에 저장된 주소 >> Dog@483bf400
this >> Dog@483bf400
참조 변수 jason 에 저장된 주소 >> Dog@7a92922
this >> Dog@7a92922

 

다른 파일에서 이전에 썼던 class 명을 썼을 경우

클래스는 타입이라 이미 정의가 되어 있어서 저장이 안됨

같은 경로(패키지)에 같은 이름의 class 생성 불가능 !!!!

 

해결 방법

1) 클래스명을 바꾼다

2) 다른 경로로 만든다 -> 패키지 만들기

 

 

setter / getter 자동 생성 단축키 : 알트 + 쉬프트 + S 

 

2-2. 멤버 변수 -  인스턴스(객체) 변수

field 종류 - instance field / static field (class field) 

class Cat {
	
    // [ field ] : 필드, 멤버 변수
    // 인스턴스(객체) 변수
    int age;
    String name;
	
	
	// setter / getter 
    public int getAge() {
        return age;
    }
	
    public void setAge(int age) {
        this.age = age;
    }
	
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
} 

public class InstanceEx05 {

    public static void main(String[] args) {
    
        // 인스턴스 생성
        Cat thor = new Cat();
        Cat happy = new Cat();

        // 인스턴스에 이름 저장
        thor.setName("토르");
        happy.setName("해피");

        // 인스턴스에 저장된 이름 출력
        System.out.println("고양이 이름 : " + thor.getName());
        System.out.println("고양이 이름 : " + happy.getName());

    }
}

 

class Person {
	
    // 멤버 변수 : instance field
    int age;
    String name;

    // 멤버 메서드 : instance method
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
	
}

public class InstanceEx06 {

	public static void main(String[] args) {

        // hong 객체 생성
        Person hong = new Person();

        // 멤버 변수 값 설정 - 나이 설정 : 25, 이름 : 홍길동
        hong.setName("홍길동");
        hong.setAge(25);

        // 출력
        System.out.println("이름 : " + hong.getName());
        System.out.println("나이 : " + hong.getAge());

        // park 객체 생성
        Person park = new Person();

        // 멤버 변수 값 설정 - 나이 설정 : 35, 이름 : 박보검
        park.setName("박보검");
        park.setAge(35);

        // 출력
        System.out.println("이름 : " + park.getName());
        System.out.println("이름 : " + park.getAge());
	}
}

 

3) 생성자 constructor

/*
 * [생성자] constructor
 * 
 * << 생성자를 사용하는 이유 >> 
 * 1) 객체를 생성하면서, 멤버 변수(인스턴스 필드)를 초기화 하고자 할 때
 * 2) 객체를 생성하면서, 원하는 기능을 실행하기 위해서 (특정 멤버 메서드를 호출)
 * 
 * 
 * 
 * - 객체 생성시, 무조건 하나의 생성자 호출(실행)
 * - 생성자는 '메소드'이다 -> '메소드 오버로딩 ' 가능 -> 생성자 여러개 정의 가능
 * 	cf) 메소드 오버로딩
 * 		* 메소드명이 같고, 매개변수의 정보가 다름
 * 					       --------------- (개수, 자료형)
 *   	* 단, 반환형과는 관련 없다
 * - 생성자는 반환값이 없다 -> 반환형을 명시하지 않음(void 자체도 안씀)
 * - 생성자명은 클래스명과 같아야 함
 * 
 * << default constructor >> 기본 생성자
 * - 생성자를 명시하지 않으면, 기본 생성자가 실행
 * - 매개 변수가 없고, 하는 일도 없음 --> 형식상 실행
 * - 컴파일러가 만듦
 * - 생성자가 하나라도 명시되어 있다면, 기본 생성자는 실행되지 않음
 */

 

[ 인스턴스(객체) 생성 순서 ]
1. 메모리 할당
2. 생성자 할당

class Car {
    // instance field ==============================================
    int door;
    String color;

    // default constructor (컴파일러가 만든 것)
    //	Car() {} // 클래스명과 동일

    // constructor (메서드오버로딩 된 것)===========================
    Car() {
        System.out.println("[매개변수가 없는 생성자 실행]");
    }

    Car(String color) {
        this.color = color;
        System.out.println("[매개변수가 1개인 생성자 실행] String");
    }

    Car(int door) {
        this.door = door;
        System.out.println("[매개변수가 1개인 생성자 실행] int");
    }

    Car(int door, String color) {
        this.door = door;
        this.color = color;
        System.out.println("[매개변수가 2개인 생성자 실행]");
    }

    // instance method =============================================
    void setDoor (int door) {
        this.door = door;
    }

    void showInfo() {
        System.out.printf("door : %d, color : %s\n\n", door, color);
    }
}


public class InstanceEx07 {

	public static void main(String[] args) {
		
        // 소괄호를 생략하면 안되는 이유 : 매개 변수가 없을 때 기본 생성자를 호출하기 때문
        Car c1 = new Car(5); // 객체가 생성되는 과정 중에 원하는 값을 넣을 것 
        c1.showInfo();

        Car c2 = new Car(); // [매개변수가 없는 생성자 실행]
        c2.showInfo();

        Car c3 = new Car("black");
        c3.showInfo(); // door : 0, color : black

        Car c4 = new Car(2, "blue");
        c4.showInfo();

        // c1.setDoor(4);
        // c1.showInfo();
		
	}
}

# 실행 결과
[매개변수가 1개인 생성자 실행] int
door : 5, color : null

[매개변수가 없는 생성자 실행]
door : 0, color : null

[매개변수가 1개인 생성자 실행] String
door : 0, color : black

[매개변수가 2개인 생성자 실행] String / int
door : 2, color : blue

---

📍 24.04.05(금) 9일차

https://print-blue.tistory.com/140

JAVA 프로그래밍 기초 연습 문제 - 재귀 호출

https://print-blue.tistory.com/141

JAVA 프로그래밍 기초 연습 문제 - class 안에 정의하지 않고, 메서드 정의하기

https://print-blue.tistory.com/142

JAVA 프로그래밍 기초 연습 문제 - 클래스 정의 후 main 메소드에서 호출하기

https://print-blue.tistory.com/143

JAVA 프로그래밍 기초 연습 문제 - 클래스 정의 후 main 메소드에서 호출하기 - 2

 

https://print-blue.tistory.com/144

JAVA 프로그래밍 기초 연습 문제 - class 생성자 만들기

 

 

Garbage Collection(가비지 컬렉션)

// p240404/scr/InstanceEx06 이어서

class Robot {
    int productYear;
    String productName;

    public int getProductYear() {
        return productYear;
    }

    public void setProductYear(int productYear) {
        this.productYear = productYear;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }
}


public class InstanceEx01 {
	
    // static 을 붙여야 main 메소드에서 호출이 가능함
    // (반환형) 위치에 Robot 으로 할 것
    // 리턴형이 참조형인 것
    public static Robot constructRobot() {
        Robot robot = new Robot();
        robot.setProductName("옵티머스");
        robot.setProductYear(2000);
        return robot; // 여기서 robot 은 주소
    }
	

    public static void main(String[] args) {

        // constructRobot 메서드 호출
        // heap 영역에서 만들어진 주소는 어디서든지 호출이 가능
        // constructRobot() robot 주소가 main()의 robot 으로 주소 복사된 것
        Robot robot = constructRobot();
		
        // 주소가 같은지 아닌지 확인해보기
        if (robot == robot2) {
            System.out.println("주소가 같음");
        } else {
            System.out.println("주소가 다름");
        }
        
        System.out.println("로봇의 생산년도 >> " + robot.getProductYear());
        System.out.println("로봇의 제품명 >> " + robot.getProductName());

    }
}

# 실행 결과
로봇의 생산년도 >> 2000
로봇의 제품명 >> 옵티머스

4) Array 배열 / 파이썬은 리스트

String Class
Wrapper Class
향상된 for문

/* 
 * [ 배열 ] array
 * : 하나의 이름으로 여러 값(요소, 원소, 객체)을 관리
 * : 여러 값(요소)이 메모리에 연속해서 할당
 * : 여러 값(요소)을 구분하기 위해 인덱스 사용
 * => 인덱스(index)는 0부터 시작
 * 
 * : 자바는 무조건 배열을 객체(인스턴스)로 생성 -->heap 영역 생성
 * : 그래서 주소로 접근(갑접 전근)
 * 
 * [ 문법 ]
 * 자료형[] 참조변수 = new 자료형[길이];
 */

public class ArrayEx02 {

	public static void main(String[] args) {
		
        // [ 학생들의 수학 점수 저장 ]

        // 1. 배열 생성 -------------------------------------
        // 1-1. 참조 변수 선언
        int[] math; 						// [] 자료형
        // 자료형[] 참조변수;
        // int 형 1차원 배열의 참조변수 math 를 선언

        // 1-2. 배열 생성
        // 배열이 한 번 선언하면 나중에는 변경 x
        math = new int[5]; 					// [] 배열의 길이
        // 참조변수 = new 자료형[길이] 
        // int 형 길이가 5인 1차원 배열 생성 후 참조변수 math 에 주소 저장


        // 2. 배열 여소(원소)에 값 설정
        math[0] = 80; 						// [] 배열의 index
        math[1] = 95;
        math[2] = 90;
        math[3] = 70;
        math[4] = 100;

        // 3. 배열 요소(원소)에 저장된 값 출력
        // 번호를 부여하는 것은 index
        //		System.out.println("math[0] >> " + math[0]);
        //		System.out.println("math[1] >> " + math[1]);
        //		System.out.println("math[2] >> " + math[2]);
        //		System.out.println("math[3] >> " + math[3]);
        //		System.out.println("math[4] >> " + math[4]);

        System.out.println("배열의 길이 >> " + math.length);
        // math.length = 100; // error !

        // for 문  
        for (int i=0; i<math.length; i++) {
            System.out.println("math[" + i + "] >> " + math[i]);
        }

        // [ enhanced for loop ] 향상된 for 문 
        // [ 문법 ]
        // for(자료형 변수명: 베열의 참조변수) {
        //		명령어;
        // }

        for (int element: math) {
            System.out.println(element);
        }
	} 
}

# 실행 결과
배열의 길이 >> 5
math[0] >> 80
math[1] >> 95
math[2] >> 90
math[3] >> 70
math[4] >> 100
80
95
90
70
100

public class ArrayEx02CleanCode {

	public static void main(String[] args) {
		
        // [ 학생들의 수학 점수 저장 ]

        // 1. 배열 생성과 동시에 요소 초기화
        // 반드시 길이 생략
        // int[] math = new int[] {80, 95, 90, 70, 100};
        int[] math = {80, 95, 90, 70, 100};

        // 2. 배열 요소(원소)에 저장된 값 출력
        // 2-1. for 문
        for (int i=0; i<math.length; i++) {
            System.out.println("math[" + i + "] >> " + math[i]);
        }

        // 2-2. [ enhanced for loop ] 향상된 for 문 : 배열에서 사용
        for (int element: math) {
            System.out.println(element);
        }
	} 
}

1차원 배열과 2차원 배열

arr >> [I@f5f2bb7 		// '[' 1차원 / i = 인티저
arr2 >> [[I@21a06946 	// '[[' 2차원

public class ArrayEx03 {

	public static void main(String[] args) {
		
		// [ 1차원 배열 ] 길이가 1개인 배열
		int[] arr = new int[5];
		// 자료형[] 참조변수 = new 자료형[열길이];
		
		// [ 2차원 배열 ] 길이가 2개인 배열
		int[][] arr2 = new int[2][4];
		// 자료형[][] 참조변수 = new 자료형[행길이][열길이];
	} 
}

public class ArrayEx03 {

	public static void main(String[] args) {
		
        // [ 1차원 배열 ] 길이가 1개인 배열
        int[] arr = new int[5];
        // 자료형[] 참조변수 = new 자료형[열길이];
        System.out.println("arr >> " + arr);


        // [ 2차원 배열 ] 길이가 2개인 배열
        int[][] arr2 = new int[2][4];
        // 자료형[][] 참조변수 = new 자료형[행길이][열길이];
        System.out.println("arr2 >> " + arr2);
		
        // 2차원 배열의 참조변수
        // arr2 	: 참조변수 - 행의 시작 주소
        // arr2[0]	: 참조변수 - 첫 번째 1차원 배열의 시작 주소
        // arr2[1]	: 참조변수 - 두 번째 1차원 배열의 시작 주소
        System.out.println("arr2 >> " + arr2);
        System.out.println("arr2[0] >> " + arr2[0]);
        System.out.println("arr2[1] >> " + arr2[1]);
        System.out.println();

        // 2. 값 설정
        arr2[0][0] = 2;
        arr2[0][1] = 4;
        arr2[0][2] = 6;
        arr2[1][0] = 8;
        arr2[1][1] = 10;
        arr2[1][2] = 12;

        // 3. 값 출력
        // 3-1. 중첩 for 문
        System.out.println("중첩 for 문");
        for (int i=0; i<2; i++) {		// 행
            for (int j=0; j<3; j++) {	// 열
                System.out.print(arr2[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();


        // 3-2. 중첩 for 문: 내장변수 length 사용
        System.out.println("중첩 for문 : 내장변수 length 사용");
        for (int i=0; i<arr2.length; i++) {		// 행
            for (int j=0; j<3; j++) {	// 열
                System.out.print(arr2[i][j] + " ");
            }
            System.out.println();
        }

	} 
}

# 실행 결과
arr >> [I@f5f2bb7
arr2 >> [[I@21a06946
arr2 >> [[I@21a06946
arr2[0] >> [I@77f03bb1
arr2[1] >> [I@326de728

중첩 for 문
2 4 6 
8 10 12 

중첩 for문 : 내장변수 length 사용
2 4 6 
8 10 12

진짜 잘 확인해라 ...

---

📍 24.04.08(월) 10일차

https://print-blue.tistory.com/145

JAVA 프로그래밍 기초 연습 문제 - constructor 와 setter 의 차이

https://print-blue.tistory.com/146

JAVA 프로그래밍 기초 연습 문제 - 중첩된 for문과 향상된 for문

https://print-blue.tistory.com/147

JAVA 프로그래밍 기초 연습 문제 - 2차원 배열 생성과 동시에 초기화하기

2차원 배열

2차원 배열 생성
: 행 길이는 반드시 설정 - 생략 불가능
: 열 길이 생략 가능

public class ArrayEx01 {

	public static void main(String[] args) {

        // 2차원 배열 생성
        // : 행 길이는 반드시 설정 - 생략 불가능
        // : 열 길이 생략 가능
        int[][] arr2 = new int[2][]; // 눈에는 안보이지만, Integer 로 바뀐거임
        System.out.println("arr2 : " + arr2);
        System.out.println("arr2[0] : " + arr2[0]);
        System.out.println("arr2[1] : " + arr2[1]);

        // 열 : 1차원 배열 생성
        arr2[0] = new int[3]; // 2) 열 선언하기
        arr2[1] = new int[] {8}; 

        // 향상된 for 문
        for(int[] row: arr2) {
            for (int column: row) {
                System.out.print(column + " ");
            }
            System.out.println();
        }
		
	}
}

# 실행 결과
arr2 : [[I@372f7a8d
arr2[0] : null
arr2[1] : null
0 0 0 
8

 

객체 배열

객체 배열 : 1차원 배열
타입[] 배열명 = new 타입[길이];

[객체 생성 순서]
1. 메모리 할당
2. 생성자 실행

 

class Student {
    // field : 필드, 멤버변수
    int age;
    String name;

    // constructor
    Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    // method
    void showInfo() {
        System.out.println("나이 : " + this.age);
        System.out.println("이름 : " + this.name);
    }
	
}

public class ArrayEx02 {

	public static void main(String[] args) {
		
        // 객체 배열 : 1차원 배열
        // 타입[] 배열명 = new 타입[길이];
        Student[] smart = new Student[3];

        System.out.println("smart[0] >> " + smart[0]);
        System.out.println("smart[1] >> " + smart[1]);
        System.out.println("smart[2] >> " + smart[2]);
        System.out.println();
		
	}
}

# 실행 결과
smart[0] >> null
smart[1] >> null
smart[2] >> null

 

인스턴스 객체도 계속 메모리에 할당이 된건가 ? => 안된 것, 참조변수가 메모리 할당된 것

class Student {
    // field : 필드, 멤버변수
    int age;
    String name;

    // constructor
    Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    // method
    void showInfo() {
        System.out.println("나이 : " + this.age);
        System.out.println("이름 : " + this.name);
    }
}

public class ArrayEx02 {

	public static void main(String[] args) {
		
        // 객체 배열 : 1차원 배열
        // 타입[] 배열명 = new 타입[길이];
        Student[] smart = new Student[3];

        smart[0] = new Student(20, "hong");
        smart[1] = new Student(35, "park");
        smart[2] = new Student(52, "lee");

        // 1) 배열의 요소는 참조변수로 구성됨
        // 1-1) 일반 for 문 : 내장변수 length
        System.out.println("**** [배열의 요소] 일반 for 문 : 내장변수 length ****");
        for (int i=0; i<smart.length; i++) {
            System.out.println(smart[i]);
        }
        System.out.println();

        // 1-2) 향상된 for 문
        System.out.println("**** [배열의 요소] 향상된 for문 ****");
        for (Student student: smart) {
            System.out.println(student);
        }
        System.out.println();

        // 과제 ========================================================================
        // 2) 학생의 정보 출력 : showInfo() 호출
        // 2-1) 일반 for 문 : 내장변수 length
        System.out.println("**** [학생의 정보 출력] 일반 for 문 : 내장변수 length ****");
        for (int i=0; i<smart.length; i++) {
            smart[i].showInfo();
        }
        System.out.println();

        // 2-2) 향상된 for 문
        System.out.println("**** [학생의 정보 출력] 향상된 for문 ****");
        for (Student student: smart) {
            student.showInfo();
        }
        System.out.println();

        // 3) 모든 학생의 나이를 1 증가 (향상된 for 문으로 하기)
        System.out.println("**** [모든 학생의 나이 1 증가] 향상된 for문 ****");
        for (Student student: smart) {
            student.age += 1;
            student.showInfo();
        }
        System.out.println();

        // 4) 학생의 정보 출력 : showInfo() 호출
        System.out.println("**** [학생의 정보 출력] 향상된 for문 ****");
        for (Student student: smart) {
            student.showInfo();
        }
		
	}
}

# 실행 결과
**** [배열의 요소] 일반 for 문 : 내장변수 length ****
Student@483bf400
Student@21a06946
Student@77f03bb1

**** [배열의 요소] 향상된 for문 ****
Student@483bf400
Student@21a06946
Student@77f03bb1

**** [학생의 정보 출력] 일반 for 문 : 내장변수 length ****
나이 : 20
이름 : hong
나이 : 35
이름 : park
나이 : 52
이름 : lee

**** [학생의 정보 출력] 향상된 for문 ****
나이 : 20
이름 : hong
나이 : 35
이름 : park
나이 : 52
이름 : lee

**** [모든 학생의 나이 1 증가] 향상된 for문 ****
나이 : 21
이름 : hong
나이 : 36
이름 : park
나이 : 53
이름 : lee

**** [학생의 정보 출력] 향상된 for문 ****
나이 : 21
이름 : hong
나이 : 36
이름 : park
나이 : 53
이름 : lee

 

향상된 for문으로 요소 값 변경하기

public class ArrayEx03 {

	public static void main(String[] args) {
		
		// 1차원 배열 생성
		int[] arr = {2, 4, 6};
		
		// enhanced for loop : 출력
		for (int ar: arr) {
			System.out.print(ar + " ");
		}
		System.out.println();
		
		// enhanced for loop : 요소 값 변경
		for (int ar: arr) {
			ar += 1;
			System.out.print(ar + " ");
		}
		System.out.println();
		
		// enhanced for loop : 변경된 요소 값 출력
		for (int ar: arr) {
			System.out.print(ar + " ");
		}
		System.out.println();
	}

}

 

 

String 의 문자열 비교 .equals()

public class StringEx01 {

	public static void main(String[] args) {

        // [ 문자열 ] 문자 여러 개 연속
        // 배열과 같은 형태로 메모리에 할당됨
        String s1 = "안녕";
        String s2 = "안녕";
        String s3 = new String("안녕");
        String s4 = new String("안녕");

        System.out.println("s3 >> " + s3);
        System.out.println("s4 >> " + s4);

        // = : 주소 비교
        if (s3 == s4) { // 이렇게 하면 주소가지고 비교하는 것
            System.out.println("주소 같음");
        } else {
            System.out.println("주소 다름");
        }

        // equals() : 문자열 비교
        if (s3.equals(s4)) {
            System.out.println("같은 문자열");
        } else {
            System.out.println("다른 문자열");
        }
		
	}
}
s3 >> 안녕
s4 >> 안녕
주소 다름
같은 문자열

 

 

toString()

https://docs.oracle.com/javase/8/docs/api/index.html / toString()

Java Platform SE 8

class Person {
	// 멤버 없음
}

public class StringEx02 {

    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p);							// Person@282ba1e / object toStrting
        System.out.println(p.toString()); 				// Person@282ba1e
        System.out.println(p.getClass()); 				// class Person
        System.out.println(p.getClass().getName()); 	// Person

        String str = "안녕";
        System.out.println(str);						// 안녕
        System.out.println(str.toString());				// 안녕 / Strting toStrting

        String str2 = new String("안녕");
        System.out.println(str2);
        System.out.println(str2.toString());

    }
}

 

class Person {
	
    // [ overriding ] 오버라이딩
    @Override // 어노테이션(애노테이션)
    public String toString() {
        return "[오버라이딩] Person";
	}
}

public class StringEx02 {

	public static void main(String[] args) {
		
		Person p = new Person();
		System.out.println(p);							
		System.out.println(p.toString()); 				
		System.out.println(p.getClass()); 				
		System.out.println(p.getClass().getName()); 	
		
		String str = "안녕";
		System.out.println(str);						
		System.out.println(str.toString());			
		
		String str2 = new String("안녕");
		System.out.println(str2);
		System.out.println(str2.toString());
        
	}
}

# 실행 결과
[오버라이딩] Person
[오버라이딩] Person
class Person
Person
안녕
안녕
안녕
안녕

 

 

parameter

인수 = 인자

가변 인자

[ 가변 인자 ] variable arguments
- JDK 1.5 부터 지원
- 선언 형태 :  type ... parameter
- 내부적으로 배열 생성
- 마지막 위치에 선언

public class parameterEx01 {

    public static void sum(int n1, int n2) {

        int sum = n1 + n2;
        System.out.println("덧셈 결과 >> " + sum);
    }
	
    // error : The variable argument type int of the method add must be the last parameter
    //	public static void add(int n1, int ... args, int n2) {
    //	}
    
	// 가변 인자
	// 인수가 정해져 있지 않은 매개변수
	public static void sum(int ... args) {
        System.out.println("\n** 가변 인자 **");
        System.out.println("args >> " + args);

        // inthancdeg loop[
        for (int ar: args) {
            System.out.print(ar + " ");
        }

        System.out.println();
		
	}
	
	public static void main(String[] args) {

        sum(3, 5);
        sum(1);
        sum(2, 4, 6);
        sum(1, 7, 9, 11);
	}
}

# 실행 결과
덧셈 결과 >> 8

** 가변 인자 **
args >> [I@5474c6c
1 

** 가변 인자 **
args >> [I@591f989e
2 4 6 

** 가변 인자 **
args >> [I@66048bfd
1 7 9 11

 

public class parameterEx02 {

	public static void sum(int[] args) {
		System.out.println("args : " + args);
		
		for(int ar: args) {
			System.out.print(ar + " ");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
//		sum();			// error : 인수 없음
//		sum(1, 2);		// error : type 불일치
//		sum({1, 2});	// error : new int[] 생략 불가능
		
		sum(new int[] {3, 5});
		sum(new int[0]); // 길이가 0인 배열
//		sum(null);    	 // 참조값 없음
	}
}

# 실행 결과
args : [I@f5f2bb7
3 5 
args : [I@591f989e

 

Wrapper Calss

<< 자동 형변환 >>

[ primitive type ] =======================================

byte - short - char - int - long

float - double

boolean

 

[ reference type ] wrapper class ===========================

Byte - Short - Character - Integer - Long

Float - Double

Boolean

기본형		참조형
primitive type	----> (boxing) <----> (unboxing)	reference type

public class WrapperClass {

	public static void main(String[] args) {
		
		int num = 3;
		Integer num2 = 5;
		System.out.println("num >> " + num);
		System.out.println("num2 >> " + num2);
		System.out.println("num2.toString() >> " + num2.toString());
		
		Integer num3 = num; // boxing
		int num4 = num3;	// unboxing
		
		System.out.println("num3 >> " + num3);
		System.out.println("num4 >> " + num4);
		
		Integer num5 = new Integer(7);
		Integer num6 = Integer.valueOf(7);
		System.out.println("num5 >> " + num5);
		System.out.println("num6 >> " + num6);
		
	}
}

# 실행 결과
num >> 3
num2 >> 5
num2.toString() >> 5
num3 >> 3
num4 >> 3
num5 >> 7
num6 >> 7

 

---

📍 24.04.09(화) 11일차

https://print-blue.tistory.com/148

JAVA 프로그래밍 기초 연습 문제 - 향상된 for문

https://print-blue.tistory.com/149

JAVA 프로그래밍 기초 연습 문제 - Parameter

 

Final

Final 
: 금지

cf) final ===========
final 변수
final 메서드
final 클래스
=====================

[ final 변수 ]
: 초기화한 값으로 변수의 값 고정
: 값 변경 금지
: 변수를 상수화(시켰다 라고 말함) ==> 상수 (constant)
: 이름 있음 (상수는 없지만 final 변수는 있다는 뜻)
: 변수명은 대문자로

[ literal ] 리터럴
: 값 그 자체
: 이름 없음

 

# 기존 코드

public class FinalEx01 {
	
	public static void main(String [] atgs) {
		
		// [ 지역 변수 ]
		// 변수 선언
		int num;
		
		// 변수 초기화
		num = 5;
		System.out.println("num >> " + num);
		
		// 변수 값 변경
		num = 10;
		System.out.println("num >> " + num);
	}
}

# final 변수 사용
public class FinalEx01 {
	
	public static void main(String [] atgs) {
		
		// [ 지역 변수 ]
		// final 변수 선언, 지역 변수니까 stack 영역에 저장
		final int num;
		
		// 변수 초기화
		num = 5;
		System.out.println("num >> " + num);
		
		// 변수 값 변경
		// num = 10;
		// System.out.println("num >> " + num);
	}
}

 

constuctor 생성자 단축키

알트 + 쉬프트 + s -> Generate Constuctor using Fields 선택

 

 

// constructor
public Item(int year, String name, String company) {
    super();
    this.year = year;
    this.name = name;
    this.company = company;
}

 

 

변수종류

	메모리 영역	메모리 할당 시기	초기화를 하지 않으면
local variable	stack	해당 영역이 실행	쓰레기 값
instance field	heap	인스턴스 생성될 때	0 or null
static field	static (class)	class 가 load(로드) 될 때	0 or null

 

static

 # StaticEx01.java
 
 * [ static ] 
 * - static(class) field ===========================================================
 * : class 가 메모리에 로드(load) 될 때, static(class) 영역에 할당
 * : 클래스명으로 관리 -> 클래스명으로 접근
 * : instance(object, 객체) 생성과 상관없이 접근(사용) 가능
 * 	--> 객체 생성과 상관없이 field 사용하고자 할 때
 * 
 * : [ 문법 ] 클래스명.필드명
 * : 해당 클래스로 생성된 객체들이 공유하는 변수
 * 
 * - static(class) method ==========================================================
 * : class 가 메모리에 로드(load) 될 때, static(class) 영역에 할당
 * : 클래스명으로 관리 -> 클래스명으로 접근
 * : instance(object, 객체) 생성과 상관없이 호출(사용) 가능
 * 	--> 객체 생성과 상관없이 method 호출(사용) 사용하고자 할 때
 * : static(class) 메소드 내에서는 static 멤버만 접근(사용) 가능
 * 	--> 생성(메모리 할당) 시기가 다름
 * 	--> static 멤버가 메모리 할당된 후, 객체 생성 시 instance 멤버가 메모리 할당 됨
 * 
 * : [ 문법 ] 클래스명.메서드명()
 * : 해당 클래스로 생성된 객체들이 공유하는 메서드

 

loading

하드 디스크에 있는 클래스 파일이 ram 메모리에 들어가는걸 load

클래스명으로 관리가 되고, 접근이 됨, 메모리 해제 되는 시기 : 프로그램 종료

 

class Number {
	
    // field : instance(object) field, static(class) field
    static int one; // 클래스가 로드될 때 제일 먼저 메모리에 할당
    int two;

    // constructor 
    public Number() {
    }

    public Number(int two) {
        this.two = two;
    }
	
}	

public class StaticEx01 {

	public static void main(String[] args) {

        System.out.println("[ static field ] one : " + Number.one);
        Number.one = 1;

        Number number = new Number();
        System.out.println("[ instance field ] two : " + number.two); // 참조변수 통해서 접근한 것

        // *** 권장 x ***
        // static field 는 static 방식으로 접근 : 클래스.멤버변수명
        // static 멤버가 먼저 저장되고, 주소가 있기 때문에 가져올 수 있지만,
        // static 으로 접근을 해야함 < number.one -> Number.one >
        System.out.println("one >> " + number.one); 				  
		
	}
}

 

 

공유 필드

지역 변수 -> instance field -> static field 순으로 찾음

class Baseball {
    // [ static(class) field ]
    static int count;

    // [ instance method ]
    void increment() {
        count++; // Baseball.count 이 아니라 같은 멤버라서 이렇게 쓰는 것
    }

    void decrement() {
        count--;
    }

    void basevallInfo() {
        System.out.println("현재 개수 : " + count);
    }
}

public class StaticEx02 {

	public static void main(String[] args) {
		
        System.out.println("개수 : " + Baseball.count);

        Baseball b1 = new Baseball();
        b1.increment();
        b1.basevallInfo();

        Baseball b2 = new Baseball();
        b2.increment();
        b2.basevallInfo();
        System.out.println("개수 : " + Baseball.count);
	
	}
}

 

class Animal {
	
    // [ field ] static final field
    // final field : 초기화한 값으로 값 고정 --> 값 변경 금지
    static final int COUNT = 5;
	
}

public class StaticEx03 {

	public static void main(String[] args) {

        // static int num; // stack 영역에 저장되는 지역변수가 static 영역에 못만듦


        System.out.println("동물 몇 마리 : " + Animal.COUNT);
        // Animal.COUNT = 10;	// error ! : final field
		
	}
}

class Person {
	
    // field
    static int count;  	// static field
    int age;		 	// instance field, non-static field

    // method
    // static method
    static void staticShow() {
        System.out.println("** static method staticShow() **");
        System.out.println("현재 인원 : " + count); // static field 접근 가능
        // static 영역에 없어서 없는 필드라 에러뜸, 객체가 생성되도 heap 영역에 생성
        // System.out.println("나이 :" + age);		// error ! : instance 필드라 접근 불가능

        staticMethod();			// static 	method 호출 가능
        // instanceMethod();	// instance method 호출 불가능 
    }

    static void staticMethod() {
        System.out.println("[ staticMethod ] 실행");
    }

    // instance method
    // 객체가 생성이 되면 메모리에 할당이 되는데, 선언과 동시에 할당된 static 영역에 있는 count 를 가져올 수 있음
    // 지역 변수 -> instance field -> static field 순으로 찾음
    void show() {
        System.out.println("** instance method show() **");
        System.out.println("현재 인원 : " + count); // static 	field 접근 가능
        System.out.println("나이 :" + age);			// instance field 접근 불가능

        staticMethod();		// static 	method 호출 가능 (미리 할당되었기 때문에 접근 가능)
        instanceMethod(); 	// instance method 호출 가능
    }

    void instanceMethod() {
        System.out.println("[ instanceMethod ] 실행");
    }
	
}

public class StaticEx04 {

	public static void main(String[] args) {

		Person p = new Person();
		
	}
}

 

class Cat {
	
    // field
    static int count;
    String name;

    // method
    static void showCount() {
        System.out.println("몇 마리 : " + count);
    }

    void setName(String name) {
        this.name = name;
    }

    void showInfo() {
        System.out.println("이름 : " + name);
    }
}

public class StaticEx05 {

	public static void main(String[] args) {

        // static 멤버 접근 =========================
        // 클래스명.멤버이름 
        Cat.showCount();		// static method
        Cat.count = 3;			// static field

        // instance 멤버 접근 =========================
        Cat cat = new Cat();
        cat.setName("미미");	// instance method
        cat.showInfo();			// instance method
	}
}

 

public class StaticEx06 {

	// [ 메서드 정의 ] ==============================
	// static 을 붙여야 하는 이유
	// : main 메소스도 static 영역에 들어가기 때문에 
	static void sum(int n1, int n2) {
		int result = n1 + n2;
		System.out.println("덧셈 결과 : " + result);
	}
	
	// [ main method ] ==============================
	public static void main(String[] args) {
		
		sum(1, 3);
	}
	
}

 

 

/*
 * ===================
 * |class 는 '자료형'|
 * ===================
 * 
 */

public class StaticEx07 {
	
    // static field
    // StaticEx07 도 자료형이기 때문에 class 파일이 참조 변수에 저장이 됨
    // new 인스턴스 객체는 객체 생성 시 heap 영역에 만들어짐
    static final StaticEx07 s = new StaticEx07();

    // instance field
    int num = 100;

    // instance method
    void show() {
        System.out.println("num >> " + num);
    }
	
	public static void main(String[] args) {

//		System.out.println(num);
		s.show();
	}
}

# 실행 결과
num >> 100

 

 

 

5) 상속

상속의 좁은 의미 = class 의 재사용

[ 객체 생성 순서 ]
1. 메모리 할당 : 부모 -> 자식
2. 생성자 실행 : 부모 -> 자식

부모의 원하는 것만 상속 받은 수 있는가 ? -> no, 무조건 다 받아야 함

overriding 과 overloading

class Parent {
	
    // [ field ] instance field 
    int money = 1_000_000; // 1,000,000 대신 1_000_000

    // [ constructor ]
    Parent () {
        System.out.println("[ Parent ] 생성자 실행"); // 확인용
    }

    // [ method ]
    void buy(int money) {
        this.money -= money;
        System.out.println("남은 돈은 " + this.money + "원 입니다.");
    }
    
}

class Child extends Parent {
	
    // constructor
    // 기본 생성자
    Child () {
        // 부모의 생성자 호출();
        super(); // 위에 있어야 되는 이유 : 생성자 호출은 반드시 생성자의 첫번째 라인에 있어야함
        System.out.println("[ Child ] 생성자 실행"); // 확인용
    }
    
    // [ method overriding ] 메소드 오버라이딩
    // : 메소드 재정의
    // : <상속 관계>에서 자식 class 가 부모 class 에 멤버 메소드를 재정의 한 것
    // : 부모 class 의 멤버 메소드의 선언부 그대로, 바디(기능)만 수정
    // : 선언부 그대로 - 반환명, 메소드명, 매개변수 정보가 같아야 함
    // 부모의 메소드를 안 쓰겠다는 거임, 기능이 마음에 들지 않을 때 재정의해서 쓰면 됨
	void buy(int money) {
		System.out.println("부모님 용돈 " + this.money + "원 주세요");
	}
    
    // [ method overloading ] 메소드 오버로딩
	// : 같은 이름의 메소드 여러 정의
	// : 단, 매개변수의 정보가 달라야 함
	// : 	 ---------------
	// :     자료형, 개수
	// : 반환형과는 관련 없음
	void buy() {
		System.out.println("용돈조 !! 용돈 !!!");
	}
    
}


public class InheritanceEx01 {

	public static void main(String[] args) {
        // child 의 기본 생성자 실행 요청 -> child 에 super 가 있음
        //  -> 부모 class 에 매개 변수가 없는 기본 생성자 실행 요청 -> 실행 완료 -> 자식의 생성자 실행 완료
        Child c1 = new Child(); 
        
        // child 에 일단 먼저 간 다음 buy 가 있으면 바로 실행이 되지만, 없으면 부모로 가서 실행
		// child 에 갔는데 부모도 자식도 같은 메소드 있다면(기능이 달라도), 자식 메소드를 사용
		c1.buy(10_0000); 
		c1.buy();
	}
}

# 실행 결과
[ Parent ] 생성자 실행
[ Child ] 생성자 실행
부모님 용돈 1000000원 주세요
용돈조 !! 용돈 !!!


[ 객체 생성 순서 ]
1. 메모리 할당 : 부모 -> 자식
2. 생성자 실행 : 부모 -> 자식

 

---