띠용

final

: 변경, 오버라이딩, 상속 등을 불가하게 제한하는 키워드

상수

: 변하지 않고 항상 일정한 값을 갖는 수

- 대문자로 표현(권장)

선언

- static final 키워드 사용

// static: 프로그램 시작 시 한 번만 초기화 후 모든 객체에서 공용

// final: 불변

불변 객체

: 내부 상태를 변경할 수 없는 객체

방법: 필드 final로 선언

public final class Circle {
    
    private static final double PI = 3.14159;
    private final double radius;

    public Circle(double radius)
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public double getArea() {
        return PI * radius * radius;
    }

    public double getPerimeter() {
        return 2 * PI * radius;
    }
}

Static

: 모든 객체가 공용하는 변수, 메서드 생성 시 사용하는 키워드

- 메모리 절약에 기여

클래스 멤버

: 객체를 생성하지 않고도 클래스 자체로 접근할 수 있는 멤버(static으로 선언된 변수와 메서드)

특징

- 클래스 변수(static var), 클래스 메서드(static method)는 한 번만 생성

- 공용o

- Method Area에 저장

- static 메서드에서 인스턴스 변수에 접근 불가

          => 객체 생성 후 접근 가능

public class Main {
    public static void main(String[] args) {

        Person p1 = new Person();
        p1.age = 20;

        // Person.age = 10;
        Person.s_age = 10;
    }
}
class Person {
    int age;
    static int s_age;
}

사용

// 객체 생성 불필요

- 클래스명.변수

- 클래스명.메서드();

public class Main {
    public static void main(String[] args) {
        System.out.println("static 변수: " + Person.population);
        Person.printPopulation();
    }
}
class Person {
    static int population = 0;

    static void printPopulation() {
        System.out.println("현재 인구 수: " + population);
    }
}

인스턴스 멤버

: 객체를 만들 때마다 생성되는 변수와 메서드

특징

- 객체 생성 후에만 사용 가능

- 공용x

- Heap Area에 저장

사용

- 객체 생성 필요

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();

        p1.age = 10;
        p1.getAge();

        p2.age = 20;
        p2.getAge();
    }
}
class Person {
    int age;

    void getAge() {
        System.out.println(age);
    }
}

참조형

: 값이 저장되어 있는 곳의 메모리 주소를 저장하는 타입

- 해당 타입의 변수(참조형 변수)는 참조값의 주소를 저장

특징

- null 개념 존재

- 변경 시 동기화

예시

- 객체, 배열, 문자열 등

메모리 구조

- 힙 영역에 참조값 저장 후 참조

파라미터: 참조형변수

- 출력값: 클래스명@해시코드     // 객체 식별자o     실제 메모리 주소x

파라미터: 참조형변수.속성

- 출력값: 값

Person p = new Person("Stever");
System.out.println(p.name);	//p는 Person 객체의 주소를 저장, 그 주소의 name 필드의 값을 출력
System.out.println(p);	//Person 객체의 주소를 출력(물리적 메모리 주소는 아니고 객체 식별 정보)

래퍼클래스

: 기본 자료형을 객체로 감싸는 클래스

래퍼클래스 변수(참조형 변수)

- 출력값: 값

- 이유: toString() 오버라이딩해서 객체가 가진 값을 그대로 출력하도록 함

// 변수는 주소를 저장

선언 및 할당

1) 래퍼클래스 변수명 = 값; // 오토박싱 덕분에 2)의 방식 필수x

2) 래퍼클래스 변수명 = new 래퍼클래스(값);     // 오토박싱: 위 코드를 내부적으로 수행

필요성

: 기본형과 달리 속성, 기능을 제공해 데이터 처리 용이

커스텀 래퍼클래스(Integer)

class customInteger{
	int value;
    
	CustomInteger(int value){
    	this.value = value; //this.value는 customInteger의 value, value는 파라미터
    }

	int getValue(){
    	return value;
    }
	
    void setValue(int value){
    	this.value = value;
    }

	@Override
    public String toString(){
    	return String.valueOf(value);
    }
}

오토박싱: 기본형 -> 래퍼 클래스

int i = 10;
Integer j = i;	// Integer j = new Integer(n) 또는 Integer.valueOf(n)과정이 컴파일러에 의해 내부적으로 수행

오토언박싱: 래퍼 클래스 -> 기본형

Integer i = 10;
int j = i;	//int j = i.intValue()과정이 컴파일러에 의해 내부적으로 실행됨

NullPointerException

: 객체가 null인 상태인데 메서드 호출을 시도할 때 발생하는 문제

Integer i = null;
//intValue()메서드 호출 => NullPointerException 발생
int j = i;

- 해결책

1) null 체크 후 null이 아닌 경우에만 사용

2) Optional 사용(null )

- Optional<Integer>: 정수형이 있을 수도 없을 수도 있음을 의미

