상상코딩

신호등 앞에만 서면 사람들은 파랑과 빨강의 표시등을 바라본다

빨간불이면 언제 파란불로 바뀌는지 조급해 하고...

파란불이면 빨간불로 바뀌지 않을까 초조해 한다

인생도 비슷하리라

좌절하고 불행한 시기에 서 있으면 행복이 과연 언제 올지 조급해 한다

행복을 즐기고 있는 시기에는 언제 이 행복이 떠나갈까 초조해 한다

.

.

.

신호등 앞에서 무심히 서 있어 보라

빨강, 파랑의 색깔을 바라보지 말고...

나의 생각과 내가 가지고 있는 무엇인가에 집중해 보라

집중하여 무엇인가를 하고 있으면...

자연스럽게 빨간불에서 파란불로 바뀌어 건너갈 수 있으리라

집중하여 무엇인가를 하고 있으면...

파란불에서 빨간불로 바뀌어 잠시 쉬어갈 수 있으리라

.

.

.

삶에 과정에서 잠시 쉬어가고 건너가다 보면

어느덧 내가 향하던 길의 끝에 갈 수 있으리라

1. 상수(Constant)

• 변수와 같이 값을 저장하는 공간이지만, 입력된 값을 변경할 수 없는 고정된 값을 의미한다
• 변수의 타입 앞에 final 을 붙여서 사용한다
• 상수의 참조변수명은 일반적으로 대문자로 사용하며, 언더스코어 '_'를 넣어서 구분한다
• 값을 한 번만 저장할 수 있다

final int A_B = 3.141592;
final double B_C = 3.141592;

final int A_B;   //상수를 선언한다 
A_B = 3.141592;  //한번에 한하여 값을 저장할 수 있다
A_B = 3          //변경이 불가하므로 에러가 발생한다

 1) 상수의 사용 목적

• 프로그램 실행 시 값이 변하면 안되는 경우에 사용한다
  - 실수로 값을 재할당 할 경우 에러가 발생하여 문제 발생을 차단할 수 있다
• 고정된 값의 상수명을 사용하여 코드의 효율을 높인다
• 코드의 여러 부분에 상수를 사용한 후 값을 변경할 때 상수 한 개의 값만 변경해 주면 된다

2. 리터럴(Literal)

• 변수의 값 자체를 가르킨다
• float 타입의 변수에 실수형 리터럴을 할당할 때, 접미사 f를 붙여준다
• long 타입의 변수에 정수형 리터럴을 할당할 때, 접미사 L을 붙여준다
• 소문자 l을 붙여도 되지만, 숫자와의 혼동을 방지하기 위해 보통 대문자 L을 사용한다

1. 문자열 변환 후 저장

 1) StringBuilder

• StringBuffer() 과 동일하다
• 단, 동기화만 되어 있지 않다

 2) StringBuffer

• String 클래스의 인스턴스는 한 번 생성되면 그 값을 읽기만 할 수 있고, 변경할 수 없다(immutable)
• StringBuffer 클래스의 인스턴스는 값을 변경하거나 추가할 수 있다(mutable)
• StringBuffer 클래스는 내부적으로 버퍼(buffer)라고 하는 독립적인 공간을 가진다
• 버퍼 크기의 기본값은 16개의 문자를 저장할 수 있는 크기이다
• 생성자를 통해 버퍼의 크기를 별도로 설정할 수 있지만 인스턴스 생성 시 언제나 설정한 크기보다 16개의 문자를 더 저장할 수 있는 크기로 생성된다
• 문자열 저장(StringBuffer)은 equals 가 아닌 "=="로 대입비교 된다
• equals 를 사용하기 위해서는  String으로 변환 후 비교하여야 한다

 2. 문자열 저장(StringBuilder / StringBuffer) 메서드

 1) append() 메서드

• 문자열 뒤에 새로 할당된 문자열 값을 추가한다

public class Aaaa {
    public static void main(String[] args) {
        String abc = "SrtingBuffer";
        StringBuffer bcd = new StringBuffer(abc);
        StringBuffer cde =  bcd.append("append method");
            System.out.println(" "+cde);
            System.out.print(bcd.append(" result "));
        }
    }

result
 SrtingBufferappend method
SrtingBufferappend method result

 2) capacity() 메서드

• 해당 문자열에 할당된 버퍼의 크기를 출력한다

public class Aaaa {
    public static void main(String[] args) {
        String abc = "SrtingBuffer";
        StringBuffer bcd = new StringBuffer(abc);
        StringBuffer cde =  bcd.append("append method");
            System.out.println(bcd.capacity());
            System.out.print(cde.capacity());
        }
    }
    
result
28
28
//abc 저장공간 12 + 기본 버퍼공간 16

 3) delete() 메서드

• 기존 문자열의 지정된 위치에 있는 문자를 삭제한다
• 참조변수의 값은 변경된 문자열로 저장된다

public class Aaaa {
    public static void main(String[] args) {
        String abc = "StringBuffer";
        StringBuffer bcd = new StringBuffer(abc);
        StringBuffer cde =  bcd.append("delete method");
        System.out.println(cde.deleteCharAt(1)); //1번째 문자열 삭제
        System.out.println(bcd.delete(3,6));     //1번째 삭제된 상태에서 3번째부터 5번째까지 삭제
        System.out.print(cde.deleteCharAt(10));  //삭제 누적된 상태에서 10번째 삭제
    }
}

result
SringBufferdelete method
Sriufferdelete method
Sriufferdeete method

 4) insert() 메서드

• 기존 문자열의 지정된 위치에 추가 문자열을 삽입한다
• 참조변수의 값은 변경된 문자열로 저장된다

public class Aaaa {
    public static void main(String[] args) {
        String abc = "String-method";
        StringBuffer bcd = new StringBuffer(abc);
        StringBuffer cde =  bcd.append(" insert method");

        System.out.println(bcd.insert(6," + insert + "));
        System.out.print(bcd.insert(12,"insert"));
    }
}

result
String + insert + -method insert method
String + insinsertert + -method insert method

※ 참조

https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html

1. 문자열 분리(StringTokenizer)

• 지정한 구분자로 문자열을 쪼개주는 클래스이다
• 쪼개진 문자열을 토큰(token)이라고 한다
• StringTokenizer(참조변수,"구분할 기호, 문자") 의 형식으로 사용한다
• StringTokenizer 는 반복문이 필요하다

import java.util.StringTokenizer;

public class Aaaa {
    public static void main(String[] args) {
        String abc = "SrtingTokenizer/result/is/token";
        StringTokenizer bcd = new StringTokenizer(abc, "/");
        while (bcd.hasMoreTokens()) {
            String cde = bcd.nextToken();
            System.out.print(" "+cde);
        }
    }
}

result
 SrtingTokenizer result is token

• 더 검색할 문자열이 있는지 확인하는 hasMoreTokens 메서드와 다음 문자열을 가져오는 nextToken 메서드를 사용한다

2. StringTokenizer 메서드

1. 큐(Queue)

• 큐는 줄을 서서 기다리다, 대기행렬 이라는 뜻이다
• FIFO(First In First Out) 또는 LILO(Last In Last Out) 구조이다
• 먼저 저장한 데이터를 먼저 꺼내는 구조이다
• 순차적으로 출력되는 구조이다
• 링크드리스트에 적용하기에 적합하다
• enqueue 는 큐에 데이터를 넣는 것으로 add 메서드를 사용한다
• dequeue 는 큐에 데이터를 꺼내는 것으로 poll 메서드를 사용한다
•  

2. 큐 메서드

• add(): 큐에 데이터를 추가할 수 있어야 합니다.
• poll(): 가장 먼저 추가된 데이터를 큐에서 삭제하고 삭제한 데이터를 리턴해야 합니다.
• size(): 큐에 추가된 데이터의 크기를 리턴해야 합니다.
• peek(): 큐에 가장 먼저 추가된 데이터를 리턴해야 합니다.
• show(): 큐에 들어있는 모든 데이터를 String 타입으로 변환하여 리턴합니다.
• clear(): 큐에 들어있는 모든 데이터를 삭제합니다.

