[Java] 자바 기본 프로그래밍

MINJEE·2023년 12월 18일
Java

SMHRD_8_Java

목록 보기
1/10
post-thumbnail

🔷패키지 (Package)

  • 서로 관련된 클래스들을 분류하여 묶어 놓은 것
  • 계층 구조, 폴더 개념과 유사
  • 패키지를 사용하는 이유 : 클래스명이 충돌하지 않도록 클래스명의 유일성을 보장하기 위해서
  • 실무에서 주로 회사 URL을 반대로 패키지명을 생성한다.
  • 패키지명 : [상위패키지명].[하위패키지명]
    • 온점(.)으로 패키지명을 구분
    • 폴더 개념으로, 상위 패키지 폴더 안에 하위 패키지 폴더가 존재
  • 클래스 생성 후, 작업 폴더 안에 위와 같은 경로로 들어가면 생성한 클래스의 자바 원본 파일(.java) 생성되어 있다.
  • 실행 파일(.class)는 bin폴더 하위의 같은 경로에 생성되어 있다.

🔷자바 클래스의 기본 구조

package j231218;  // 패키지 선언부

public class BasicStructure {  // 클래스 선언
	
    // 메소드(함수) 선언
	public static int sum(int n, int m) {
		return n+m;
	}
    
    // main() 메소드
	public static void main(String[] args) {
		// 변수 선언
        int i = 20;
		int s;
		
		s = sum(i, 10); // sum()메소드 호출
		System.out.println(s);
	}

}
  • 패키지 선언 : 패키지는 소스 코드 파일의 맨 위에 선언
    • 다른 패키지에 속하는 클래스를 사용하기 위해서는 해당 패키지를 import해야 한다.
  • 클래스 선언 : class 키워드로 클래스 선언
    (public으로 선언 시 다른 클래스에서 접근 가능)
  • 변수 선언 : 메소드 내에서 선언된 변수는 지역변수
    (메소드 실행이 끝나면 저장공간 반환)
  • 메소드(함수) 선언 : main() 메소드에서 호출되기 전에는 선언만 되고 메모리 차지 없음
    • main() 메소드에서 호출되면, 반환 값 반환할 때까지 메모리를 차지하고 사라짐
  • main() 메소드
    • 자바 프로그램은 main()메소드에서 실행 시작
    • main()메소드는 한 클래스 안에 하나만 존재!
    • 실행이 시작되면 main()메소드는 메모리 공간을 차지
      → main() 메소드가 끝나면 메모리 초기화
    • 변수 선언 시, main() 메소드의 메모리 공간 안에 변수 공간 생성
      • 예외 : 문자열은 따로 저장되는 임시 기억 공간인 heap에 저장되고, 변수 공간은 heap을 가리킴

🔷식별자 (Identifier)

: 변수, 상수, 메서드, 클래스 등의 이름을 지정하는 데 사용되는 단어나 문자열
  • 원칙
    • 특수문자, 공백, 탭은 사용 불가능 But, _, $는 사용 가능
    • 유니코드 문자 사용 가능, 한글 사용 가능 But, 되도록 영문으로 사용하자!
    • 키워드(if 등)는 사용 불가능
    • 식별자의 첫번째 문자는 숫자는 사용 불가능 → 영문자, _ , $ 로 시작
    • 불린(true,false) 와 null 사용 불가능
    • 길이 제한 없음
    • 대소문자 구별
      • int barChart; 와 int barchart; 는 서로 다른 식별자
    • 일반적으로 카멜(Camel) 표기법 사용
      • 카멜 표기법 : 여러 단어가 이어져 있는 경우, 첫 단어는 소문자로 시작하고, 그 이후의 단어들은 첫 문자를 대문자로 표기

🔷데이터 타입 (DataType)

🔹기본형(Primitive Type)

  • 크기는 CPU나 운영체제에 따라 변하지 않음
  • 메모리에 실제 값을 저장
  1. 논리형 - boolean(1바이트)
  2. 문자형 - char(2바이트)
  3. 정수형 - byte(1바이트), short(2바이트), int(4바이트), long(8바이트)
  4. 실수형 - float(4바이트), double(8바이트)
  • 문자열은 기본 타입이 아님!