Integer i = null;
Optional<Integer> opt = Optional.ofNullable(i);
int j = opt.orElse(0); // null이면 0으로 처리

기본형

: 자바에서 미리 형식을 정의하여 제공하는 타입

- 기본값 존재(null x)

필요성

: 빠른 작업, 연산에 용이(래퍼 클래스는 연산 시 추가작업 발생하므로 느림)

Method Area

: .java파일의 데이터 즉 클래스의 정보가 저장되는 영역

특징

     - 프로그램 실행 시점에 한 번만 저장

     - method 영역의 데이터는 프로그램 전체에서 공용 가능

Stack Area

- 메서드가 호출될 때마다 Stack 영역에 메모리 할당

- LIFO(후입선출) 구조

- 메서드 시작 시 추가, 종료 시 메모리에서 제거

- 메서드 내 선언된 지역변수가 저장되는 영역

- 변수에 객체 담기면 객체의 Heap 메모리 주소를 저장

Heap Area

- 객체가 생성돼 저장되는 영역

- Stack Area의 변수가 Heap 영역의 객체를 참조

- GC가 필요없는 객체 정리해 메모리 확보

변수

선언 및 할당: 데이터 타입 변수명 = 리터럴;

                         int          a         =    1;

리터럴: 프로그램에서 직접 표현한 값

1. 정수 리터럴

2. 실수 리터럴

/*

과학적 표기법

형식: aEb

- a = 소수 또는 정수

- b = 지수

- E = x 10의 제곱을 뜻하는 지수 표기

*/

3. 문자 리터럴

- 인코딩, 디코딩 방식: 유니코드 따름

/*

유니코드

: 전 세계 모든 문자를 하나의 코드 체계로 통일한 표준

형식: U+(4자리 16진수)

- Basic Latin: U+0000 ~ U+007F

- 한글: U+AC00 ~ U+9FFF

- 이모지: U+1F600 ~ U+1F64F     // 범위 확장한 것

인코딩(자바_UTF-16방식 기준)

: 문자, 텍스트를 이진수로 변환하는 과정

이유: 컴퓨터가 처리 가능하게 하기 위함

EX) 'A': UTF-16 인코딩을 사용해 2바이트로 저장

     - 'A'의 유니코드 값: U+0041 

     - 10진수: 65     -> 2진수: 1000001

     => 00000000 01000001

디코딩 (자바_UTF-16방식 기준)

: 인코딩된 데이터를 원래 문자로 되돌리는 과정

방식: 2바이트를 읽고 유니코드 코드 포인트 얻음 -> 문자로 변환

*/

4. 문자열 리터럴

5. 논리 리터럴

- 0: false, 1: true로 사용 불가

6. null 리터럴

- null로 초기화 가능한 타입: 참조형          (즉, 기본형은 null로 초기화 불가)

1) 클래스 타입

     - String, Object, 사용자 정의 클래스, 래퍼 클래스          (래퍼 클래스: 기본형의 객체 버전)

2) 인터페이스 타입

3) 배열 타입

형 변환(casting)

1. UpCasting

: 묵시적 형 변환(작은 데이터 -> 큰 데이터)

방식: 자동

int a = 10;
double b = a;	// int가 double로 자동 형 변환

2. DownCasting

: 명시적 형 변환

double d = 3.141592;
int i = (int)d;	//3

메서드

구조

- 클래스 내에 위치

- camelCase로  이름 사

1. 반환타입: void

void 메서드명(파라미터1, 파라미터2...){
	실행코드
}

2. 반환타입: void 외 나머지

- return값의 타입이 메서드의 반환자료형과 동일

반환자료형 메서드명(파라미터1, 파라미터2...){
	실행코드
    return 반환값
}

메서드 활용

1. 객체 생성

클래스명 객체명 = new 생성자();

2. 함수 호출

객체명.함수(파라미터);

배열(Array)

선언

방법1) 자료형[] 변수명 = new 자료형[배열 길이];

방법2) 자료형[] 변수명;     변수명 = new 자료형[배열 길이]

// 배열 길이: 변수명.length();

// 정적 배열 => 길이 변경 불

접근

- 인덱스

: 0부터 시작

- ArrayIndexOutOfBoundsException

: 배열 범위를 벗어난 요소에 접근 시 에러 발생

- 탐색

: System.out.println(변수명[인덱스]);

- 삽입, 수정

: 변수명[인덱스] = 값;

2차원 배열

형식: 자료형[][] 변수명 = new 자료형[행 길이][열 길이]

연산자

기본 연산자

우선순위

산술 -> 비교 -> 논리 -> 대입

비교 연산자

우선순위

산술 후 비교

논리 연산자

우선순위

! -> && -> ||

조건문

if문, if-else문, else if문

if(){
	실행코드
}
else if(){
	실행코드
}
else{
	실행코드
}