• ArrayList로 Queue를 사용할 때 add, pull 이외에 필요한 메서드를 어떻게 구현할 수 있나요?
• Java의 배열로 Queue를 구현했을때 어떤 단점이 존재할까요?

• 원형 큐 (Circular Queue)

1. 스택(Stack)

• Stack는 쌓다, 포개지다 의 뜻을 가진 단어로 데이터를 순서대로 앃는 자료구조이다
• LIFO(Last In First Out) 또는 FILO(First In Last Out) 구조라고 한다
• 가장 먼저 저장한 데이터가 가장 나중에 나가는 구조
• 순차적으로 추가되고 순차적으로 삭제되는 구조
• 배열에 적용하기에 적합하다

• 저장과 추출이 하나의 통로로 이루어지는 제한적 접근 구조이다
• 데이터 저장을 PUSH , 데이터 추출을 POP 라고 한다
• 한번에 여러개의 데이터를 저장하거나 추출할 수 없다
• 웹페이지의 뒤로 가기, 앞으로 가기 등의 기능에 사용된다

• 0번 데이터부터 한방향으로 저장된다

• 마지막에 저장된 5번 데이터부터 추출된다

2. 스택 선언

• Stack<Element> stack = new Stack<>(); 의 형식으로 선언한다
• Stack을 적용하기 위하여 import java.util.Stack 으로 Stack을 가져온다

package stack;
import java.util.Stack;

public class Lifo {
    public static void main(String[] args) {
            Stack<Integer> stack = new Stack<>();
            stack.push(0);
            stack.push(1);
            stack.push(2);
            stack.push(3);
            stack.push(4);
            stack.push(5);
    }
}

3. 스택 메서드

package stack;
import java.util.Stack;

public class Lifo {
    public static void main(String[] args) {
            Stack<Integer> stack = new Stack<>();
            stack.push(0);
            stack.push(1);
            stack.push(2);
            stack.push(3);
            stack.push(4);
            stack.push(5);
//            stack.peek(); //stack 맨 위의 값 출력
//            stack.pop(); //값 제거
//            stack.clear(); //stack 전체 값 제거
//            stack.size(); //stack 크기 출력
//            stack.empty(); //stack이 비어있는지 확인(비었으면 true 출력)
//            stack.contains(3) //stack 값 중에 3의 값이 있는지 확인(있으면 true)

		System.out.println(stack.pop());
    }
}

※ 참조

https://docs.oracle.com/javase/7/docs/api/

https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html

1. 클래스

• 클래스는 객체를 정의한다
• 클래스는 객체를 생성하는데 사용한다
• 클래스는 객체를 만들기 위한 설계도라고 할 수 있다

 1) 클래스 구성

• 필드(field) : 클래스의 속성을 나타내는 변수이다
• 메서드(method) : 클래스의 기능을 나타내는 함수이다
• 생성자(constructor) : 클래스의 객체를 생성하는 역활을 한다
• 이너클래스(inner class) : 클래스 내부의 클래스를 의미한다
• 위의 4가지 요소로 구성된다
• 필드, 메서드, 이너클래스를 통틀어 멤버(member)라고 한다

public class Example {                //Example class 선언
	int a = 10;                       //필드
	if a(){ };                        //메서드 
    void printX() {...}               //메서드
	Example exe = new Exanple()       //생성자
	class Example2 {...}              //이너 클래스
}

 2) 클래스 추가 정의

• 클래스 == 데이터 + 함수 의 결합으로 사용할 수 있다
  - 클래스 : 데이터와 함수의 결합 (구조체 + 함수)
  - 데이터는 변수와 같다
  - 함수는 메서드와 같으며, 명령문의 집합체이다
  - 함수의 작업은 데이터를 재료로 계산을 한다
  - 데이터와 함수는 상호 관련성이 있으므로 결합하여 사용하는 것이 용이하다
  
  
• 데이터 저장의 변화는 다음과 같다
  - 변    수 : 하나의 데이터를 저장할 수 있는 공간
  - 배    열 : 같은 종류의 여러 데이터를 하나로 저장할 수 있는 공간
  - 구조체 : 서로 다른 종류의 데이터라도 관련성이 있다면 하나로 저장할 수 있는 공간
  - 클래스 : 데이터와 함수의 결합 (구조체 + 함수)

• 클래스는 사용자 정의 타입이다
  - 원하는 타입을 사용자가 직접 만들 수 있다
  - 
  ex) 사용자 정의 변수를 통하여 코그의 단순화한 경우

2. 객체

• 실제로 존재하는 사물이나 개념, 논리 등을 말한다
• 객체가 가지는 기능과 속성에 따라 사용되는 용도가 다르다
• 실제 존재물 HW을 컴퓨터가 실행할 수 있는 SW 로 만들는 과정에서 사용된다
• 모든 인스턴스를 대표하는 일반적 용어이다
• 클래스를 객체로 생성하기 위해서 메모리로 할당하는 과정을 인스턴스화 한다고 말한다

 1) 구성요소

• 객체 = 속성(변수) + 기능(메서드) 로 구성된다
• 객체를 사용하기 위해서는 속성과 기능을 부여해 줘야 한다
• HW를 분석하여 SW화 하는 방법이다

 2) 객체의 생성

1. 클래스명 ; //클래스를 선언한다
2. 클래스명 변수명 ; //클래스의 객체를 참조하기 위한 변수(참조변수)를 선언한다
3. 변수명 = new 클래스명( ) ; //클래스 인스턴스를 생성하여 참조변수에 주소를 저장한다. 메모리에 참조변수 영역을 확보한 객체가 생성된다
4. 2와 3은 다음과 같이 줄여서 사용할 수 있다 -> Audio audio = new Audio( );

    ex) 1 class Audio;                             class Audio;  

          2 Audio audio;                 ->        Audio audio = new Audio( );

          3 audio = new Audio( );

 3) 객체의 사용

• 클래스 작성 -> 객체 생성 -> 객체 사용 의 순서로 작성한다
  - 클래스는 객체를 만들기 위한 설계도 역활이며, 객체는 객체를 사용하기 위하여 생성된다.
• 객체의 사용은 변수와 메서드를 사용한다는 의미이다
• 객체 사용 시에는 참조변수를 필히 호출하여 사용한다
  - 참조변수.멤버변수 = 값 ; //참조변수 객체의 멤버변수에 값을 저장하는 경우에 사용한다
    ex) audio.volume = 50 ; //오디오 객체의 볼륨변수의 값을 50으로 저장한다 
  
  - 참조변수.메서드변수( ) ; -> 참조변수 객체의 메서드변수를 호출하여 실행하는 경우에 사용한다
    ex) audio.volumeup( ) ; //오디오 객체의 볼륨변수에 있는 기능을 실행시킨다 (volume++)
• 변수가 생성되면 기본값으로 초기화된다

ex1) 

ex2)

ex3)

class Audio {
   public static void main(String arg[]){
       Audio audio = new Audio( );
       audio.model;//변수 사용
       audio.power = power; //전원 true
       audio.volume = 50; //현재 볼륨 입력
       audio.volumeup( ); //메서드 사용, 볼륨 +1 상승 = 50+1 = 51
       System.out.println("현재의 볼륨은" + audio.volume + "입니다");
	}
}
class audio {
	String model;
    Int volume;
    boolean power = power;
    
    audio.model( ) {“white”;}
    audio.power( ) {power = !power;}
    audio.volumeup( ) {volume++;}
    audio.volumedown( ) {volume--;}
}

result
"현재의 볼륨은 51입니다

import java.util.Scanner;  //Scanner 유틸 호출