🔹참조형(Reference Type)

  • 용도는 3가지
  • 객체의 메모리 주소를 저장하는 변수
  • 클래스, 인터페이스, 배열 등
  • 해당 객체의 데이터와 메서드에 접근 가능
  • String : 자바에서 제공하는 클래스, 문자열 데이터를 다루는 데 사용
    • 실제 문자열 데이터를 직접 저장하지 않고, 문자열 데이터가 저장된 객체의 주소를 참조
    • main메소드 메모리에 저장되지 않고, heap이라는 임시 기억공간에 저장 → String 클래스로 문자열을 표현

🔷변수 (Variable)

: 값을 저장하기 위해 사용되는 이름이 있는 메모리 공간
: 프로그램 실행 중 값을 임시 저장하기 위한 공간
  • 변수 선언 : 데이터타입 변수명; (ex. int a;)
  • 변수는 데이터 타입과 함께 선언된다.
  • 선언된 데이터 타입에 맞는 값을 저장할 수 있다.
  • 프로그램 실행 중에 값 변경 가능하다.
int age; // 변수 age를 선언
age = 25; // 변수 age에 값 25를 할당 (초기화)
int age = 25; // 변수 age 선언과 초기화 동시에 진행

🔷리터럴(literal)

: 프로그램에서 직접 표현한 값
: 소스 코드에서 고정된 값을 나타내는 것으로, 직접 값을 표현하는 것
  • 예를 들어, 정수 리터럴은 숫자로 표현되고, 문자열 리터럴은 큰따옴표(")로 둘러싸인 문자열로 표현
    • ex. int a = 3; 에서 3은 리터럴
  • 정수, 실수, 문자, 논리, 문자열 리터럴
int age = 25; // 정수 리터럴 25
double pi = 3.14; // 실수 리터럴 3.14
char grade = 'A'; // 문자 리터럴 'A'
String name = "John"; // 문자열 리터럴 "John"
boolean isTrue = true; // 논리 리터럴 true
  1. 정수 리터럴 : 10진수, 8진수, 16진수, 2진수 리터럴(int타입으로 컴파일), Long타입 리터럴
int n = 15; //10진수 리터럴 15
int m = 015; //8진수 (10진수로 8*1 + 1*5 = 13)  //영문자O가 아닌, 숫자0임!!
int k = 0x15; //16진수 (10진수로 16*1 + 1*5 = 21)
int b = 0b0101; //2진수 (10진수로 4*1 + 2*0 + 1*1 = 5)

long g = 24L; //long타입 리터럴 : 숫자 뒤에 L 또는 l을 붙여서 표시

2진수로 바꾸기
: 8진수는 2진수의 3자리씩 8진수의 1자리,
16진수는 2진수의 4자리씩 16진수의 한자리

  • ex. 16(10) → 00010000(2)
  • ex. 16(8) → 001 110(2)
  • ex. 16(16) → 0001 0110(2)
  1. 실수 리터럴 : double타입, float타입으로 컴파일
double d = 0.1234;
double e = 1234E-4; //1234*(10의 -4승) = 0.1234 과 동일

// 숫자 뒤에 f(float)나 d(double)을 명시적으로 붙이기도 함(생략하면 double타입)
float f = 0.1234f;
double w = 0.1234D; //0.1234와 동일
  1. 문자 리터럴 : 단일 인용부호(’ ’)로 문자 표현
char a = '글';
char b = 'W';
char c = \uae00;  // \u 다음에 4자리 16진수로 2바이트의 유니코드

  1. 특수문자 리터럴 : 백슬래시(\)로 시작

    • \b :백스페이스
    • \t : 탭
    • \n : 라인피드
    • \f : 폼피드
    • \r : 캐리지 리턴
    • \” : 이중 인용부호
    • \’ : 단일 인용부호
    • \\ : 백슬래시)

  2. null 리터럴 : 레퍼런스에 대입 사용
    (기본타입에 사용불가)