switch case문

switch (){
	case 값:
    	실행코드
        break;
    case 값:
    	실행코드
        break;
    case 값:
    	실행코드
        break;
	default:
    	실행코드
}

반복문

for문

for(시작 조건; 종결조건; 조건 변화 수식){
	실행코드
}

/*반복 탈출하기

1. break

- 반복문을 벗어남

2. continue

- 건너뜀

*/

향상된 for문

- 배열에서 하나씩 꺼내 변수에 저장

for(int 변수명 : 배열명){
	실행코드
}

while문

- 조건 체크 후 반복

- 조건이 false가 될 때까지 반복

while(조건){
	실행코드
}

do-while문

- 반복 후 조건 체크

- 조건이 false가 될 때까지 반복

do{
	실행코드
}while(조건)

클래스

- 구조

: 속성, 생성자, 함수

class 클래스명{
    필드
    
    생성자
    
    함수
}

- 접근

1) 객체 생성

클래스명 객체명 = new 생성자;

2) 객체 통해 접근

Person person = new Person();
System.out.println(person.name);	// person객체의 name 변수에 접근

생성자

: 객체를 어떻게 만들지 정의해 놓은 것

- 사용자가 생성자 직접 정의 시 기본 생성자 자동 제거

/*this 키워드

: 객체 자신을 가리키는 키워드

*/

메서드

- Getter: 속성을 가져오는 메서드

String getName(){
	return this.name;
}

- Setter: 속성을 설정하는 메서드

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

Input/Output

Input

Scanner 객체

1) java.util.Scanner를 import

import java.util.Scanner;

2) Scanner객체 생성

Scanner sc = new Scanner(System.in);

3) 객체의 메서드를 적절히 활용하여 입력 받음

int a = sc.nextInt();	//정수
double d = sc.nextDouble();	//실수
long l = sc.nextLong();	//정수
String s = sc.nextLint();	//문자열

Output

1. System.out.print();     <->    System.out.println();

: 출력 메서드(개행X)                     : 출력 메서드(개행O)

- 파라미터: 참조형, 기본형

2. System.out.printf()

- 서식 지정자를 통해 값을 특정 형식으로 출력할 수 있게 하는 메서드

방식: 형식 문자열 내에 서식 지정자를 넣고 그 자리에 값을 삽입

BufferedReader / BufferedWriter

예외처리

: throws IOException 필수

- 이유: readLine()에 입력된 값이 null일 경우 IOException을 반환하기 때문이다.

import java.io.IOException;

public class Main{
    public static void main(String[] args) throws IOException{
	    //코드
    }
}

BufferedReader

1) java.io.BufferedReader와 java.io.InputStreamReader를 import(ctrl + shift + o 이클립스 자동 import)

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

2) BufferedReader 객체 생성

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

3) readLine()을 통해 입력을 받음

String s = br.readLine();

- 다른 타입 원하면 형변환 필수(리턴값(고정): String)

- 예외 처리 필수

          방법 1) throws IOException(추천)

               (1) import java.io.IOException;

               (2) public static void maint(String[] args) throws IOException{}

          방법 2) try & catch

- 공백단위 가공 시(읽어들인 데이터가 Line 단위로만 분리되기 때문)

          방법 1) StringTokenizer의 nextToken 함수 사용(추천)

               (1) import java.util.StringTokenizer;

               (2) StringTokenizer 객체 생성

               (3) nextToken()을 사용해 공백 단위로 구분된 데이터 할당

//입력: 10 20
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());	// 10
int b = Integer.parseInt(st.nextToken());	// 20

          방법 2) String.split() 사용

String s = br.readLine();
String[] words = s.split(" ");

BufferedWriter

1) java.io.BufferedWriter과 java.io.OutputStreamWriter를 import(ctrl + shift + o 이클립스 자동 import)

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;

2) BufferedWriter 객체 생성

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

3) write()을 통해 버퍼 내 값 출력

// 숫자를 출력하고자 한다면 형변환이 필요하다.

String s = br.readLine();
bw.write(s);

Int a = Integer.parseInt(br.readLine());
bw.write(Integer.toString(a));

4) flush() / close()로 뒤처리

flush(): 남아있는 데이터 모두 출력(스트림 비움)

close(): 출력 스트림 닫음

+ BufferedWriter의 메서드

1) 개행: newLine()

bw.newLine();	// 개행

2) char 배열의 일정 구간 출력: write(배열명, 시작점, 길이)

char[] bf = {'h', 'e', 'l', 'l', 'o'};
writer.write(bf, 0, 5); //hello

3) 문자열의 일정 구간 출력: write(문자열명, 시작점, 길이)

String s = "hello";
writer.write(s, 0, 5); //hello

4) 한 글자 출력: write(int c)     //유니코드

writer.write(65);	//A