//간이계산기 프로그램 
public class Calculator {
    public static void main(String[] args) { //maun 메서드 선언
        Scanner scan = new Scanner(System.in); //Scanner 객체 생성 : 외부입력

        System.out.println("첫 번째 숫자를 입력하세요."); //콘솔출력
        String no1 = scan.nextLine(); //첫 번째 숫자 입력
        
        System.out.println("사칙연산자를 입력하세요.");
        String op = scan.nextLine(); //사칙연산자 입력

        System.out.println("두 번째 숫자를 입력하세요.");
        String no2 = scan.nextLine(); //두 번째 숫자 입력

        int num1 = Integer.parseInt(no1); //입력받은 첫 번째 문자를 숫자형으로 변환
        int num2 = Integer.parseInt(no2); //입력받은 두 번째 문자를 숫자형으로 변환
        int result;

        if(op.equals("+")) {              //덧셈 연산
            result = num1 + num2;
        }
        else if(op.equals("-")) {         //뺄셈 연산
            result = num1 - num2;
        }
        else if(op.equals("/")) {         //나누기 연산
            result = num1 / num2;
        }
        else{
            result = num1 * num2;         //곱하기 연산
        }

        System.out.println(no1 + " " + op + " " + no2 + " = " + result); // 결과값 출력
    }
}

3. 소스파일과 클래스의 관계

• 하나의 소스 파일에는 하나의 public class만 존재해야 한다
• 또한, 하나의 소스 파일에는 하나의 클래스만 존재하는 것을 권장한다
• 소스파일의 이름은 main 메서드가 있는 클래스의 이름과 일치해야 한다
• 하나의 소스 파일에 여러 개의 클래스가 존재할 경우 소스파일의 이름은 아래와 같이 사용한다

• 아래와 같은 경우는 오류가 발생한다

※ 참조 링크

▶ 해시넷 객체 : http://wiki.hash.kr/index.php/%EA%B0%9D%EC%B2%B4

▶ 위키피아 객체 : https://en.wikipedia.org/wiki/Object_(computer_science) 

▶  Classes & Objects | Java | Tutorial 26 : https://www.youtube.com/watch?v=Mm06BuD3PlY

1. 문자열(String)이란?

• 클래스(class)를 통해 문자열 타입으로 선언된다
• char 타입의 배열을 의미한다
• String 타입은 참조 자료형이다

2. String  클래스 선언

• 'String 참조변수 ; 참조변수 = "문자열"'의 형태로 선언 : 문자열 리터럴을 대입하는 방식
• 'String 참조변수 = "문자열"'의 형태로 선언 : 문자열 리터럴을 대입하는 방식
• 'String 참조변수 = new String("문자열")'의 형태로 선언 : 객체를 생성하고 문자열을 대입하는 방식

public class Grade {
    public static void main(String[] args) {
        String str;
        str = "문자열";
        System.out.println(str);

        String str1 = "문자열1";
        System.out.println(str1);

        String str2 = new String("문자열2");
        System.out.println(str2);
    }
}

result
문자열
문자열1
문자열2

• 'String 참조변수 = "문자열"'의 형태로 선언
• 문자열 리터럴을 대입하는 방식의 주소값과 객체를 생성하는 방식의 주소값은 서로 다르다
• 그러므로, 문자열을 비교할 경우 등호"=" 대신 equals를 사용한다 ("=="은 저장공간의 주소를 비교하므로 문자열에 적합하지 않다)

public class Grade {
    public static void main(String[] args) {
        String str;
        str = "문자열";
        String str1 = "문자열";
        String str2 = new String("문자열");

        System.out.println(str==str1);
        System.out.println(str==str2);
    }
}

result
true
false

• 위에 코드에서 str==str1은 true로 같지만, str==str2는 false로 서로 다르다

3. String 특성

• String 문자열은 내용을 변경할 수 없다
• a = a+ b로 인하여 문자열 결합을 하였을 때 새로운 a의 저장공간이 생성된다
• a = a + b의 결과가 "문자열1"이 아닌 "문자열1문자열2"로 출력되며, a라는 새로운 저장공간이 생성된다

a = "문자열1";
b = "문자열2";
a = a + b;
System.out.println(a);

result
문자열1문자열2

• 수식에 의한 새로운 저장공간의 생성은 데이터의 처리 속도를 지연시킨다
• 문자열 변환이 필요한 변수에는 StingBuffer 메서드를 사용하는  것이 편리하다
• 같은 내용의 문자열 리터럴은 하나만 만들어진다 

String a = "abc";
String b = "abc";
String c = "abc";

//문자열이 동일하므로 "abc" 저장공간 1개만 생성된다

4. String 관련 대표 method

 1) charAt( )

• 해당 문자열의 특정 인덱스에 해당하는 문자를 반환한다
• 해당 문자열의 길이보다 큰 인덱스나 음수를 전달하면, 오류가 발생한다

public class Grade {
    public static void main(String[] args) {
        String str =new String("charAt method");
        System.out.println("문자열 : "+ str);// "문자열 : charAt method""
        System.out.println(str.charAt(0));// 'c'
        System.out.println(str.charAt(4));// 'A'
        System.out.println(str.charAt(6));// ' '
        System.out.println(str.charAt(12));// 'd'
        System.out.println(str.charAt(13));// 'error'
        System.out.println("\ncharAt() 메서드 호출 후 문자열 : "+ str);
    }
}

result
문자열 : charAt method
c
A
 
d
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 13
	at java.base/java.lang.StringLatin1.charAt(StringLatin1.java:47)
	at java.base/java.lang.String.charAt(String.java:693)
	at Grade.main(Grade.java:9)
    
//13번째문자열이 인덱스를 벗어났다고 에러 표시

public class Grade {
    public static void main(String[] args) {
        String str =new String("charAt method");
        System.out.println("문자열 : "+ str);// "문자열 : charAt method""
        System.out.println(str.charAt(0));// 'c'
        System.out.println(str.charAt(4));// 'A'
        System.out.println(str.charAt(6));// ' '
        System.out.println(str.charAt(12));// 'd'
        //System.out.println(str.charAt(13));// 'error'
        System.out.println("\ncharAt() 메서드 호출 후 문자열 : "+ str);
    }
}

result
문자열 : charAt method
c
A
 
d

charAt() 메서드 호출 후 문자열 : charAt method

//index 13을 주석 처리 후 정상 출력

 2) compareTo( )

• 해당 문자열을 인수로 전달된 문자열과 사전 편찬 순으로 비교
• 문자열을 비교할 때 대소문자를 구분하여 비교한다

• 두 문자열이 같다면 0을 반환
• 해당 문자열이 인수로 전달된 문자열보다 작으면 음수를, 크면 양수를 반환

• - 문자열을 비교할 때 대소문자를 구분하지 않으려면 compareToIgnoreCase() 메서드를 사용

public class Grade {
    public static void main(String[] args) {
        String str =new String("abcde");
        System.out.println("문자열 : "+ str);// "문자열 : charAt method""
        System.out.println(str.compareTo("abcdef"));// 인수가 매개변수보다 작으므로 -1
        System.out.println(str.compareTo("abcde"));// 인수와 매개변수가 같으므로 0
        System.out.println(str.compareTo("abcd"));//인수가 매개변수보다 크므로 1
        System.out.println(str.compareTo("aBcde"));// 'd'
        System.out.println(str.compareToIgnoreCase("aBcde"+ str));
    }
}

result
문자열 : abcde
-1
0
1
32
-5

 3) contact( )

• 해당 문자열의 뒤에 인수로 전달된 문자열을 추가한 새로운 문자열을 반환한다
• concatenate의 약자로 '연결한다'는 의미이다
• 인수로 전달된 문자열의 길이가 0이면, 해당 문자열을 그대로 반환한다