int n = null; // 사용불가능 (int형은 기본 타입)
String str = null; // 가능
  1. 문자열 리터럴 : 이중 인용부호로 묶어 표현
String str = "Good";

🔷상수(Constant)

: 변하지 않는 값을 나타내는 식별자
  • 한 번 정의된 값이 변경되지 않아야 하는 경우에 사용
  • 주로 프로그램에서 고정된 값이나 설정값을 나타내는 데 사용

🔹상수 선언

  • final 키워드 사용
  • 선언 시 초기값 지정, 변경 불가능
  • final 데이터타입 상수명 = 초기값;
  • 상수는 대문자로 작성하는 것이 관례
  • 단어 사이를 언더스코어(_)로 구분하는 스네이크 케이스(Snake Case) 표기법이 일반적
// 예시
final int MAX_SIZE = 100;

🔹클래스 상수 선언

  • static 키워드와 final 키워드를 함께 사용
  • 클래스 상수 : 해당 클래스의 인스턴스가 생성되기 전에 이미 메모리에 상주하며, 클래스 전체에서 공유되는 값
  • static final 데이터타입 상수이름 = 값;
  • 클래스 이름으로 접근 가능
// 예시
public class MathUtil {
    public static final double PI = 3.14159;
}

🔷타입 변환 (Type Conversion)

: 한 데이터 타입을 다른 데이터 타입으로 변환하는 과정

🔹자동(Automatic) 타입 변환

: 원래의 타입보다 큰 타입으로 자동 변환

  • 작은 크기의 데이터 타입은 큰 크기의 데이터 타입으로 안전하게 변환될 수 있기 때문에 별도의 캐스팅(casting) 연산자가 필요하지 않음
  • 데이터 손실 없이 안전하게 이루어짐
long m = 25;  //25는 int타입이 long타입으로 자동 변환
double d = 3.14*10;  //실수연산을 위해 10이 10.0으로 자동 변환

byte b = 127;
int i = 100;
System.out.println(b+i);  //227, b가 int타입으로 자동변환

🔹강제(Explicit) 타입 변환 (=Casting)

: 개발자의 의도적 타입 변환

  • 큰 크기의 데이터 타입을 작은 크기의 데이터 타입으로 변환하는 것
  • 데이터 손실이 발생할 수 있으므로, 개발자가 명시적으로 타입 캐스팅 연산자를 사용하여 변환을 수행
int n = 300;
byte b = n;  //오류 : int타입이 byte로 자동변환 안됨
byte b = (byte)n;  //강제 변환 (값 손실 우려)

double d = 1.9;
int n = (int)d;  //강제 변환 => n=1(소수점 이하 0.9 손실)

System.out.println((int)2.9 + 1.8); // 2+1.8=3.8 (2.9를 int형으로 강제변환)

🔷표준 입출력 스트림

: 프로그램과 외부 환경(사용자 또는 파일) 간의 데이터 흐름을 처리하는 데 사용되는 스트림

🔹표준 출력 스트림(System.out)

  • 콘솔에 데이터를 출력하는 출력 스트림
  • System.out.println('출력 내용'); : 출력 후 다음 행으로 커서 이동
  • System.out.print('출력 내용'); : 출력 (다음 행으로 이동x)
  • System.out.printf('출력서식', '출력내용'); : 출력내용을 출력서식에 따라 출력 (다음 행으로 이동x)
    • 출력 서식 : %[-][0][전체자리수][.소수점이하자리수]지시자
      • - : 전체 자리수가 지정되면 왼쪽 정렬하고 오른쪽 빈칸에 공백 (기본값(-생략) : 오른쪽 정렬)
      • 0 : 전체 자리수가 지정되면 남은 공백에 0을 대입
      • 지시자 : b(논리), d(정수), o(8진수), x(16진수), f(실수), c(문자), s(문자열), n(줄바꿈), e(지수 형식)
    • ex. System.out.printf("%04x%n",a); : 16진수로, 전체 4자리, 공백은 0으로 채워서, 마지막 줄바꿈

예시