public class Grade {
    public static void main(String[] args) {
        String str =new String("concat");
        System.out.println("문자열 : "+ str);
        System.out.println(str.concat(" - method"));
        System.out.println(str.concat(""));
        System.out.println("concat() 메서드 호출 전 문자열 : "+ str);
    }
}

result
문자열 : concat
concat - method
concat
concat() 메서드 호출 전 문자열 : concat

 4) indexOf( )

• 해당 문자열에서 특정 문자나 문자열이 처음으로 등장하는 위치의 인덱스를 반환한다
• 문자열의 대소문자를 구분한다
• 만약 해당 문자열에 전달된 문자나 문자열이 포함되어 있지 않으면 -1을 반환한다

public class Grade {
    public static void main(String[] args) {
        String str =new String("indexOf-method");
        System.out.println("문자열 : "+ str);
        System.out.println(str.indexOf('o'));//소문자 'o'의 위치값
        System.out.println(str.indexOf('O'));//대문자 'O'의 위치값
        System.out.println(str.indexOf('a'));//소문자 'a'의 위치값
        System.out.println(str.indexOf("-"));//특수문자 '-'의 위치값
        System.out.println("indexOf() 메서드 호출 후 원본 문자열 : "+ str);
    }
}

result
문자열 : indexOf-method
12
5
-1
7
indexOf() 메서드 호출 후 원본 문자열 : indexOf-method

 5) trim( )

• 해당 문자열의 맨 앞과 맨 뒤에 포함된 모든 공백 문자를 제거한다

public class Grade {
    public static void main(String[] args) {
        String str =new String("   trim     ");
        System.out.println("문자열 : "+ str);
        System.out.println(str +"end");
        System.out.println("0"+str.trim()+"-end");
        System.out.println("trim() 메서드 호출 후 문자열 : "+ str);
    }
}

result
문자열 :    trim     
   trim     end
0trim-end
trim() 메서드 호출 후 문자열 :    trim

public class Grade {
    public static void main(String[] args) {
        String str =new String("toUpper/LowerCase");
        System.out.println("문자열 : "+ str);
        System.out.println(str.toLowerCase());
        System.out.println(str.toUpperCase());
        System.out.println("두 메서드 호출 후 문자열 : "+ str);
    }
}

result
문자열 : toUpper/LowerCase
toupper/lowercase
TOUPPER/LOWERCASE
두 메서드 호출 후 문자열 : toUpper/LowerCase

 7) 그 외 String 메서드 설명

※ 참조

https://docs.oracle.com/javase/7/docs/api/java/lang/package-summary.html

1. 배열(array)이란?

• 같은 타입의 여러 변수를 하나의 묶음으로 표시한다
• 배열이 가진 각각의 값을 배열의 요소(element)라고 한다

2. 배열의 선언

• '타입[ ] + 참조변수' 또는 '타입 + 참조변수[ ]' 의 형태로 선언한다
• 배열의 선언은 참조변수를 위한 저장공간을 등록한다는 의미이다

※ 참조 변수

• 참조 타입의 값을 가지고 있는 변수를 의미한다
• 변수가 특정 값을 저장하고 있는 것이 아니라 값이 저장될 시작 주소의 값을 저장한다

3. 배열의 생성

• '참조변수 = new 타입[index]' 의 형태로 생성한다
• 배열 선언과 함께 '타입[ ] + 참조변수 = new 타입[index] 로도 사용한다
• index는 저장 공간의 개수를 의미한다
• index의 개수만큼 타입에 맞는 저장 공간이 연속적으로 생성된다
• 배열은 타입의 종류와 index의 크기에 따라 메모리 크기가 유동적으로 확보된다

※ 인덱스(index)

• 참조변수[ ]에 배열의 값이 각각 자동으로 대입되며, 대입되는 값의 번호를 인덱스(index)라고 한다
• index 의 범위는 0부터 '배열길이-1' 까지이며 '-1'을 하는 이유는 '0'부터 시작하기 때문이다

ublic class Grade {
    public static void main(String[] args) {
        int a=0, b=1, c=2, d=3, e=4; //a,b,c,d,e의 초기값 선언-5개 변수 사용

        System.out.println(a); //a의 결과값 출력
        System.out.println(b); //b의 결과값 출력
        System.out.println(c); //c의 결과값 출력
        System.out.println(d); //d의 결과값 출력
        System.out.println(e); //e의 결과값 출력

        int[] score = new int[5]; //int 타입의 참조변수 score에 대해 5개의 저장공간을 확보
        score[0] = 1;
        score[1] = 2;
        score[2] = 3;
        score[3] = 4;
        score[4] = 5;
        System.out.println(score[0]);//score의 0번째 값
        System.out.println(score[1]);//score의 1번째 값
        System.out.println(score[2]);//score의 2번째 값
        System.out.println(score[3]);//score의 3번째 값
        System.out.println(score[4]);//score의 4번째 값
    }
}


result
0
1
2
3
4
1
2
3
4
5

//다중 변수의 연속 사용과 한개의 변수에 여러 값 사용의 차이

• 위에서 int a=0 은 정수 a에 대한 메모리 공간 4byte 1개를 확보한다
• score는 int[5] 를 통해서 메모리에 5개의 저장공간을 연속으로 확보한다

• '타입[ ] + 참조변수 = new 타입[ ]{요소 값}'  처럼 사용하기도 한다

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

        int[] score = new int[]{1,2,3,4,5}; //int 타입의 참조변수 score에 대해 5개의 저장공간을 확보

        System.out.println(score[0]);//score의 0번째 값
        System.out.println(score[1]);//score의 1번째 값
        System.out.println(score[2]);//score의 2번째 값
        System.out.println(score[3]);//score의 3번째 값
        System.out.println(score[4]);//score의 4번째 값
    }
}

result
1
2
3
4
5

• .length 를 사용하여 배열의 길이를 확인할 수 있다

4. 다차원 배열

 1) 다차원 배열이란?

• 1차원 이상의 논리적인 구조를 가진다는 의미이다
• 배열이 배열의 요소로 사용되는 경우이다

 2) 2차원 배열

• '타입[ ][ ] + 참조변수' 또는 '타입 + 참조변수[ index1] [index2] ]' 의 형태로 선언한다
• 동일한 방식으로 반복되면 3차원, 4차원,...다차원 배열이 된다

5. 문자열 배열

• 문자열 배열은 문자 배열과 문자열을 배열하는 방법이 있다
• 문자를 배열할 경우에는 char[ ] 또는 char[ ] [ ]를 사용한다

// 가변 배열로 2차원 배열 선언
char[][] letters = new char[3][];
letters[0] = new char[5];
letters[1] = new char[4];
letters[2] = new char[5];

letters[0][0] = 'H';
letters[0][1] = 'e';
letters[0][2] = 'l';
letters[0][3] = 'l';
letters[0][4] = 'o';

letters[1][0] = 'J';
letters[1][1] = 'a';
letters[1][2] = 'v';
letters[1][3] = 'a';

letters[2][0] = 'W';
letters[2][1] = 'o';
letters[2][2] = 'r';
letters[2][3] = 'l';
letters[2][4] = 'd';

• 문자열을 배열할 경우에는 String[ ]을 사용한다

※ 문자와 문자열을 담는 기호에 주의한다

// 선언 후 각 배열에 값을 넣어 초기화하는 경우
String[] str = new String[3];
str[0] = "Hello";
str[1] = "Java";
str[2] = "World";

// 선언과 동시에 값을 넣어 초기화하는 경우
String[] str = new String[] {"Hello", "Java", "World"};
String[] str = {"Hello", "Java", "World"}; // new String[] 생략 가능

// String Class를 사용해서 선언하고 초기화하면 이렇게 간편하게 만들 수 있다
String str = "Hello Java World";

6. 객체의 배열

• 객체 배열 == 참조변수 배열
• 객체는 참조변수의 집합이므로 객체배열 또한 참조변수의 배열과 같다
• Speak 클래스의 참조변수 speak1, speak2, speak3는 아래와 같이 작성할 수 있다
  Speak speak1, speak2, speak3; // Spaea[ ] speakArr = new Speak[3];

1. 변수(variable)란?

• 하나의 데이터 값을 저장할 수 있는 메모리의 공간을 의미한다

 1) 변수 선언

• 변수는 메모리에 데이터를 임시로 저장하기 위하여 선언한다
• '변수타입 + 변수명 = 값' 으로 작성한다 
  

  exe)	int num = 1 ;
  	좌항 = 우항
  	변수 = 값

• 변수 선언 후에는 항상 ' ; '을 붙인다
• 변수에 값을 저장하는 것을 대입 또는 할당 이라고 한다
• 변수에 값을 처음으로 할당하였을 경우를 '초기화 한다' 라고 한다
• 초기화 후에 다시 변수에 값을 할당하는 것을 재할당 이라고 한다
• 변수에 값을 재할당하면 기존에 가지고 있던 값이 재할당 되는 값으로 변경된다
• 기존의 값이 재할당을 통해 변할 수 있으므로 변수라고 한다 

class Example {
	public static void main(String[] args) {
		int num; // 변수 선언
		num = 1; // 값 할당(변수 선언 및 초기화)
		num = 2; // 값 할당(재할당)
	}
}

 2) 메모리와 변수의 관계

• 메모리는 메모리셀의 집합체이다
• 메모리셀은 1byte의 크기를 가진다
• 각각의 메모리셀에 데이터를 저장할 수 있다
• 각각의 메모리셀에는 주소가 지정되어 있다
• 메모리셀의 주소에 값을 대입할 수 있으나, 식별이 어렵다
• 식별을 용이하게 하기 위하여 변수를 사용한다
  

  메모리 주소 사용	변수 사용
  class Example {    public static void main(String[] args) {       0xf38d2a6c = 1;       0xa92d42b2 = 2;       0x24de241c = 3;       ...    } }	class Example {    public static void main(String[] args) {       int num1 = 1;    // num1(변수) , 1(값)       int num2 = 2;       int num3 = 3;       ...    } }

2. 변수 사용의 목적

• 메모리에 데이터 저장 공간을 확보하기 위해서 사용한다
• 여러 개발자와 협업을 진행할 경우 변수명을 붙여 데이터의 흐름을 상호간에 식별하여 소통할 수 있게 한다
• 데이터를 재사용할 경우 변수명만으로 사용할 수 있어서 용이하다

public class Grade {
    public static void main(String[] args) {
        int a=10, b=2, c=5; //a, b, c의 초기값

        System.out.println(a+b); //a+b의 결과값 출력
        System.out.println(a+b*c); //a+b*c의 결과값 출력
        System.out.println(a+b+c); //a+b+c의 결과값 출력
        System.out.println(a+b/c); //a+b/c의 결과값 출력
    }
}

result
12
20
17
10
//a,b,c 값을 한번 선언함으로 여러가지 수식에 의한 값을 도출할 수 있다

 2) 변수의 선언 타입

• 변수 a의 값을 10으로 선언한다면 10이 정수이므로 int 타입으로 선언할 수 있다

public class Grade {
    public static void main(String[] args) {
             int a=10; //10이 정수이므로 int 타입으로 선언
    }
}

• 데이터의 종류에 따라 타입을 사용할 수 있다

public class Grade {
    public static void main(String[] args) {
        int a=10; //10이 정수이므로 int 타입으로 선언
        float b=1.23456789F; //실수이므로 float 타입으로 선언
        double c=1.23456789012345678D; //실수이므로 double 타입으로 선언
        char d=75; //K를 유니코드 75로 char 타입으로 선언
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}


result
10
1.2345679
1.2345678901234567
K

• 변수는 동일한 타입일 경우 타입은 한번만 선언해도 된다

public class Grade {
    public static void main(String[] args) {
        int a=10, b=20, c=30, d=40; //10이 정수이므로 int 타입으로 선언

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

result
10
20
30
40

• 변수의 값은 마지막에 적용된 변수의 값으로 저장된다

public class Grade {
    public static void main(String[] args) {
        int a=10; //a의 초기값
        a=a+1; //a+1의 결과값
        System.out.println(a); //최종 a+1의 결과값 a 출력
    }
}

result
11

3. 변수의 종류

 1) 클래스 변수

• 클래스 영역 내에서 static이 붙는 변수이다
• 클래스 정의에서 static 필드로 객체가 공유하는 변수이다
• 선언된 클래스 내부에서 사용 가능하다
• 클래스 외부에서의 사용은 접근제어자(access modifier)에 따라 다르다

 2) 인스턴스 변수

• 클래스 정의에서 static이 아닌 필드로 객체가 소유하는 변수이다
• 객체는 인스턴스 변수의 묶음이다
• 객체가 생성되었을 때 생성된다
• 선언된 클래스 내부에서 사용 가능하다
• 클래스 외부에서의 사용은 접근제어자(access modifier)에 따라 다르다

 3) 지역 변수

• 메서드 내부 또는 블록 내부에서 선언된 변수이다
• 메서드가 실행될 때 만들어지고 실행 후 사라진다
• 초기값을 지정한 후 사용해야 한다
• 변수 선언 시 접근 제어자를 사용하지 않는다

 4) 파라미터

• 메서드 호출 시 전달하는 값을 저장하기 위한 변수이다
• 메서드가 실행될 때 만들어지고 실행 후 사라진다

4. 변수명

• 변수명은 영문자(대문자, 소문자)나 숫자,  _, $ 를 사용할 수 있다
• 영문자는 대소문자가 구별되어 인식된다
  - a와 A는 다른 문자로 인식한다
• 자바에서 변수명은 일반적으로 카멜 케이스(camelCase)를 사용한다
   - 카멜케이스는 두 번째 단어부터 대문자로 시작해 구분한다
   - camelCase 는 낙타와 닮았다고 붙여진 명칭이다
• 변수명은 숫자로 시작하여 작명할 수 없다
• 자바에서 사용 중인 예약어로 작명할 수 없다
  - 예약어 : https://www.w3schools.com/java/java_ref_keywords.asp

▶ 자바(Java) 명명 규칙

※ 참조 사이트 : Code Conventions for the Java Programming Language: 9. Naming Conventions (oracle.com)

■ 아래는 변수 a와 b에 대한 성적을 처리하기 위한 프로그램이다

• a와 b의 성적을 합산한다
• c1과 c2 학생의 값을 출력한다
• 잘못된 부분을 수정하고 보충 작성하여 a와 b에 대한 성적을 구하도록 한다

public class Grade {
        int a[2];
        int b[2];

        void input_grade(){
            a[0]=90;
            a[1]=80;
            b[0]=85;
            b[1]=80;
        }
        void output_grade(){
            System.out.printf("%c, %c", a[0]+b[0], a[1]+b[1]);
        }
        void main(void) {

            input_grade();
            output_grade();
    }
}

해답은 아래에...

.

.

.

.

.

.

.

.

.

    class Record {
        int a;
        int b;

        void output_grade(){
            System.out.println(a+b);
        }
    }
    public class Grade{
        public static void main(String[] args) {
            Record c1=new Record();
            Record c2=new Record();
            c1.a=90;
            c1.b=80;
            c2.a=85;
            c2.b=80;

            c1.output_grade();
            c2.output_grade();
        }
    }

※ 다음과 같이 작성할 수도 있다