public class Main {
    public static void main(String[] args) {
        int age = 25;
        double height = 175.5;
        char grade = 'A';
        String name = "John";

        System.out.printf("이름: %s%n", name);
        System.out.printf("나이: %d세%n", age);
        System.out.printf("키: %.1fcm%n", height);
        System.out.printf("학점: %c%n", grade);
    }
}

출력 결과

이름: John
나이: 25세
키: 175.5cm
학점: A

🔹표준 입력 스트림(System.in)

  • 키보드로부터 데이터를 읽는 입력 스트림
  • 입력되는 키 값을 공백을 기준으로 구분되는 토큰 단위로 읽음
    • 공백 : ‘\t’, ‘\f’, ‘\r’, ‘ ‘, ‘\n’
  • 데이터타입 변수명 = System.in.read(); : 입력받은 것을 변수에 대입
  • 보통 java.util.Scanner 클래스와 함께 사용되어 사용자의 입력을 받을 때 주로 사용
    • Scanner 클래스 : 읽은 바이트를 다양한 타입으로 변환하여 리턴
import java.util.Scanner; // Ctrl+Shift+영문자O 로 자동 import 가능

public class ScannerEx{

	public static void main(String args[]){
    	Scanner 스캐너객체명 = new Scanner(System.in);  // Scanner 객체 생성
		
        String 스캐너객체명.next(); // 다음 토큰을 문자열로 리턴
        byte 스캐너객체명.nextByte();  // byte타입으로 리턴
        short 스캐너객체명.nextShort();  // short타입으로 리턴
        int 스캐너객체명.nextInt();  // int타입으로 리턴
        long 스캐너객체명.nextLong();  // long타입으로 리턴
        float 스캐너객체명.nextFloat();  //float타입으로 리턴
        double 스캐너객체명.nextDouble();  //double타입으로 리턴
        boolean 스캐너객체명.nextBoolean();  //boolean타입으로 리턴
        String 스캐너객체명.nextLine();  // '\n'을 포함하는 한 라인을 읽고, '\n'제외한 나머지를 리턴
        boolean 스캐너객체명.hasnext();  // 현재 입력된 토큰이 있으면 true, crtl+z 키 입력되면 입력 끝이므로 false 리턴
        
        스캐너객체명.close();  // Scanner 사용 종료
	}
}

🔷연산자

a > n
→
a>n은 식(expression),
a와n은 피연산자(operand),
>는 연산자(operator)

  • 산술 연산자 : +(더하기), -(빼기), *(곱하기), /(나누기), %(나머지)
    • 몫 : / 이용 (정수형/정수형 = 몫)
  • 비트 연산자 : &,|,^,~
    • a&b : a,b의 각 비트들의 and연산
      ex. 1100(2) & 1010(2) → 1000(2)
    • a|b : a,b 각 비트들의 or연산
      ex. 1100(2) | 1010(2) → 1110(2)
    • a^b : a,b 각 비트들의 XOR연산, 비트가 서로 다르면1, 같으면0
      ex. 1100(2) ^ 1010(2) → 0110(2)
    • ~a : a의 각 비트들에 not연산
      ex. ~1100(2) → 0011(2)
    • // 예제 : 냉장고 8개 센서 중 냉장고 온도가 0도 이상으로 올라가면 비트3이 1, 이하이면 0을 유지할 때
		// 현재 냉장고의 온도가 0도 이상인지 판단하는 코드는?
byte flag = 0b00001010;  // 냉장고의 8개의 센서
// flag & 0b00001000 : 3비트를 제외한 나머지는 0비트를 반환하고
									// 3비트는 flag의 3비트가 1이면 1을, 0이면 0을 반환
if ( flag & 0b00001000 == 0 ): // flag의 3비트가 0일 때
		System.out.print("온도는 0도 이하");