class Record {
    int e; //성적1을 위한 필드
    int m; //성적2를 위한 필드
    void input_record(int a,int b){ //input_record에 대한 함수 정의
        e=a; //성적1 입력
        m=b; //성적2 입력
    }
    void output_record(){ //output_record에 대한 함수 정의
        System.out.println(e+m); //합계 출력
    }
}
public class Grade{
    public static void main(String[] args) {
        Record c1=new Record(); //학생1에 대한 객체 생성
        Record c2=new Record(); //학생2에 대한 객체 생성
        c1.input_record(90,80); //학생1에 대한 성적 입력
        c2.input_record(80,85); //학생2에 대한 성적 입력

        c1.output_record(); //합계 출력
        c2.output_record(); //합계 출력
    }
}

어느 여름 날 상하이 어느 음식점 골목...한국과 별반 다르지 않다

 샤오룽샤...한국에서는 한 냄비를 먹으려면 최소 5만원 이상인데...역시 중국이다...1만원도 안한다는...^^

한국 사람은 역시 국물이 필요해서...얼큰한 조개탕도 함께...

문어를 주축으로 가리비, 전복, 백합, 오징어, 피조개, 새우까지 서해안 바다를 모두 가져온 듯한 한 상이다

문어는 언제나 옳다...기운을 북돋아 주는 대표적인 해산물이다

1. 타입(Type)

• 타입은 데이터 값의 특성을 표시해 주는 역활을 한다
• 값이 차지하는 메모리의 크기와 저장되는 방식을 결정한다

2. 타입의 분류

 1) 기본 타입(primitive type)

•  'OO은 OO이다' 와 같이 직접적으로 표현하는 데이터이다
• 데이터의 실제 값을 의미하며 4가지 타입으로 구분된다
  - 정수 타입 : byte, short, int, long
  - 실수 타입 : float, double
  - 문자 타입 : char
  - 논리 타입 : Boolean

 2) 참조 타입(reference type)

• 데이터가 저장된 주소값을 의미한다
• 객체의 주소를 저장한다
  - 참조타입변수 = 객체;
• 8개의 기본타입을 제외한 나머지를 참조 타입이라 한다
• ‘OO은 OO에서 찾을 수 있다’처럼 간접적으로 표현하는 데이터이다

class Example {
	public static void main(String[] args) {
    Object object = new Object();       //Object 객체를 참조변수 object에 저장한다
    System.out.pringln(object);         //참조변수 object가 저장하고 있는 값을 출력한다
    }
}

• System.out.println(object); 의 결과로 Object 객체에 대한 주소값을 출력한다
• 저장하려는 객체의 위치, 주소값을 저장하는 변수를 참조타입 변수 라고 한다 

3. 정수 타입(byte, short, int, long)

 : 숫자 데이터를 의미하며 크기별로 타입을 지정해 준다

 1) 정수 타입의 종류

※ byte= 컴퓨터가 처리하는 정보의 기본 단위

   1byte = 8bit = 하나의 문자를 나타내는 가장 작은 단위
   1bit = 0 또는 1을 저장하는 최소 단위

 2) 정수 타입의 특성

• int는 정수형의 기본타입이다
• 정수를 입력하면 기본적으로 int 로 인식한다

ex1) byte 타입 변수 a에 값 120을 할당하면, byte 범위 내에 있으므로 컴파일러가 byte로 바꿔서 전달한다

      byte 타입 변수 a1에 값 128을 할당하면, byte 범위 밖에 있으므로 컴파일러에서 오류가 발생한다

public class Main {
    public static void main(String[] args){
        Object object =new Object();
        byte a = 120; //정상 실행
        System.out.println(a);
        byte a1 = 128; //byte 127의 범위를 벗어남으로 오류 발생
        System.out.println(a1);
    }
}

/*java: incompatible types: possible lossy conversion from int to byte 에러 코드 발생
  (     호환이 안되는 유형: byte에서 int로 전환 가능하다               ) */

ex2) int 타입 변수 a에 값 120을 할당하면, int 범위 내에 있으므로 컴파일러가 byte로 바꿔서 전달한다

      int 타입 변수 a1에 값 2147483648을 할당하면, int 범위 밖에 있으므로 컴파일러에서 오류가 발생한다

public class Main {
    public static void main(String[] args){
        Object object =new Object();
        int a = 120;
        System.out.println(a);
        int a1 = 2147483648;
        System.out.println(a1);
    }
}

/*java: integer number too large 에러발생
        (정수가 너무 크다       )*/

• long 타입은 입력값 마지막에 'L'을 붙여준다
• 변수의 값이 자료형의 범위를 넘을 경우 오버플로우(overflow) 또는 언더플로우(underflow)가 발생하기 때문에 필요에 따라 long과 같은 타입을 사용

ex3)  long 타입 변수 a1에 값 2147483648+'l' 또는 2147483648+'L' 을 할당하면, long 범위 내에 있으므로 컴파일러가 byte로 바꿔서 전달한다

public class Main {
    public static void main(String[] args){
        Object object =new Object();
        int a = 2147483647;
        System.out.println(a);
        long a1 = 2147483648l;
        //마지막에 'l'을 붙이지 않으면 java: integer number too large 에러 발생
        System.out.println(a1);
        long a2 = 2147483648L;
        //마지막에 'l'을 붙여도 에러는 발생하지 않지만 'L'을 사용하여 준자
        System.out.println(a2);
    }
}

 3) 오버플로우(Overflow)

• 자료형이 표현할 수 있는 범위 이상의 값을 표현한 경우 발생하는 현상
• 어떤 값이 byte형이고, byte형의 최댓값인 127을 값으로 가지는 경우, 이 값에 1을 더하면 128이 아니라 -128이 됩니다.

 4) 언더플로우(Underflow)

• 자료형이 표현할 수 있는 범위 이하의 값을 표현한 경우 발생하는 현상
• 어떤 값이 byte형이고, byte 형의 최솟값인 -128을 값으로 가지는 경우, 이 값에 1을 빼면 -129가 아니라 127이 됩니다.

4. 실수 타입(float, double)

: 실수는 소숫점을 가지고 있는 값을 말한다

• 정수가 아닌 소수점 단위의 값을 데이터로 가져올 때 사용한다
• 실수 타입의 값은 두가지 유형 모두 정확하지 않다

public class Grade {
    public static void main(String[] args) {
        float f1 = 12345.123456789012345678901234567890f;
        double d1 =12345.123456789012345678901234567890;

        System.out.println("float f1 : " + f1);
        System.out.println("double d1 : " + d1);
    }
}




result
float f1 : 12345.123
double d1 : 12345.123456789011

5.  논리 타입(boolean)

 : 참(true) 또는 거짓(false)를 저장할 수 있는 타입이다

• 값으로 true 와 false를 가진다
• 컴퓨터 언어로 0과 1로 저장하며 1bit로 표현된다
• JVM이 다루는 최소 단위가 1byte이므로 1byte의 크기를 차지한다
• 조건이 참 또는 거짓일 경우 사용한다

public class Grade {
    public static void main(String[] args) {
        boolean Rain = true;
        if (Rain == false) {
                System.out.println("우산을 들고 나간다");
            }
        else {
                System.out.println("우산을 놓고 나간다");
            }
        System.out.println(Rain);
        }
    }
    
    
    
    
result
우산을 놓고 나간다
true

6. 문자 타입(char)

 : 단 하나의 문자만 저장하는 타입

• 여러 문자를 저장하기 위해서는 문자열(String)를 사용한다
• 문자와 문자열은 전혀 다른 타입이다
• 자바는 유니코드에 바탕을 두고 문자를 표현한다
• cahr 변수 값에 숫자를 할당하여 보면 각기 다른 문자가 출력되는 것을 볼 수 있다

public class Grade {
    public static void main(String[] args) {
        char a=1;
        char a1=12;
        char a2=123;
        char a3=1234;
        char a4=12345;

        System.out.println(a);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);

    }
}



result



{
Ӓ
〹

7. 타입 변환

 1) 자동 변환

• 바이트 크기가 작은 타입에서 큰 타입으로 변환된다
• 덜 정밀한 타입에서 더 정밀한 타입으로 변환된다

long longValue = 12345L;
float floatValue = longValue;
// float이 long보다 정밀하므로, 자동으로 타입이 변환된다

System.out.println(floatValue); 
// 12345.0이 출력된다

 2) 수동 변환

• 메모리 용량이 큰 타입에서 작은 타입으로 변환은 자동변환이 되지 않는다
• 큰 데이터 타입을 작은 데이터 타입의 변수에 저장하는 것을 캐스팅(casting)이라고 한다
• 캐스팅 연산자 ( )를 사용하며, 연산자 안에 변환하고자 하는 타입을 작성해 준다

int intValue = 128;
byte byteValue = (byte)intValue;
//int 타입으로 선언된 변수 intValue를 더 작은 단위인 byte로 변환

System.out.println(byteValue);
//출력값은 byte의 최대 표현 값인 127이 아니라 -128이다
//표현 범위를 넘으면 한 바퀴를 돌아 음수로 출력하기 때문이다

※ 참조

https://stackoverflow.com/questions/5071040/java-convert-integer-to-string

https://www.delftstack.com/ko/howto/java/how-to-convert-a-string-to-an-int-in-java/

1. Java 프로그램 설치

• IntelliJ IDEA 의 Community 버전을 설치한다 : 설치 방법은 별도 IntelliJ 문서에서 참조

2. IntelliJ에서 파일을 생성하고 관련된 기본 사항을 알아보자

 1) 프로젝트를 만들고 프로젝트 내에 package를 생성한다

• 경우에 따라 package를 생성하지 않을 수 있다
• package는 폴더의 역활을 한다

 2) 생성된 package 안에 new class를 생성하면 아래와 같이 화면에 표시된다

package 패키지명;
public class 클래스명 {
     public static void main(String[] args) {
      }

• class name의 첫 글자는 무조건 대문자로 지정한다
• public class Main : 여기서 Main은 class를 생성할 때 작성한 title을 표시한다
• public static void main(String[] args) { } : main메서드를 나타내며, 자바 프로그램을 실행하는 진입점(Entry point)역활을 한다. main메서드가 없으면 자바 파일은 실행될 수 없다

 3) 클래스 (class) 

• 자바 프로그램의 모든 문장들은 class { } 안에 작성한다
• 클래스는 객체를 만드는 틀의 역활을 한다
• 만들어 낼 객체의 구조를 클래스 안에 작성하면 동일한 객체를 쉽게 생성할 수 있다

 4) main 메서드

• 클래스 내브에 정의된 함수이다
• 자바 프로그램을 실행하면 가장 먼저 main() 메서드를 찾아 실행한다
• 특정한 작업을 수행하기 위하여 명령문을 작성하고 모아놓은 집합이다

package main;

public class Main {
        public static void main(String[] args){
            System.out.println("Hello, World!");
            print("Hello, Java!");
        }
            static void print(String input){
            System.out.println(input);
        }
}

• 'main' package 에 'Main'이라는 class를 생성하여 "Hello, World! / Hello, Java"를 출력하는 코드이다
• 모든 코드들은 main(){ } 안에 작성되어야 한다
•  파일을 실행하면 main(){ } 안에 있는 명령들을 순차적으로 전부 실행한 후 완료되면 프로그램을 종료한다
•  main(){ } 밖에서 작성한 코드는 컴파일 과정에서 에러가 발생한다

1. JVM(Java Virtual Machine)

• Java는 컴파일러(Compiler)를 통해 기계어(Machine Language)로 변환되는 언어이다
• 컴파일(Compile)은 특정 프로그래밍 언어를 기계가 이해할 수 있는 언어로 옮기는 번역 과정으로 자바 언어를 JVM(Java Virtual Machine)이 이해할 수 있는 코드(바이트코드, Bytecode)로 변환한다
• JVM은 바이트코드를 운영체제에 맞는 기계어로 변환해 주는 자바 프로그램을 실행시키는 도구이다
• 자바 코드로 작성한 프로그램을 해석해 실행하는 별도의 프로그램으로 프로그램을 실행하는 프로그램이다
• JDK나 JRE를 설치하면 자동으로 설치된다
• Java 프로그램은 JVM을 거치기 때문에 C나 C++에 비해 속도는 느린 편이다

2. JDK(Java Development Kit)

• JRE(Java Runtime Environment)는 JVM + 표준 클래스 라이브러리로 구성되어 있다
• JDK(Java Development Kit)는 JRE + 개발에 필요한 도구로 구성되어 있다
•  1) JDK 종류

1. OracleJDK : 오라클 회사에서 관리하는 버전
2. OpenJDK : 오픈소스

1. java란?

• 프로그래밍 언어
• 애플리케이션 개발용 프로그램
• JRE(Java Runtime Environment) : JVM(자바 가상머신) + 표준 클래스 라이브러리가 설치되어 있는 모든 운영체제에서 실행이 가능

2. Java History

• JDK 1.0 (1996.01.23) : 자바 개발도구 출시
• J2SE 1.2 (1996.12.08) : Java2 Standard Edition ver 1.2 출시
• J2SE 5.0 (2004.09.30) : Java2 Standard Edition ver 5.0 출시
• Java SE 8 (2014.03.18) : Java Standard Edition ver 8 출시
• Java SE 13 (2019.09.17) : Java Standard Edition ver 13 출시

3. Java 프로그램 종류

• JSE (Java Standard Edition) : 일반용 프로그램
• JME (Java Micro Edition) : 모바일 또는 소형기기용 프로그램
• JEE (Java Enterprise Edition) : 대기업용 프로그램

4. Java 특성

 1) 운영체제의 독립성

   - JRE(Java Runtime Environment)

    : JVM(Java Virtual Machine, 자바 가상머신) + 표준 클래스 라이브러리가 설치되어 있는 모든 운영체제에서 실행이 가능

 2) 객체 지향 언어(Object Oriented Programming, OOP)

  - 자바는 객체지향 프로그래밍 개념을 사용하는 언어이다

  - 객체(Object)는 프로그램이 동작하는 부품 모든 기능은 객체로 만들어 사용한다

  - 여러 부품(객체)들을 만들고 조립하여 하나의 프로그램을 실행하는 개념이 OOP이다

  - 객체 지향적으로 설계된 프로그램은 유지보수가 쉽고 확장성이 높다

 3) 함수형 프로그래밍 지원

  - 자바 8버전부터 함수형 프로그래밍을 지원하는 문법인 람다식과 스트림이 추가되었다

  - 컬렉션의 요소를 처리하기가 쉬워지고 코드가 간결해지는 장점이 있다

 4) 자동 메모리 관리(Garbage Collection)

  - 가비지 컬렉터(Garbage Collector)를 실행시켜 자동으로 사용하지 않는 메모리를 수거하여 관리한다

  - 프로그래머가 직접 메모리를 관리할 필요가 없다

 5) 라이브러리가 다양하고 풍부하여 쉽게 개발할 수 있다

1. this()

• 자기가 속한 클래스에서 다른 생성자를 호출하는 경우 사용
• 항상 함수의 첫 줄에 위치하여야 한다

ex1) A() 와 A(int x)라는 2개의 생성자가 있는 경우 this()의 결과 

#15 this(); 는 class Thistest 내에서 A(int x)가 아닌 다른 생성자 A()를 호출하여 출력한다  

ex2) this() 를 한번 더 사용할 경우 출력 순서

 - 자기 외의 생성자 A() 와 A(int x)를 전부 출력하는 것을 확인할 수 있다

2. this

• this 키워드는 변수 자신을 지칭하는 역활을 한다
• this는 참조변수로써 통상적으로는 컴파일러가 자동으로 추가해 주기 때문에 생략한다
• 동일한 이름의 인스턴스 변수와 매개변수가 있다면 구분이 어렵기 때문에 이런 경우 this 키워드를 사용하여 변수의 성격을 확인시켜 준다 
• this 키워드는 this.변수이름 의 형식으로 사용한다