else  // flag의 3비트가 1일 때
		System.out.print("온도는 0도 이상");
  • 시프트 연산자 : >>,>>>,<<
    • a>>b : a의 각 비트를 오른쪽으로 b번 시프트, 빈자리는 시프트 전의 최상위 비트로 채움
      • 최상위 비트는 양수이면 0, 음수이면 1
      • 10진수로 a ÷ 2의 b승 효과
    • a>>>b : >>와 동일, But 빈자리는 0으로 채움
    • a<<b : a의 각 비트를 왼쪽으로 b번 시프트, 빈자리는 0으로 채움
      • 10진수로 a ⨯ 2의 b승 효과
  • 비교 연산자 : <,>,<=,>=,==,!=
  • 논리 연산자 : !,^,||,&&
    • !a : a가 true이면 false, false이면 true
    • a^b : a,b같으면 false
    • a||b : a,b 중 하나라도 true이면 true
    • a&&b : a,b 모두 true이면 true
  • 대입 연산자 : =,+=,-=,*=,/=,%=,&=,^=,|=,<<=,>>=,>>>=
  • 증감 연산자 : a++, a--, ++a, --a
    • 증감연산자가 변수 뒤에 있으면(a++,a- -) : a를 먼저 사용한 후에 1 증가/감소
    • 증감연산자가 변수 앞에 있으면(++a, - -a) : a를 먼저 증가/감소 한 후에 사용
    • int a, b = 4;
a = b++ * 3; //a=12, b=5 (b*3을 a에 대입한 후에 b를 1증가)
a = ++b * 3; //a=15, b=5 (b를 1증가 시킨후 *3을 a에 대입)
  • 조건(삼항) 연산자 : 조건?값1:값2

    • 시간복잡도를 줄이기 좋은 연산!!!

    • 조건이 참이면 값1, 거짓이면 값2를 반환

      int big;
if (x>y)
		big = x ;
else
		big = y ;

// if-else를 조건연산자로 간결하게 표현가능
int big = (x>y)?x:y ;

🔷조건문 IF

단순 if문

if(조건식) {
	실행문장;  //조건식이 참인 경우
}

if-else문

if(조건식) {
	실행문장1;  //조건식이 참인 경우
else {
	실행문장2;  //조건식이 거짓인 경우
}

if-else if-else문
(조건문이 너무 많은 경우, switch문 사용 권장)

if(조건식1) {
	실행문장1;  //조건식1이 참인 경우
}
else if(조건식2) {
	실행문장2;  //조건식2가 참인 경우
}
else if(조건식3) {
	실행문장3;  //조건식3이 참인 경우
} ...
else {
	실행문장n;  //앞의 모든 조건이 거짓인 경우
}

🔷switch문

switch(식) {
	case 값1:
		실행문장1;  //식의 결과가 값1일 때
		break;
	case 값2;
		실행문장2;  //식의 결과가 값2일 때
		break;
		...
	default:  //어느 값과도 같지 않을 때 (생략가능)
		실행문장n;
}
  • case 여러 값에 실행문장 하나 적용 가능
  • //예제 : 월을 입력받아 봄, 여름, 가을, 겨울을 출력
import java.util.Scanner;
public class Season {
		public static void main(String[] args) {
				Scanner a = new Scanner(System.in);
				System.out.print("월(1~12)을 입력하시오:"); int month = a.nextIn(); 
				switch(month) {
						case 3: case 4: case 5:
								System.out.println("봄입니다");
								break;
						case 6: case 7: case 8:
								System.out.println("여름입니다");
								break;
						case 9: case 10: case 11:
								System.out.println("가을입니다");
								break;
						case 12: case 1: case 2:
								System.out.println("겨울입니다");
				}
		}
}

🔷반복문

for문

for(초기문; 조건식; 반복 후 작업) {
	반복문장;
}

while문

while(조건식) {
	반복문장;
}

do-while문

do {
	반복문장;
} while(조건식);
  • continue; : 반복문을 빠져 나가지 않고, 다음 반복으로 제어 변경
  • break; : 하나의 반복문을 즉시 벗어남
    • 중첩 반복문일 때, 안쪽 반복문 안에서 break; 실행되면 안쪽 반복문만 벗어남
profile
MINJEE
개발, 분석 배운 내용 정리하기!
다음 포스트

[Java] 배열

1개의 댓글

comment-user-thumbnail
서민국
2023년 12월 22일

정말 좋은 내용이네요 잘 보고 갑니다~

답글 달기