ex2) 변수의 지정을 안 한 경우 출력값

1. 클래스란?

• 자바 프로그램 구성의 기본 단위이다
• 객체(object)를 생성하기 위하여 정의한 설계도(blueprint) 또는 틀(frame)이다
• 객체(object)는 클래스(class)에 의해 정의되고, 클래스에 의해 설계된 내용을 생성한 결과물이다
• 자바는 객체지향 언어이기 때문에 모든 코드를 클래스 내에서 작성한다
• 객체의 구조를 클래스 내에서 코드로 정의하면 이후에 동일한 구조의 클래스는 쉽게 생성할 수 있다
• 객체의 상태는 필드(데이터)로, 행위는 메소드로 구현된다
• 객체는 특정 클래스의 인스턴스이다
• 클래스는 자체로 타입으로 사용할 수 있으며 연관된 기능들을 묶을 수 있다

  ※ 인스턴스(instance)

• 클래스를 통해 생성된 객체를 말한다
• 클래스로부터 객체를 만드는 과정을 '인스턴스화(instantiate)라고 한다
• 객체와 인스턴스는 비슷한 맥락의 의미를 가지지만 객체가 메모리에 할당되어 구현될 때를 인스턴스로 볼 수 있다

2. 클래스 구성

 1) 필드(field)

• 클래스의 속성(state)을 나타내는 변수
• 모델명, 컬러, 바퀴의 수 등등...

 2) 메서드(method)

• 클래스의 기능(behavior)을 나타내는 함수
• 시동걸기, 가속하기, 정지하기 등등...

 3) 생성자(constructor)

• 클래스의 객체를 생성하는 역할

 4) 이너 클래스(inner class)

• 클래스 내부의 클래스를 의미

※ 필드, 메서드, 이너클래스 3요소를 클래스의 멤버(member)라고 부른다

※ 참조 링크

▶ 해시넷 클래스 : http://wiki.hash.kr/index.php/%ED%81%B4%EB%9E%98%EC%8A%A4

▶ 위키피아 클래스 : https://en.wikipedia.org/wiki/Class_(computer_programming) 

3. 내부 클래스(Inner Class)

• 클래스 내에 선언된 클래스이다
• 외부 클래스와 내부 클래스가 서로 연관되어 있을 때 사용한다
• 내부 클래스를 사용하면 외부 클래스의 멤버들에 쉽게 접근 할 수 있고, 코드의 복잡성을 줄일 수 있다
• 외부적으로 불필요한 데이터를 감출 수 있어 캡슐화(encapsulation)를 달성하는 데 유용하다
• 기본적으로 내부 클래스는 외부 클래스 내에 선언된다는 점을 제외하면 일반 클래스와 차이점이 없다
  - 외부 클래스와 내부 클래스가 서로 연관되어 있을 때 사용의 편의성을 고려하여 만들어진 문법 요소이다

class Outer { // 외부 클래스
	
	class Inner {
		// 인스턴스 내부 클래스	
	}
	
	static class StaticInner {
		// 정적 내부 클래스
	}

	void run() {
		class LocalInner {
		// 지역 내부 클래스
		}
	}
}

• 내부 클래스의 종류는 세가지로 구분한다
  - 인스턴스 내부 클래스
  - 정적 내부 클래스
  - 지역 내부 클래스
• 세 가지 내부 클래스는 변수가 선언 위치에 따라 인스턴스 변수, 클래스 변수, 그리고 지역 변수로 구분되는 것과 유사하게 그 위치를 중심으로 구분될 수 있다
• 각각의 유효범위(scope)와 특성이 변수의 구분과 매우 유사하다
• 내부클래스 종류

 1) 인스턴스 내부 클래스(instance inner class)

• 인스턴스 내부 클래스는 외부 클래스의 내부에 위치해 있다
• private 접근 제어자(해당 클래스 안에서만 접근 가능한 멤버에 사용)를 사용하고 있음에도 내부에서 외부 클래스의 인스턴스 변수와 정적 변수에 각각 접근하여 해당 값을 사용하고 있다
• 인스턴스 내부 클래스는 반드시 외부 클래스를 생성한 이후에 사용해야 한다
• 클래스의 생성과 상관없이 사용할 수 있는 정적 변수와 정적 메서드는 인스턴스 내부 클래스에서 선언할 수 없다

class Outer{
    private int num = 1;
    private static int sNum = 2;
    private InnerClass innerClass;
    public Outer(){
       innerClass = new InnerClass();
    }

    class InnerClass{
        int inNum = 10;
        void innerMethod(){
            System.out.println("Outer num = " + num + "(instance variable of outer class)");
            System.out.println("Outer sNum = " + sNum + "(static variable of outer class");
        }
    }
    public void testClass(){
        innerClass.innerMethod();
    }
}

public class MainClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        System.out.println("call up inner class function used outer class");
        outer.testClass();
    }
}

 2) 정적 내부 클래스

• 내부 클래스가 외부 클래스의 존재와 무관하게 정적 변수를 사용할 수 있는 것이 정적 내부 클래스이다
• 인스턴스 내부 클래스와 동일하게 클래스의 멤버 변수 위치에 정의하지만 static 키워드를 사용한다

class Outer1{
    private int num = 3;
    private static int sNum = 4;
    void getPrint(){
        System.out.println("Instance Method");
    }
    static void getPrintStatic(){
        System.out.println("Static Method");
    }

    static class StaticInClass {
        void test() {
            System.out.println("Outer num = " + sNum + "(static variable of outer class)");
            getPrintStatic();
        }
    }
}
public class StaticInnerClass {
    public static void main(String[] args) {
        Outer1.StaticInClass a = new Outer1.StaticInClass();
        a.test();
    }
}

4. 지역 내부 클래스(local inner class)

class Outer2{
    int num = 5;
    void test(){
        int num2 = 6;
        class LocalInClass{
            void getPrint(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        LocalInClass localInClass = new LocalInClass();
        localInClass.getPrint();
    }
}
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer2 outer = new Outer2();
        outer.test();
    }
}

1. 객체(Objcet)란?

사물이나 논리 등과 같이 시각적, 촉각적, 정신적으로 인지할 수 있는 모든 실재의 대상이다

2. 객체지향이론

실제 세계는 객체들로 구성되어 있으며, 발생하는 모든 사건들은 객체들 간의 상호작용에 의해 발생한다는 이론

3. 객체지향 프로그래밍

• 객체지향론에 바탕을 둔 프로그래밍 방법으로 데이터를 모아서 추상화시킨 객체(상태와 행위를 가진 객체)를 만들고 객체들 간의 상호작용을 통해 특정 기능을 구성하는 방법이다
• 실제 사물의 속성(state)과 기능(behavior)을 분석한 후에 프로그래밍의 변수와 함수로 정의함으로 실제 세계를 최대한 컴퓨터 프로그래밍에 반영하려 하고 있다
• 기존 코드를 활용해서 새로운 코드를 상대적으로 손쉽게 작성할 수 있고, 코드 간의 관계 설정을 통해 적은 노력으로도 쉽게 코드를 변경할 수 있다는 장점이 있다
• 코드의 재사용성 향상, 유지보수 용이 및 중복 코드 제거의 장점이 있다

객체지향 언어 = 프로그래밍 언어 + 객체지향 개념(규칙)

객체지향 프로그래밍의 규칙은 외우는 것이 최선이다!!!

• 객체지향 프로그래밍 : WIKIPEDIA - Object-oriented programming - Wikipedia

•  객체지향 : 해시넷 - 객체지향 - 해시넷 (hash.kr)

• 잊혀진 OOP의 역사 : Eric Elliott - The Forgotten History of OOP. Most of the programming paradigms we… | by Eric Elliott | JavaScript Scene | Medium